bfd/mach-o.c

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