bfd/mach-o.c

   1 /* Mach-O support for BFD.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004
   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 #if 0
 383   for (i = 0; i < mdata->header.ncmds; i++)
 384     {
 385       bfd_mach_o_load_command *cur = &mdata->commands[i];
 386       if (cur->type != BFD_MACH_O_LC_SEGMENT)
 387         break;
 388
 389       {
 390         bfd_mach_o_segment_command *seg = &cur->command.segment;
 391         char buf[1024];
 392         bfd_vma nbytes = seg->filesize;
 393         bfd_vma curoff = seg->fileoff;
 394
 395         while (nbytes > 0)
 396           {
 397             bfd_vma thisread = nbytes;
 398
 399             if (thisread > 1024)
 400               thisread = 1024;
 401
 402             bfd_seek (abfd, curoff, SEEK_SET);
 403             if (bfd_bread ((PTR) buf, thisread, abfd) != thisread)
 404               return FALSE;
 405
 406             bfd_seek (abfd, curoff, SEEK_SET);
 407             if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread)
 408               return FALSE;
 409
 410             nbytes -= thisread;
 411             curoff += thisread;
 412           }
 413       }
 414   }
 415 #endif
 416
 417   /* Now write header information.  */
 418   if (bfd_mach_o_write_header (abfd, &mdata->header) != 0)
 419     return FALSE;
 420
 421   for (i = 0; i < mdata->header.ncmds; i++)
 422     {
 423       unsigned char buf[8];
 424       bfd_mach_o_load_command *cur = &mdata->commands[i];
 425       unsigned long typeflag;
 426
 427       typeflag = cur->type_required ? cur->type & BFD_MACH_O_LC_REQ_DYLD : cur->type;
 428
 429       bfd_h_put_32 (abfd, typeflag, buf);
 430       bfd_h_put_32 (abfd, cur->len, buf + 4);
 431
 432       bfd_seek (abfd, cur->offset, SEEK_SET);
 433       if (bfd_bwrite ((PTR) buf, 8, abfd) != 8)
 434         return FALSE;
 435
 436       switch (cur->type)
 437         {
 438         case BFD_MACH_O_LC_SEGMENT:
 439           if (bfd_mach_o_scan_write_segment (abfd, cur) != 0)
 440             return FALSE;
 441           break;
 442         case BFD_MACH_O_LC_SYMTAB:
 443           if (bfd_mach_o_scan_write_symtab (abfd, cur) != 0)
 444             return FALSE;
 445           break;
 446         case BFD_MACH_O_LC_SYMSEG:
 447           break;
 448         case BFD_MACH_O_LC_THREAD:
 449         case BFD_MACH_O_LC_UNIXTHREAD:
 450           if (bfd_mach_o_scan_write_thread (abfd, cur) != 0)
 451             return FALSE;
 452           break;
 453         case BFD_MACH_O_LC_LOADFVMLIB:
 454         case BFD_MACH_O_LC_IDFVMLIB:
 455         case BFD_MACH_O_LC_IDENT:
 456         case BFD_MACH_O_LC_FVMFILE:
 457         case BFD_MACH_O_LC_PREPAGE:
 458         case BFD_MACH_O_LC_DYSYMTAB:
 459         case BFD_MACH_O_LC_LOAD_DYLIB:
 460         case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
 461         case BFD_MACH_O_LC_ID_DYLIB:
 462         case BFD_MACH_O_LC_LOAD_DYLINKER:
 463         case BFD_MACH_O_LC_ID_DYLINKER:
 464         case BFD_MACH_O_LC_PREBOUND_DYLIB:
 465         case BFD_MACH_O_LC_ROUTINES:
 466         case BFD_MACH_O_LC_SUB_FRAMEWORK:
 467           break;
 468         default:
 469           fprintf (stderr,
 470                    "unable to write unknown load command 0x%lx\n",
 471                    (long) cur->type);
 472           return FALSE;
 473         }
 474     }
 475
 476   return TRUE;
 477 }
 478
 479 static int
 480 bfd_mach_o_sizeof_headers (a, b)
 481      bfd *a ATTRIBUTE_UNUSED;
 482      bfd_boolean b ATTRIBUTE_UNUSED;
 483 {
 484   return 0;
 485 }
 486
 487 /* Make an empty symbol.  This is required only because
 488    bfd_make_section_anyway wants to create a symbol for the section.  */
 489
 490 static asymbol *
 491 bfd_mach_o_make_empty_symbol (abfd)
 492      bfd *abfd;
 493 {
 494   asymbol *new;
 495
 496   new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
 497   if (new == NULL)
 498     return new;
 499   new->the_bfd = abfd;
 500   return new;
 501 }
 502
 503 static int
 504 bfd_mach_o_write_header (abfd, header)
 505      bfd *abfd;
 506      bfd_mach_o_header *header;
 507 {
 508   unsigned char buf[28];
 509
 510   bfd_h_put_32 (abfd, header->magic, buf + 0);
 511   bfd_h_put_32 (abfd, header->cputype, buf + 4);
 512   bfd_h_put_32 (abfd, header->cpusubtype, buf + 8);
 513   bfd_h_put_32 (abfd, header->filetype, buf + 12);
 514   bfd_h_put_32 (abfd, header->ncmds, buf + 16);
 515   bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20);
 516   bfd_h_put_32 (abfd, header->flags, buf + 24);
 517
 518   bfd_seek (abfd, 0, SEEK_SET);
 519   if (bfd_bwrite ((PTR) buf, 28, abfd) != 28)
 520     return -1;
 521
 522   return 0;
 523 }
 524
 525 static int
 526 bfd_mach_o_read_header (abfd, header)
 527      bfd *abfd;
 528      bfd_mach_o_header *header;
 529 {
 530   unsigned char buf[28];
 531   bfd_vma (*get32) (const void *) = NULL;
 532
 533   bfd_seek (abfd, 0, SEEK_SET);
 534
 535   if (bfd_bread ((PTR) buf, 28, abfd) != 28)
 536     return -1;
 537
 538   if (bfd_getb32 (buf) == 0xfeedface)
 539     {
 540       header->byteorder = BFD_ENDIAN_BIG;
 541       header->magic = 0xfeedface;
 542       get32 = bfd_getb32;
 543     }
 544   else if (bfd_getl32 (buf) == 0xfeedface)
 545     {
 546       header->byteorder = BFD_ENDIAN_LITTLE;
 547       header->magic = 0xfeedface;
 548       get32 = bfd_getl32;
 549     }
 550   else
 551     {
 552       header->byteorder = BFD_ENDIAN_UNKNOWN;
 553       return -1;
 554     }
 555
 556   header->cputype = (*get32) (buf + 4);
 557   header->cpusubtype = (*get32) (buf + 8);
 558   header->filetype = (*get32) (buf + 12);
 559   header->ncmds = (*get32) (buf + 16);
 560   header->sizeofcmds = (*get32) (buf + 20);
 561   header->flags = (*get32) (buf + 24);
 562
 563   return 0;
 564 }
 565
 566 static asection *
 567 bfd_mach_o_make_bfd_section (abfd, section)
 568      bfd *abfd;
 569      bfd_mach_o_section *section;
 570 {
 571   asection *bfdsec;
 572   char *sname;
 573   const char *prefix = "LC_SEGMENT";
 574   unsigned int snamelen;
 575
 576   snamelen = strlen (prefix) + 1
 577     + strlen (section->segname) + 1
 578     + strlen (section->sectname) + 1;
 579
 580   sname = (char *) bfd_alloc (abfd, snamelen);
 581   if (sname == NULL)
 582     return NULL;
 583   sprintf (sname, "%s.%s.%s", prefix, section->segname, section->sectname);
 584
 585   bfdsec = bfd_make_section_anyway (abfd, sname);
 586   if (bfdsec == NULL)
 587     return NULL;
 588
 589   bfdsec->vma = section->addr;
 590   bfdsec->lma = section->addr;
 591   bfdsec->size = section->size;
 592   bfdsec->filepos = section->offset;
 593   bfdsec->alignment_power = section->align;
 594
 595   if (section->flags & BFD_MACH_O_S_ZEROFILL)
 596     bfdsec->flags = SEC_ALLOC;
 597   else
 598     bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
 599
 600   return bfdsec;
 601 }
 602
 603 static int
 604 bfd_mach_o_scan_read_section (abfd, section, offset)
 605      bfd *abfd;
 606      bfd_mach_o_section *section;
 607      bfd_vma offset;
 608 {
 609   unsigned char buf[68];
 610
 611   bfd_seek (abfd, offset, SEEK_SET);
 612   if (bfd_bread ((PTR) buf, 68, abfd) != 68)
 613     return -1;
 614
 615   memcpy (section->sectname, buf, 16);
 616   section->sectname[16] = '\0';
 617   memcpy (section->segname, buf + 16, 16);
 618   section->segname[16] = '\0';
 619   section->addr = bfd_h_get_32 (abfd, buf + 32);
 620   section->size = bfd_h_get_32 (abfd, buf + 36);
 621   section->offset = bfd_h_get_32 (abfd, buf + 40);
 622   section->align = bfd_h_get_32 (abfd, buf + 44);
 623   section->reloff = bfd_h_get_32 (abfd, buf + 48);
 624   section->nreloc = bfd_h_get_32 (abfd, buf + 52);
 625   section->flags = bfd_h_get_32 (abfd, buf + 56);
 626   section->reserved1 = bfd_h_get_32 (abfd, buf + 60);
 627   section->reserved2 = bfd_h_get_32 (abfd, buf + 64);
 628   section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section);
 629
 630   if (section->bfdsection == NULL)
 631     return -1;
 632
 633   return 0;
 634 }
 635
 636 static int
 637 bfd_mach_o_scan_write_section (abfd, section, offset)
 638      bfd *abfd;
 639      bfd_mach_o_section *section;
 640      bfd_vma offset;
 641 {
 642   unsigned char buf[68];
 643
 644   memcpy (buf, section->sectname, 16);
 645   memcpy (buf + 16, section->segname, 16);
 646   bfd_h_put_32 (abfd, section->addr, buf + 32);
 647   bfd_h_put_32 (abfd, section->size, buf + 36);
 648   bfd_h_put_32 (abfd, section->offset, buf + 40);
 649   bfd_h_put_32 (abfd, section->align, buf + 44);
 650   bfd_h_put_32 (abfd, section->reloff, buf + 48);
 651   bfd_h_put_32 (abfd, section->nreloc, buf + 52);
 652   bfd_h_put_32 (abfd, section->flags, buf + 56);
 653   /* bfd_h_put_32 (abfd, section->reserved1, buf + 60); */
 654   /* bfd_h_put_32 (abfd, section->reserved2, buf + 64); */
 655
 656   bfd_seek (abfd, offset, SEEK_SET);
 657   if (bfd_bwrite ((PTR) buf, 68, abfd) != 68)
 658     return -1;
 659
 660   return 0;
 661 }
 662
 663 static int
 664 bfd_mach_o_scan_write_symtab_symbols (abfd, command)
 665      bfd *abfd;
 666      bfd_mach_o_load_command *command;
 667 {
 668   bfd_mach_o_symtab_command *sym = &command->command.symtab;
 669   asymbol *s = NULL;
 670   unsigned long i;
 671
 672   for (i = 0; i < sym->nsyms; i++)
 673     {
 674       unsigned char buf[12];
 675       bfd_vma symoff = sym->symoff + (i * 12);
 676       unsigned char ntype = 0;
 677       unsigned char nsect = 0;
 678       short ndesc = 0;
 679
 680       s = &sym->symbols[i];
 681
 682       /* Don't set this from the symbol information; use stored values.  */
 683 #if 0
 684       if (s->flags & BSF_GLOBAL)
 685         ntype |= N_EXT;
 686       if (s->flags & BSF_DEBUGGING)
 687         ntype |= N_STAB;
 688
 689       if (s->section == bfd_und_section_ptr)
 690         ntype |= N_UNDF;
 691       else if (s->section == bfd_abs_section_ptr)
 692         ntype |= N_ABS;
 693       else
 694         ntype |= N_SECT;
 695 #endif
 696
 697       /* Instead just set from the stored values.  */
 698       ntype = (s->udata.i >> 24) & 0xff;
 699       nsect = (s->udata.i >> 16) & 0xff;
 700       ndesc = s->udata.i & 0xffff;
 701
 702       bfd_h_put_32 (abfd, s->name - sym->strtab, buf);
 703       bfd_h_put_8 (abfd, ntype, buf + 4);
 704       bfd_h_put_8 (abfd, nsect, buf + 5);
 705       bfd_h_put_16 (abfd, ndesc, buf + 6);
 706       bfd_h_put_32 (abfd, s->section->vma + s->value, buf + 8);
 707
 708       bfd_seek (abfd, symoff, SEEK_SET);
 709       if (bfd_bwrite ((PTR) buf, 12, abfd) != 12)
 710         {
 711           fprintf (stderr, "bfd_mach_o_scan_write_symtab_symbols: unable to write %d bytes at %lu\n",
 712                    12, (unsigned long) symoff);
 713           return -1;
 714         }
 715     }
 716
 717   return 0;
 718 }
 719
 720 int
 721 bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, i)
 722      bfd *abfd;
 723      bfd_mach_o_symtab_command *sym;
 724      asymbol *s;
 725      unsigned long i;
 726 {
 727   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
 728   bfd_vma symoff = sym->symoff + (i * 12);
 729   unsigned char buf[12];
 730   unsigned char type = -1;
 731   unsigned char section = -1;
 732   short desc = -1;
 733   unsigned long value = -1;
 734   unsigned long stroff = -1;
 735   unsigned int symtype = -1;
 736
 737   BFD_ASSERT (sym->strtab != NULL);
 738
 739   bfd_seek (abfd, symoff, SEEK_SET);
 740   if (bfd_bread ((PTR) buf, 12, abfd) != 12)
 741     {
 742       fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n",
 743                12, (unsigned long) symoff);
 744       return -1;
 745     }
 746
 747   stroff = bfd_h_get_32 (abfd, buf);
 748   type = bfd_h_get_8 (abfd, buf + 4);
 749   symtype = (type & 0x0e);
 750   section = bfd_h_get_8 (abfd, buf + 5) - 1;
 751   desc = bfd_h_get_16 (abfd, buf + 6);
 752   value = bfd_h_get_32 (abfd, buf + 8);
 753
 754   if (stroff >= sym->strsize)
 755     {
 756       fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
 757                (unsigned long) stroff, (unsigned long) sym->strsize);
 758       return -1;
 759     }
 760
 761   s->the_bfd = abfd;
 762   s->name = sym->strtab + stroff;
 763   s->value = value;
 764   s->udata.i = (type << 24) | (section << 16) | desc;
 765   s->flags = 0x0;
 766
 767   if (type & BFD_MACH_O_N_STAB)
 768     {
 769       s->flags |= BSF_DEBUGGING;
 770       s->section = bfd_und_section_ptr;
 771     }
 772   else
 773     {
 774       if (type & BFD_MACH_O_N_PEXT)
 775         {
 776           type &= ~BFD_MACH_O_N_PEXT;
 777           s->flags |= BSF_GLOBAL;
 778         }
 779
 780       if (type & BFD_MACH_O_N_EXT)
 781         {
 782           type &= ~BFD_MACH_O_N_EXT;
 783           s->flags |= BSF_GLOBAL;
 784         }
 785
 786       switch (symtype)
 787         {
 788         case BFD_MACH_O_N_UNDF:
 789           s->section = bfd_und_section_ptr;
 790           break;
 791         case BFD_MACH_O_N_PBUD:
 792           s->section = bfd_und_section_ptr;
 793           break;
 794         case BFD_MACH_O_N_ABS:
 795           s->section = bfd_abs_section_ptr;
 796           break;
 797         case BFD_MACH_O_N_SECT:
 798           if ((section > 0) && (section <= mdata->nsects))
 799             {
 800               s->section = mdata->sections[section - 1]->bfdsection;
 801               s->value = s->value - mdata->sections[section - 1]->addr;
 802             }
 803           else
 804             {
 805               /* Mach-O uses 0 to mean "no section"; not an error.  */
 806               if (section != 0)
 807                 {
 808                   fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
 809                            "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
 810                            s->name, section, mdata->nsects);
 811                 }
 812               s->section = bfd_und_section_ptr;
 813             }
 814           break;
 815         case BFD_MACH_O_N_INDR:
 816           fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
 817                    "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
 818                    s->name);
 819           s->section = bfd_und_section_ptr;
 820           break;
 821         default:
 822           fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
 823                    "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
 824                    s->name, symtype);
 825           s->section = bfd_und_section_ptr;
 826           break;
 827         }
 828     }
 829
 830   return 0;
 831 }
 832
 833 int
 834 bfd_mach_o_scan_read_symtab_strtab (abfd, sym)
 835      bfd *abfd;
 836      bfd_mach_o_symtab_command *sym;
 837 {
 838   BFD_ASSERT (sym->strtab == NULL);
 839
 840   if (abfd->flags & BFD_IN_MEMORY)
 841     {
 842       struct bfd_in_memory *b;
 843
 844       b = (struct bfd_in_memory *) abfd->iostream;
 845
 846       if ((sym->stroff + sym->strsize) > b->size)
 847         {
 848           bfd_set_error (bfd_error_file_truncated);
 849           return -1;
 850         }
 851       sym->strtab = b->buffer + sym->stroff;
 852       return 0;
 853     }
 854
 855   sym->strtab = bfd_alloc (abfd, sym->strsize);
 856   if (sym->strtab == NULL)
 857     return -1;
 858
 859   bfd_seek (abfd, sym->stroff, SEEK_SET);
 860   if (bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize)
 861     {
 862       fprintf (stderr, "bfd_mach_o_scan_read_symtab_strtab: unable to read %lu bytes at %lu\n",
 863                sym->strsize, sym->stroff);
 864       return -1;
 865     }
 866
 867   return 0;
 868 }
 869
 870 int
 871 bfd_mach_o_scan_read_symtab_symbols (abfd, sym)
 872      bfd *abfd;
 873      bfd_mach_o_symtab_command *sym;
 874 {
 875   unsigned long i;
 876   int ret;
 877
 878   BFD_ASSERT (sym->symbols == NULL);
 879   sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (asymbol));
 880
 881   if (sym->symbols == NULL)
 882     {
 883       fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n");
 884       return -1;
 885     }
 886
 887   ret = bfd_mach_o_scan_read_symtab_strtab (abfd, sym);
 888   if (ret != 0)
 889     return ret;
 890
 891   for (i = 0; i < sym->nsyms; i++)
 892     {
 893       ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
 894       if (ret != 0)
 895         return ret;
 896     }
 897
 898   return 0;
 899 }
 900
 901 int
 902 bfd_mach_o_scan_read_dysymtab_symbol (abfd, dysym, sym, s, i)
 903      bfd *abfd;
 904      bfd_mach_o_dysymtab_command *dysym;
 905      bfd_mach_o_symtab_command *sym;
 906      asymbol *s;
 907      unsigned long i;
 908 {
 909   unsigned long isymoff = dysym->indirectsymoff + (i * 4);
 910   unsigned long symindex;
 911   unsigned char buf[4];
 912
 913   BFD_ASSERT (i < dysym->nindirectsyms);
 914
 915   bfd_seek (abfd, isymoff, SEEK_SET);
 916   if (bfd_bread ((PTR) buf, 4, abfd) != 4)
 917     {
 918       fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
 919                (unsigned long) 4, isymoff);
 920       return -1;
 921     }
 922   symindex = bfd_h_get_32 (abfd, buf);
 923
 924   return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex);
 925 }
 926
 927 static const char *
 928 bfd_mach_o_i386_flavour_string (flavour)
 929      unsigned int flavour;
 930 {
 931   switch ((int) flavour)
 932     {
 933     case BFD_MACH_O_i386_NEW_THREAD_STATE: return "i386_NEW_THREAD_STATE";
 934     case BFD_MACH_O_i386_FLOAT_STATE: return "i386_FLOAT_STATE";
 935     case BFD_MACH_O_i386_ISA_PORT_MAP_STATE: return "i386_ISA_PORT_MAP_STATE";
 936     case BFD_MACH_O_i386_V86_ASSIST_STATE: return "i386_V86_ASSIST_STATE";
 937     case BFD_MACH_O_i386_REGS_SEGS_STATE: return "i386_REGS_SEGS_STATE";
 938     case BFD_MACH_O_i386_THREAD_SYSCALL_STATE: return "i386_THREAD_SYSCALL_STATE";
 939     case BFD_MACH_O_i386_THREAD_STATE_NONE: return "i386_THREAD_STATE_NONE";
 940     case BFD_MACH_O_i386_SAVED_STATE: return "i386_SAVED_STATE";
 941     case BFD_MACH_O_i386_THREAD_STATE: return "i386_THREAD_STATE";
 942     case BFD_MACH_O_i386_THREAD_FPSTATE: return "i386_THREAD_FPSTATE";
 943     case BFD_MACH_O_i386_THREAD_EXCEPTSTATE: return "i386_THREAD_EXCEPTSTATE";
 944     case BFD_MACH_O_i386_THREAD_CTHREADSTATE: return "i386_THREAD_CTHREADSTATE";
 945     default: return "UNKNOWN";
 946     }
 947 }
 948
 949 static const char *
 950 bfd_mach_o_ppc_flavour_string (flavour)
 951      unsigned int flavour;
 952 {
 953   switch ((int) flavour)
 954     {
 955     case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
 956     case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
 957     case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
 958     case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
 959     default: return "UNKNOWN";
 960     }
 961 }
 962
 963 static int
 964 bfd_mach_o_scan_write_thread (abfd, command)
 965      bfd *abfd;
 966      bfd_mach_o_load_command *command;
 967 {
 968   bfd_mach_o_thread_command *cmd = &command->command.thread;
 969   unsigned int i;
 970   unsigned char buf[8];
 971   bfd_vma offset;
 972   unsigned int nflavours;
 973
 974   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
 975               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
 976
 977   offset = 8;
 978   nflavours = 0;
 979   for (i = 0; i < cmd->nflavours; i++)
 980     {
 981       BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
 982       BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8));
 983
 984       bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf);
 985       bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
 986
 987       bfd_seek (abfd, command->offset + offset, SEEK_SET);
 988       if (bfd_bwrite ((PTR) buf, 8, abfd) != 8)
 989         return -1;
 990
 991       offset += cmd->flavours[i].size + 8;
 992     }
 993
 994   return 0;
 995 }
 996
 997 static int
 998 bfd_mach_o_scan_read_dylinker (abfd, command)
 999      bfd *abfd;
1000      bfd_mach_o_load_command *command;
1001 {
1002   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1003   unsigned char buf[4];
1004   unsigned int nameoff;
1005   asection *bfdsec;
1006   char *sname;
1007   const char *prefix;
1008
1009   BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
1010               || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
1011
1012   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1013   if (bfd_bread ((PTR) buf, 4, abfd) != 4)
1014     return -1;
1015
1016   nameoff = bfd_h_get_32 (abfd, buf + 0);
1017
1018   cmd->name_offset = command->offset + nameoff;
1019   cmd->name_len = command->len - nameoff;
1020
1021   if (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)
1022     prefix = "LC_LOAD_DYLINKER";
1023   else if (command->type == BFD_MACH_O_LC_ID_DYLINKER)
1024     prefix = "LC_ID_DYLINKER";
1025   else
1026     abort ();
1027
1028   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1029   if (sname == NULL)
1030     return -1;
1031   strcpy (sname, prefix);
1032
1033   bfdsec = bfd_make_section_anyway (abfd, sname);
1034   if (bfdsec == NULL)
1035     return -1;
1036
1037   bfdsec->vma = 0;
1038   bfdsec->lma = 0;
1039   bfdsec->size = command->len - 8;
1040   bfdsec->filepos = command->offset + 8;
1041   bfdsec->alignment_power = 0;
1042   bfdsec->flags = SEC_HAS_CONTENTS;
1043
1044   cmd->section = bfdsec;
1045
1046   return 0;
1047 }
1048
1049 static int
1050 bfd_mach_o_scan_read_dylib (abfd, command)
1051      bfd *abfd;
1052      bfd_mach_o_load_command *command;
1053 {
1054   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1055   unsigned char buf[16];
1056   unsigned int nameoff;
1057   asection *bfdsec;
1058   char *sname;
1059   const char *prefix;
1060
1061   BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLIB)
1062               || (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1063               || (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB));
1064
1065   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1066   if (bfd_bread ((PTR) buf, 16, abfd) != 16)
1067     return -1;
1068
1069   nameoff = bfd_h_get_32 (abfd, buf + 0);
1070   cmd->timestamp = bfd_h_get_32 (abfd, buf + 4);
1071   cmd->current_version = bfd_h_get_32 (abfd, buf + 8);
1072   cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12);
1073
1074   cmd->name_offset = command->offset + nameoff;
1075   cmd->name_len = command->len - nameoff;
1076
1077   if (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1078     prefix = "LC_LOAD_DYLIB";
1079   else if (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB)
1080     prefix = "LC_LOAD_WEAK_DYLIB";
1081   else if (command->type == BFD_MACH_O_LC_ID_DYLIB)
1082     prefix = "LC_ID_DYLIB";
1083   else
1084     abort ();
1085
1086   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1087   if (sname == NULL)
1088     return -1;
1089   strcpy (sname, prefix);
1090
1091   bfdsec = bfd_make_section_anyway (abfd, sname);
1092   if (bfdsec == NULL)
1093     return -1;
1094
1095   bfdsec->vma = 0;
1096   bfdsec->lma = 0;
1097   bfdsec->size = command->len - 8;
1098   bfdsec->filepos = command->offset + 8;
1099   bfdsec->alignment_power = 0;
1100   bfdsec->flags = SEC_HAS_CONTENTS;
1101
1102   cmd->section = bfdsec;
1103
1104   return 0;
1105 }
1106
1107 static int
1108 bfd_mach_o_scan_read_prebound_dylib (abfd, command)
1109      bfd *abfd ATTRIBUTE_UNUSED;
1110      bfd_mach_o_load_command *command ATTRIBUTE_UNUSED;
1111 {
1112   /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
1113
1114   BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
1115   return 0;
1116 }
1117
1118 static int
1119 bfd_mach_o_scan_read_thread (abfd, command)
1120      bfd *abfd;
1121      bfd_mach_o_load_command *command;
1122 {
1123   bfd_mach_o_data_struct *mdata = NULL;
1124   bfd_mach_o_thread_command *cmd = &command->command.thread;
1125   unsigned char buf[8];
1126   bfd_vma offset;
1127   unsigned int nflavours;
1128   unsigned int i;
1129
1130   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1131               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1132
1133   BFD_ASSERT (bfd_mach_o_valid (abfd));
1134   mdata = abfd->tdata.mach_o_data;
1135
1136   offset = 8;
1137   nflavours = 0;
1138   while (offset != command->len)
1139     {
1140       if (offset >= command->len)
1141         return -1;
1142
1143       bfd_seek (abfd, command->offset + offset, SEEK_SET);
1144
1145       if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1146         return -1;
1147
1148       offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
1149       nflavours++;
1150     }
1151
1152   cmd->flavours =
1153     ((bfd_mach_o_thread_flavour *)
1154      bfd_alloc (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour)));
1155   if (cmd->flavours == NULL)
1156     return -1;
1157   cmd->nflavours = nflavours;
1158
1159   offset = 8;
1160   nflavours = 0;
1161   while (offset != command->len)
1162     {
1163       if (offset >= command->len)
1164         return -1;
1165
1166       if (nflavours >= cmd->nflavours)
1167         return -1;
1168
1169       bfd_seek (abfd, command->offset + offset, SEEK_SET);
1170
1171       if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1172         return -1;
1173
1174       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
1175       cmd->flavours[nflavours].offset = command->offset + offset + 8;
1176       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4;
1177       offset += cmd->flavours[nflavours].size + 8;
1178       nflavours++;
1179     }
1180
1181   for (i = 0; i < nflavours; i++)
1182     {
1183       asection *bfdsec;
1184       unsigned int snamelen;
1185       char *sname;
1186       const char *flavourstr;
1187       const char *prefix = "LC_THREAD";
1188       unsigned int j = 0;
1189
1190       switch (mdata->header.cputype)
1191         {
1192         case BFD_MACH_O_CPU_TYPE_POWERPC:
1193           flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
1194           break;
1195         case BFD_MACH_O_CPU_TYPE_I386:
1196           flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
1197           break;
1198         default:
1199           flavourstr = "UNKNOWN_ARCHITECTURE";
1200           break;
1201         }
1202
1203       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
1204       sname = (char *) bfd_alloc (abfd, snamelen);
1205       if (sname == NULL)
1206         return -1;
1207
1208       for (;;)
1209         {
1210           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
1211           if (bfd_get_section_by_name (abfd, sname) == NULL)
1212             break;
1213           j++;
1214         }
1215
1216       bfdsec = bfd_make_section (abfd, sname);
1217
1218       bfdsec->vma = 0;
1219       bfdsec->lma = 0;
1220       bfdsec->size = cmd->flavours[i].size;
1221       bfdsec->filepos = cmd->flavours[i].offset;
1222       bfdsec->alignment_power = 0x0;
1223       bfdsec->flags = SEC_HAS_CONTENTS;
1224
1225       cmd->section = bfdsec;
1226     }
1227
1228   return 0;
1229 }
1230
1231 static int
1232 bfd_mach_o_scan_write_symtab (abfd, command)
1233      bfd *abfd;
1234      bfd_mach_o_load_command *command;
1235 {
1236   bfd_mach_o_symtab_command *seg = &command->command.symtab;
1237   unsigned char buf[16];
1238
1239   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1240
1241   bfd_h_put_32 (abfd, seg->symoff, buf);
1242   bfd_h_put_32 (abfd, seg->nsyms, buf + 4);
1243   bfd_h_put_32 (abfd, seg->stroff, buf + 8);
1244   bfd_h_put_32 (abfd, seg->strsize, buf + 12);
1245
1246   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1247   if (bfd_bwrite ((PTR) buf, 16, abfd) != 16)
1248     return -1;
1249
1250   if (bfd_mach_o_scan_write_symtab_symbols (abfd, command) != 0)
1251     return -1;
1252
1253   return 0;
1254 }
1255
1256 static int
1257 bfd_mach_o_scan_read_dysymtab (abfd, command)
1258      bfd *abfd;
1259      bfd_mach_o_load_command *command;
1260 {
1261   bfd_mach_o_dysymtab_command *seg = &command->command.dysymtab;
1262   unsigned char buf[72];
1263
1264   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1265
1266   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1267   if (bfd_bread ((PTR) buf, 72, abfd) != 72)
1268     return -1;
1269
1270   seg->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
1271   seg->nlocalsym = bfd_h_get_32 (abfd, buf + 4);
1272   seg->iextdefsym = bfd_h_get_32 (abfd, buf + 8);
1273   seg->nextdefsym = bfd_h_get_32 (abfd, buf + 12);
1274   seg->iundefsym = bfd_h_get_32 (abfd, buf + 16);
1275   seg->nundefsym = bfd_h_get_32 (abfd, buf + 20);
1276   seg->tocoff = bfd_h_get_32 (abfd, buf + 24);
1277   seg->ntoc = bfd_h_get_32 (abfd, buf + 28);
1278   seg->modtaboff = bfd_h_get_32 (abfd, buf + 32);
1279   seg->nmodtab = bfd_h_get_32 (abfd, buf + 36);
1280   seg->extrefsymoff = bfd_h_get_32 (abfd, buf + 40);
1281   seg->nextrefsyms = bfd_h_get_32 (abfd, buf + 44);
1282   seg->indirectsymoff = bfd_h_get_32 (abfd, buf + 48);
1283   seg->nindirectsyms = bfd_h_get_32 (abfd, buf + 52);
1284   seg->extreloff = bfd_h_get_32 (abfd, buf + 56);
1285   seg->nextrel = bfd_h_get_32 (abfd, buf + 60);
1286   seg->locreloff = bfd_h_get_32 (abfd, buf + 64);
1287   seg->nlocrel = bfd_h_get_32 (abfd, buf + 68);
1288
1289   return 0;
1290 }
1291
1292 static int
1293 bfd_mach_o_scan_read_symtab (abfd, command)
1294      bfd *abfd;
1295      bfd_mach_o_load_command *command;
1296 {
1297   bfd_mach_o_symtab_command *seg = &command->command.symtab;
1298   unsigned char buf[16];
1299   asection *bfdsec;
1300   char *sname;
1301   const char *prefix = "LC_SYMTAB.stabs";
1302
1303   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1304
1305   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1306   if (bfd_bread ((PTR) buf, 16, abfd) != 16)
1307     return -1;
1308
1309   seg->symoff = bfd_h_get_32 (abfd, buf);
1310   seg->nsyms = bfd_h_get_32 (abfd, buf + 4);
1311   seg->stroff = bfd_h_get_32 (abfd, buf + 8);
1312   seg->strsize = bfd_h_get_32 (abfd, buf + 12);
1313   seg->symbols = NULL;
1314   seg->strtab = NULL;
1315
1316   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1317   if (sname == NULL)
1318     return -1;
1319   strcpy (sname, prefix);
1320
1321   bfdsec = bfd_make_section_anyway (abfd, sname);
1322   if (bfdsec == NULL)
1323     return -1;
1324
1325   bfdsec->vma = 0;
1326   bfdsec->lma = 0;
1327   bfdsec->size = seg->nsyms * 12;
1328   bfdsec->filepos = seg->symoff;
1329   bfdsec->alignment_power = 0;
1330   bfdsec->flags = SEC_HAS_CONTENTS;
1331
1332   seg->stabs_segment = bfdsec;
1333
1334   prefix = "LC_SYMTAB.stabstr";
1335   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1336   if (sname == NULL)
1337     return -1;
1338   strcpy (sname, prefix);
1339
1340   bfdsec = bfd_make_section_anyway (abfd, sname);
1341   if (bfdsec == NULL)
1342     return -1;
1343
1344   bfdsec->vma = 0;
1345   bfdsec->lma = 0;
1346   bfdsec->size = seg->strsize;
1347   bfdsec->filepos = seg->stroff;
1348   bfdsec->alignment_power = 0;
1349   bfdsec->flags = SEC_HAS_CONTENTS;
1350
1351   seg->stabstr_segment = bfdsec;
1352
1353   return 0;
1354 }
1355
1356 static int
1357 bfd_mach_o_scan_read_segment (abfd, command)
1358      bfd *abfd;
1359      bfd_mach_o_load_command *command;
1360 {
1361   unsigned char buf[48];
1362   bfd_mach_o_segment_command *seg = &command->command.segment;
1363   unsigned long i;
1364   asection *bfdsec;
1365   char *sname;
1366   const char *prefix = "LC_SEGMENT";
1367   unsigned int snamelen;
1368
1369   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1370
1371   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1372   if (bfd_bread ((PTR) buf, 48, abfd) != 48)
1373     return -1;
1374
1375   memcpy (seg->segname, buf, 16);
1376   seg->vmaddr = bfd_h_get_32 (abfd, buf + 16);
1377   seg->vmsize = bfd_h_get_32 (abfd, buf + 20);
1378   seg->fileoff = bfd_h_get_32 (abfd, buf + 24);
1379   seg->filesize = bfd_h_get_32 (abfd, buf +  28);
1380   /* seg->maxprot = bfd_h_get_32 (abfd, buf + 32); */
1381   /* seg->initprot = bfd_h_get_32 (abfd, buf + 36); */
1382   seg->nsects = bfd_h_get_32 (abfd, buf + 40);
1383   seg->flags = bfd_h_get_32 (abfd, buf + 44);
1384
1385   snamelen = strlen (prefix) + 1 + strlen (seg->segname) + 1;
1386   sname = (char *) bfd_alloc (abfd, snamelen);
1387   if (sname == NULL)
1388     return -1;
1389   sprintf (sname, "%s.%s", prefix, seg->segname);
1390
1391   bfdsec = bfd_make_section_anyway (abfd, sname);
1392   if (bfdsec == NULL)
1393     return -1;
1394
1395   bfdsec->vma = seg->vmaddr;
1396   bfdsec->lma = seg->vmaddr;
1397   bfdsec->size = seg->filesize;
1398   bfdsec->filepos = seg->fileoff;
1399   bfdsec->alignment_power = 0x0;
1400   bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
1401
1402   seg->segment = bfdsec;
1403
1404   if (seg->nsects != 0)
1405     {
1406       seg->sections =
1407         ((bfd_mach_o_section *)
1408          bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section)));
1409       if (seg->sections == NULL)
1410         return -1;
1411
1412       for (i = 0; i < seg->nsects; i++)
1413         {
1414           bfd_vma segoff = command->offset + 48 + 8 + (i * 68);
1415
1416           if (bfd_mach_o_scan_read_section (abfd, &seg->sections[i],
1417                                             segoff) != 0)
1418             return -1;
1419         }
1420     }
1421
1422   return 0;
1423 }
1424
1425 static int
1426 bfd_mach_o_scan_write_segment (abfd, command)
1427      bfd *abfd;
1428      bfd_mach_o_load_command *command;
1429 {
1430   unsigned char buf[48];
1431   bfd_mach_o_segment_command *seg = &command->command.segment;
1432   unsigned long i;
1433
1434   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1435
1436   memcpy (buf, seg->segname, 16);
1437   bfd_h_put_32 (abfd, seg->vmaddr, buf + 16);
1438   bfd_h_put_32 (abfd, seg->vmsize, buf + 20);
1439   bfd_h_put_32 (abfd, seg->fileoff, buf + 24);
1440   bfd_h_put_32 (abfd, seg->filesize, buf + 28);
1441   bfd_h_put_32 (abfd, 0 /* seg->maxprot */, buf + 32);
1442   bfd_h_put_32 (abfd, 0 /* seg->initprot */, buf + 36);
1443   bfd_h_put_32 (abfd, seg->nsects, buf + 40);
1444   bfd_h_put_32 (abfd, seg->flags, buf + 44);
1445
1446   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1447   if (bfd_bwrite ((PTR) buf, 48, abfd) != 48)
1448     return -1;
1449
1450   {
1451     char buf[1024];
1452     bfd_vma nbytes = seg->filesize;
1453     bfd_vma curoff = seg->fileoff;
1454
1455     while (nbytes > 0)
1456       {
1457         bfd_vma thisread = nbytes;
1458
1459         if (thisread > 1024)
1460           thisread = 1024;
1461
1462         bfd_seek (abfd, curoff, SEEK_SET);
1463         if (bfd_bread ((PTR) buf, thisread, abfd) != thisread)
1464           return -1;
1465
1466         bfd_seek (abfd, curoff, SEEK_SET);
1467         if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread)
1468           return -1;
1469
1470         nbytes -= thisread;
1471         curoff += thisread;
1472       }
1473   }
1474
1475   for (i = 0; i < seg->nsects; i++)
1476     {
1477       bfd_vma segoff = command->offset + 48 + 8 + (i * 68);
1478
1479       if (bfd_mach_o_scan_write_section (abfd, &seg->sections[i], segoff) != 0)
1480         return -1;
1481     }
1482
1483   return 0;
1484 }
1485
1486 static int
1487 bfd_mach_o_scan_read_command (abfd, command)
1488      bfd *abfd;
1489      bfd_mach_o_load_command *command;
1490 {
1491   unsigned char buf[8];
1492
1493   bfd_seek (abfd, command->offset, SEEK_SET);
1494   if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1495     return -1;
1496
1497   command->type = (bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD);
1498   command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD
1499                             ? 1 : 0);
1500   command->len = bfd_h_get_32 (abfd, buf + 4);
1501
1502   switch (command->type)
1503     {
1504     case BFD_MACH_O_LC_SEGMENT:
1505       if (bfd_mach_o_scan_read_segment (abfd, command) != 0)
1506         return -1;
1507       break;
1508     case BFD_MACH_O_LC_SYMTAB:
1509       if (bfd_mach_o_scan_read_symtab (abfd, command) != 0)
1510         return -1;
1511       break;
1512     case BFD_MACH_O_LC_SYMSEG:
1513       break;
1514     case BFD_MACH_O_LC_THREAD:
1515     case BFD_MACH_O_LC_UNIXTHREAD:
1516       if (bfd_mach_o_scan_read_thread (abfd, command) != 0)
1517         return -1;
1518       break;
1519     case BFD_MACH_O_LC_LOAD_DYLINKER:
1520     case BFD_MACH_O_LC_ID_DYLINKER:
1521       if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0)
1522         return -1;
1523       break;
1524     case BFD_MACH_O_LC_LOAD_DYLIB:
1525     case BFD_MACH_O_LC_ID_DYLIB:
1526     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1527       if (bfd_mach_o_scan_read_dylib (abfd, command) != 0)
1528         return -1;
1529       break;
1530     case BFD_MACH_O_LC_PREBOUND_DYLIB:
1531       if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0)
1532         return -1;
1533       break;
1534     case BFD_MACH_O_LC_LOADFVMLIB:
1535     case BFD_MACH_O_LC_IDFVMLIB:
1536     case BFD_MACH_O_LC_IDENT:
1537     case BFD_MACH_O_LC_FVMFILE:
1538     case BFD_MACH_O_LC_PREPAGE:
1539     case BFD_MACH_O_LC_ROUTINES:
1540     case BFD_MACH_O_LC_SUB_FRAMEWORK:
1541       break;
1542     case BFD_MACH_O_LC_DYSYMTAB:
1543       if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0)
1544         return -1;
1545       break;
1546     case BFD_MACH_O_LC_SUB_UMBRELLA:
1547     case BFD_MACH_O_LC_SUB_CLIENT:
1548     case BFD_MACH_O_LC_SUB_LIBRARY:
1549     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
1550     case BFD_MACH_O_LC_PREBIND_CKSUM:
1551       break;
1552     default:
1553       fprintf (stderr, "unable to read unknown load command 0x%lx\n",
1554                (unsigned long) command->type);
1555       break;
1556     }
1557
1558   return 0;
1559 }
1560
1561 static void
1562 bfd_mach_o_flatten_sections (abfd)
1563      bfd *abfd;
1564 {
1565   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1566   long csect = 0;
1567   unsigned long i, j;
1568
1569   mdata->nsects = 0;
1570
1571   for (i = 0; i < mdata->header.ncmds; i++)
1572     {
1573       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT)
1574         {
1575           bfd_mach_o_segment_command *seg;
1576
1577           seg = &mdata->commands[i].command.segment;
1578           mdata->nsects += seg->nsects;
1579         }
1580     }
1581
1582   mdata->sections = bfd_alloc (abfd,
1583                                mdata->nsects * sizeof (bfd_mach_o_section *));
1584   csect = 0;
1585
1586   for (i = 0; i < mdata->header.ncmds; i++)
1587     {
1588       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT)
1589         {
1590           bfd_mach_o_segment_command *seg;
1591
1592           seg = &mdata->commands[i].command.segment;
1593           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
1594
1595           for (j = 0; j < seg->nsects; j++)
1596             mdata->sections[csect++] = &seg->sections[j];
1597         }
1598     }
1599 }
1600
1601 int
1602 bfd_mach_o_scan_start_address (abfd)
1603      bfd *abfd;
1604 {
1605   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1606   bfd_mach_o_thread_command *cmd = NULL;
1607   unsigned long i;
1608
1609   for (i = 0; i < mdata->header.ncmds; i++)
1610     {
1611       if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
1612           (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
1613         {
1614           if (cmd == NULL)
1615             cmd = &mdata->commands[i].command.thread;
1616           else
1617             return 0;
1618         }
1619     }
1620
1621   if (cmd == NULL)
1622     return 0;
1623
1624   for (i = 0; i < cmd->nflavours; i++)
1625     {
1626       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
1627           && (cmd->flavours[i].flavour
1628               == (unsigned long) BFD_MACH_O_i386_THREAD_STATE))
1629         {
1630           unsigned char buf[4];
1631
1632           bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET);
1633
1634           if (bfd_bread (buf, 4, abfd) != 4)
1635             return -1;
1636
1637           abfd->start_address = bfd_h_get_32 (abfd, buf);
1638         }
1639       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
1640                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
1641         {
1642           unsigned char buf[4];
1643
1644           bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET);
1645
1646           if (bfd_bread (buf, 4, abfd) != 4)
1647             return -1;
1648
1649           abfd->start_address = bfd_h_get_32 (abfd, buf);
1650         }
1651     }
1652
1653   return 0;
1654 }
1655
1656 int
1657 bfd_mach_o_scan (abfd, header, mdata)
1658      bfd *abfd;
1659      bfd_mach_o_header *header;
1660      bfd_mach_o_data_struct *mdata;
1661 {
1662   unsigned int i;
1663   enum bfd_architecture cputype;
1664   unsigned long cpusubtype;
1665
1666   mdata->header = *header;
1667   mdata->symbols = NULL;
1668
1669   abfd->flags = (abfd->xvec->object_flags
1670                  | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
1671   abfd->tdata.mach_o_data = mdata;
1672
1673   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
1674                                    &cputype, &cpusubtype);
1675   if (cputype == bfd_arch_unknown)
1676     {
1677       fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
1678                header->cputype, header->cpusubtype);
1679       return -1;
1680     }
1681
1682   bfd_set_arch_mach (abfd, cputype, cpusubtype);
1683
1684   if (header->ncmds != 0)
1685     {
1686       mdata->commands =
1687         ((bfd_mach_o_load_command *)
1688          bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command)));
1689       if (mdata->commands == NULL)
1690         return -1;
1691
1692       for (i = 0; i < header->ncmds; i++)
1693         {
1694           bfd_mach_o_load_command *cur = &mdata->commands[i];
1695
1696           if (i == 0)
1697             cur->offset = 28;
1698           else
1699             {
1700               bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
1701               cur->offset = prev->offset + prev->len;
1702             }
1703
1704           if (bfd_mach_o_scan_read_command (abfd, cur) < 0)
1705             return -1;
1706         }
1707     }
1708
1709   if (bfd_mach_o_scan_start_address (abfd) < 0)
1710     {
1711 #if 0
1712       fprintf (stderr, "bfd_mach_o_scan: unable to scan start address: %s\n",
1713                bfd_errmsg (bfd_get_error ()));
1714       abfd->tdata.mach_o_data = NULL;
1715       return -1;
1716 #endif
1717     }
1718
1719   bfd_mach_o_flatten_sections (abfd);
1720
1721   return 0;
1722 }
1723
1724 bfd_boolean
1725 bfd_mach_o_mkobject (abfd)
1726      bfd *abfd;
1727 {
1728   bfd_mach_o_data_struct *mdata = NULL;
1729
1730   mdata = ((bfd_mach_o_data_struct *)
1731            bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct)));
1732   if (mdata == NULL)
1733     return FALSE;
1734   abfd->tdata.mach_o_data = mdata;
1735
1736   mdata->header.magic = 0;
1737   mdata->header.cputype = 0;
1738   mdata->header.cpusubtype = 0;
1739   mdata->header.filetype = 0;
1740   mdata->header.ncmds = 0;
1741   mdata->header.sizeofcmds = 0;
1742   mdata->header.flags = 0;
1743   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
1744   mdata->commands = NULL;
1745   mdata->nsymbols = 0;
1746   mdata->symbols = NULL;
1747   mdata->nsects = 0;
1748   mdata->sections = NULL;
1749   mdata->ibfd = NULL;
1750
1751   return TRUE;
1752 }
1753
1754 const bfd_target *
1755 bfd_mach_o_object_p (abfd)
1756      bfd *abfd;
1757 {
1758   struct bfd_preserve preserve;
1759   bfd_mach_o_header header;
1760
1761   preserve.marker = NULL;
1762   if (bfd_mach_o_read_header (abfd, &header) != 0)
1763     goto wrong;
1764
1765   if (! (header.byteorder == BFD_ENDIAN_BIG
1766          || header.byteorder == BFD_ENDIAN_LITTLE))
1767     {
1768       fprintf (stderr, "unknown header byte-order value 0x%lx\n",
1769                (long) header.byteorder);
1770       goto wrong;
1771     }
1772
1773   if (! ((header.byteorder == BFD_ENDIAN_BIG
1774           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
1775           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
1776          || (header.byteorder == BFD_ENDIAN_LITTLE
1777              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
1778              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
1779     goto wrong;
1780
1781   preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
1782   if (preserve.marker == NULL
1783       || !bfd_preserve_save (abfd, &preserve))
1784     goto fail;
1785
1786   if (bfd_mach_o_scan (abfd, &header,
1787                        (bfd_mach_o_data_struct *) preserve.marker) != 0)
1788     goto wrong;
1789
1790   bfd_preserve_finish (abfd, &preserve);
1791   return abfd->xvec;
1792
1793  wrong:
1794   bfd_set_error (bfd_error_wrong_format);
1795
1796  fail:
1797   if (preserve.marker != NULL)
1798     bfd_preserve_restore (abfd, &preserve);
1799   return NULL;
1800 }
1801
1802 const bfd_target *
1803 bfd_mach_o_core_p (abfd)
1804      bfd *abfd;
1805 {
1806   struct bfd_preserve preserve;
1807   bfd_mach_o_header header;
1808
1809   preserve.marker = NULL;
1810   if (bfd_mach_o_read_header (abfd, &header) != 0)
1811     goto wrong;
1812
1813   if (! (header.byteorder == BFD_ENDIAN_BIG
1814          || header.byteorder == BFD_ENDIAN_LITTLE))
1815     {
1816       fprintf (stderr, "unknown header byte-order value 0x%lx\n",
1817                (long) header.byteorder);
1818       abort ();
1819     }
1820
1821   if (! ((header.byteorder == BFD_ENDIAN_BIG
1822           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
1823           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
1824          || (header.byteorder == BFD_ENDIAN_LITTLE
1825              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
1826              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
1827     goto wrong;
1828
1829   if (header.filetype != BFD_MACH_O_MH_CORE)
1830     goto wrong;
1831
1832   preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
1833   if (preserve.marker == NULL
1834       || !bfd_preserve_save (abfd, &preserve))
1835     goto fail;
1836
1837   if (bfd_mach_o_scan (abfd, &header,
1838                        (bfd_mach_o_data_struct *) preserve.marker) != 0)
1839     goto wrong;
1840
1841   bfd_preserve_finish (abfd, &preserve);
1842   return abfd->xvec;
1843
1844  wrong:
1845   bfd_set_error (bfd_error_wrong_format);
1846
1847  fail:
1848   if (preserve.marker != NULL)
1849     bfd_preserve_restore (abfd, &preserve);
1850   return NULL;
1851 }
1852
1853 typedef struct mach_o_fat_archentry
1854 {
1855   unsigned long cputype;
1856   unsigned long cpusubtype;
1857   unsigned long offset;
1858   unsigned long size;
1859   unsigned long align;
1860   bfd *abfd;
1861 } mach_o_fat_archentry;
1862
1863 typedef struct mach_o_fat_data_struct
1864 {
1865   unsigned long magic;
1866   unsigned long nfat_arch;
1867   mach_o_fat_archentry *archentries;
1868 } mach_o_fat_data_struct;
1869
1870 const bfd_target *
1871 bfd_mach_o_archive_p (abfd)
1872      bfd *abfd;
1873 {
1874   mach_o_fat_data_struct *adata = NULL;
1875   unsigned char buf[20];
1876   unsigned long i;
1877
1878   bfd_seek (abfd, 0, SEEK_SET);
1879   if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1880     goto error;
1881
1882   adata = (mach_o_fat_data_struct *)
1883     bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
1884   if (adata == NULL)
1885     goto error;
1886
1887   adata->magic = bfd_getb32 (buf);
1888   adata->nfat_arch = bfd_getb32 (buf + 4);
1889   if (adata->magic != 0xcafebabe)
1890     goto error;
1891
1892   adata->archentries = (mach_o_fat_archentry *)
1893     bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
1894   if (adata->archentries == NULL)
1895     goto error;
1896
1897   for (i = 0; i < adata->nfat_arch; i++)
1898     {
1899       bfd_seek (abfd, 8 + 20 * i, SEEK_SET);
1900
1901       if (bfd_bread ((PTR) buf, 20, abfd) != 20)
1902         goto error;
1903       adata->archentries[i].cputype = bfd_getb32 (buf);
1904       adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
1905       adata->archentries[i].offset = bfd_getb32 (buf + 8);
1906       adata->archentries[i].size = bfd_getb32 (buf + 12);
1907       adata->archentries[i].align = bfd_getb32 (buf + 16);
1908       adata->archentries[i].abfd = NULL;
1909     }
1910
1911   abfd->tdata.mach_o_fat_data = adata;
1912   return abfd->xvec;
1913
1914  error:
1915   if (adata != NULL)
1916     bfd_release (abfd, adata);
1917   bfd_set_error (bfd_error_wrong_format);
1918   return NULL;
1919 }
1920
1921 bfd *
1922 bfd_mach_o_openr_next_archived_file (archive, prev)
1923   bfd *archive;
1924   bfd *prev;
1925 {
1926   mach_o_fat_data_struct *adata;
1927   mach_o_fat_archentry *entry = NULL;
1928   unsigned long i;
1929
1930   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
1931   BFD_ASSERT (adata != NULL);
1932
1933   /* Find index of previous entry.  */
1934   if (prev == NULL)
1935     i = 0;      /* Start at first one.  */
1936   else
1937     {
1938       for (i = 0; i < adata->nfat_arch; i++)
1939         {
1940           if (adata->archentries[i].abfd == prev)
1941             break;
1942         }
1943
1944       if (i == adata->nfat_arch)
1945         {
1946           /* Not found.  */
1947           bfd_set_error (bfd_error_bad_value);
1948           return NULL;
1949         }
1950     i++;        /* Get next entry.  */
1951   }
1952
1953   if (i >= adata->nfat_arch)
1954     {
1955       bfd_set_error (bfd_error_no_more_archived_files);
1956       return NULL;
1957     }
1958
1959   entry = &adata->archentries[i];
1960   if (entry->abfd == NULL)
1961     {
1962       bfd *nbfd = _bfd_new_bfd_contained_in (archive);
1963       char *s = NULL;
1964
1965       if (nbfd == NULL)
1966         return NULL;
1967
1968       nbfd->origin = entry->offset;
1969       s = bfd_malloc (strlen (archive->filename) + 1);
1970       if (s == NULL)
1971         return NULL;
1972       strcpy (s, archive->filename);
1973       nbfd->filename = s;
1974       nbfd->iostream = NULL;
1975       entry->abfd = nbfd;
1976     }
1977
1978   return entry->abfd;
1979 }
1980
1981 int
1982 bfd_mach_o_lookup_section (abfd, section, mcommand, msection)
1983      bfd *abfd;
1984      asection *section;
1985      bfd_mach_o_load_command **mcommand;
1986      bfd_mach_o_section **msection;
1987 {
1988   struct mach_o_data_struct *md = abfd->tdata.mach_o_data;
1989   unsigned int i, j, num;
1990
1991   bfd_mach_o_load_command *ncmd = NULL;
1992   bfd_mach_o_section *nsect = NULL;
1993
1994   BFD_ASSERT (mcommand != NULL);
1995   BFD_ASSERT (msection != NULL);
1996
1997   num = 0;
1998   for (i = 0; i < md->header.ncmds; i++)
1999     {
2000       struct bfd_mach_o_load_command *cmd = &md->commands[i];
2001       struct bfd_mach_o_segment_command *seg = NULL;
2002
2003       if (cmd->type != BFD_MACH_O_LC_SEGMENT)
2004         continue;
2005       seg = &cmd->command.segment;
2006
2007       if (seg->segment == section)
2008         {
2009           if (num == 0)
2010             ncmd = cmd;
2011           num++;
2012         }
2013
2014       for (j = 0; j < seg->nsects; j++)
2015         {
2016           struct bfd_mach_o_section *sect = &seg->sections[j];
2017
2018           if (sect->bfdsection == section)
2019             {
2020               if (num == 0)
2021                 nsect = sect;
2022               num++;
2023             }
2024         }
2025     }
2026
2027   *mcommand = ncmd;
2028   *msection = nsect;
2029   return num;
2030 }
2031
2032 int
2033 bfd_mach_o_lookup_command (abfd, type, mcommand)
2034      bfd *abfd;
2035      bfd_mach_o_load_command_type type;
2036      bfd_mach_o_load_command **mcommand;
2037 {
2038   struct mach_o_data_struct *md = NULL;
2039   bfd_mach_o_load_command *ncmd = NULL;
2040   unsigned int i, num;
2041
2042   md = abfd->tdata.mach_o_data;
2043
2044   BFD_ASSERT (md != NULL);
2045   BFD_ASSERT (mcommand != NULL);
2046
2047   num = 0;
2048   for (i = 0; i < md->header.ncmds; i++)
2049     {
2050       struct bfd_mach_o_load_command *cmd = &md->commands[i];
2051
2052       if (cmd->type != type)
2053         continue;
2054
2055       if (num == 0)
2056         ncmd = cmd;
2057       num++;
2058     }
2059
2060   *mcommand = ncmd;
2061   return num;
2062 }
2063
2064 unsigned long
2065 bfd_mach_o_stack_addr (type)
2066      enum bfd_mach_o_cpu_type type;
2067 {
2068   switch (type)
2069     {
2070     case BFD_MACH_O_CPU_TYPE_MC680x0:
2071       return 0x04000000;
2072     case BFD_MACH_O_CPU_TYPE_MC88000:
2073       return 0xffffe000;
2074     case BFD_MACH_O_CPU_TYPE_POWERPC:
2075       return 0xc0000000;
2076     case BFD_MACH_O_CPU_TYPE_I386:
2077       return 0xc0000000;
2078     case BFD_MACH_O_CPU_TYPE_SPARC:
2079       return 0xf0000000;
2080     case BFD_MACH_O_CPU_TYPE_I860:
2081       return 0;
2082     case BFD_MACH_O_CPU_TYPE_HPPA:
2083       return 0xc0000000 - 0x04000000;
2084     default:
2085       return 0;
2086     }
2087 }
2088
2089 int
2090 bfd_mach_o_core_fetch_environment (abfd, rbuf, rlen)
2091      bfd *abfd;
2092      unsigned char **rbuf;
2093      unsigned int *rlen;
2094 {
2095   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
2096   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
2097   unsigned int i = 0;
2098
2099   for (i = 0; i < mdata->header.ncmds; i++)
2100     {
2101       bfd_mach_o_load_command *cur = &mdata->commands[i];
2102       bfd_mach_o_segment_command *seg = NULL;
2103
2104       if (cur->type != BFD_MACH_O_LC_SEGMENT)
2105         continue;
2106
2107       seg = &cur->command.segment;
2108
2109       if ((seg->vmaddr + seg->vmsize) == stackaddr)
2110         {
2111           unsigned long start = seg->fileoff;
2112           unsigned long end = seg->fileoff + seg->filesize;
2113           unsigned char *buf = bfd_malloc (1024);
2114           unsigned long size = 1024;
2115
2116           for (;;)
2117             {
2118               bfd_size_type nread = 0;
2119               unsigned long offset;
2120               int found_nonnull = 0;
2121
2122               if (size > (end - start))
2123                 size = (end - start);
2124
2125               buf = bfd_realloc (buf, size);
2126
2127               bfd_seek (abfd, end - size, SEEK_SET);
2128               nread = bfd_bread (buf, size, abfd);
2129
2130               if (nread != size)
2131                 return -1;
2132
2133               for (offset = 4; offset <= size; offset += 4)
2134                 {
2135                   unsigned long val;
2136
2137                   val = *((unsigned long *) (buf + size - offset));
2138                   if (! found_nonnull)
2139                     {
2140                       if (val != 0)
2141                         found_nonnull = 1;
2142                     }
2143                   else if (val == 0x0)
2144                     {
2145                       unsigned long bottom;
2146                       unsigned long top;
2147
2148                       bottom = seg->fileoff + seg->filesize - offset;
2149                       top = seg->fileoff + seg->filesize - 4;
2150                       *rbuf = bfd_malloc (top - bottom);
2151                       *rlen = top - bottom;
2152
2153                       memcpy (*rbuf, buf + size - *rlen, *rlen);
2154                       return 0;
2155                     }
2156                 }
2157
2158               if (size == (end - start))
2159                 break;
2160
2161               size *= 2;
2162             }
2163         }
2164     }
2165
2166   return -1;
2167 }
2168
2169 char *
2170 bfd_mach_o_core_file_failing_command (abfd)
2171      bfd *abfd;
2172 {
2173   unsigned char *buf = NULL;
2174   unsigned int len = 0;
2175   int ret = -1;
2176
2177   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
2178   if (ret < 0)
2179     return NULL;
2180
2181   return buf;
2182 }
2183
2184 int
2185 bfd_mach_o_core_file_failing_signal (abfd)
2186      bfd *abfd ATTRIBUTE_UNUSED;
2187 {
2188   return 0;
2189 }
2190
2191 bfd_boolean
2192 bfd_mach_o_core_file_matches_executable_p (core_bfd, exec_bfd)
2193      bfd *core_bfd ATTRIBUTE_UNUSED;
2194      bfd *exec_bfd ATTRIBUTE_UNUSED;
2195 {
2196   return TRUE;
2197 }
2198
2199 #define TARGET_NAME mach_o_be_vec
2200 #define TARGET_STRING "mach-o-be"
2201 #define TARGET_BIG_ENDIAN 1
2202 #define TARGET_ARCHIVE 0
2203
2204 #include "mach-o-target.c"
2205
2206 #undef TARGET_NAME
2207 #undef TARGET_STRING
2208 #undef TARGET_BIG_ENDIAN
2209 #undef TARGET_ARCHIVE
2210
2211 #define TARGET_NAME mach_o_le_vec
2212 #define TARGET_STRING "mach-o-le"
2213 #define TARGET_BIG_ENDIAN 0
2214 #define TARGET_ARCHIVE 0
2215
2216 #include "mach-o-target.c"
2217
2218 #undef TARGET_NAME
2219 #undef TARGET_STRING
2220 #undef TARGET_BIG_ENDIAN
2221 #undef TARGET_ARCHIVE
2222
2223 #define TARGET_NAME mach_o_fat_vec
2224 #define TARGET_STRING "mach-o-fat"
2225 #define TARGET_BIG_ENDIAN 1
2226 #define TARGET_ARCHIVE 1
2227
2228 #include "mach-o-target.c"
2229
2230 #undef TARGET_NAME
2231 #undef TARGET_STRING
2232 #undef TARGET_BIG_ENDIAN
2233 #undef TARGET_ARCHIVE