bfd/mach-o.c

   1 /* Mach-O support for BFD.
   2    Copyright (C) 1999-2015 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "mach-o.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "libiberty.h"
  26 #include "aout/stab_gnu.h"
  27 #include "mach-o/reloc.h"
  28 #include "mach-o/external.h"
  29 #include <ctype.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
  34 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
  35 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
  36
  37 #define FILE_ALIGN(off, algn) \
  38   (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
  39
  40 static bfd_boolean
  41 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd);
  42
  43 unsigned int
  44 bfd_mach_o_version (bfd *abfd)
  45 {
  46   bfd_mach_o_data_struct *mdata = NULL;
  47
  48   BFD_ASSERT (bfd_mach_o_valid (abfd));
  49   mdata = bfd_mach_o_get_data (abfd);
  50
  51   return mdata->header.version;
  52 }
  53
  54 bfd_boolean
  55 bfd_mach_o_valid (bfd *abfd)
  56 {
  57   if (abfd == NULL || abfd->xvec == NULL)
  58     return FALSE;
  59
  60   if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
  61     return FALSE;
  62
  63   if (bfd_mach_o_get_data (abfd) == NULL)
  64     return FALSE;
  65   return TRUE;
  66 }
  67
  68 static INLINE bfd_boolean
  69 mach_o_wide_p (bfd_mach_o_header *header)
  70 {
  71   switch (header->version)
  72     {
  73     case 1:
  74       return FALSE;
  75     case 2:
  76       return TRUE;
  77     default:
  78       BFD_FAIL ();
  79       return FALSE;
  80     }
  81 }
  82
  83 static INLINE bfd_boolean
  84 bfd_mach_o_wide_p (bfd *abfd)
  85 {
  86   return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
  87 }
  88
  89 /* Tables to translate well known Mach-O segment/section names to bfd
  90    names.  Use of canonical names (such as .text or .debug_frame) is required
  91    by gdb.  */
  92
  93 /* __TEXT Segment.  */
  94 static const mach_o_section_name_xlat text_section_names_xlat[] =
  95   {
  96     {   ".text",                                "__text",
  97         SEC_CODE | SEC_LOAD,                    BFD_MACH_O_S_REGULAR,
  98         BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS,    0},
  99     {   ".const",                               "__const",
 100         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_REGULAR,
 101         BFD_MACH_O_S_ATTR_NONE,                 0},
 102     {   ".static_const",                        "__static_const",
 103         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_REGULAR,
 104         BFD_MACH_O_S_ATTR_NONE,                 0},
 105     {   ".cstring",                             "__cstring",
 106         SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
 107                                                 BFD_MACH_O_S_CSTRING_LITERALS,
 108         BFD_MACH_O_S_ATTR_NONE,                 0},
 109     {   ".literal4",                            "__literal4",
 110         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_4BYTE_LITERALS,
 111         BFD_MACH_O_S_ATTR_NONE,                 2},
 112     {   ".literal8",                            "__literal8",
 113         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_8BYTE_LITERALS,
 114         BFD_MACH_O_S_ATTR_NONE,                 3},
 115     {   ".literal16",                           "__literal16",
 116         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_16BYTE_LITERALS,
 117         BFD_MACH_O_S_ATTR_NONE,                 4},
 118     {   ".constructor",                         "__constructor",
 119         SEC_CODE | SEC_LOAD,                    BFD_MACH_O_S_REGULAR,
 120         BFD_MACH_O_S_ATTR_NONE,                 0},
 121     {   ".destructor",                          "__destructor",
 122         SEC_CODE | SEC_LOAD,                    BFD_MACH_O_S_REGULAR,
 123         BFD_MACH_O_S_ATTR_NONE,                 0},
 124     {   ".eh_frame",                            "__eh_frame",
 125         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_COALESCED,
 126         BFD_MACH_O_S_ATTR_LIVE_SUPPORT
 127         | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
 128         | BFD_MACH_O_S_ATTR_NO_TOC,             2},
 129     { NULL, NULL, 0, 0, 0, 0}
 130   };
 131
 132 /* __DATA Segment.  */
 133 static const mach_o_section_name_xlat data_section_names_xlat[] =
 134   {
 135     {   ".data",                        "__data",
 136         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 137         BFD_MACH_O_S_ATTR_NONE,         0},
 138     {   ".bss",                         "__bss",
 139         SEC_NO_FLAGS,                   BFD_MACH_O_S_ZEROFILL,
 140         BFD_MACH_O_S_ATTR_NONE,         0},
 141     {   ".const_data",                  "__const",
 142         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 143         BFD_MACH_O_S_ATTR_NONE,         0},
 144     {   ".static_data",                 "__static_data",
 145         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 146         BFD_MACH_O_S_ATTR_NONE,         0},
 147     {   ".mod_init_func",               "__mod_init_func",
 148         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
 149         BFD_MACH_O_S_ATTR_NONE,         2},
 150     {   ".mod_term_func",               "__mod_term_func",
 151         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
 152         BFD_MACH_O_S_ATTR_NONE,         2},
 153     {   ".dyld",                        "__dyld",
 154         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 155         BFD_MACH_O_S_ATTR_NONE,         0},
 156     {   ".cfstring",                    "__cfstring",
 157         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 158         BFD_MACH_O_S_ATTR_NONE,         2},
 159     { NULL, NULL, 0, 0, 0, 0}
 160   };
 161
 162 /* __DWARF Segment.  */
 163 static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
 164   {
 165     {   ".debug_frame",                 "__debug_frame",
 166         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 167         BFD_MACH_O_S_ATTR_DEBUG,        0},
 168     {   ".debug_info",                  "__debug_info",
 169         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 170         BFD_MACH_O_S_ATTR_DEBUG,        0},
 171     {   ".debug_abbrev",                "__debug_abbrev",
 172         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 173         BFD_MACH_O_S_ATTR_DEBUG,        0},
 174     {   ".debug_aranges",               "__debug_aranges",
 175         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 176         BFD_MACH_O_S_ATTR_DEBUG,        0},
 177     {   ".debug_macinfo",               "__debug_macinfo",
 178         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 179         BFD_MACH_O_S_ATTR_DEBUG,        0},
 180     {   ".debug_line",                  "__debug_line",
 181         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 182         BFD_MACH_O_S_ATTR_DEBUG,        0},
 183     {   ".debug_loc",                   "__debug_loc",
 184         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 185         BFD_MACH_O_S_ATTR_DEBUG,        0},
 186     {   ".debug_pubnames",              "__debug_pubnames",
 187         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 188         BFD_MACH_O_S_ATTR_DEBUG,        0},
 189     {   ".debug_pubtypes",              "__debug_pubtypes",
 190         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 191         BFD_MACH_O_S_ATTR_DEBUG,        0},
 192     {   ".debug_str",                   "__debug_str",
 193         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 194         BFD_MACH_O_S_ATTR_DEBUG,        0},
 195     {   ".debug_ranges",                "__debug_ranges",
 196         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 197         BFD_MACH_O_S_ATTR_DEBUG,        0},
 198     {   ".debug_macro",                 "__debug_macro",
 199         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 200         BFD_MACH_O_S_ATTR_DEBUG,        0},
 201     {   ".debug_gdb_scripts",           "__debug_gdb_scri",
 202         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 203         BFD_MACH_O_S_ATTR_DEBUG,        0},
 204     { NULL, NULL, 0, 0, 0, 0}
 205   };
 206
 207 /* __OBJC Segment.  */
 208 static const mach_o_section_name_xlat objc_section_names_xlat[] =
 209   {
 210     {   ".objc_class",                  "__class",
 211         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 212         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 213     {   ".objc_meta_class",             "__meta_class",
 214         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 215         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 216     {   ".objc_cat_cls_meth",           "__cat_cls_meth",
 217         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 218         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 219     {   ".objc_cat_inst_meth",          "__cat_inst_meth",
 220         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 221         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 222     {   ".objc_protocol",               "__protocol",
 223         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 224         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 225     {   ".objc_string_object",          "__string_object",
 226         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 227         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 228     {   ".objc_cls_meth",               "__cls_meth",
 229         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 230         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 231     {   ".objc_inst_meth",              "__inst_meth",
 232         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 233         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 234     {   ".objc_cls_refs",               "__cls_refs",
 235         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_LITERAL_POINTERS,
 236         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 237     {   ".objc_message_refs",           "__message_refs",
 238         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_LITERAL_POINTERS,
 239         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 240     {   ".objc_symbols",                "__symbols",
 241         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 242         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 243     {   ".objc_category",               "__category",
 244         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 245         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 246     {   ".objc_class_vars",             "__class_vars",
 247         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 248         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 249     {   ".objc_instance_vars",          "__instance_vars",
 250         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 251         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 252     {   ".objc_module_info",            "__module_info",
 253         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 254         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 255     {   ".objc_selector_strs",          "__selector_strs",
 256         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_CSTRING_LITERALS,
 257         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 258     {   ".objc_image_info",             "__image_info",
 259         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 260         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 261     {   ".objc_selector_fixup",         "__sel_fixup",
 262         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 263         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 264     /* Objc V1 */
 265     {   ".objc1_class_ext",             "__class_ext",
 266         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 267         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 268     {   ".objc1_property_list",         "__property",
 269         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 270         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 271     {   ".objc1_protocol_ext",          "__protocol_ext",
 272         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 273         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 274     { NULL, NULL, 0, 0, 0, 0}
 275   };
 276
 277 static const mach_o_segment_name_xlat segsec_names_xlat[] =
 278   {
 279     { "__TEXT", text_section_names_xlat },
 280     { "__DATA", data_section_names_xlat },
 281     { "__DWARF", dwarf_section_names_xlat },
 282     { "__OBJC", objc_section_names_xlat },
 283     { NULL, NULL }
 284   };
 285
 286 static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
 287
 288 /* For both cases bfd-name => mach-o name and vice versa, the specific target
 289    is checked before the generic.  This allows a target (e.g. ppc for cstring)
 290    to override the generic definition with a more specific one.  */
 291
 292 /* Fetch the translation from a Mach-O section designation (segment, section)
 293    as a bfd short name, if one exists.  Otherwise return NULL.
 294
 295    Allow the segment and section names to be unterminated 16 byte arrays.  */
 296
 297 const mach_o_section_name_xlat *
 298 bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
 299                                        const char *sectname)
 300 {
 301   const struct mach_o_segment_name_xlat *seg;
 302   const mach_o_section_name_xlat *sec;
 303   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
 304
 305   /* First try any target-specific translations defined...  */
 306   if (bed->segsec_names_xlat)
 307     for (seg = bed->segsec_names_xlat; seg->segname; seg++)
 308       if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
 309         for (sec = seg->sections; sec->mach_o_name; sec++)
 310           if (strncmp (sec->mach_o_name, sectname,
 311                        BFD_MACH_O_SECTNAME_SIZE) == 0)
 312             return sec;
 313
 314   /* ... and then the Mach-O generic ones.  */
 315   for (seg = segsec_names_xlat; seg->segname; seg++)
 316     if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
 317       for (sec = seg->sections; sec->mach_o_name; sec++)
 318         if (strncmp (sec->mach_o_name, sectname,
 319                      BFD_MACH_O_SECTNAME_SIZE) == 0)
 320           return sec;
 321
 322   return NULL;
 323 }
 324
 325 /* If the bfd_name for this section is a 'canonical' form for which we
 326    know the Mach-O data, return the segment name and the data for the
 327    Mach-O equivalent.  Otherwise return NULL.  */
 328
 329 const mach_o_section_name_xlat *
 330 bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
 331                                       const char **segname)
 332 {
 333   const struct mach_o_segment_name_xlat *seg;
 334   const mach_o_section_name_xlat *sec;
 335   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
 336   *segname = NULL;
 337
 338   if (bfd_name[0] != '.')
 339     return NULL;
 340
 341   /* First try any target-specific translations defined...  */
 342   if (bed->segsec_names_xlat)
 343     for (seg = bed->segsec_names_xlat; seg->segname; seg++)
 344       for (sec = seg->sections; sec->bfd_name; sec++)
 345         if (strcmp (bfd_name, sec->bfd_name) == 0)
 346           {
 347             *segname = seg->segname;
 348             return sec;
 349           }
 350
 351   /* ... and then the Mach-O generic ones.  */
 352   for (seg = segsec_names_xlat; seg->segname; seg++)
 353     for (sec = seg->sections; sec->bfd_name; sec++)
 354       if (strcmp (bfd_name, sec->bfd_name) == 0)
 355         {
 356           *segname = seg->segname;
 357           return sec;
 358         }
 359
 360   return NULL;
 361 }
 362
 363 /* Convert Mach-O section name to BFD.
 364
 365    Try to use standard/canonical names, for which we have tables including
 366    default flag settings - which are returned.  Otherwise forge a new name
 367    in the form "<segmentname>.<sectionname>" this will be prefixed with
 368    LC_SEGMENT. if the segment name does not begin with an underscore.
 369
 370    SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
 371    terminated if the name length is exactly 16 bytes - but must be if the name
 372    length is less than 16 characters).  */
 373
 374 void
 375 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
 376                                         const char *secname, const char **name,
 377                                         flagword *flags)
 378 {
 379   const mach_o_section_name_xlat *xlat;
 380   char *res;
 381   unsigned int len;
 382   const char *pfx = "";
 383
 384   *name = NULL;
 385   *flags = SEC_NO_FLAGS;
 386
 387   /* First search for a canonical name...
 388      xlat will be non-null if there is an entry for segname, secname.  */
 389   xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
 390   if (xlat)
 391     {
 392       len = strlen (xlat->bfd_name);
 393       res = bfd_alloc (abfd, len + 1);
 394       if (res == NULL)
 395         return;
 396       memcpy (res, xlat->bfd_name, len+1);
 397       *name = res;
 398       *flags = xlat->bfd_flags;
 399       return;
 400     }
 401
 402   /* ... else we make up a bfd name from the segment concatenated with the
 403      section.  */
 404
 405   len = 16 + 1 + 16 + 1;
 406
 407   /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
 408      with an underscore.  */
 409   if (segname[0] != '_')
 410     {
 411       static const char seg_pfx[] = "LC_SEGMENT.";
 412
 413       pfx = seg_pfx;
 414       len += sizeof (seg_pfx) - 1;
 415     }
 416
 417   res = bfd_alloc (abfd, len);
 418   if (res == NULL)
 419     return;
 420   snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
 421   *name = res;
 422 }
 423
 424 /* Convert a bfd section name to a Mach-O segment + section name.
 425
 426    If the name is a canonical one for which we have a Darwin match
 427    return the translation table - which contains defaults for flags,
 428    type, attribute and default alignment data.
 429
 430    Otherwise, expand the bfd_name (assumed to be in the form
 431    "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL.  */
 432
 433 static const mach_o_section_name_xlat *
 434 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
 435                                            asection *sect,
 436                                            bfd_mach_o_section *section)
 437 {
 438   const mach_o_section_name_xlat *xlat;
 439   const char *name = bfd_get_section_name (abfd, sect);
 440   const char *segname;
 441   const char *dot;
 442   unsigned int len;
 443   unsigned int seglen;
 444   unsigned int seclen;
 445
 446   memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
 447   memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
 448
 449   /* See if is a canonical name ... */
 450   xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
 451   if (xlat)
 452     {
 453       strcpy (section->segname, segname);
 454       strcpy (section->sectname, xlat->mach_o_name);
 455       return xlat;
 456     }
 457
 458   /* .. else we convert our constructed one back to Mach-O.
 459      Strip LC_SEGMENT. prefix, if present.  */
 460   if (strncmp (name, "LC_SEGMENT.", 11) == 0)
 461     name += 11;
 462
 463   /* Find a dot.  */
 464   dot = strchr (name, '.');
 465   len = strlen (name);
 466
 467   /* Try to split name into segment and section names.  */
 468   if (dot && dot != name)
 469     {
 470       seglen = dot - name;
 471       seclen = len - (dot + 1 - name);
 472
 473       if (seglen <= BFD_MACH_O_SEGNAME_SIZE
 474           && seclen <= BFD_MACH_O_SECTNAME_SIZE)
 475         {
 476           memcpy (section->segname, name, seglen);
 477           section->segname[seglen] = 0;
 478           memcpy (section->sectname, dot + 1, seclen);
 479           section->sectname[seclen] = 0;
 480           return NULL;
 481         }
 482     }
 483
 484   /* The segment and section names are both missing - don't make them
 485      into dots.  */
 486   if (dot && dot == name)
 487     return NULL;
 488
 489   /* Just duplicate the name into both segment and section.  */
 490   if (len > 16)
 491     len = 16;
 492   memcpy (section->segname, name, len);
 493   section->segname[len] = 0;
 494   memcpy (section->sectname, name, len);
 495   section->sectname[len] = 0;
 496   return NULL;
 497 }
 498
 499 /* Return the size of an entry for section SEC.
 500    Must be called only for symbol pointer section and symbol stubs
 501    sections.  */
 502
 503 unsigned int
 504 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
 505 {
 506   switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 507     {
 508     case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 509     case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 510       return bfd_mach_o_wide_p (abfd) ? 8 : 4;
 511     case BFD_MACH_O_S_SYMBOL_STUBS:
 512       return sec->reserved2;
 513     default:
 514       BFD_FAIL ();
 515       return 0;
 516     }
 517 }
 518
 519 /* Return the number of indirect symbols for a section.
 520    Must be called only for symbol pointer section and symbol stubs
 521    sections.  */
 522
 523 unsigned int
 524 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
 525 {
 526   unsigned int elsz;
 527
 528   elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
 529   if (elsz == 0)
 530     return 0;
 531   else
 532     return sec->size / elsz;
 533 }
 534
 535 /* Append command CMD to ABFD.  Note that header.ncmds is not updated.  */
 536
 537 static void
 538 bfd_mach_o_append_command (bfd *abfd, bfd_mach_o_load_command *cmd)
 539 {
 540   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 541
 542   if (mdata->last_command != NULL)
 543     mdata->last_command->next = cmd;
 544   else
 545     mdata->first_command = cmd;
 546   mdata->last_command = cmd;
 547   cmd->next = NULL;
 548 }
 549
 550 /* Copy any private info we understand from the input symbol
 551    to the output symbol.  */
 552
 553 bfd_boolean
 554 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 555                                          asymbol *isymbol,
 556                                          bfd *obfd ATTRIBUTE_UNUSED,
 557                                          asymbol *osymbol)
 558 {
 559   bfd_mach_o_asymbol *os, *is;
 560
 561   os = (bfd_mach_o_asymbol *)osymbol;
 562   is = (bfd_mach_o_asymbol *)isymbol;
 563   os->n_type = is->n_type;
 564   os->n_sect = is->n_sect;
 565   os->n_desc = is->n_desc;
 566   os->symbol.udata.i = is->symbol.udata.i;
 567
 568   return TRUE;
 569 }
 570
 571 /* Copy any private info we understand from the input section
 572    to the output section.  */
 573
 574 bfd_boolean
 575 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd, asection *isection,
 576                                           bfd *obfd, asection *osection)
 577 {
 578   bfd_mach_o_section *os = bfd_mach_o_get_mach_o_section (osection);
 579   bfd_mach_o_section *is = bfd_mach_o_get_mach_o_section (isection);
 580
 581   if (ibfd->xvec->flavour != bfd_target_mach_o_flavour
 582       || obfd->xvec->flavour != bfd_target_mach_o_flavour)
 583     return TRUE;
 584
 585   BFD_ASSERT (is != NULL && os != NULL);
 586
 587   os->flags = is->flags;
 588   os->reserved1 = is->reserved1;
 589   os->reserved2 = is->reserved2;
 590   os->reserved3 = is->reserved3;
 591
 592   return TRUE;
 593 }
 594
 595 /* Copy any private info we understand from the input bfd
 596    to the output bfd.  */
 597
 598 bfd_boolean
 599 bfd_mach_o_bfd_copy_private_header_data (bfd *ibfd, bfd *obfd)
 600 {
 601   bfd_mach_o_data_struct *imdata;
 602   bfd_mach_o_data_struct *omdata;
 603   bfd_mach_o_load_command *icmd;
 604
 605   if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
 606       || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
 607     return TRUE;
 608
 609   BFD_ASSERT (bfd_mach_o_valid (ibfd));
 610   BFD_ASSERT (bfd_mach_o_valid (obfd));
 611
 612   imdata = bfd_mach_o_get_data (ibfd);
 613   omdata = bfd_mach_o_get_data (obfd);
 614
 615   /* Copy header flags.  */
 616   omdata->header.flags = imdata->header.flags;
 617
 618   /* Copy commands.  */
 619   for (icmd = imdata->first_command; icmd != NULL; icmd = icmd->next)
 620     {
 621       bfd_mach_o_load_command *ocmd;
 622
 623       switch (icmd->type)
 624         {
 625         case BFD_MACH_O_LC_LOAD_DYLIB:
 626         case BFD_MACH_O_LC_LOAD_DYLINKER:
 627         case BFD_MACH_O_LC_DYLD_INFO:
 628           /* Command is copied.  */
 629           ocmd = bfd_alloc (obfd, sizeof (bfd_mach_o_load_command));
 630           if (ocmd == NULL)
 631             return FALSE;
 632
 633           /* Copy common fields.  */
 634           ocmd->type = icmd->type;
 635           ocmd->type_required = icmd->type_required;
 636           ocmd->offset = 0;
 637           ocmd->len = icmd->len;
 638           break;
 639
 640         default:
 641           /* Command is not copied.  */
 642           continue;
 643           break;
 644         }
 645
 646       switch (icmd->type)
 647         {
 648         case BFD_MACH_O_LC_LOAD_DYLIB:
 649           {
 650             bfd_mach_o_dylib_command *idy = &icmd->command.dylib;
 651             bfd_mach_o_dylib_command *ody = &ocmd->command.dylib;
 652
 653             ody->name_offset = idy->name_offset;
 654             ody->timestamp = idy->timestamp;
 655             ody->current_version = idy->current_version;
 656             ody->compatibility_version = idy->compatibility_version;
 657             ody->name_str = idy->name_str;
 658           }
 659           break;
 660
 661         case BFD_MACH_O_LC_LOAD_DYLINKER:
 662           {
 663             bfd_mach_o_dylinker_command *idy = &icmd->command.dylinker;
 664             bfd_mach_o_dylinker_command *ody = &ocmd->command.dylinker;
 665
 666             ody->name_offset = idy->name_offset;
 667             ody->name_str = idy->name_str;
 668           }
 669           break;
 670
 671         case BFD_MACH_O_LC_DYLD_INFO:
 672           {
 673             bfd_mach_o_dyld_info_command *idy = &icmd->command.dyld_info;
 674             bfd_mach_o_dyld_info_command *ody = &ocmd->command.dyld_info;
 675
 676             if (bfd_mach_o_read_dyld_content (ibfd, idy))
 677               {
 678                 ody->rebase_size = idy->rebase_size;
 679                 ody->rebase_content = idy->rebase_content;
 680
 681                 ody->bind_size = idy->bind_size;
 682                 ody->bind_content = idy->bind_content;
 683
 684                 ody->weak_bind_size = idy->weak_bind_size;
 685                 ody->weak_bind_content = idy->weak_bind_content;
 686
 687                 ody->lazy_bind_size = idy->lazy_bind_size;
 688                 ody->lazy_bind_content = idy->lazy_bind_content;
 689
 690                 ody->export_size = idy->export_size;
 691                 ody->export_content = idy->export_content;
 692               }
 693             /* PR 17512L: file: 730e492d.  */
 694             else
 695               {
 696                 ody->rebase_size =
 697                   ody->bind_size =
 698                   ody->weak_bind_size =
 699                   ody->lazy_bind_size =
 700                   ody->export_size = 0;
 701                 ody->rebase_content =
 702                   ody->bind_content =
 703                   ody->weak_bind_content =
 704                   ody->lazy_bind_content =
 705                   ody->export_content = NULL;
 706               }
 707           }
 708           break;
 709
 710         default:
 711           /* That command should be handled.  */
 712           abort ();
 713         }
 714
 715       /* Insert command.  */
 716       bfd_mach_o_append_command (obfd, ocmd);
 717     }
 718
 719   return TRUE;
 720 }
 721
 722 /* This allows us to set up to 32 bits of flags (unless we invent some
 723    fiendish scheme to subdivide).  For now, we'll just set the file flags
 724    without error checking - just overwrite.  */
 725
 726 bfd_boolean
 727 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
 728 {
 729   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 730
 731   if (!mdata)
 732     return FALSE;
 733
 734   mdata->header.flags = flags;
 735   return TRUE;
 736 }
 737
 738 /* Count the total number of symbols.  */
 739
 740 static long
 741 bfd_mach_o_count_symbols (bfd *abfd)
 742 {
 743   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 744
 745   if (mdata->symtab == NULL)
 746     return 0;
 747   return mdata->symtab->nsyms;
 748 }
 749
 750 long
 751 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
 752 {
 753   long nsyms = bfd_mach_o_count_symbols (abfd);
 754
 755   return ((nsyms + 1) * sizeof (asymbol *));
 756 }
 757
 758 long
 759 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 760 {
 761   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 762   long nsyms = bfd_mach_o_count_symbols (abfd);
 763   bfd_mach_o_symtab_command *sym = mdata->symtab;
 764   unsigned long j;
 765
 766   if (nsyms < 0)
 767     return nsyms;
 768
 769   if (nsyms == 0)
 770     {
 771       /* Do not try to read symbols if there are none.  */
 772       alocation[0] = NULL;
 773       return 0;
 774     }
 775
 776   if (!bfd_mach_o_read_symtab_symbols (abfd))
 777     {
 778       (*_bfd_error_handler)
 779         (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
 780       return 0;
 781     }
 782
 783   BFD_ASSERT (sym->symbols != NULL);
 784
 785   for (j = 0; j < sym->nsyms; j++)
 786     alocation[j] = &sym->symbols[j].symbol;
 787
 788   alocation[j] = NULL;
 789
 790   return nsyms;
 791 }
 792
 793 /* Create synthetic symbols for indirect symbols.  */
 794
 795 long
 796 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
 797                                  long symcount ATTRIBUTE_UNUSED,
 798                                  asymbol **syms ATTRIBUTE_UNUSED,
 799                                  long dynsymcount ATTRIBUTE_UNUSED,
 800                                  asymbol **dynsyms ATTRIBUTE_UNUSED,
 801                                  asymbol **ret)
 802 {
 803   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 804   bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
 805   bfd_mach_o_symtab_command *symtab = mdata->symtab;
 806   asymbol *s;
 807   char * s_start;
 808   char * s_end;
 809   unsigned long count, i, j, n;
 810   size_t size;
 811   char *names;
 812   char *nul_name;
 813   const char stub [] = "$stub";
 814
 815   *ret = NULL;
 816
 817   /* Stop now if no symbols or no indirect symbols.  */
 818   if (dysymtab == NULL || dysymtab->nindirectsyms == 0
 819       || symtab == NULL || symtab->symbols == NULL)
 820     return 0;
 821
 822   /* We need to allocate a bfd symbol for every indirect symbol and to
 823      allocate the memory for its name.  */
 824   count = dysymtab->nindirectsyms;
 825   size = count * sizeof (asymbol) + 1;
 826
 827   for (j = 0; j < count; j++)
 828     {
 829       const char * strng;
 830       unsigned int isym = dysymtab->indirect_syms[j];
 831
 832       /* Some indirect symbols are anonymous.  */
 833       if (isym < symtab->nsyms && (strng = symtab->symbols[isym].symbol.name))
 834         /* PR 17512: file: f5b8eeba.  */
 835         size += strnlen (strng, symtab->strsize - (strng - symtab->strtab)) + sizeof (stub);
 836     }
 837
 838   s_start = bfd_malloc (size);
 839   s = *ret = (asymbol *) s_start;
 840   if (s == NULL)
 841     return -1;
 842   names = (char *) (s + count);
 843   nul_name = names;
 844   *names++ = 0;
 845   s_end = s_start + size;
 846
 847   n = 0;
 848   for (i = 0; i < mdata->nsects; i++)
 849     {
 850       bfd_mach_o_section *sec = mdata->sections[i];
 851       unsigned int first, last;
 852       bfd_vma addr;
 853       bfd_vma entry_size;
 854
 855       switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 856         {
 857         case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 858         case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 859         case BFD_MACH_O_S_SYMBOL_STUBS:
 860           /* Only these sections have indirect symbols.  */
 861           first = sec->reserved1;
 862           last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
 863           addr = sec->addr;
 864           entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
 865
 866           /* PR 17512: file: 08e15eec.  */
 867           if (first >= count || last >= count || first > last)
 868             goto fail;
 869
 870           for (j = first; j < last; j++)
 871             {
 872               unsigned int isym = dysymtab->indirect_syms[j];
 873
 874               /* PR 17512: file: 04d64d9b.  */
 875               if (((char *) s) + sizeof (* s) > s_end)
 876                 goto fail;
 877
 878               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
 879               s->section = sec->bfdsection;
 880               s->value = addr - sec->addr;
 881               s->udata.p = NULL;
 882
 883               if (isym < symtab->nsyms
 884                   && symtab->symbols[isym].symbol.name)
 885                 {
 886                   const char *sym = symtab->symbols[isym].symbol.name;
 887                   size_t len;
 888
 889                   s->name = names;
 890                   len = strlen (sym);
 891                   /* PR 17512: file: 47dfd4d2.  */
 892                   if (names + len >= s_end)
 893                     goto fail;
 894                   memcpy (names, sym, len);
 895                   names += len;
 896                   /* PR 17512: file: 18f340a4.  */
 897                   if (names + sizeof (stub) >= s_end)
 898                     goto fail;
 899                   memcpy (names, stub, sizeof (stub));
 900                   names += sizeof (stub);
 901                 }
 902               else
 903                 s->name = nul_name;
 904
 905               addr += entry_size;
 906               s++;
 907               n++;
 908             }
 909           break;
 910         default:
 911           break;
 912         }
 913     }
 914
 915   return n;
 916
 917  fail:
 918   free (s_start);
 919   * ret = NULL;
 920   return -1;
 921 }
 922
 923 void
 924 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 925                             asymbol *symbol,
 926                             symbol_info *ret)
 927 {
 928   bfd_symbol_info (symbol, ret);
 929 }
 930
 931 void
 932 bfd_mach_o_print_symbol (bfd *abfd,
 933                          void * afile,
 934                          asymbol *symbol,
 935                          bfd_print_symbol_type how)
 936 {
 937   FILE *file = (FILE *) afile;
 938   const char *name;
 939   bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
 940
 941   switch (how)
 942     {
 943     case bfd_print_symbol_name:
 944       fprintf (file, "%s", symbol->name);
 945       break;
 946     default:
 947       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 948       if (asym->n_type & BFD_MACH_O_N_STAB)
 949         name = bfd_get_stab_name (asym->n_type);
 950       else
 951         switch (asym->n_type & BFD_MACH_O_N_TYPE)
 952           {
 953           case BFD_MACH_O_N_UNDF:
 954             if (symbol->value == 0)
 955               name = "UND";
 956             else
 957               name = "COM";
 958             break;
 959           case BFD_MACH_O_N_ABS:
 960             name = "ABS";
 961             break;
 962           case BFD_MACH_O_N_INDR:
 963             name = "INDR";
 964             break;
 965           case BFD_MACH_O_N_PBUD:
 966             name = "PBUD";
 967             break;
 968           case BFD_MACH_O_N_SECT:
 969             name = "SECT";
 970             break;
 971           default:
 972             name = "???";
 973             break;
 974           }
 975       if (name == NULL)
 976         name = "";
 977       fprintf (file, " %02x %-6s %02x %04x",
 978                asym->n_type, name, asym->n_sect, asym->n_desc);
 979       if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
 980           && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
 981         fprintf (file, " [%s]", symbol->section->name);
 982       fprintf (file, " %s", symbol->name);
 983     }
 984 }
 985
 986 static void
 987 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
 988                                  bfd_mach_o_cpu_subtype msubtype,
 989                                  enum bfd_architecture *type,
 990                                  unsigned long *subtype)
 991 {
 992   *subtype = bfd_arch_unknown;
 993
 994   switch (mtype)
 995     {
 996     case BFD_MACH_O_CPU_TYPE_VAX:
 997       *type = bfd_arch_vax;
 998       break;
 999     case BFD_MACH_O_CPU_TYPE_MC680x0:
1000       *type = bfd_arch_m68k;
1001       break;
1002     case BFD_MACH_O_CPU_TYPE_I386:
1003       *type = bfd_arch_i386;
1004       *subtype = bfd_mach_i386_i386;
1005       break;
1006     case BFD_MACH_O_CPU_TYPE_X86_64:
1007       *type = bfd_arch_i386;
1008       *subtype = bfd_mach_x86_64;
1009       break;
1010     case BFD_MACH_O_CPU_TYPE_MIPS:
1011       *type = bfd_arch_mips;
1012       break;
1013     case BFD_MACH_O_CPU_TYPE_MC98000:
1014       *type = bfd_arch_m98k;
1015       break;
1016     case BFD_MACH_O_CPU_TYPE_HPPA:
1017       *type = bfd_arch_hppa;
1018       break;
1019     case BFD_MACH_O_CPU_TYPE_ARM:
1020       *type = bfd_arch_arm;
1021       switch (msubtype)
1022         {
1023         case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
1024           *subtype = bfd_mach_arm_4T;
1025           break;
1026         case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
1027           *subtype = bfd_mach_arm_4T;   /* Best fit ?  */
1028           break;
1029         case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
1030           *subtype = bfd_mach_arm_5TE;
1031           break;
1032         case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
1033           *subtype = bfd_mach_arm_XScale;
1034           break;
1035         case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
1036           *subtype = bfd_mach_arm_5TE;  /* Best fit ?  */
1037           break;
1038         case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
1039         default:
1040           break;
1041         }
1042       break;
1043     case BFD_MACH_O_CPU_TYPE_MC88000:
1044       *type = bfd_arch_m88k;
1045       break;
1046     case BFD_MACH_O_CPU_TYPE_SPARC:
1047       *type = bfd_arch_sparc;
1048       *subtype = bfd_mach_sparc;
1049       break;
1050     case BFD_MACH_O_CPU_TYPE_I860:
1051       *type = bfd_arch_i860;
1052       break;
1053     case BFD_MACH_O_CPU_TYPE_ALPHA:
1054       *type = bfd_arch_alpha;
1055       break;
1056     case BFD_MACH_O_CPU_TYPE_POWERPC:
1057       *type = bfd_arch_powerpc;
1058       *subtype = bfd_mach_ppc;
1059       break;
1060     case BFD_MACH_O_CPU_TYPE_POWERPC_64:
1061       *type = bfd_arch_powerpc;
1062       *subtype = bfd_mach_ppc64;
1063       break;
1064     case BFD_MACH_O_CPU_TYPE_ARM64:
1065       *type = bfd_arch_aarch64;
1066       *subtype = bfd_mach_aarch64;
1067       break;
1068     default:
1069       *type = bfd_arch_unknown;
1070       break;
1071     }
1072 }
1073
1074 /* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4.  Return the
1075    number of bytes written or -1 in case of error.  */
1076
1077 static int
1078 bfd_mach_o_pad4 (bfd *abfd, unsigned int len)
1079 {
1080   if (len % 4 != 0)
1081     {
1082       char pad[4] = {0,0,0,0};
1083       unsigned int padlen = 4 - (len % 4);
1084
1085       if (bfd_bwrite (pad, padlen, abfd) != padlen)
1086         return -1;
1087
1088       return padlen;
1089     }
1090   else
1091     return 0;
1092 }
1093
1094 /* Likewise, but for a command.  */
1095
1096 static int
1097 bfd_mach_o_pad_command (bfd *abfd, unsigned int len)
1098 {
1099   unsigned int align = bfd_mach_o_wide_p (abfd) ? 8 : 4;
1100
1101   if (len % align != 0)
1102     {
1103       char pad[8] = {0};
1104       unsigned int padlen = align - (len % align);
1105
1106       if (bfd_bwrite (pad, padlen, abfd) != padlen)
1107         return -1;
1108
1109       return padlen;
1110     }
1111   else
1112     return 0;
1113 }
1114
1115 static bfd_boolean
1116 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
1117 {
1118   struct mach_o_header_external raw;
1119   unsigned int size;
1120
1121   size = mach_o_wide_p (header) ?
1122     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1123
1124   bfd_h_put_32 (abfd, header->magic, raw.magic);
1125   bfd_h_put_32 (abfd, header->cputype, raw.cputype);
1126   bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
1127   bfd_h_put_32 (abfd, header->filetype, raw.filetype);
1128   bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
1129   bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
1130   bfd_h_put_32 (abfd, header->flags, raw.flags);
1131
1132   if (mach_o_wide_p (header))
1133     bfd_h_put_32 (abfd, header->reserved, raw.reserved);
1134
1135   if (bfd_seek (abfd, 0, SEEK_SET) != 0
1136       || bfd_bwrite (&raw, size, abfd) != size)
1137     return FALSE;
1138
1139   return TRUE;
1140 }
1141
1142 static bfd_boolean
1143 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
1144 {
1145   bfd_mach_o_thread_command *cmd = &command->command.thread;
1146   unsigned int i;
1147   struct mach_o_thread_command_external raw;
1148   unsigned int offset;
1149
1150   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1151               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1152
1153   offset = BFD_MACH_O_LC_SIZE;
1154   for (i = 0; i < cmd->nflavours; i++)
1155     {
1156       BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
1157       BFD_ASSERT (cmd->flavours[i].offset ==
1158                   (command->offset + offset + BFD_MACH_O_LC_SIZE));
1159
1160       bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
1161       bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
1162
1163       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
1164           || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1165         return FALSE;
1166
1167       offset += cmd->flavours[i].size + sizeof (raw);
1168     }
1169
1170   return TRUE;
1171 }
1172
1173 static bfd_boolean
1174 bfd_mach_o_write_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
1175 {
1176   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1177   struct mach_o_str_command_external raw;
1178   unsigned int namelen;
1179
1180   bfd_h_put_32 (abfd, cmd->name_offset, raw.str);
1181
1182   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1183       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1184     return FALSE;
1185
1186   namelen = strlen (cmd->name_str) + 1;
1187   if (bfd_bwrite (cmd->name_str, namelen, abfd) != namelen)
1188     return FALSE;
1189
1190   if (bfd_mach_o_pad_command (abfd, namelen) < 0)
1191     return FALSE;
1192
1193   return TRUE;
1194 }
1195
1196 static bfd_boolean
1197 bfd_mach_o_write_dylib (bfd *abfd, bfd_mach_o_load_command *command)
1198 {
1199   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1200   struct mach_o_dylib_command_external raw;
1201   unsigned int namelen;
1202
1203   bfd_h_put_32 (abfd, cmd->name_offset, raw.name);
1204   bfd_h_put_32 (abfd, cmd->timestamp, raw.timestamp);
1205   bfd_h_put_32 (abfd, cmd->current_version, raw.current_version);
1206   bfd_h_put_32 (abfd, cmd->compatibility_version, raw.compatibility_version);
1207
1208   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1209       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1210     return FALSE;
1211
1212   namelen = strlen (cmd->name_str) + 1;
1213   if (bfd_bwrite (cmd->name_str, namelen, abfd) != namelen)
1214     return FALSE;
1215
1216   if (bfd_mach_o_pad_command (abfd, namelen) < 0)
1217     return FALSE;
1218
1219   return TRUE;
1220 }
1221
1222 static bfd_boolean
1223 bfd_mach_o_write_main (bfd *abfd, bfd_mach_o_load_command *command)
1224 {
1225   bfd_mach_o_main_command *cmd = &command->command.main;
1226   struct mach_o_entry_point_command_external raw;
1227
1228   bfd_h_put_64 (abfd, cmd->entryoff, raw.entryoff);
1229   bfd_h_put_64 (abfd, cmd->stacksize, raw.stacksize);
1230
1231   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1232       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1233     return FALSE;
1234
1235   return TRUE;
1236 }
1237
1238 static bfd_boolean
1239 bfd_mach_o_write_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
1240 {
1241   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
1242   struct mach_o_dyld_info_command_external raw;
1243
1244   bfd_h_put_32 (abfd, cmd->rebase_off, raw.rebase_off);
1245   bfd_h_put_32 (abfd, cmd->rebase_size, raw.rebase_size);
1246   bfd_h_put_32 (abfd, cmd->bind_off, raw.bind_off);
1247   bfd_h_put_32 (abfd, cmd->bind_size, raw.bind_size);
1248   bfd_h_put_32 (abfd, cmd->weak_bind_off, raw.weak_bind_off);
1249   bfd_h_put_32 (abfd, cmd->weak_bind_size, raw.weak_bind_size);
1250   bfd_h_put_32 (abfd, cmd->lazy_bind_off, raw.lazy_bind_off);
1251   bfd_h_put_32 (abfd, cmd->lazy_bind_size, raw.lazy_bind_size);
1252   bfd_h_put_32 (abfd, cmd->export_off, raw.export_off);
1253   bfd_h_put_32 (abfd, cmd->export_size, raw.export_size);
1254
1255   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1256       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1257     return FALSE;
1258
1259   if (cmd->rebase_size != 0)
1260     if (bfd_seek (abfd, cmd->rebase_off, SEEK_SET) != 0
1261         || (bfd_bwrite (cmd->rebase_content, cmd->rebase_size, abfd) !=
1262             cmd->rebase_size))
1263       return FALSE;
1264
1265   if (cmd->bind_size != 0)
1266     if (bfd_seek (abfd, cmd->bind_off, SEEK_SET) != 0
1267         || (bfd_bwrite (cmd->bind_content, cmd->bind_size, abfd) !=
1268             cmd->bind_size))
1269       return FALSE;
1270
1271   if (cmd->weak_bind_size != 0)
1272     if (bfd_seek (abfd, cmd->weak_bind_off, SEEK_SET) != 0
1273         || (bfd_bwrite (cmd->weak_bind_content, cmd->weak_bind_size, abfd) !=
1274             cmd->weak_bind_size))
1275       return FALSE;
1276
1277   if (cmd->lazy_bind_size != 0)
1278     if (bfd_seek (abfd, cmd->lazy_bind_off, SEEK_SET) != 0
1279         || (bfd_bwrite (cmd->lazy_bind_content, cmd->lazy_bind_size, abfd) !=
1280             cmd->lazy_bind_size))
1281       return FALSE;
1282
1283   if (cmd->export_size != 0)
1284     if (bfd_seek (abfd, cmd->export_off, SEEK_SET) != 0
1285         || (bfd_bwrite (cmd->export_content, cmd->export_size, abfd) !=
1286             cmd->export_size))
1287       return FALSE;
1288
1289   return TRUE;
1290 }
1291
1292 long
1293 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
1294                                   asection *asect)
1295 {
1296   return (asect->reloc_count + 1) * sizeof (arelent *);
1297 }
1298
1299 /* In addition to the need to byte-swap the symbol number, the bit positions
1300    of the fields in the relocation information vary per target endian-ness.  */
1301
1302 static void
1303 bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
1304                                        unsigned char *fields)
1305 {
1306   unsigned char info = fields[3];
1307
1308   if (bfd_big_endian (abfd))
1309     {
1310       rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
1311       rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1312       rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
1313       rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
1314                       & BFD_MACH_O_LENGTH_MASK;
1315       rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
1316     }
1317   else
1318     {
1319       rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1320       rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1321       rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1322       rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1323                       & BFD_MACH_O_LENGTH_MASK;
1324       rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1325     }
1326 }
1327
1328 static int
1329 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
1330                                    struct mach_o_reloc_info_external *raw,
1331                                    arelent *res, asymbol **syms)
1332 {
1333   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1334   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1335   bfd_mach_o_reloc_info reloc;
1336   bfd_vma addr;
1337   asymbol **sym;
1338
1339   addr = bfd_get_32 (abfd, raw->r_address);
1340   res->sym_ptr_ptr = NULL;
1341   res->addend = 0;
1342
1343   if (addr & BFD_MACH_O_SR_SCATTERED)
1344     {
1345       unsigned int j;
1346       bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1347
1348       /* Scattered relocation, can't be extern. */
1349       reloc.r_scattered = 1;
1350       reloc.r_extern = 0;
1351
1352       /*   Extract section and offset from r_value (symnum).  */
1353       reloc.r_value = symnum;
1354       /* FIXME: This breaks when a symbol in a reloc exactly follows the
1355          end of the data for the section (e.g. in a calculation of section
1356          data length).  At present, the symbol will end up associated with
1357          the following section or, if it falls within alignment padding, as
1358          null - which will assert later.  */
1359       for (j = 0; j < mdata->nsects; j++)
1360         {
1361           bfd_mach_o_section *sect = mdata->sections[j];
1362           if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1363             {
1364               res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1365               res->addend = symnum - sect->addr;
1366               break;
1367             }
1368         }
1369
1370       /* Extract the info and address fields from r_address.  */
1371       reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1372       reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1373       reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1374       reloc.r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1375       res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1376     }
1377   else
1378     {
1379       unsigned int num;
1380
1381       /* Non-scattered relocation.  */
1382       reloc.r_scattered = 0;
1383
1384       /* The value and info fields have to be extracted dependent on target
1385          endian-ness.  */
1386       bfd_mach_o_swap_in_non_scattered_reloc (abfd, &reloc, raw->r_symbolnum);
1387       num = reloc.r_value;
1388
1389       if (reloc.r_extern)
1390         {
1391           /* PR 17512: file: 8396-1185-0.004.  */
1392           if (num >= (unsigned) bfd_mach_o_count_symbols (abfd))
1393             sym = bfd_und_section_ptr->symbol_ptr_ptr;
1394           else if (syms == NULL)
1395             sym = bfd_und_section_ptr->symbol_ptr_ptr;
1396           else
1397             /* An external symbol number.  */
1398             sym = syms + num;
1399         }
1400       else if (num == 0x00ffffff || num == 0)
1401         {
1402           /* The 'symnum' in a non-scattered PAIR is 0x00ffffff.  But as this
1403              is generic code, we don't know wether this is really a PAIR.
1404              This value is almost certainly not a valid section number, hence
1405              this specific case to avoid an assertion failure.
1406              Target specific swap_reloc_in routine should adjust that.  */
1407           sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1408         }
1409       else
1410         {
1411           /* PR 17512: file: 006-2964-0.004.  */
1412           if (num > mdata->nsects)
1413             return -1;
1414
1415           /* A section number.  */
1416           sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1417           /* For a symbol defined in section S, the addend (stored in the
1418              binary) contains the address of the section.  To comply with
1419              bfd convention, subtract the section address.
1420              Use the address from the header, so that the user can modify
1421              the vma of the section.  */
1422           res->addend = -mdata->sections[num - 1]->addr;
1423         }
1424       /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1425          in the lower 16bits of the address value.  So we have to find the
1426          'symbol' from the preceding reloc.  We do this even though the
1427          section symbol is probably not needed here, because NULL symbol
1428          values cause an assert in generic BFD code.  This must be done in
1429          the PPC swap_reloc_in routine.  */
1430       res->sym_ptr_ptr = sym;
1431
1432       /* The 'address' is just r_address.
1433          ??? maybe this should be masked with  0xffffff for safety.  */
1434       res->address = addr;
1435       reloc.r_address = addr;
1436     }
1437
1438   /* We have set up a reloc with all the information present, so the swapper
1439      can modify address, value and addend fields, if necessary, to convey
1440      information in the generic BFD reloc that is mach-o specific.  */
1441
1442   if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1443     return -1;
1444
1445   return 0;
1446 }
1447
1448 static int
1449 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1450                                 unsigned long count,
1451                                 arelent *res, asymbol **syms)
1452 {
1453   unsigned long i;
1454   struct mach_o_reloc_info_external *native_relocs;
1455   bfd_size_type native_size;
1456
1457   /* Allocate and read relocs.  */
1458   native_size = count * BFD_MACH_O_RELENT_SIZE;
1459
1460   /* PR 17512: file: 09477b57.  */
1461   if (native_size < count)
1462     return -1;
1463
1464   native_relocs =
1465     (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1466   if (native_relocs == NULL)
1467     return -1;
1468
1469   if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1470       || bfd_bread (native_relocs, native_size, abfd) != native_size)
1471     goto err;
1472
1473   for (i = 0; i < count; i++)
1474     {
1475       if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1476                                              &res[i], syms) < 0)
1477         goto err;
1478     }
1479   free (native_relocs);
1480   return i;
1481  err:
1482   free (native_relocs);
1483   return -1;
1484 }
1485
1486 long
1487 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1488                                arelent **rels, asymbol **syms)
1489 {
1490   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1491   unsigned long i;
1492   arelent *res;
1493
1494   if (asect->reloc_count == 0)
1495     return 0;
1496
1497   /* No need to go further if we don't know how to read relocs.  */
1498   if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1499     return 0;
1500
1501   if (asect->relocation == NULL)
1502     {
1503       if (asect->reloc_count * sizeof (arelent) < asect->reloc_count)
1504         return -1;
1505       res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1506       if (res == NULL)
1507         return -1;
1508
1509       if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1510                                           asect->reloc_count, res, syms) < 0)
1511         {
1512           free (res);
1513           return -1;
1514         }
1515       asect->relocation = res;
1516     }
1517
1518   res = asect->relocation;
1519   for (i = 0; i < asect->reloc_count; i++)
1520     rels[i] = &res[i];
1521   rels[i] = NULL;
1522
1523   return i;
1524 }
1525
1526 long
1527 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1528 {
1529   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1530
1531   if (mdata->dysymtab == NULL)
1532     return 1;
1533   return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1534     * sizeof (arelent *);
1535 }
1536
1537 long
1538 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1539                                        struct bfd_symbol **syms)
1540 {
1541   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1542   bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1543   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1544   unsigned long i;
1545   arelent *res;
1546
1547   if (dysymtab == NULL)
1548     return 0;
1549   if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1550     return 0;
1551
1552   /* No need to go further if we don't know how to read relocs.  */
1553   if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1554     return 0;
1555
1556   if (mdata->dyn_reloc_cache == NULL)
1557     {
1558       if ((dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent)
1559           < (dysymtab->nextrel + dysymtab->nlocrel))
1560         return -1;
1561
1562       res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1563                         * sizeof (arelent));
1564       if (res == NULL)
1565         return -1;
1566
1567       if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1568                                           dysymtab->nextrel, res, syms) < 0)
1569         {
1570           free (res);
1571           return -1;
1572         }
1573
1574       if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1575                                           dysymtab->nlocrel,
1576                                           res + dysymtab->nextrel, syms) < 0)
1577         {
1578           free (res);
1579           return -1;
1580         }
1581
1582       mdata->dyn_reloc_cache = res;
1583     }
1584
1585   res = mdata->dyn_reloc_cache;
1586   for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1587     rels[i] = &res[i];
1588   rels[i] = NULL;
1589   return i;
1590 }
1591
1592 /* In addition to the need to byte-swap the symbol number, the bit positions
1593    of the fields in the relocation information vary per target endian-ness.  */
1594
1595 static void
1596 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1597                                        bfd_mach_o_reloc_info *rel)
1598 {
1599   unsigned char info = 0;
1600
1601   BFD_ASSERT (rel->r_type <= 15);
1602   BFD_ASSERT (rel->r_length <= 3);
1603
1604   if (bfd_big_endian (abfd))
1605     {
1606       fields[0] = (rel->r_value >> 16) & 0xff;
1607       fields[1] = (rel->r_value >> 8) & 0xff;
1608       fields[2] = rel->r_value & 0xff;
1609       info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1610       info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1611       info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1612       info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1613     }
1614   else
1615     {
1616       fields[2] = (rel->r_value >> 16) & 0xff;
1617       fields[1] = (rel->r_value >> 8) & 0xff;
1618       fields[0] = rel->r_value & 0xff;
1619       info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1620       info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1621       info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1622       info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1623     }
1624   fields[3] = info;
1625 }
1626
1627 static bfd_boolean
1628 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1629 {
1630   unsigned int i;
1631   arelent **entries;
1632   asection *sec;
1633   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1634
1635   sec = section->bfdsection;
1636   if (sec->reloc_count == 0)
1637     return TRUE;
1638
1639   if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1640     return TRUE;
1641
1642   if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1643     return FALSE;
1644
1645   /* Convert and write.  */
1646   entries = section->bfdsection->orelocation;
1647   for (i = 0; i < section->nreloc; i++)
1648     {
1649       arelent *rel = entries[i];
1650       struct mach_o_reloc_info_external raw;
1651       bfd_mach_o_reloc_info info, *pinfo = &info;
1652
1653       /* Convert relocation to an intermediate representation.  */
1654       if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1655         return FALSE;
1656
1657       /* Lower the relocation info.  */
1658       if (pinfo->r_scattered)
1659         {
1660           unsigned long v;
1661
1662           v = BFD_MACH_O_SR_SCATTERED
1663             | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1664             | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
1665             | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
1666             | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
1667           /* Note: scattered relocs have field in reverse order...  */
1668           bfd_put_32 (abfd, v, raw.r_address);
1669           bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1670         }
1671       else
1672         {
1673           bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1674           bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1675                                                    pinfo);
1676         }
1677
1678       if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1679           != BFD_MACH_O_RELENT_SIZE)
1680         return FALSE;
1681     }
1682   return TRUE;
1683 }
1684
1685 static bfd_boolean
1686 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1687 {
1688   struct mach_o_section_32_external raw;
1689
1690   memcpy (raw.sectname, section->sectname, 16);
1691   memcpy (raw.segname, section->segname, 16);
1692   bfd_h_put_32 (abfd, section->addr, raw.addr);
1693   bfd_h_put_32 (abfd, section->size, raw.size);
1694   bfd_h_put_32 (abfd, section->offset, raw.offset);
1695   bfd_h_put_32 (abfd, section->align, raw.align);
1696   bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1697   bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1698   bfd_h_put_32 (abfd, section->flags, raw.flags);
1699   bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1700   bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1701
1702   if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1703       != BFD_MACH_O_SECTION_SIZE)
1704     return FALSE;
1705
1706   return TRUE;
1707 }
1708
1709 static bfd_boolean
1710 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1711 {
1712   struct mach_o_section_64_external raw;
1713
1714   memcpy (raw.sectname, section->sectname, 16);
1715   memcpy (raw.segname, section->segname, 16);
1716   bfd_h_put_64 (abfd, section->addr, raw.addr);
1717   bfd_h_put_64 (abfd, section->size, raw.size);
1718   bfd_h_put_32 (abfd, section->offset, raw.offset);
1719   bfd_h_put_32 (abfd, section->align, raw.align);
1720   bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1721   bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1722   bfd_h_put_32 (abfd, section->flags, raw.flags);
1723   bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1724   bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1725   bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1726
1727   if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1728       != BFD_MACH_O_SECTION_64_SIZE)
1729     return FALSE;
1730
1731   return TRUE;
1732 }
1733
1734 static bfd_boolean
1735 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1736 {
1737   struct mach_o_segment_command_32_external raw;
1738   bfd_mach_o_segment_command *seg = &command->command.segment;
1739   bfd_mach_o_section *sec;
1740
1741   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1742
1743   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1744     if (!bfd_mach_o_write_relocs (abfd, sec))
1745       return FALSE;
1746
1747   memcpy (raw.segname, seg->segname, 16);
1748   bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1749   bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1750   bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1751   bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1752   bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1753   bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1754   bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1755   bfd_h_put_32 (abfd, seg->flags, raw.flags);
1756
1757   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1758       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1759     return FALSE;
1760
1761   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1762     if (!bfd_mach_o_write_section_32 (abfd, sec))
1763       return FALSE;
1764
1765   return TRUE;
1766 }
1767
1768 static bfd_boolean
1769 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1770 {
1771   struct mach_o_segment_command_64_external raw;
1772   bfd_mach_o_segment_command *seg = &command->command.segment;
1773   bfd_mach_o_section *sec;
1774
1775   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1776
1777   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1778     if (!bfd_mach_o_write_relocs (abfd, sec))
1779       return FALSE;
1780
1781   memcpy (raw.segname, seg->segname, 16);
1782   bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1783   bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1784   bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1785   bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1786   bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1787   bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1788   bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1789   bfd_h_put_32 (abfd, seg->flags, raw.flags);
1790
1791   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1792       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1793     return FALSE;
1794
1795   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1796     if (!bfd_mach_o_write_section_64 (abfd, sec))
1797       return FALSE;
1798
1799   return TRUE;
1800 }
1801
1802 static bfd_boolean
1803 bfd_mach_o_write_symtab_content (bfd *abfd, bfd_mach_o_symtab_command *sym)
1804 {
1805   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1806   unsigned long i;
1807   unsigned int wide = bfd_mach_o_wide_p (abfd);
1808   struct bfd_strtab_hash *strtab;
1809   asymbol **symbols = bfd_get_outsymbols (abfd);
1810   int padlen;
1811
1812   /* Write the symbols first.  */
1813   if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1814     return FALSE;
1815
1816   strtab = _bfd_stringtab_init ();
1817   if (strtab == NULL)
1818     return FALSE;
1819
1820   if (sym->nsyms > 0)
1821     /* Although we don't strictly need to do this, for compatibility with
1822        Darwin system tools, actually output an empty string for the index
1823        0 entry.  */
1824     _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1825
1826   for (i = 0; i < sym->nsyms; i++)
1827     {
1828       bfd_size_type str_index;
1829       bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1830
1831       if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1832         /* An index of 0 always means the empty string.  */
1833         str_index = 0;
1834       else
1835         {
1836           str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1837
1838           if (str_index == (bfd_size_type) -1)
1839             goto err;
1840         }
1841
1842       if (wide)
1843         {
1844           struct mach_o_nlist_64_external raw;
1845
1846           bfd_h_put_32 (abfd, str_index, raw.n_strx);
1847           bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1848           bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1849           bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1850           bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1851                         raw.n_value);
1852
1853           if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1854             goto err;
1855         }
1856       else
1857         {
1858           struct mach_o_nlist_external raw;
1859
1860           bfd_h_put_32 (abfd, str_index, raw.n_strx);
1861           bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1862           bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1863           bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1864           bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1865                         raw.n_value);
1866
1867           if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1868             goto err;
1869         }
1870     }
1871   sym->strsize = _bfd_stringtab_size (strtab);
1872   sym->stroff = mdata->filelen;
1873   mdata->filelen += sym->strsize;
1874
1875   if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
1876     goto err;
1877
1878   if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1879     goto err;
1880
1881   /* Pad string table.  */
1882   padlen = bfd_mach_o_pad4 (abfd, sym->strsize);
1883   if (padlen < 0)
1884     return FALSE;
1885   mdata->filelen += padlen;
1886   sym->strsize += padlen;
1887
1888   return TRUE;
1889
1890  err:
1891   _bfd_stringtab_free (strtab);
1892   sym->strsize = 0;
1893   return FALSE;
1894 }
1895
1896 static bfd_boolean
1897 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1898 {
1899   bfd_mach_o_symtab_command *sym = &command->command.symtab;
1900   struct mach_o_symtab_command_external raw;
1901
1902   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1903
1904   /* The command.  */
1905   bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1906   bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1907   bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1908   bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1909
1910   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1911       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1912     return FALSE;
1913
1914   return TRUE;
1915 }
1916
1917 /* Count the number of indirect symbols in the image.
1918    Requires that the sections are in their final order.  */
1919
1920 static unsigned int
1921 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
1922 {
1923   unsigned int i;
1924   unsigned int nisyms = 0;
1925
1926   for (i = 0; i < mdata->nsects; ++i)
1927     {
1928       bfd_mach_o_section *sec = mdata->sections[i];
1929
1930       switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1931         {
1932           case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
1933           case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
1934           case BFD_MACH_O_S_SYMBOL_STUBS:
1935             nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
1936             break;
1937           default:
1938             break;
1939         }
1940     }
1941   return nisyms;
1942 }
1943
1944 /* Create the dysymtab.  */
1945
1946 static bfd_boolean
1947 bfd_mach_o_build_dysymtab (bfd *abfd, bfd_mach_o_dysymtab_command *cmd)
1948 {
1949   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1950
1951   /* TODO:
1952      We are not going to try and fill these in yet and, moreover, we are
1953      going to bail if they are already set.  */
1954   if (cmd->nmodtab != 0
1955       || cmd->ntoc != 0
1956       || cmd->nextrefsyms != 0)
1957     {
1958       (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
1959                                 " implemented for dysymtab commands."));
1960       return FALSE;
1961     }
1962
1963   cmd->ilocalsym = 0;
1964
1965   if (bfd_get_symcount (abfd) > 0)
1966     {
1967       asymbol **symbols = bfd_get_outsymbols (abfd);
1968       unsigned long i;
1969
1970        /* Count the number of each kind of symbol.  */
1971       for (i = 0; i < bfd_get_symcount (abfd); ++i)
1972         {
1973           bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1974           if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
1975             break;
1976         }
1977       cmd->nlocalsym = i;
1978       cmd->iextdefsym = i;
1979       for (; i < bfd_get_symcount (abfd); ++i)
1980         {
1981           bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1982           if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
1983             break;
1984         }
1985       cmd->nextdefsym = i - cmd->nlocalsym;
1986       cmd->iundefsym = cmd->nextdefsym + cmd->iextdefsym;
1987       cmd->nundefsym = bfd_get_symcount (abfd)
1988                         - cmd->nlocalsym
1989                         - cmd->nextdefsym;
1990     }
1991   else
1992     {
1993       cmd->nlocalsym = 0;
1994       cmd->iextdefsym = 0;
1995       cmd->nextdefsym = 0;
1996       cmd->iundefsym = 0;
1997       cmd->nundefsym = 0;
1998     }
1999
2000   cmd->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2001   if (cmd->nindirectsyms > 0)
2002     {
2003       unsigned i;
2004       unsigned n;
2005
2006       mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2007       cmd->indirectsymoff = mdata->filelen;
2008       mdata->filelen += cmd->nindirectsyms * 4;
2009
2010       if (cmd->nindirectsyms * 4 < cmd->nindirectsyms)
2011         return FALSE;
2012       cmd->indirect_syms = bfd_zalloc (abfd, cmd->nindirectsyms * 4);
2013       if (cmd->indirect_syms == NULL)
2014         return FALSE;
2015
2016       n = 0;
2017       for (i = 0; i < mdata->nsects; ++i)
2018         {
2019           bfd_mach_o_section *sec = mdata->sections[i];
2020
2021           switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2022             {
2023               case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2024               case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2025               case BFD_MACH_O_S_SYMBOL_STUBS:
2026                 {
2027                   unsigned j, num;
2028                   bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2029
2030                   num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2031                   if (isyms == NULL || num == 0)
2032                     break;
2033                   /* Record the starting index in the reserved1 field.  */
2034                   sec->reserved1 = n;
2035                   for (j = 0; j < num; j++, n++)
2036                     {
2037                       if (isyms[j] == NULL)
2038                         cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2039                       else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2040                                && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2041                         cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2042                                                  | BFD_MACH_O_INDIRECT_SYM_ABS;
2043                       else
2044                         cmd->indirect_syms[n] = isyms[j]->symbol.udata.i;
2045                     }
2046                 }
2047                 break;
2048               default:
2049                 break;
2050             }
2051         }
2052     }
2053
2054   return TRUE;
2055 }
2056
2057 /* Write a dysymtab command.
2058    TODO: Possibly coalesce writes of smaller objects.  */
2059
2060 static bfd_boolean
2061 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2062 {
2063   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2064
2065   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2066
2067   if (cmd->nmodtab != 0)
2068     {
2069       unsigned int i;
2070
2071       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2072         return FALSE;
2073
2074       for (i = 0; i < cmd->nmodtab; i++)
2075         {
2076           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2077           unsigned int iinit;
2078           unsigned int ninit;
2079
2080           iinit = module->iinit & 0xffff;
2081           iinit |= ((module->iterm & 0xffff) << 16);
2082
2083           ninit = module->ninit & 0xffff;
2084           ninit |= ((module->nterm & 0xffff) << 16);
2085
2086           if (bfd_mach_o_wide_p (abfd))
2087             {
2088               struct mach_o_dylib_module_64_external w;
2089
2090               bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
2091               bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
2092               bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
2093               bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
2094               bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
2095               bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
2096               bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
2097               bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
2098               bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
2099               bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
2100               bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
2101               bfd_h_put_64 (abfd, module->objc_module_info_addr,
2102                             &w.objc_module_info_addr);
2103               bfd_h_put_32 (abfd, module->objc_module_info_size,
2104                             &w.objc_module_info_size);
2105
2106               if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
2107                 return FALSE;
2108             }
2109           else
2110             {
2111               struct mach_o_dylib_module_external n;
2112
2113               bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
2114               bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
2115               bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
2116               bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
2117               bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
2118               bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
2119               bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
2120               bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
2121               bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
2122               bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
2123               bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
2124               bfd_h_put_32 (abfd, module->objc_module_info_addr,
2125                             &n.objc_module_info_addr);
2126               bfd_h_put_32 (abfd, module->objc_module_info_size,
2127                             &n.objc_module_info_size);
2128
2129               if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
2130                 return FALSE;
2131             }
2132         }
2133     }
2134
2135   if (cmd->ntoc != 0)
2136     {
2137       unsigned int i;
2138
2139       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2140         return FALSE;
2141
2142       for (i = 0; i < cmd->ntoc; i++)
2143         {
2144           struct mach_o_dylib_table_of_contents_external raw;
2145           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2146
2147           bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
2148           bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
2149
2150           if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2151             return FALSE;
2152         }
2153     }
2154
2155   if (cmd->nindirectsyms > 0)
2156     {
2157       unsigned int i;
2158
2159       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2160         return FALSE;
2161
2162       for (i = 0; i < cmd->nindirectsyms; ++i)
2163         {
2164           unsigned char raw[4];
2165
2166           bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
2167           if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2168             return FALSE;
2169         }
2170     }
2171
2172   if (cmd->nextrefsyms != 0)
2173     {
2174       unsigned int i;
2175
2176       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2177         return FALSE;
2178
2179       for (i = 0; i < cmd->nextrefsyms; i++)
2180         {
2181           unsigned long v;
2182           unsigned char raw[4];
2183           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2184
2185           /* Fields isym and flags are written as bit-fields, thus we need
2186              a specific processing for endianness.  */
2187
2188           if (bfd_big_endian (abfd))
2189             {
2190               v = ((ref->isym & 0xffffff) << 8);
2191               v |= ref->flags & 0xff;
2192             }
2193           else
2194             {
2195               v = ref->isym  & 0xffffff;
2196               v |= ((ref->flags & 0xff) << 24);
2197             }
2198
2199           bfd_h_put_32 (abfd, v, raw);
2200           if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2201             return FALSE;
2202         }
2203     }
2204
2205   /* The command.  */
2206   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
2207     return FALSE;
2208   else
2209     {
2210       struct mach_o_dysymtab_command_external raw;
2211
2212       bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
2213       bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
2214       bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
2215       bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
2216       bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
2217       bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
2218       bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
2219       bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
2220       bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
2221       bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
2222       bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
2223       bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
2224       bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
2225       bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
2226       bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
2227       bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
2228       bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
2229       bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
2230
2231       if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2232         return FALSE;
2233     }
2234
2235   return TRUE;
2236 }
2237
2238 static unsigned
2239 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
2240 {
2241   unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
2242
2243   /* Just leave debug symbols where they are (pretend they are local, and
2244      then they will just be sorted on position).  */
2245   if (s->n_type & BFD_MACH_O_N_STAB)
2246     return 0;
2247
2248   /* Local (we should never see an undefined local AFAICT).  */
2249   if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
2250     return 0;
2251
2252   /* Common symbols look like undefined externs.  */
2253   if (mtyp == BFD_MACH_O_N_UNDF)
2254     return 2;
2255
2256   /* A defined non-local, non-debug symbol.  */
2257   return 1;
2258 }
2259
2260 static int
2261 bfd_mach_o_cf_symbols (const void *a, const void *b)
2262 {
2263   bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
2264   bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
2265   unsigned int soa, sob;
2266
2267   soa = bfd_mach_o_primary_symbol_sort_key (sa);
2268   sob = bfd_mach_o_primary_symbol_sort_key (sb);
2269   if (soa < sob)
2270     return -1;
2271
2272   if (soa > sob)
2273     return 1;
2274
2275   /* If it's local or stab, just preserve the input order.  */
2276   if (soa == 0)
2277     {
2278       if (sa->symbol.udata.i < sb->symbol.udata.i)
2279         return -1;
2280       if (sa->symbol.udata.i > sb->symbol.udata.i)
2281         return  1;
2282
2283       /* This is probably an error.  */
2284       return 0;
2285     }
2286
2287   /* The second sort key is name.  */
2288   return strcmp (sa->symbol.name, sb->symbol.name);
2289 }
2290
2291 /* Process the symbols.
2292
2293    This should be OK for single-module files - but it is not likely to work
2294    for multi-module shared libraries.
2295
2296    (a) If the application has not filled in the relevant mach-o fields, make
2297        an estimate.
2298
2299    (b) Order them, like this:
2300         (  i) local.
2301                 (unsorted)
2302         ( ii) external defined
2303                 (by name)
2304         (iii) external undefined/common
2305                 (by name)
2306         ( iv) common
2307                 (by name)
2308 */
2309
2310 static bfd_boolean
2311 bfd_mach_o_mangle_symbols (bfd *abfd)
2312 {
2313   unsigned long i;
2314   asymbol **symbols = bfd_get_outsymbols (abfd);
2315
2316   if (symbols == NULL || bfd_get_symcount (abfd) == 0)
2317     return TRUE;
2318
2319   for (i = 0; i < bfd_get_symcount (abfd); i++)
2320     {
2321       bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2322
2323       /* We use this value, which is out-of-range as a symbol index, to signal
2324          that the mach-o-specific data are not filled in and need to be created
2325          from the bfd values.  It is much preferable for the application to do
2326          this, since more meaningful diagnostics can be made that way.  */
2327
2328       if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
2329         {
2330           /* No symbol information has been set - therefore determine
2331              it from the bfd symbol flags/info.  */
2332           if (s->symbol.section == bfd_abs_section_ptr)
2333             s->n_type = BFD_MACH_O_N_ABS;
2334           else if (s->symbol.section == bfd_und_section_ptr)
2335             {
2336               s->n_type = BFD_MACH_O_N_UNDF;
2337               if (s->symbol.flags & BSF_WEAK)
2338                 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
2339               /* mach-o automatically makes undefined symbols extern.  */
2340               s->n_type |= BFD_MACH_O_N_EXT;
2341               s->symbol.flags |= BSF_GLOBAL;
2342             }
2343           else if (s->symbol.section == bfd_com_section_ptr)
2344             {
2345               s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
2346               s->symbol.flags |= BSF_GLOBAL;
2347             }
2348           else
2349             s->n_type = BFD_MACH_O_N_SECT;
2350
2351           if (s->symbol.flags & BSF_GLOBAL)
2352             s->n_type |= BFD_MACH_O_N_EXT;
2353         }
2354
2355       /* Put the section index in, where required.  */
2356       if ((s->symbol.section != bfd_abs_section_ptr
2357           && s->symbol.section != bfd_und_section_ptr
2358           && s->symbol.section != bfd_com_section_ptr)
2359           || ((s->n_type & BFD_MACH_O_N_STAB) != 0
2360                && s->symbol.name == NULL))
2361         s->n_sect = s->symbol.section->output_section->target_index;
2362
2363       /* Number to preserve order for local and debug syms.  */
2364       s->symbol.udata.i = i;
2365     }
2366
2367   /* Sort the symbols.  */
2368   qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
2369          sizeof (asymbol *), bfd_mach_o_cf_symbols);
2370
2371   for (i = 0; i < bfd_get_symcount (abfd); ++i)
2372     {
2373       bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2374       s->symbol.udata.i = i;  /* renumber.  */
2375     }
2376
2377   return TRUE;
2378 }
2379
2380 /* We build a flat table of sections, which can be re-ordered if necessary.
2381    Fill in the section number and other mach-o-specific data.  */
2382
2383 static bfd_boolean
2384 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
2385 {
2386   asection *sec;
2387   unsigned target_index;
2388   unsigned nsect;
2389
2390   nsect = bfd_count_sections (abfd);
2391
2392   /* Don't do it if it's already set - assume the application knows what it's
2393      doing.  */
2394   if (mdata->nsects == nsect
2395       && (mdata->nsects == 0 || mdata->sections != NULL))
2396     return TRUE;
2397
2398   /* We need to check that this can be done...  */
2399   if (nsect > 255)
2400     {
2401       (*_bfd_error_handler) (_("mach-o: there are too many sections (%u)"
2402                                " maximum is 255,\n"), nsect);
2403       return FALSE;
2404     }
2405
2406   mdata->nsects = nsect;
2407   mdata->sections = bfd_alloc2 (abfd,
2408                                 mdata->nsects, sizeof (bfd_mach_o_section *));
2409   if (mdata->sections == NULL)
2410     return FALSE;
2411
2412   /* Create Mach-O sections.
2413      Section type, attribute and align should have been set when the
2414      section was created - either read in or specified.  */
2415   target_index = 0;
2416   for (sec = abfd->sections; sec; sec = sec->next)
2417     {
2418       unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
2419       bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
2420
2421       mdata->sections[target_index] = msect;
2422
2423       msect->addr = bfd_get_section_vma (abfd, sec);
2424       msect->size = bfd_get_section_size (sec);
2425
2426       /* Use the largest alignment set, in case it was bumped after the
2427          section was created.  */
2428       msect->align = msect->align > bfd_align ? msect->align : bfd_align;
2429
2430       msect->offset = 0;
2431       sec->target_index = ++target_index;
2432     }
2433
2434   return TRUE;
2435 }
2436
2437 bfd_boolean
2438 bfd_mach_o_write_contents (bfd *abfd)
2439 {
2440   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2441   bfd_mach_o_load_command *cmd;
2442   bfd_mach_o_symtab_command *symtab = NULL;
2443   bfd_mach_o_dysymtab_command *dysymtab = NULL;
2444   bfd_mach_o_segment_command *linkedit = NULL;
2445
2446   /* Make the commands, if not already present.  */
2447   if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
2448     return FALSE;
2449   abfd->output_has_begun = TRUE;
2450
2451   /* Write the header.  */
2452   if (!bfd_mach_o_write_header (abfd, &mdata->header))
2453     return FALSE;
2454
2455   /* First pass: allocate the linkedit segment.  */
2456   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2457     switch (cmd->type)
2458       {
2459       case BFD_MACH_O_LC_SEGMENT_64:
2460       case BFD_MACH_O_LC_SEGMENT:
2461         if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
2462           linkedit = &cmd->command.segment;
2463         break;
2464       case BFD_MACH_O_LC_SYMTAB:
2465         symtab = &cmd->command.symtab;
2466         break;
2467       case BFD_MACH_O_LC_DYSYMTAB:
2468         dysymtab = &cmd->command.dysymtab;
2469         break;
2470       case BFD_MACH_O_LC_DYLD_INFO:
2471         {
2472           bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
2473
2474           if (di->rebase_size != 0)
2475             {
2476               di->rebase_off = mdata->filelen;
2477               mdata->filelen += di->rebase_size;
2478             }
2479           if (di->bind_size != 0)
2480             {
2481               di->bind_off = mdata->filelen;
2482               mdata->filelen += di->bind_size;
2483             }
2484           if (di->weak_bind_size != 0)
2485             {
2486               di->weak_bind_off = mdata->filelen;
2487               mdata->filelen += di->weak_bind_size;
2488             }
2489           if (di->lazy_bind_size != 0)
2490             {
2491               di->lazy_bind_off = mdata->filelen;
2492               mdata->filelen += di->lazy_bind_size;
2493             }
2494           if (di->export_size != 0)
2495             {
2496               di->export_off = mdata->filelen;
2497               mdata->filelen += di->export_size;
2498             }
2499         }
2500         break;
2501       case BFD_MACH_O_LC_LOAD_DYLIB:
2502       case BFD_MACH_O_LC_LOAD_DYLINKER:
2503       case BFD_MACH_O_LC_MAIN:
2504         /* Nothing to do.  */
2505         break;
2506       default:
2507         (*_bfd_error_handler)
2508           (_("unable to allocate data for load command 0x%lx"),
2509            (unsigned long) cmd->type);
2510         break;
2511       }
2512
2513   /* Specially handle symtab and dysymtab.  */
2514
2515   /* Pre-allocate the symbol table (but not the string table).  The reason
2516      is that the dysymtab is after the symbol table but before the string
2517      table (required by the native strip tool).  */
2518   if (symtab != NULL)
2519     {
2520       unsigned int symlen;
2521       unsigned int wide = bfd_mach_o_wide_p (abfd);
2522
2523       symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2524
2525       /* Align for symbols.  */
2526       mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
2527       symtab->symoff = mdata->filelen;
2528
2529       symtab->nsyms = bfd_get_symcount (abfd);
2530       mdata->filelen += symtab->nsyms * symlen;
2531     }
2532
2533   /* Build the dysymtab.  */
2534   if (dysymtab != NULL)
2535     if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
2536       return FALSE;
2537
2538   /* Write symtab and strtab.  */
2539   if (symtab != NULL)
2540     if (!bfd_mach_o_write_symtab_content (abfd, symtab))
2541       return FALSE;
2542
2543   /* Adjust linkedit size.  */
2544   if (linkedit != NULL)
2545     {
2546       /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2547
2548       linkedit->vmsize = mdata->filelen - linkedit->fileoff;
2549       /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2550       linkedit->filesize = mdata->filelen - linkedit->fileoff;
2551
2552       linkedit->initprot = BFD_MACH_O_PROT_READ;
2553       linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2554         | BFD_MACH_O_PROT_EXECUTE;
2555     }
2556
2557   /* Second pass: write commands.  */
2558   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2559     {
2560       struct mach_o_load_command_external raw;
2561       unsigned long typeflag;
2562
2563       typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
2564
2565       bfd_h_put_32 (abfd, typeflag, raw.cmd);
2566       bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
2567
2568       if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
2569           || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
2570         return FALSE;
2571
2572       switch (cmd->type)
2573         {
2574         case BFD_MACH_O_LC_SEGMENT:
2575           if (!bfd_mach_o_write_segment_32 (abfd, cmd))
2576             return FALSE;
2577           break;
2578         case BFD_MACH_O_LC_SEGMENT_64:
2579           if (!bfd_mach_o_write_segment_64 (abfd, cmd))
2580             return FALSE;
2581           break;
2582         case BFD_MACH_O_LC_SYMTAB:
2583           if (!bfd_mach_o_write_symtab (abfd, cmd))
2584             return FALSE;
2585           break;
2586         case BFD_MACH_O_LC_DYSYMTAB:
2587           if (!bfd_mach_o_write_dysymtab (abfd, cmd))
2588             return FALSE;
2589           break;
2590         case BFD_MACH_O_LC_THREAD:
2591         case BFD_MACH_O_LC_UNIXTHREAD:
2592           if (!bfd_mach_o_write_thread (abfd, cmd))
2593             return FALSE;
2594           break;
2595         case BFD_MACH_O_LC_LOAD_DYLIB:
2596           if (!bfd_mach_o_write_dylib (abfd, cmd))
2597             return FALSE;
2598           break;
2599         case BFD_MACH_O_LC_LOAD_DYLINKER:
2600           if (!bfd_mach_o_write_dylinker (abfd, cmd))
2601             return FALSE;
2602           break;
2603         case BFD_MACH_O_LC_MAIN:
2604           if (!bfd_mach_o_write_main (abfd, cmd))
2605             return FALSE;
2606           break;
2607         case BFD_MACH_O_LC_DYLD_INFO:
2608           if (!bfd_mach_o_write_dyld_info (abfd, cmd))
2609             return FALSE;
2610           break;
2611         default:
2612           (*_bfd_error_handler)
2613             (_("unable to write unknown load command 0x%lx"),
2614              (unsigned long) cmd->type);
2615           return FALSE;
2616         }
2617     }
2618
2619   return TRUE;
2620 }
2621
2622 static void
2623 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2624                                       bfd_mach_o_section *s)
2625 {
2626   if (seg->sect_head == NULL)
2627     seg->sect_head = s;
2628   else
2629     seg->sect_tail->next = s;
2630   seg->sect_tail = s;
2631 }
2632
2633 /* Create section Mach-O flags from BFD flags.  */
2634
2635 static void
2636 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2637                                        asection *sec)
2638 {
2639   flagword bfd_flags;
2640   bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2641
2642   /* Create default flags.  */
2643   bfd_flags = bfd_get_section_flags (abfd, sec);
2644   if ((bfd_flags & SEC_CODE) == SEC_CODE)
2645     s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2646       | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2647       | BFD_MACH_O_S_REGULAR;
2648   else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2649     s->flags = BFD_MACH_O_S_ZEROFILL;
2650   else if (bfd_flags & SEC_DEBUGGING)
2651     s->flags = BFD_MACH_O_S_REGULAR |  BFD_MACH_O_S_ATTR_DEBUG;
2652   else
2653     s->flags = BFD_MACH_O_S_REGULAR;
2654 }
2655
2656 static bfd_boolean
2657 bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2658 {
2659   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2660   unsigned int i, j;
2661
2662   seg->vmaddr = 0;
2663   seg->fileoff = mdata->filelen;
2664   seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2665     | BFD_MACH_O_PROT_EXECUTE;
2666   seg->maxprot = seg->initprot;
2667
2668   /*  Append sections to the segment.
2669
2670       This is a little tedious, we have to honor the need to account zerofill
2671       sections after all the rest.  This forces us to do the calculation of
2672       total vmsize in three passes so that any alignment increments are
2673       properly accounted.  */
2674   for (i = 0; i < mdata->nsects; ++i)
2675     {
2676       bfd_mach_o_section *s = mdata->sections[i];
2677       asection *sec = s->bfdsection;
2678
2679       /* Although we account for zerofill section sizes in vm order, they are
2680          placed in the file in source sequence.  */
2681       bfd_mach_o_append_section_to_segment (seg, s);
2682       s->offset = 0;
2683
2684       /* Zerofill sections have zero file size & offset, the only content
2685          written to the file is the symbols.  */
2686       if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2687           || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2688               == BFD_MACH_O_S_GB_ZEROFILL))
2689         continue;
2690
2691       /* The Darwin system tools (in MH_OBJECT files, at least) always account
2692          sections, even those with zero size.  */
2693       if (s->size > 0)
2694         {
2695           seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2696           seg->vmsize += s->size;
2697
2698           /* MH_OBJECT files have unaligned content.  */
2699           if (1)
2700             {
2701               seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2702               mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2703             }
2704           seg->filesize += s->size;
2705
2706           /* The system tools write even zero-sized sections with an offset
2707              field set to the current file position.  */
2708           s->offset = mdata->filelen;
2709         }
2710
2711       sec->filepos = s->offset;
2712       mdata->filelen += s->size;
2713     }
2714
2715   /* Now pass through again, for zerofill, only now we just update the
2716      vmsize, and then for zerofill_GB.  */
2717   for (j = 0; j < 2; j++)
2718     {
2719       unsigned int stype;
2720
2721       if (j == 0)
2722         stype = BFD_MACH_O_S_ZEROFILL;
2723       else
2724         stype = BFD_MACH_O_S_GB_ZEROFILL;
2725
2726       for (i = 0; i < mdata->nsects; ++i)
2727         {
2728           bfd_mach_o_section *s = mdata->sections[i];
2729
2730           if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
2731             continue;
2732
2733           if (s->size > 0)
2734             {
2735               seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2736               seg->vmsize += s->size;
2737             }
2738         }
2739     }
2740
2741   /* Allocate space for the relocations.  */
2742   mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2743
2744   for (i = 0; i < mdata->nsects; ++i)
2745     {
2746       bfd_mach_o_section *ms = mdata->sections[i];
2747       asection *sec = ms->bfdsection;
2748
2749       ms->nreloc = sec->reloc_count;
2750       if (ms->nreloc == 0)
2751         {
2752           /* Clear nreloc and reloff if there is no relocs.  */
2753           ms->reloff = 0;
2754           continue;
2755         }
2756       sec->rel_filepos = mdata->filelen;
2757       ms->reloff = sec->rel_filepos;
2758       mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2759     }
2760
2761   return TRUE;
2762 }
2763
2764 static bfd_boolean
2765 bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2766 {
2767   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2768   unsigned int i;
2769   bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
2770   bfd_vma vma;
2771   bfd_mach_o_section *s;
2772
2773   seg->vmsize = 0;
2774
2775   seg->fileoff = mdata->filelen;
2776   seg->maxprot = 0;
2777   seg->initprot = 0;
2778   seg->flags = 0;
2779
2780   /*  Append sections to the segment.  We assume they are properly ordered
2781       by vma (but we check that).  */
2782   vma = 0;
2783   for (i = 0; i < mdata->nsects; ++i)
2784     {
2785       s = mdata->sections[i];
2786
2787       /* Consider only sections for this segment.  */
2788       if (strcmp (seg->segname, s->segname) != 0)
2789         continue;
2790
2791       bfd_mach_o_append_section_to_segment (seg, s);
2792
2793       if (s->addr < vma)
2794         {
2795           (*_bfd_error_handler)
2796             (_("section address (%lx) below start of segment (%lx)"),
2797                (unsigned long) s->addr, (unsigned long) vma);
2798           return FALSE;
2799         }
2800
2801       vma = s->addr + s->size;
2802     }
2803
2804   /* Set segment file offset: make it page aligned.  */
2805   vma = seg->sect_head->addr;
2806   seg->vmaddr = vma & ~pagemask;
2807   if ((mdata->filelen & pagemask) > (vma & pagemask))
2808     mdata->filelen += pagemask + 1;
2809   seg->fileoff = mdata->filelen & ~pagemask;
2810   mdata->filelen = seg->fileoff + (vma & pagemask);
2811
2812   /* Set section file offset.  */
2813   for (s = seg->sect_head; s != NULL; s = s->next)
2814     {
2815       asection *sec = s->bfdsection;
2816       flagword flags = bfd_get_section_flags (abfd, sec);
2817
2818       /* Adjust segment size.  */
2819       seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2820       seg->vmsize += s->size;
2821
2822       /* File offset and length.  */
2823       seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2824
2825       if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
2826           && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2827               != BFD_MACH_O_S_GB_ZEROFILL))
2828         {
2829           mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2830
2831           s->offset = mdata->filelen;
2832           s->bfdsection->filepos = s->offset;
2833
2834           seg->filesize += s->size;
2835           mdata->filelen += s->size;
2836         }
2837       else
2838         {
2839           s->offset = 0;
2840           s->bfdsection->filepos = 0;
2841         }
2842
2843       /* Set protection.  */
2844       if (flags & SEC_LOAD)
2845         {
2846           if (flags & SEC_CODE)
2847             seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
2848           if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
2849             seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
2850         }
2851
2852       /* Relocs shouldn't appear in non-object files.  */
2853       if (s->bfdsection->reloc_count != 0)
2854         return FALSE;
2855     }
2856
2857   /* Set maxprot.  */
2858   if (seg->initprot != 0)
2859     seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2860                  | BFD_MACH_O_PROT_EXECUTE;
2861   else
2862     seg->maxprot = 0;
2863
2864   /* Round segment size (and file size).  */
2865   seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
2866   seg->filesize = (seg->filesize + pagemask) & ~pagemask;
2867   mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
2868
2869   return TRUE;
2870 }
2871
2872 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2873    fields in header.  */
2874
2875 static bfd_boolean
2876 bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
2877 {
2878   unsigned wide = mach_o_wide_p (&mdata->header);
2879   unsigned int hdrlen;
2880   ufile_ptr offset;
2881   bfd_mach_o_load_command *cmd;
2882   unsigned int align;
2883   bfd_boolean ret = TRUE;
2884
2885   hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2886   align = wide ? 8 - 1 : 4 - 1;
2887   offset = hdrlen;
2888   mdata->header.ncmds = 0;
2889
2890   for (cmd = mdata->first_command; cmd; cmd = cmd->next)
2891     {
2892       mdata->header.ncmds++;
2893       cmd->offset = offset;
2894
2895       switch (cmd->type)
2896         {
2897         case BFD_MACH_O_LC_SEGMENT_64:
2898           cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2899             + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
2900           break;
2901         case BFD_MACH_O_LC_SEGMENT:
2902           cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2903             + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
2904           break;
2905         case BFD_MACH_O_LC_SYMTAB:
2906           cmd->len = sizeof (struct mach_o_symtab_command_external)
2907             + BFD_MACH_O_LC_SIZE;
2908           break;
2909         case BFD_MACH_O_LC_DYSYMTAB:
2910           cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2911                  + BFD_MACH_O_LC_SIZE;
2912           break;
2913         case BFD_MACH_O_LC_LOAD_DYLIB:
2914           cmd->len = sizeof (struct mach_o_dylib_command_external)
2915                  + BFD_MACH_O_LC_SIZE;
2916           cmd->command.dylib.name_offset = cmd->len;
2917           cmd->len += strlen (cmd->command.dylib.name_str);
2918           cmd->len = (cmd->len + align) & ~align;
2919           break;
2920         case BFD_MACH_O_LC_LOAD_DYLINKER:
2921           cmd->len = sizeof (struct mach_o_str_command_external)
2922                  + BFD_MACH_O_LC_SIZE;
2923           cmd->command.dylinker.name_offset = cmd->len;
2924           cmd->len += strlen (cmd->command.dylinker.name_str);
2925           cmd->len = (cmd->len + align) & ~align;
2926           break;
2927         case BFD_MACH_O_LC_MAIN:
2928           cmd->len = sizeof (struct mach_o_entry_point_command_external)
2929                  + BFD_MACH_O_LC_SIZE;
2930           break;
2931         case BFD_MACH_O_LC_DYLD_INFO:
2932           cmd->len = sizeof (struct mach_o_dyld_info_command_external)
2933                  + BFD_MACH_O_LC_SIZE;
2934           break;
2935         default:
2936           (*_bfd_error_handler)
2937             (_("unable to layout unknown load command 0x%lx"),
2938              (unsigned long) cmd->type);
2939           ret = FALSE;
2940           break;
2941         }
2942
2943       BFD_ASSERT (cmd->len % (align + 1) == 0);
2944       offset += cmd->len;
2945     }
2946   mdata->header.sizeofcmds = offset - hdrlen;
2947   mdata->filelen = offset;
2948
2949   return ret;
2950 }
2951
2952 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2953    segment.  */
2954
2955 static void
2956 bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
2957                          bfd_mach_o_load_command *cmd,
2958                          const char *segname, unsigned int nbr_sect)
2959 {
2960   bfd_mach_o_segment_command *seg = &cmd->command.segment;
2961   unsigned wide = mach_o_wide_p (&mdata->header);
2962
2963   /* Init segment command.  */
2964   cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
2965   cmd->type_required = FALSE;
2966
2967   strcpy (seg->segname, segname);
2968   seg->nsects = nbr_sect;
2969
2970   seg->vmaddr = 0;
2971   seg->vmsize = 0;
2972
2973   seg->fileoff = 0;
2974   seg->filesize = 0;
2975   seg->maxprot = 0;
2976   seg->initprot = 0;
2977   seg->flags = 0;
2978   seg->sect_head = NULL;
2979   seg->sect_tail = NULL;
2980 }
2981
2982 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2983    TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2984    and copy functionality.  */
2985
2986 bfd_boolean
2987 bfd_mach_o_build_commands (bfd *abfd)
2988 {
2989   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2990   unsigned wide = mach_o_wide_p (&mdata->header);
2991   unsigned int nbr_segcmd = 0;
2992   bfd_mach_o_load_command *commands;
2993   unsigned int nbr_commands;
2994   int symtab_idx = -1;
2995   int dysymtab_idx = -1;
2996   int main_idx = -1;
2997   unsigned int i;
2998
2999   /* Return now if already built.  */
3000   if (mdata->header.ncmds != 0)
3001     return TRUE;
3002
3003   /* Fill in the file type, if not already set.  */
3004   if (mdata->header.filetype == 0)
3005     {
3006       if (abfd->flags & EXEC_P)
3007         mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
3008       else if (abfd->flags & DYNAMIC)
3009         mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
3010       else
3011         mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
3012     }
3013
3014   /* If hasn't already been done, flatten sections list, and sort
3015      if/when required.  Must be done before the symbol table is adjusted,
3016      since that depends on properly numbered sections.  */
3017   if (mdata->nsects == 0 || mdata->sections == NULL)
3018     if (! bfd_mach_o_mangle_sections (abfd, mdata))
3019       return FALSE;
3020
3021   /* Order the symbol table, fill-in/check mach-o specific fields and
3022      partition out any indirect symbols.  */
3023   if (!bfd_mach_o_mangle_symbols (abfd))
3024     return FALSE;
3025
3026   /* Segment commands.  */
3027   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3028     {
3029       /* Only one segment for all the sections.  But the segment is
3030          optional if there is no sections.  */
3031       nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
3032     }
3033   else
3034     {
3035       bfd_mach_o_section *prev_sect = NULL;
3036
3037       /* One pagezero segment and one linkedit segment.  */
3038       nbr_segcmd = 2;
3039
3040       /* Create one segment for associated segment name in sections.
3041          Assume that sections with the same segment name are consecutive.  */
3042       for (i = 0; i < mdata->nsects; i++)
3043         {
3044           bfd_mach_o_section *this_sect = mdata->sections[i];
3045
3046           if (prev_sect == NULL
3047               || strcmp (prev_sect->segname, this_sect->segname) != 0)
3048             {
3049               nbr_segcmd++;
3050               prev_sect = this_sect;
3051             }
3052         }
3053     }
3054
3055   nbr_commands = nbr_segcmd;
3056
3057   /* One command for the symbol table (only if there are symbols.  */
3058   if (bfd_get_symcount (abfd) > 0)
3059     symtab_idx = nbr_commands++;
3060
3061   /* FIXME:
3062      This is a rather crude test for whether we should build a dysymtab.  */
3063   if (bfd_mach_o_should_emit_dysymtab ()
3064       && bfd_get_symcount (abfd))
3065     {
3066       /* If there should be a case where a dysymtab could be emitted without
3067          a symtab (seems improbable), this would need amending.  */
3068       dysymtab_idx = nbr_commands++;
3069     }
3070
3071   /* Add an entry point command.  */
3072   if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3073       && bfd_get_start_address (abfd) != 0)
3074     main_idx = nbr_commands++;
3075
3076   /* Well, we must have a header, at least.  */
3077   mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3078
3079   /* A bit unusual, but no content is valid;
3080      as -n empty.s -o empty.o  */
3081   if (nbr_commands == 0)
3082     {
3083       /* Layout commands (well none...) and set headers command fields.  */
3084       return bfd_mach_o_layout_commands (mdata);
3085     }
3086
3087   /* Create commands for segments (and symtabs), prepend them.  */
3088   commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3089   if (commands == NULL)
3090     return FALSE;
3091   for (i = 0; i < nbr_commands - 1; i++)
3092     commands[i].next = &commands[i + 1];
3093   commands[nbr_commands - 1].next = mdata->first_command;
3094   if (mdata->first_command == NULL)
3095     mdata->last_command = &commands[nbr_commands - 1];
3096   mdata->first_command = &commands[0];
3097
3098   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3099     {
3100       /* For object file, there is only one segment.  */
3101       bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3102     }
3103   else if (nbr_segcmd != 0)
3104     {
3105       bfd_mach_o_load_command *cmd;
3106
3107       BFD_ASSERT (nbr_segcmd >= 2);
3108
3109       /* The pagezero.  */
3110       cmd = &commands[0];
3111       bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3112
3113       /* Segments from sections.  */
3114       cmd++;
3115       for (i = 0; i < mdata->nsects;)
3116         {
3117           const char *segname = mdata->sections[i]->segname;
3118           unsigned int nbr_sect = 1;
3119
3120           /* Count number of sections for this segment.  */
3121           for (i++; i < mdata->nsects; i++)
3122             if (strcmp (mdata->sections[i]->segname, segname) == 0)
3123               nbr_sect++;
3124             else
3125               break;
3126
3127           bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3128           cmd++;
3129         }
3130
3131       /* The linkedit.  */
3132       bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
3133     }
3134
3135   if (symtab_idx >= 0)
3136     {
3137       /* Init symtab command.  */
3138       bfd_mach_o_load_command *cmd = &commands[symtab_idx];
3139
3140       cmd->type = BFD_MACH_O_LC_SYMTAB;
3141       cmd->type_required = FALSE;
3142     }
3143
3144   /* If required, setup symtab command, see comment above about the quality
3145      of this test.  */
3146   if (dysymtab_idx >= 0)
3147     {
3148       bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
3149
3150       cmd->type = BFD_MACH_O_LC_DYSYMTAB;
3151       cmd->type_required = FALSE;
3152     }
3153
3154   /* Create the main command.  */
3155   if (main_idx >= 0)
3156     {
3157       bfd_mach_o_load_command *cmd = &commands[main_idx];
3158
3159       cmd->type = BFD_MACH_O_LC_MAIN;
3160       cmd->type_required = TRUE;
3161
3162       cmd->command.main.entryoff = 0;
3163       cmd->command.main.stacksize = 0;
3164     }
3165
3166   /* Layout commands.  */
3167   if (! bfd_mach_o_layout_commands (mdata))
3168     return FALSE;
3169
3170   /* So, now we have sized the commands and the filelen set to that.
3171      Now we can build the segment command and set the section file offsets.  */
3172   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3173     {
3174       for (i = 0; i < nbr_segcmd; i++)
3175         if (!bfd_mach_o_build_obj_seg_command
3176             (abfd, &commands[i].command.segment))
3177           return FALSE;
3178     }
3179   else
3180     {
3181       bfd_vma maxvma = 0;
3182
3183       /* Skip pagezero and linkedit segments.  */
3184       for (i = 1; i < nbr_segcmd - 1; i++)
3185         {
3186           bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3187
3188           if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3189             return FALSE;
3190
3191           if (seg->vmaddr + seg->vmsize > maxvma)
3192             maxvma = seg->vmaddr + seg->vmsize;
3193         }
3194
3195       /* Set the size of __PAGEZERO.  */
3196       commands[0].command.segment.vmsize =
3197         commands[1].command.segment.vmaddr;
3198
3199       /* Set the vma and fileoff of __LINKEDIT.  */
3200       commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3201       commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3202
3203       /* Set entry point (once segments have been laid out).  */
3204       if (main_idx >= 0)
3205         commands[main_idx].command.main.entryoff =
3206           bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3207     }
3208
3209   return TRUE;
3210 }
3211
3212 /* Set the contents of a section.  */
3213
3214 bfd_boolean
3215 bfd_mach_o_set_section_contents (bfd *abfd,
3216                                  asection *section,
3217                                  const void * location,
3218                                  file_ptr offset,
3219                                  bfd_size_type count)
3220 {
3221   file_ptr pos;
3222
3223   /* Trying to write the first section contents will trigger the creation of
3224      the load commands if they are not already present.  */
3225   if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
3226     return FALSE;
3227
3228   if (count == 0)
3229     return TRUE;
3230
3231   pos = section->filepos + offset;
3232   if (bfd_seek (abfd, pos, SEEK_SET) != 0
3233       || bfd_bwrite (location, count, abfd) != count)
3234     return FALSE;
3235
3236   return TRUE;
3237 }
3238
3239 int
3240 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
3241                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
3242 {
3243   return 0;
3244 }
3245
3246 /* Make an empty symbol.  This is required only because
3247    bfd_make_section_anyway wants to create a symbol for the section.  */
3248
3249 asymbol *
3250 bfd_mach_o_make_empty_symbol (bfd *abfd)
3251 {
3252   asymbol *new_symbol;
3253
3254   new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3255   if (new_symbol == NULL)
3256     return new_symbol;
3257   new_symbol->the_bfd = abfd;
3258   new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
3259   return new_symbol;
3260 }
3261
3262 static bfd_boolean
3263 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
3264 {
3265   struct mach_o_header_external raw;
3266   unsigned int size;
3267   bfd_vma (*get32) (const void *) = NULL;
3268
3269   /* Just read the magic number.  */
3270   if (bfd_seek (abfd, 0, SEEK_SET) != 0
3271       || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
3272     return FALSE;
3273
3274   if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3275     {
3276       header->byteorder = BFD_ENDIAN_BIG;
3277       header->magic = BFD_MACH_O_MH_MAGIC;
3278       header->version = 1;
3279       get32 = bfd_getb32;
3280     }
3281   else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3282     {
3283       header->byteorder = BFD_ENDIAN_LITTLE;
3284       header->magic = BFD_MACH_O_MH_MAGIC;
3285       header->version = 1;
3286       get32 = bfd_getl32;
3287     }
3288   else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3289     {
3290       header->byteorder = BFD_ENDIAN_BIG;
3291       header->magic = BFD_MACH_O_MH_MAGIC_64;
3292       header->version = 2;
3293       get32 = bfd_getb32;
3294     }
3295   else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3296     {
3297       header->byteorder = BFD_ENDIAN_LITTLE;
3298       header->magic = BFD_MACH_O_MH_MAGIC_64;
3299       header->version = 2;
3300       get32 = bfd_getl32;
3301     }
3302   else
3303     {
3304       header->byteorder = BFD_ENDIAN_UNKNOWN;
3305       return FALSE;
3306     }
3307
3308   /* Once the size of the header is known, read the full header.  */
3309   size = mach_o_wide_p (header) ?
3310     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3311
3312   if (bfd_seek (abfd, 0, SEEK_SET) != 0
3313       || bfd_bread (&raw, size, abfd) != size)
3314     return FALSE;
3315
3316   header->cputype = (*get32) (raw.cputype);
3317   header->cpusubtype = (*get32) (raw.cpusubtype);
3318   header->filetype = (*get32) (raw.filetype);
3319   header->ncmds = (*get32) (raw.ncmds);
3320   header->sizeofcmds = (*get32) (raw.sizeofcmds);
3321   header->flags = (*get32) (raw.flags);
3322
3323   if (mach_o_wide_p (header))
3324     header->reserved = (*get32) (raw.reserved);
3325   else
3326     header->reserved = 0;
3327
3328   return TRUE;
3329 }
3330
3331 bfd_boolean
3332 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3333 {
3334   bfd_mach_o_section *s;
3335   unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
3336
3337   s = bfd_mach_o_get_mach_o_section (sec);
3338   if (s == NULL)
3339     {
3340       flagword bfd_flags;
3341       static const mach_o_section_name_xlat * xlat;
3342
3343       s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3344       if (s == NULL)
3345         return FALSE;
3346       sec->used_by_bfd = s;
3347       s->bfdsection = sec;
3348
3349       /* Create the Darwin seg/sect name pair from the bfd name.
3350          If this is a canonical name for which a specific paiting exists
3351          there will also be defined flags, type, attribute and alignment
3352          values.  */
3353       xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3354       if (xlat != NULL)
3355         {
3356           s->flags = xlat->macho_sectype | xlat->macho_secattr;
3357           s->align = xlat->sectalign > bfdalign ? xlat->sectalign
3358                                                 : bfdalign;
3359           (void) bfd_set_section_alignment (abfd, sec, s->align);
3360           bfd_flags = bfd_get_section_flags (abfd, sec);
3361           if (bfd_flags == SEC_NO_FLAGS)
3362             bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
3363         }
3364       else
3365         /* Create default flags.  */
3366         bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
3367     }
3368
3369   return _bfd_generic_new_section_hook (abfd, sec);
3370 }
3371
3372 static void
3373 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
3374                                      unsigned long prot)
3375 {
3376   flagword flags;
3377   bfd_mach_o_section *section;
3378
3379   flags = bfd_get_section_flags (abfd, sec);
3380   section = bfd_mach_o_get_mach_o_section (sec);
3381
3382   /* TODO: see if we should use the xlat system for doing this by
3383      preference and fall back to this for unknown sections.  */
3384
3385   if (flags == SEC_NO_FLAGS)
3386     {
3387       /* Try to guess flags.  */
3388       if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
3389         flags = SEC_DEBUGGING;
3390       else
3391         {
3392           flags = SEC_ALLOC;
3393           if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3394               != BFD_MACH_O_S_ZEROFILL)
3395             {
3396               flags |= SEC_LOAD;
3397               if (prot & BFD_MACH_O_PROT_EXECUTE)
3398                 flags |= SEC_CODE;
3399               if (prot & BFD_MACH_O_PROT_WRITE)
3400                 flags |= SEC_DATA;
3401               else if (prot & BFD_MACH_O_PROT_READ)
3402                 flags |= SEC_READONLY;
3403             }
3404         }
3405     }
3406   else
3407     {
3408       if ((flags & SEC_DEBUGGING) == 0)
3409         flags |= SEC_ALLOC;
3410     }
3411
3412   if (section->offset != 0)
3413     flags |= SEC_HAS_CONTENTS;
3414   if (section->nreloc != 0)
3415     flags |= SEC_RELOC;
3416
3417   bfd_set_section_flags (abfd, sec, flags);
3418
3419   sec->vma = section->addr;
3420   sec->lma = section->addr;
3421   sec->size = section->size;
3422   sec->filepos = section->offset;
3423   sec->alignment_power = section->align;
3424   sec->segment_mark = 0;
3425   sec->reloc_count = section->nreloc;
3426   sec->rel_filepos = section->reloff;
3427 }
3428
3429 static asection *
3430 bfd_mach_o_make_bfd_section (bfd *abfd,
3431                              const unsigned char *segname,
3432                              const unsigned char *sectname)
3433 {
3434   const char *sname;
3435   flagword flags;
3436
3437   bfd_mach_o_convert_section_name_to_bfd
3438     (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3439   if (sname == NULL)
3440     return NULL;
3441
3442   return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3443 }
3444
3445 static asection *
3446 bfd_mach_o_read_section_32 (bfd *abfd,
3447                             unsigned int offset,
3448                             unsigned long prot)
3449 {
3450   struct mach_o_section_32_external raw;
3451   asection *sec;
3452   bfd_mach_o_section *section;
3453
3454   if (bfd_seek (abfd, offset, SEEK_SET) != 0
3455       || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3456           != BFD_MACH_O_SECTION_SIZE))
3457     return NULL;
3458
3459   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3460   if (sec == NULL)
3461     return NULL;
3462
3463   section = bfd_mach_o_get_mach_o_section (sec);
3464   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3465   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3466   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3467   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3468   section->addr = bfd_h_get_32 (abfd, raw.addr);
3469   section->size = bfd_h_get_32 (abfd, raw.size);
3470   section->offset = bfd_h_get_32 (abfd, raw.offset);
3471   section->align = bfd_h_get_32 (abfd, raw.align);
3472   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3473   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3474   section->flags = bfd_h_get_32 (abfd, raw.flags);
3475   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3476   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3477   section->reserved3 = 0;
3478
3479   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3480
3481   return sec;
3482 }
3483
3484 static asection *
3485 bfd_mach_o_read_section_64 (bfd *abfd,
3486                             unsigned int offset,
3487                             unsigned long prot)
3488 {
3489   struct mach_o_section_64_external raw;
3490   asection *sec;
3491   bfd_mach_o_section *section;
3492
3493   if (bfd_seek (abfd, offset, SEEK_SET) != 0
3494       || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3495           != BFD_MACH_O_SECTION_64_SIZE))
3496     return NULL;
3497
3498   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3499   if (sec == NULL)
3500     return NULL;
3501
3502   section = bfd_mach_o_get_mach_o_section (sec);
3503   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3504   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3505   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3506   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3507   section->addr = bfd_h_get_64 (abfd, raw.addr);
3508   section->size = bfd_h_get_64 (abfd, raw.size);
3509   section->offset = bfd_h_get_32 (abfd, raw.offset);
3510   section->align = bfd_h_get_32 (abfd, raw.align);
3511   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3512   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3513   section->flags = bfd_h_get_32 (abfd, raw.flags);
3514   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3515   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3516   section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3517
3518   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3519
3520   return sec;
3521 }
3522
3523 static asection *
3524 bfd_mach_o_read_section (bfd *abfd,
3525                          unsigned int offset,
3526                          unsigned long prot,
3527                          unsigned int wide)
3528 {
3529   if (wide)
3530     return bfd_mach_o_read_section_64 (abfd, offset, prot);
3531   else
3532     return bfd_mach_o_read_section_32 (abfd, offset, prot);
3533 }
3534
3535 static bfd_boolean
3536 bfd_mach_o_read_symtab_symbol (bfd *abfd,
3537                                bfd_mach_o_symtab_command *sym,
3538                                bfd_mach_o_asymbol *s,
3539                                unsigned long i)
3540 {
3541   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3542   unsigned int wide = mach_o_wide_p (&mdata->header);
3543   unsigned int symwidth =
3544     wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3545   unsigned int symoff = sym->symoff + (i * symwidth);
3546   struct mach_o_nlist_64_external raw;
3547   unsigned char type = -1;
3548   unsigned char section = -1;
3549   short desc = -1;
3550   symvalue value = -1;
3551   unsigned long stroff = -1;
3552   unsigned int symtype = -1;
3553
3554   BFD_ASSERT (sym->strtab != NULL);
3555
3556   if (bfd_seek (abfd, symoff, SEEK_SET) != 0
3557       || bfd_bread (&raw, symwidth, abfd) != symwidth)
3558     {
3559       (*_bfd_error_handler)
3560         (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3561          symwidth, (unsigned long) symoff);
3562       return FALSE;
3563     }
3564
3565   stroff = bfd_h_get_32 (abfd, raw.n_strx);
3566   type = bfd_h_get_8 (abfd, raw.n_type);
3567   symtype = type & BFD_MACH_O_N_TYPE;
3568   section = bfd_h_get_8 (abfd, raw.n_sect);
3569   desc = bfd_h_get_16 (abfd, raw.n_desc);
3570   if (wide)
3571     value = bfd_h_get_64 (abfd, raw.n_value);
3572   else
3573     value = bfd_h_get_32 (abfd, raw.n_value);
3574
3575   if (stroff >= sym->strsize)
3576     {
3577       (*_bfd_error_handler)
3578         (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3579          (unsigned long) stroff,
3580          (unsigned long) sym->strsize);
3581       return FALSE;
3582     }
3583
3584   s->symbol.the_bfd = abfd;
3585   s->symbol.name = sym->strtab + stroff;
3586   s->symbol.value = value;
3587   s->symbol.flags = 0x0;
3588   s->symbol.udata.i = i;
3589   s->n_type = type;
3590   s->n_sect = section;
3591   s->n_desc = desc;
3592
3593   if (type & BFD_MACH_O_N_STAB)
3594     {
3595       s->symbol.flags |= BSF_DEBUGGING;
3596       s->symbol.section = bfd_und_section_ptr;
3597       switch (type)
3598         {
3599         case N_FUN:
3600         case N_STSYM:
3601         case N_LCSYM:
3602         case N_BNSYM:
3603         case N_SLINE:
3604         case N_ENSYM:
3605         case N_ECOMM:
3606         case N_ECOML:
3607         case N_GSYM:
3608           if ((section > 0) && (section <= mdata->nsects))
3609             {
3610               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3611               s->symbol.value =
3612                 s->symbol.value - mdata->sections[section - 1]->addr;
3613             }
3614           break;
3615         }
3616     }
3617   else
3618     {
3619       if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
3620         s->symbol.flags |= BSF_GLOBAL;
3621       else
3622         s->symbol.flags |= BSF_LOCAL;
3623
3624       switch (symtype)
3625         {
3626         case BFD_MACH_O_N_UNDF:
3627           if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3628               && s->symbol.value != 0)
3629             {
3630               /* A common symbol.  */
3631               s->symbol.section = bfd_com_section_ptr;
3632               s->symbol.flags = BSF_NO_FLAGS;
3633             }
3634           else
3635             {
3636               s->symbol.section = bfd_und_section_ptr;
3637               if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3638                 s->symbol.flags |= BSF_WEAK;
3639             }
3640           break;
3641         case BFD_MACH_O_N_PBUD:
3642           s->symbol.section = bfd_und_section_ptr;
3643           break;
3644         case BFD_MACH_O_N_ABS:
3645           s->symbol.section = bfd_abs_section_ptr;
3646           break;
3647         case BFD_MACH_O_N_SECT:
3648           if ((section > 0) && (section <= mdata->nsects))
3649             {
3650               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3651               s->symbol.value =
3652                 s->symbol.value - mdata->sections[section - 1]->addr;
3653             }
3654           else
3655             {
3656               /* Mach-O uses 0 to mean "no section"; not an error.  */
3657               if (section != 0)
3658                 {
3659                   (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3660                                            "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3661                                          s->symbol.name, section, mdata->nsects);
3662                 }
3663               s->symbol.section = bfd_und_section_ptr;
3664             }
3665           break;
3666         case BFD_MACH_O_N_INDR:
3667           /* FIXME: we don't follow the BFD convention as this indirect symbol
3668              won't be followed by the referenced one.  This looks harmless
3669              unless we start using the linker.  */
3670           s->symbol.flags |= BSF_INDIRECT;
3671           s->symbol.section = bfd_ind_section_ptr;
3672           s->symbol.value = 0;
3673           break;
3674         default:
3675           (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3676                                    "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3677                                  s->symbol.name, symtype);
3678           s->symbol.section = bfd_und_section_ptr;
3679           break;
3680         }
3681     }
3682
3683   return TRUE;
3684 }
3685
3686 bfd_boolean
3687 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3688 {
3689   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3690   bfd_mach_o_symtab_command *sym = mdata->symtab;
3691
3692   /* Fail if there is no symtab.  */
3693   if (sym == NULL)
3694     return FALSE;
3695
3696   /* Success if already loaded.  */
3697   if (sym->strtab)
3698     return TRUE;
3699
3700   if (abfd->flags & BFD_IN_MEMORY)
3701     {
3702       struct bfd_in_memory *b;
3703
3704       b = (struct bfd_in_memory *) abfd->iostream;
3705
3706       if ((sym->stroff + sym->strsize) > b->size)
3707         {
3708           bfd_set_error (bfd_error_file_truncated);
3709           return FALSE;
3710         }
3711       sym->strtab = (char *) b->buffer + sym->stroff;
3712     }
3713   else
3714     {
3715       sym->strtab = bfd_alloc (abfd, sym->strsize + 1);
3716       if (sym->strtab == NULL)
3717         return FALSE;
3718
3719       if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3720           || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3721         {
3722           /* PR 17512: file: 10888-1609-0.004.  */
3723           bfd_release (abfd, sym->strtab);
3724           sym->strtab = NULL;
3725           bfd_set_error (bfd_error_file_truncated);
3726           return FALSE;
3727         }
3728       /* Zero terminate the string table.  */
3729       sym->strtab[sym->strsize] = 0;
3730     }
3731
3732   return TRUE;
3733 }
3734
3735 bfd_boolean
3736 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3737 {
3738   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3739   bfd_mach_o_symtab_command *sym = mdata->symtab;
3740   unsigned long i;
3741
3742   if (sym == NULL || sym->symbols)
3743     /* Return now if there are no symbols or if already loaded.  */
3744     return TRUE;
3745
3746   sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
3747   if (sym->symbols == NULL)
3748     {
3749       (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3750       sym->nsyms = 0;
3751       return FALSE;
3752     }
3753
3754   if (!bfd_mach_o_read_symtab_strtab (abfd))
3755     goto fail;
3756
3757   for (i = 0; i < sym->nsyms; i++)
3758     if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3759       goto fail;
3760
3761   return TRUE;
3762
3763  fail:
3764   bfd_release (abfd, sym->symbols);
3765   sym->symbols = NULL;
3766   sym->nsyms = 0;
3767   return FALSE;
3768 }
3769
3770 static const char *
3771 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3772 {
3773   switch ((int) flavour)
3774     {
3775     case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
3776     case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
3777     case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3778     case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
3779     case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
3780     case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3781     case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
3782     case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
3783     case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
3784     case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
3785     case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
3786     case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
3787     case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3788     default: return "UNKNOWN";
3789     }
3790 }
3791
3792 static const char *
3793 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3794 {
3795   switch ((int) flavour)
3796     {
3797     case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
3798     case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
3799     case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
3800     case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
3801     case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
3802     case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3803     default: return "UNKNOWN";
3804     }
3805 }
3806
3807 static bfd_boolean
3808 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3809 {
3810   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3811   struct mach_o_str_command_external raw;
3812   unsigned int nameoff;
3813   unsigned int namelen;
3814
3815   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3816       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3817     return FALSE;
3818
3819   nameoff = bfd_h_get_32 (abfd, raw.str);
3820
3821   cmd->name_offset = nameoff;
3822   namelen = command->len - nameoff;
3823   nameoff += command->offset;
3824   cmd->name_str = bfd_alloc (abfd, namelen);
3825   if (cmd->name_str == NULL)
3826     return FALSE;
3827   if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
3828       || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3829     return FALSE;
3830   return TRUE;
3831 }
3832
3833 static bfd_boolean
3834 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3835 {
3836   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3837   struct mach_o_dylib_command_external raw;
3838   unsigned int nameoff;
3839   unsigned int namelen;
3840
3841   switch (command->type)
3842     {
3843     case BFD_MACH_O_LC_LOAD_DYLIB:
3844     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3845     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3846     case BFD_MACH_O_LC_ID_DYLIB:
3847     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3848     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3849       break;
3850     default:
3851       BFD_FAIL ();
3852       return FALSE;
3853     }
3854
3855   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3856       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3857     return FALSE;
3858
3859   nameoff = bfd_h_get_32 (abfd, raw.name);
3860   cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3861   cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3862   cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3863
3864   cmd->name_offset = command->offset + nameoff;
3865   namelen = command->len - nameoff;
3866   cmd->name_str = bfd_alloc (abfd, namelen);
3867   if (cmd->name_str == NULL)
3868     return FALSE;
3869   if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3870       || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3871     return FALSE;
3872   return TRUE;
3873 }
3874
3875 static bfd_boolean
3876 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3877                                 bfd_mach_o_load_command *command)
3878 {
3879   bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3880   struct mach_o_prebound_dylib_command_external raw;
3881   unsigned int nameoff;
3882   unsigned int modoff;
3883   unsigned int str_len;
3884   unsigned char *str;
3885
3886   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3887       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3888     return FALSE;
3889
3890   nameoff = bfd_h_get_32 (abfd, raw.name);
3891   modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3892   if (nameoff > command->len || modoff > command->len)
3893     return FALSE;
3894
3895   str_len = command->len - sizeof (raw);
3896   str = bfd_alloc (abfd, str_len);
3897   if (str == NULL)
3898     return FALSE;
3899   if (bfd_bread (str, str_len, abfd) != str_len)
3900     return FALSE;
3901
3902   cmd->name_offset = command->offset + nameoff;
3903   cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3904   cmd->linked_modules_offset = command->offset + modoff;
3905
3906   cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3907   cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3908   return TRUE;
3909 }
3910
3911 static bfd_boolean
3912 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3913                                bfd_mach_o_load_command *command)
3914 {
3915   bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3916   struct mach_o_prebind_cksum_command_external raw;
3917
3918   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3919       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3920     return FALSE;
3921
3922   cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3923   return TRUE;
3924 }
3925
3926 static bfd_boolean
3927 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3928                                 bfd_mach_o_load_command *command)
3929 {
3930   bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3931   struct mach_o_twolevel_hints_command_external raw;
3932
3933   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3934       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3935     return FALSE;
3936
3937   cmd->offset = bfd_get_32 (abfd, raw.offset);
3938   cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3939   return TRUE;
3940 }
3941
3942 static bfd_boolean
3943 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3944 {
3945   bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3946   struct mach_o_fvmlib_command_external raw;
3947   unsigned int nameoff;
3948   unsigned int namelen;
3949
3950   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3951       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3952     return FALSE;
3953
3954   nameoff = bfd_h_get_32 (abfd, raw.name);
3955   fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3956   fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3957
3958   fvm->name_offset = command->offset + nameoff;
3959   namelen = command->len - nameoff;
3960   fvm->name_str = bfd_alloc (abfd, namelen);
3961   if (fvm->name_str == NULL)
3962     return FALSE;
3963   if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3964       || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
3965     return FALSE;
3966   return TRUE;
3967 }
3968
3969 static bfd_boolean
3970 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3971 {
3972   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3973   bfd_mach_o_thread_command *cmd = &command->command.thread;
3974   unsigned int offset;
3975   unsigned int nflavours;
3976   unsigned int i;
3977
3978   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3979               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3980
3981   /* Count the number of threads.  */
3982   offset = 8;
3983   nflavours = 0;
3984   while (offset != command->len)
3985     {
3986       struct mach_o_thread_command_external raw;
3987
3988       if (offset >= command->len)
3989         return FALSE;
3990
3991       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3992           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3993         return FALSE;
3994
3995       offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3996       nflavours++;
3997     }
3998
3999   /* Allocate threads.  */
4000   cmd->flavours = bfd_alloc2
4001     (abfd, nflavours, sizeof (bfd_mach_o_thread_flavour));
4002   if (cmd->flavours == NULL)
4003     return FALSE;
4004   cmd->nflavours = nflavours;
4005
4006   offset = 8;
4007   nflavours = 0;
4008   while (offset != command->len)
4009     {
4010       struct mach_o_thread_command_external raw;
4011
4012       if (offset >= command->len)
4013         return FALSE;
4014
4015       if (nflavours >= cmd->nflavours)
4016         return FALSE;
4017
4018       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4019           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4020         return FALSE;
4021
4022       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4023       cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4024       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4025       offset += cmd->flavours[nflavours].size + sizeof (raw);
4026       nflavours++;
4027     }
4028
4029   for (i = 0; i < nflavours; i++)
4030     {
4031       asection *bfdsec;
4032       unsigned int snamelen;
4033       char *sname;
4034       const char *flavourstr;
4035       const char *prefix = "LC_THREAD";
4036       unsigned int j = 0;
4037
4038       switch (mdata->header.cputype)
4039         {
4040         case BFD_MACH_O_CPU_TYPE_POWERPC:
4041         case BFD_MACH_O_CPU_TYPE_POWERPC_64:
4042           flavourstr =
4043             bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
4044           break;
4045         case BFD_MACH_O_CPU_TYPE_I386:
4046         case BFD_MACH_O_CPU_TYPE_X86_64:
4047           flavourstr =
4048             bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
4049           break;
4050         default:
4051           flavourstr = "UNKNOWN_ARCHITECTURE";
4052           break;
4053         }
4054
4055       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
4056       sname = bfd_alloc (abfd, snamelen);
4057       if (sname == NULL)
4058         return FALSE;
4059
4060       for (;;)
4061         {
4062           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4063           if (bfd_get_section_by_name (abfd, sname) == NULL)
4064             break;
4065           j++;
4066         }
4067
4068       bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
4069
4070       bfdsec->vma = 0;
4071       bfdsec->lma = 0;
4072       bfdsec->size = cmd->flavours[i].size;
4073       bfdsec->filepos = cmd->flavours[i].offset;
4074       bfdsec->alignment_power = 0x0;
4075
4076       cmd->section = bfdsec;
4077     }
4078
4079   return TRUE;
4080 }
4081
4082 static bfd_boolean
4083 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
4084 {
4085   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
4086   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4087
4088   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4089
4090   {
4091     struct mach_o_dysymtab_command_external raw;
4092
4093     if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4094         || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4095       return FALSE;
4096
4097     cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4098     cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4099     cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4100     cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4101     cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4102     cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4103     cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4104     cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4105     cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4106     cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4107     cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4108     cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4109     cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4110     cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4111     cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4112     cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4113     cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4114     cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4115   }
4116
4117   if (cmd->nmodtab != 0)
4118     {
4119       unsigned int i;
4120       int wide = bfd_mach_o_wide_p (abfd);
4121       unsigned int module_len = wide ? 56 : 52;
4122
4123       cmd->dylib_module =
4124         bfd_alloc2 (abfd, cmd->nmodtab, sizeof (bfd_mach_o_dylib_module));
4125       if (cmd->dylib_module == NULL)
4126         return FALSE;
4127
4128       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
4129         return FALSE;
4130
4131       for (i = 0; i < cmd->nmodtab; i++)
4132         {
4133           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4134           unsigned long v;
4135           unsigned char buf[56];
4136
4137           if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4138             return FALSE;
4139
4140           module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4141           module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4142           module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4143           module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4144           module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4145           module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4146           module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4147           module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4148           module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4149           v = bfd_h_get_32 (abfd, buf +36);
4150           module->iinit = v & 0xffff;
4151           module->iterm = (v >> 16) & 0xffff;
4152           v = bfd_h_get_32 (abfd, buf + 40);
4153           module->ninit = v & 0xffff;
4154           module->nterm = (v >> 16) & 0xffff;
4155           if (wide)
4156             {
4157               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4158               module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4159             }
4160           else
4161             {
4162               module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4163               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4164             }
4165         }
4166     }
4167
4168   if (cmd->ntoc != 0)
4169     {
4170       unsigned long i;
4171
4172       cmd->dylib_toc = bfd_alloc2
4173         (abfd, cmd->ntoc, sizeof (bfd_mach_o_dylib_table_of_content));
4174       if (cmd->dylib_toc == NULL)
4175         return FALSE;
4176
4177       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
4178         return FALSE;
4179
4180       for (i = 0; i < cmd->ntoc; i++)
4181         {
4182           struct mach_o_dylib_table_of_contents_external raw;
4183           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
4184
4185           if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4186             return FALSE;
4187
4188           toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4189           toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4190         }
4191     }
4192
4193   if (cmd->nindirectsyms != 0)
4194     {
4195       unsigned int i;
4196
4197       cmd->indirect_syms = bfd_alloc2
4198         (abfd, cmd->nindirectsyms, sizeof (unsigned int));
4199       if (cmd->indirect_syms == NULL)
4200         return FALSE;
4201
4202       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
4203         return FALSE;
4204
4205       for (i = 0; i < cmd->nindirectsyms; i++)
4206         {
4207           unsigned char raw[4];
4208           unsigned int *is = &cmd->indirect_syms[i];
4209
4210           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4211             return FALSE;
4212
4213           *is = bfd_h_get_32 (abfd, raw);
4214         }
4215     }
4216
4217   if (cmd->nextrefsyms != 0)
4218     {
4219       unsigned long v;
4220       unsigned int i;
4221
4222       cmd->ext_refs = bfd_alloc2
4223         (abfd, cmd->nextrefsyms, sizeof (bfd_mach_o_dylib_reference));
4224       if (cmd->ext_refs == NULL)
4225         return FALSE;
4226
4227       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
4228         return FALSE;
4229
4230       for (i = 0; i < cmd->nextrefsyms; i++)
4231         {
4232           unsigned char raw[4];
4233           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4234
4235           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4236             return FALSE;
4237
4238           /* Fields isym and flags are written as bit-fields, thus we need
4239              a specific processing for endianness.  */
4240           v = bfd_h_get_32 (abfd, raw);
4241           if (bfd_big_endian (abfd))
4242             {
4243               ref->isym = (v >> 8) & 0xffffff;
4244               ref->flags = v & 0xff;
4245             }
4246           else
4247             {
4248               ref->isym = v & 0xffffff;
4249               ref->flags = (v >> 24) & 0xff;
4250             }
4251         }
4252     }
4253
4254   if (mdata->dysymtab)
4255     return FALSE;
4256   mdata->dysymtab = cmd;
4257
4258   return TRUE;
4259 }
4260
4261 static bfd_boolean
4262 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
4263 {
4264   bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4265   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4266   struct mach_o_symtab_command_external raw;
4267
4268   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4269
4270   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4271       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4272     return FALSE;
4273
4274   symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4275   symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4276   symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4277   symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
4278   symtab->symbols = NULL;
4279   symtab->strtab = NULL;
4280
4281   if (symtab->nsyms != 0)
4282     abfd->flags |= HAS_SYMS;
4283
4284   if (mdata->symtab)
4285     return FALSE;
4286   mdata->symtab = symtab;
4287   return TRUE;
4288 }
4289
4290 static bfd_boolean
4291 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
4292 {
4293   bfd_mach_o_uuid_command *cmd = &command->command.uuid;
4294
4295   BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4296
4297   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4298       || bfd_bread (cmd->uuid, 16, abfd) != 16)
4299     return FALSE;
4300
4301   return TRUE;
4302 }
4303
4304 static bfd_boolean
4305 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
4306 {
4307   bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
4308   struct mach_o_linkedit_data_command_external raw;
4309
4310   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4311       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4312     return FALSE;
4313
4314   cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4315   cmd->datasize = bfd_get_32 (abfd, raw.datasize);
4316   return TRUE;
4317 }
4318
4319 static bfd_boolean
4320 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
4321 {
4322   bfd_mach_o_str_command *cmd = &command->command.str;
4323   struct mach_o_str_command_external raw;
4324   unsigned long off;
4325
4326   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4327       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4328     return FALSE;
4329
4330   off = bfd_get_32 (abfd, raw.str);
4331   cmd->stroff = command->offset + off;
4332   cmd->str_len = command->len - off;
4333   cmd->str = bfd_alloc (abfd, cmd->str_len);
4334   if (cmd->str == NULL)
4335     return FALSE;
4336   if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
4337       || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
4338     return FALSE;
4339   return TRUE;
4340 }
4341
4342 static unsigned char *
4343 bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
4344 {
4345   unsigned char *buf;
4346
4347   buf = bfd_alloc (abfd, size);
4348   if (buf == NULL)
4349     return NULL;
4350   if (bfd_seek (abfd, off, SEEK_SET) != 0
4351       || bfd_bread (buf, size, abfd) != size)
4352     return NULL;
4353   return buf;
4354 }
4355
4356 static bfd_boolean
4357 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4358 {
4359   /* Read rebase content.  */
4360   if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4361     {
4362       cmd->rebase_content =
4363         bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4364       if (cmd->rebase_content == NULL)
4365         return FALSE;
4366     }
4367
4368   /* Read bind content.  */
4369   if (cmd->bind_content == NULL && cmd->bind_size != 0)
4370     {
4371       cmd->bind_content =
4372         bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4373       if (cmd->bind_content == NULL)
4374         return FALSE;
4375     }
4376
4377   /* Read weak bind content.  */
4378   if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4379     {
4380       cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4381         (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4382       if (cmd->weak_bind_content == NULL)
4383         return FALSE;
4384     }
4385
4386   /* Read lazy bind content.  */
4387   if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4388     {
4389       cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4390         (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4391       if (cmd->lazy_bind_content == NULL)
4392         return FALSE;
4393     }
4394
4395   /* Read export content.  */
4396   if (cmd->export_content == NULL && cmd->export_size != 0)
4397     {
4398       cmd->export_content = bfd_mach_o_alloc_and_read
4399         (abfd, cmd->export_off, cmd->export_size);
4400       if (cmd->export_content == NULL)
4401         return FALSE;
4402     }
4403
4404   return TRUE;
4405 }
4406
4407 static bfd_boolean
4408 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
4409 {
4410   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
4411   struct mach_o_dyld_info_command_external raw;
4412
4413   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4414       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4415     return FALSE;
4416
4417   cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4418   cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
4419   cmd->rebase_content = NULL;
4420   cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4421   cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
4422   cmd->bind_content = NULL;
4423   cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4424   cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
4425   cmd->weak_bind_content = NULL;
4426   cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4427   cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
4428   cmd->lazy_bind_content = NULL;
4429   cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4430   cmd->export_size = bfd_get_32 (abfd, raw.export_size);
4431   cmd->export_content = NULL;
4432   return TRUE;
4433 }
4434
4435 static bfd_boolean
4436 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4437 {
4438   bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4439   struct mach_o_version_min_command_external raw;
4440   unsigned int ver;
4441
4442   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4443       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4444     return FALSE;
4445
4446   ver = bfd_get_32 (abfd, raw.version);
4447   cmd->rel = ver >> 16;
4448   cmd->maj = ver >> 8;
4449   cmd->min = ver;
4450   cmd->reserved = bfd_get_32 (abfd, raw.reserved);
4451   return TRUE;
4452 }
4453
4454 static bfd_boolean
4455 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4456 {
4457   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4458   struct mach_o_encryption_info_command_external raw;
4459
4460   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4461       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4462     return FALSE;
4463
4464   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4465   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4466   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4467   return TRUE;
4468 }
4469
4470 static bfd_boolean
4471 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4472 {
4473   bfd_mach_o_main_command *cmd = &command->command.main;
4474   struct mach_o_entry_point_command_external raw;
4475
4476   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4477       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4478     return FALSE;
4479
4480   cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4481   cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4482   return TRUE;
4483 }
4484
4485 static bfd_boolean
4486 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4487 {
4488   bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4489   struct mach_o_source_version_command_external raw;
4490   bfd_uint64_t ver;
4491
4492   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4493       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4494     return FALSE;
4495
4496   ver = bfd_get_64 (abfd, raw.version);
4497   /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4498      generates warnings) in case of the host doesn't support 64 bit
4499      integers.  */
4500   cmd->e = ver & 0x3ff;
4501   ver >>= 10;
4502   cmd->d = ver & 0x3ff;
4503   ver >>= 10;
4504   cmd->c = ver & 0x3ff;
4505   ver >>= 10;
4506   cmd->b = ver & 0x3ff;
4507   ver >>= 10;
4508   cmd->a = ver & 0xffffff;
4509   return TRUE;
4510 }
4511
4512 static bfd_boolean
4513 bfd_mach_o_read_segment (bfd *abfd,
4514                          bfd_mach_o_load_command *command,
4515                          unsigned int wide)
4516 {
4517   bfd_mach_o_segment_command *seg = &command->command.segment;
4518   unsigned long i;
4519
4520   if (wide)
4521     {
4522       struct mach_o_segment_command_64_external raw;
4523
4524       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
4525
4526       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4527           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4528         return FALSE;
4529
4530       memcpy (seg->segname, raw.segname, 16);
4531       seg->segname[16] = '\0';
4532
4533       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4534       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4535       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4536       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4537       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4538       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4539       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4540       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4541     }
4542   else
4543     {
4544       struct mach_o_segment_command_32_external raw;
4545
4546       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4547
4548       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4549           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4550         return FALSE;
4551
4552       memcpy (seg->segname, raw.segname, 16);
4553       seg->segname[16] = '\0';
4554
4555       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4556       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4557       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4558       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4559       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4560       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4561       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4562       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4563     }
4564   seg->sect_head = NULL;
4565   seg->sect_tail = NULL;
4566
4567   for (i = 0; i < seg->nsects; i++)
4568     {
4569       bfd_vma segoff;
4570       asection *sec;
4571
4572       if (wide)
4573         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
4574           + (i * BFD_MACH_O_SECTION_64_SIZE);
4575       else
4576         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
4577           + (i * BFD_MACH_O_SECTION_SIZE);
4578
4579       sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
4580       if (sec == NULL)
4581         return FALSE;
4582
4583       bfd_mach_o_append_section_to_segment
4584         (seg, bfd_mach_o_get_mach_o_section (sec));
4585     }
4586
4587   return TRUE;
4588 }
4589
4590 static bfd_boolean
4591 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
4592 {
4593   return bfd_mach_o_read_segment (abfd, command, 0);
4594 }
4595
4596 static bfd_boolean
4597 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
4598 {
4599   return bfd_mach_o_read_segment (abfd, command, 1);
4600 }
4601
4602 static bfd_boolean
4603 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
4604 {
4605   struct mach_o_load_command_external raw;
4606   unsigned int cmd;
4607
4608   /* Read command type and length.  */
4609   if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
4610       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
4611     return FALSE;
4612
4613   cmd = bfd_h_get_32 (abfd, raw.cmd);
4614   command->type =  cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4615   command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
4616   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
4617
4618   switch (command->type)
4619     {
4620     case BFD_MACH_O_LC_SEGMENT:
4621       if (!bfd_mach_o_read_segment_32 (abfd, command))
4622         return FALSE;
4623       break;
4624     case BFD_MACH_O_LC_SEGMENT_64:
4625       if (!bfd_mach_o_read_segment_64 (abfd, command))
4626         return FALSE;
4627       break;
4628     case BFD_MACH_O_LC_SYMTAB:
4629       if (!bfd_mach_o_read_symtab (abfd, command))
4630         return FALSE;
4631       break;
4632     case BFD_MACH_O_LC_SYMSEG:
4633       break;
4634     case BFD_MACH_O_LC_THREAD:
4635     case BFD_MACH_O_LC_UNIXTHREAD:
4636       if (!bfd_mach_o_read_thread (abfd, command))
4637         return FALSE;
4638       break;
4639     case BFD_MACH_O_LC_LOAD_DYLINKER:
4640     case BFD_MACH_O_LC_ID_DYLINKER:
4641     case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
4642       if (!bfd_mach_o_read_dylinker (abfd, command))
4643         return FALSE;
4644       break;
4645     case BFD_MACH_O_LC_LOAD_DYLIB:
4646     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4647     case BFD_MACH_O_LC_ID_DYLIB:
4648     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4649     case BFD_MACH_O_LC_REEXPORT_DYLIB:
4650     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4651       if (!bfd_mach_o_read_dylib (abfd, command))
4652         return FALSE;
4653       break;
4654     case BFD_MACH_O_LC_PREBOUND_DYLIB:
4655       if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4656         return FALSE;
4657       break;
4658     case BFD_MACH_O_LC_LOADFVMLIB:
4659     case BFD_MACH_O_LC_IDFVMLIB:
4660       if (!bfd_mach_o_read_fvmlib (abfd, command))
4661         return FALSE;
4662       break;
4663     case BFD_MACH_O_LC_IDENT:
4664     case BFD_MACH_O_LC_FVMFILE:
4665     case BFD_MACH_O_LC_PREPAGE:
4666     case BFD_MACH_O_LC_ROUTINES:
4667     case BFD_MACH_O_LC_ROUTINES_64:
4668       break;
4669     case BFD_MACH_O_LC_SUB_FRAMEWORK:
4670     case BFD_MACH_O_LC_SUB_UMBRELLA:
4671     case BFD_MACH_O_LC_SUB_LIBRARY:
4672     case BFD_MACH_O_LC_SUB_CLIENT:
4673     case BFD_MACH_O_LC_RPATH:
4674       if (!bfd_mach_o_read_str (abfd, command))
4675         return FALSE;
4676       break;
4677     case BFD_MACH_O_LC_DYSYMTAB:
4678       if (!bfd_mach_o_read_dysymtab (abfd, command))
4679         return FALSE;
4680       break;
4681     case BFD_MACH_O_LC_PREBIND_CKSUM:
4682       if (!bfd_mach_o_read_prebind_cksum (abfd, command))
4683         return FALSE;
4684       break;
4685     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
4686       if (!bfd_mach_o_read_twolevel_hints (abfd, command))
4687         return FALSE;
4688       break;
4689     case BFD_MACH_O_LC_UUID:
4690       if (!bfd_mach_o_read_uuid (abfd, command))
4691         return FALSE;
4692       break;
4693     case BFD_MACH_O_LC_CODE_SIGNATURE:
4694     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
4695     case BFD_MACH_O_LC_FUNCTION_STARTS:
4696     case BFD_MACH_O_LC_DATA_IN_CODE:
4697     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
4698       if (!bfd_mach_o_read_linkedit (abfd, command))
4699         return FALSE;
4700       break;
4701     case BFD_MACH_O_LC_ENCRYPTION_INFO:
4702       if (!bfd_mach_o_read_encryption_info (abfd, command))
4703         return FALSE;
4704       break;
4705     case BFD_MACH_O_LC_DYLD_INFO:
4706       if (!bfd_mach_o_read_dyld_info (abfd, command))
4707         return FALSE;
4708       break;
4709     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
4710     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
4711       if (!bfd_mach_o_read_version_min (abfd, command))
4712         return FALSE;
4713       break;
4714     case BFD_MACH_O_LC_MAIN:
4715       if (!bfd_mach_o_read_main (abfd, command))
4716         return FALSE;
4717       break;
4718     case BFD_MACH_O_LC_SOURCE_VERSION:
4719       if (!bfd_mach_o_read_source_version (abfd, command))
4720         return FALSE;
4721       break;
4722     default:
4723       command->len = 0;
4724       (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
4725                             abfd, (unsigned long) command->type);
4726       return FALSE;
4727     }
4728
4729   return TRUE;
4730 }
4731
4732 static void
4733 bfd_mach_o_flatten_sections (bfd *abfd)
4734 {
4735   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4736   bfd_mach_o_load_command *cmd;
4737   long csect = 0;
4738
4739   /* Count total number of sections.  */
4740   mdata->nsects = 0;
4741
4742   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4743     {
4744       if (cmd->type == BFD_MACH_O_LC_SEGMENT
4745           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4746         {
4747           bfd_mach_o_segment_command *seg = &cmd->command.segment;
4748
4749           mdata->nsects += seg->nsects;
4750         }
4751     }
4752
4753   /* Allocate sections array.  */
4754   mdata->sections = bfd_alloc2 (abfd,
4755                                 mdata->nsects, sizeof (bfd_mach_o_section *));
4756
4757   /* Fill the array.  */
4758   csect = 0;
4759
4760   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4761     {
4762       if (cmd->type == BFD_MACH_O_LC_SEGMENT
4763           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4764         {
4765           bfd_mach_o_segment_command *seg = &cmd->command.segment;
4766           bfd_mach_o_section *sec;
4767
4768           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4769
4770           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4771             mdata->sections[csect++] = sec;
4772         }
4773     }
4774 }
4775
4776 static bfd_boolean
4777 bfd_mach_o_scan_start_address (bfd *abfd)
4778 {
4779   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4780   bfd_mach_o_thread_command *thr = NULL;
4781   bfd_mach_o_load_command *cmd;
4782   unsigned long i;
4783
4784   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4785     if (cmd->type == BFD_MACH_O_LC_THREAD
4786         || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
4787       {
4788         thr = &cmd->command.thread;
4789         break;
4790       }
4791     else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
4792       {
4793         bfd_mach_o_main_command *main_cmd = &cmd->command.main;
4794         bfd_mach_o_section *text_sect = mdata->sections[0];
4795
4796         if (text_sect)
4797           {
4798             abfd->start_address = main_cmd->entryoff
4799               + (text_sect->addr - text_sect->offset);
4800             return TRUE;
4801           }
4802       }
4803
4804   /* An object file has no start address, so do not fail if not found.  */
4805   if (thr == NULL)
4806     return TRUE;
4807
4808   /* FIXME: create a subtarget hook ?  */
4809   for (i = 0; i < thr->nflavours; i++)
4810     {
4811       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4812           && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
4813         {
4814           unsigned char buf[4];
4815
4816           if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
4817               || bfd_bread (buf, 4, abfd) != 4)
4818             return FALSE;
4819
4820           abfd->start_address = bfd_h_get_32 (abfd, buf);
4821         }
4822       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4823                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4824         {
4825           unsigned char buf[4];
4826
4827           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4828               || bfd_bread (buf, 4, abfd) != 4)
4829             return FALSE;
4830
4831           abfd->start_address = bfd_h_get_32 (abfd, buf);
4832         }
4833       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4834                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4835         {
4836           unsigned char buf[8];
4837
4838           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4839               || bfd_bread (buf, 8, abfd) != 8)
4840             return FALSE;
4841
4842           abfd->start_address = bfd_h_get_64 (abfd, buf);
4843         }
4844       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4845                && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4846         {
4847           unsigned char buf[8];
4848
4849           if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4850               || bfd_bread (buf, 8, abfd) != 8)
4851             return FALSE;
4852
4853           abfd->start_address = bfd_h_get_64 (abfd, buf);
4854         }
4855     }
4856
4857   return TRUE;
4858 }
4859
4860 bfd_boolean
4861 bfd_mach_o_set_arch_mach (bfd *abfd,
4862                           enum bfd_architecture arch,
4863                           unsigned long machine)
4864 {
4865   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4866
4867   /* If this isn't the right architecture for this backend, and this
4868      isn't the generic backend, fail.  */
4869   if (arch != bed->arch
4870       && arch != bfd_arch_unknown
4871       && bed->arch != bfd_arch_unknown)
4872     return FALSE;
4873
4874   return bfd_default_set_arch_mach (abfd, arch, machine);
4875 }
4876
4877 static bfd_boolean
4878 bfd_mach_o_scan (bfd *abfd,
4879                  bfd_mach_o_header *header,
4880                  bfd_mach_o_data_struct *mdata)
4881 {
4882   unsigned int i;
4883   enum bfd_architecture cputype;
4884   unsigned long cpusubtype;
4885   unsigned int hdrsize;
4886
4887   hdrsize = mach_o_wide_p (header) ?
4888     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4889
4890   mdata->header = *header;
4891
4892   abfd->flags = abfd->flags & BFD_IN_MEMORY;
4893   switch (header->filetype)
4894     {
4895     case BFD_MACH_O_MH_OBJECT:
4896       abfd->flags |= HAS_RELOC;
4897       break;
4898     case BFD_MACH_O_MH_EXECUTE:
4899       abfd->flags |= EXEC_P;
4900       break;
4901     case BFD_MACH_O_MH_DYLIB:
4902     case BFD_MACH_O_MH_BUNDLE:
4903       abfd->flags |= DYNAMIC;
4904       break;
4905     }
4906
4907   abfd->tdata.mach_o_data = mdata;
4908
4909   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4910                                    &cputype, &cpusubtype);
4911   if (cputype == bfd_arch_unknown)
4912     {
4913       (*_bfd_error_handler)
4914         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4915          header->cputype, header->cpusubtype);
4916       return FALSE;
4917     }
4918
4919   bfd_set_arch_mach (abfd, cputype, cpusubtype);
4920
4921   if (header->ncmds != 0)
4922     {
4923       bfd_mach_o_load_command *cmd;
4924
4925       mdata->first_command = NULL;
4926       mdata->last_command = NULL;
4927
4928       cmd = bfd_alloc2 (abfd, header->ncmds, sizeof (bfd_mach_o_load_command));
4929       if (cmd == NULL)
4930         return FALSE;
4931
4932       for (i = 0; i < header->ncmds; i++)
4933         {
4934           bfd_mach_o_load_command *cur = &cmd[i];
4935
4936           bfd_mach_o_append_command (abfd, cur);
4937
4938           if (i == 0)
4939             cur->offset = hdrsize;
4940           else
4941             {
4942               bfd_mach_o_load_command *prev = &cmd[i - 1];
4943               cur->offset = prev->offset + prev->len;
4944             }
4945
4946           if (!bfd_mach_o_read_command (abfd, cur))
4947             return FALSE;
4948         }
4949     }
4950
4951   /* Sections should be flatten before scanning start address.  */
4952   bfd_mach_o_flatten_sections (abfd);
4953   if (!bfd_mach_o_scan_start_address (abfd))
4954     return FALSE;
4955
4956   return TRUE;
4957 }
4958
4959 bfd_boolean
4960 bfd_mach_o_mkobject_init (bfd *abfd)
4961 {
4962   bfd_mach_o_data_struct *mdata = NULL;
4963
4964   mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4965   if (mdata == NULL)
4966     return FALSE;
4967   abfd->tdata.mach_o_data = mdata;
4968
4969   mdata->header.magic = 0;
4970   mdata->header.cputype = 0;
4971   mdata->header.cpusubtype = 0;
4972   mdata->header.filetype = 0;
4973   mdata->header.ncmds = 0;
4974   mdata->header.sizeofcmds = 0;
4975   mdata->header.flags = 0;
4976   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4977   mdata->first_command = NULL;
4978   mdata->last_command = NULL;
4979   mdata->nsects = 0;
4980   mdata->sections = NULL;
4981   mdata->dyn_reloc_cache = NULL;
4982
4983   return TRUE;
4984 }
4985
4986 static bfd_boolean
4987 bfd_mach_o_gen_mkobject (bfd *abfd)
4988 {
4989   bfd_mach_o_data_struct *mdata;
4990
4991   if (!bfd_mach_o_mkobject_init (abfd))
4992     return FALSE;
4993
4994   mdata = bfd_mach_o_get_data (abfd);
4995   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4996   mdata->header.cputype = 0;
4997   mdata->header.cpusubtype = 0;
4998   mdata->header.byteorder = abfd->xvec->byteorder;
4999   mdata->header.version = 1;
5000
5001   return TRUE;
5002 }
5003
5004 const bfd_target *
5005 bfd_mach_o_header_p (bfd *abfd,
5006                      bfd_mach_o_filetype filetype,
5007                      bfd_mach_o_cpu_type cputype)
5008 {
5009   bfd_mach_o_header header;
5010   bfd_mach_o_data_struct *mdata;
5011
5012   if (!bfd_mach_o_read_header (abfd, &header))
5013     goto wrong;
5014
5015   if (! (header.byteorder == BFD_ENDIAN_BIG
5016          || header.byteorder == BFD_ENDIAN_LITTLE))
5017     {
5018       (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
5019                              (unsigned long) header.byteorder);
5020       goto wrong;
5021     }
5022
5023   if (! ((header.byteorder == BFD_ENDIAN_BIG
5024           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5025           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5026          || (header.byteorder == BFD_ENDIAN_LITTLE
5027              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5028              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5029     goto wrong;
5030
5031   /* Check cputype and filetype.
5032      In case of wildcard, do not accept magics that are handled by existing
5033      targets.  */
5034   if (cputype)
5035     {
5036       if (header.cputype != cputype)
5037         goto wrong;
5038     }
5039   else
5040     {
5041 #ifndef BFD64
5042       /* Do not recognize 64 architectures if not configured for 64bit targets.
5043          This could happen only for generic targets.  */
5044       if (mach_o_wide_p (&header))
5045          goto wrong;
5046 #endif
5047     }
5048
5049   if (filetype)
5050     {
5051       if (header.filetype != filetype)
5052         goto wrong;
5053     }
5054   else
5055     {
5056       switch (header.filetype)
5057         {
5058         case BFD_MACH_O_MH_CORE:
5059           /* Handled by core_p */
5060           goto wrong;
5061         default:
5062           break;
5063         }
5064     }
5065
5066   mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5067   if (mdata == NULL)
5068     goto fail;
5069
5070   if (!bfd_mach_o_scan (abfd, &header, mdata))
5071     goto wrong;
5072
5073   return abfd->xvec;
5074
5075  wrong:
5076   bfd_set_error (bfd_error_wrong_format);
5077
5078  fail:
5079   return NULL;
5080 }
5081
5082 static const bfd_target *
5083 bfd_mach_o_gen_object_p (bfd *abfd)
5084 {
5085   return bfd_mach_o_header_p (abfd, 0, 0);
5086 }
5087
5088 static const bfd_target *
5089 bfd_mach_o_gen_core_p (bfd *abfd)
5090 {
5091   return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
5092 }
5093
5094 /* Return the base address of ABFD, ie the address at which the image is
5095    mapped.  The possible initial pagezero is ignored.  */
5096
5097 bfd_vma
5098 bfd_mach_o_get_base_address (bfd *abfd)
5099 {
5100   bfd_mach_o_data_struct *mdata;
5101   bfd_mach_o_load_command *cmd;
5102
5103   /* Check for Mach-O.  */
5104   if (!bfd_mach_o_valid (abfd))
5105     return 0;
5106   mdata = bfd_mach_o_get_data (abfd);
5107
5108   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5109     {
5110       if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5111            || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5112         {
5113           struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5114
5115           if (segcmd->initprot != 0)
5116             return segcmd->vmaddr;
5117         }
5118     }
5119   return 0;
5120 }
5121
5122 typedef struct mach_o_fat_archentry
5123 {
5124   unsigned long cputype;
5125   unsigned long cpusubtype;
5126   unsigned long offset;
5127   unsigned long size;
5128   unsigned long align;
5129 } mach_o_fat_archentry;
5130
5131 typedef struct mach_o_fat_data_struct
5132 {
5133   unsigned long magic;
5134   unsigned long nfat_arch;
5135   mach_o_fat_archentry *archentries;
5136 } mach_o_fat_data_struct;
5137
5138 const bfd_target *
5139 bfd_mach_o_archive_p (bfd *abfd)
5140 {
5141   mach_o_fat_data_struct *adata = NULL;
5142   struct mach_o_fat_header_external hdr;
5143   unsigned long i;
5144
5145   if (bfd_seek (abfd, 0, SEEK_SET) != 0
5146       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
5147     goto error;
5148
5149   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
5150   if (adata == NULL)
5151     goto error;
5152
5153   adata->magic = bfd_getb32 (hdr.magic);
5154   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
5155   if (adata->magic != 0xcafebabe)
5156     goto error;
5157   /* Avoid matching Java bytecode files, which have the same magic number.
5158      In the Java bytecode file format this field contains the JVM version,
5159      which starts at 43.0.  */
5160   if (adata->nfat_arch > 30)
5161     goto error;
5162
5163   adata->archentries =
5164     bfd_alloc2 (abfd, adata->nfat_arch, sizeof (mach_o_fat_archentry));
5165   if (adata->archentries == NULL)
5166     goto error;
5167
5168   for (i = 0; i < adata->nfat_arch; i++)
5169     {
5170       struct mach_o_fat_arch_external arch;
5171       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
5172         goto error;
5173       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5174       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5175       adata->archentries[i].offset = bfd_getb32 (arch.offset);
5176       adata->archentries[i].size = bfd_getb32 (arch.size);
5177       adata->archentries[i].align = bfd_getb32 (arch.align);
5178     }
5179
5180   abfd->tdata.mach_o_fat_data = adata;
5181
5182   return abfd->xvec;
5183
5184  error:
5185   if (adata != NULL)
5186     bfd_release (abfd, adata);
5187   bfd_set_error (bfd_error_wrong_format);
5188   return NULL;
5189 }
5190
5191 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5192    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5193    Set arelt_data and origin fields too.  */
5194
5195 static void
5196 bfd_mach_o_fat_member_init (bfd *abfd,
5197                             enum bfd_architecture arch_type,
5198                             unsigned long arch_subtype,
5199                             mach_o_fat_archentry *entry)
5200 {
5201   struct areltdata *areltdata;
5202   /* Create the member filename. Use ARCH_NAME.  */
5203   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5204
5205   if (ap)
5206     {
5207       /* Use the architecture name if known.  */
5208       abfd->filename = xstrdup (ap->printable_name);
5209     }
5210   else
5211     {
5212       /* Forge a uniq id.  */
5213       const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
5214       char *name = xmalloc (namelen);
5215       snprintf (name, namelen, "0x%lx-0x%lx",
5216                 entry->cputype, entry->cpusubtype);
5217       abfd->filename = name;
5218     }
5219
5220   areltdata = bfd_zmalloc (sizeof (struct areltdata));
5221   areltdata->parsed_size = entry->size;
5222   abfd->arelt_data = areltdata;
5223   abfd->iostream = NULL;
5224   abfd->origin = entry->offset;
5225 }
5226
5227 bfd *
5228 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
5229 {
5230   mach_o_fat_data_struct *adata;
5231   mach_o_fat_archentry *entry = NULL;
5232   unsigned long i;
5233   bfd *nbfd;
5234   enum bfd_architecture arch_type;
5235   unsigned long arch_subtype;
5236
5237   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
5238   BFD_ASSERT (adata != NULL);
5239
5240   /* Find index of previous entry.  */
5241   if (prev == NULL)
5242     {
5243       /* Start at first one.  */
5244       i = 0;
5245     }
5246   else
5247     {
5248       /* Find index of PREV.  */
5249       for (i = 0; i < adata->nfat_arch; i++)
5250         {
5251           if (adata->archentries[i].offset == prev->origin)
5252             break;
5253         }
5254
5255       if (i == adata->nfat_arch)
5256         {
5257           /* Not found.  */
5258           bfd_set_error (bfd_error_bad_value);
5259           return NULL;
5260         }
5261
5262       /* Get next entry.  */
5263       i++;
5264     }
5265
5266   if (i >= adata->nfat_arch)
5267     {
5268       bfd_set_error (bfd_error_no_more_archived_files);
5269       return NULL;
5270     }
5271
5272   entry = &adata->archentries[i];
5273   nbfd = _bfd_new_bfd_contained_in (archive);
5274   if (nbfd == NULL)
5275     return NULL;
5276
5277   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5278                                    &arch_type, &arch_subtype);
5279
5280   bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
5281
5282   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
5283
5284   return nbfd;
5285 }
5286
5287 /* Analogous to stat call.  */
5288
5289 static int
5290 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5291 {
5292   if (abfd->arelt_data == NULL)
5293     {
5294       bfd_set_error (bfd_error_invalid_operation);
5295       return -1;
5296     }
5297
5298   buf->st_mtime = 0;
5299   buf->st_uid = 0;
5300   buf->st_gid = 0;
5301   buf->st_mode = 0644;
5302   buf->st_size = arelt_size (abfd);
5303
5304   return 0;
5305 }
5306
5307 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5308    If ABFD is a fat image containing a member that corresponds to FORMAT
5309    and ARCH, returns it.
5310    In other case, returns NULL.
5311    This function allows transparent uses of fat images.  */
5312
5313 bfd *
5314 bfd_mach_o_fat_extract (bfd *abfd,
5315                         bfd_format format,
5316                         const bfd_arch_info_type *arch)
5317 {
5318   bfd *res;
5319   mach_o_fat_data_struct *adata;
5320   unsigned int i;
5321
5322   if (bfd_check_format (abfd, format))
5323     {
5324       if (bfd_get_arch_info (abfd) == arch)
5325         return abfd;
5326       return NULL;
5327     }
5328   if (!bfd_check_format (abfd, bfd_archive)
5329       || abfd->xvec != &mach_o_fat_vec)
5330     return NULL;
5331
5332   /* This is a Mach-O fat image.  */
5333   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5334   BFD_ASSERT (adata != NULL);
5335
5336   for (i = 0; i < adata->nfat_arch; i++)
5337     {
5338       struct mach_o_fat_archentry *e = &adata->archentries[i];
5339       enum bfd_architecture cpu_type;
5340       unsigned long cpu_subtype;
5341
5342       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5343                                        &cpu_type, &cpu_subtype);
5344       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5345         continue;
5346
5347       /* The architecture is found.  */
5348       res = _bfd_new_bfd_contained_in (abfd);
5349       if (res == NULL)
5350         return NULL;
5351
5352       bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
5353
5354       if (bfd_check_format (res, format))
5355         {
5356           BFD_ASSERT (bfd_get_arch_info (res) == arch);
5357           return res;
5358         }
5359       bfd_close (res);
5360       return NULL;
5361     }
5362
5363   return NULL;
5364 }
5365
5366 int
5367 bfd_mach_o_lookup_command (bfd *abfd,
5368                            bfd_mach_o_load_command_type type,
5369                            bfd_mach_o_load_command **mcommand)
5370 {
5371   struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5372   struct bfd_mach_o_load_command *cmd;
5373   unsigned int num;
5374
5375   BFD_ASSERT (mdata != NULL);
5376   BFD_ASSERT (mcommand != NULL);
5377
5378   num = 0;
5379   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5380     {
5381       if (cmd->type != type)
5382         continue;
5383
5384       if (num == 0)
5385         *mcommand = cmd;
5386       num++;
5387     }
5388
5389   return num;
5390 }
5391
5392 unsigned long
5393 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
5394 {
5395   switch (type)
5396     {
5397     case BFD_MACH_O_CPU_TYPE_MC680x0:
5398       return 0x04000000;
5399     case BFD_MACH_O_CPU_TYPE_MC88000:
5400       return 0xffffe000;
5401     case BFD_MACH_O_CPU_TYPE_POWERPC:
5402       return 0xc0000000;
5403     case BFD_MACH_O_CPU_TYPE_I386:
5404       return 0xc0000000;
5405     case BFD_MACH_O_CPU_TYPE_SPARC:
5406       return 0xf0000000;
5407     case BFD_MACH_O_CPU_TYPE_I860:
5408       return 0;
5409     case BFD_MACH_O_CPU_TYPE_HPPA:
5410       return 0xc0000000 - 0x04000000;
5411     default:
5412       return 0;
5413     }
5414 }
5415
5416 /* The following two tables should be kept, as far as possible, in order of
5417    most frequently used entries to optimize their use from gas.  */
5418
5419 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
5420 {
5421   { "regular", BFD_MACH_O_S_REGULAR},
5422   { "coalesced", BFD_MACH_O_S_COALESCED},
5423   { "zerofill", BFD_MACH_O_S_ZEROFILL},
5424   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5425   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5426   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
5427   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
5428   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
5429   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5430   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
5431   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5432   { "interposing", BFD_MACH_O_S_INTERPOSING},
5433   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
5434   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5435   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
5436   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
5437   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5438   { NULL, 0}
5439 };
5440
5441 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
5442 {
5443   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5444   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
5445   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5446   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
5447   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
5448   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5449   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5450   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5451   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
5452   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5453   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5454   { NULL, 0}
5455 };
5456
5457 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
5458
5459 unsigned int
5460 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
5461 {
5462   const bfd_mach_o_xlat_name *x;
5463   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5464
5465   for (x = bfd_mach_o_section_type_name; x->name; x++)
5466     if (strcmp (x->name, name) == 0)
5467       {
5468         /* We found it... does the target support it?  */
5469         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5470             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5471           return x->val; /* OK.  */
5472         else
5473           break; /* Not supported.  */
5474       }
5475   /* Maximum section ID = 0xff.  */
5476   return 256;
5477 }
5478
5479 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
5480
5481 unsigned int
5482 bfd_mach_o_get_section_attribute_from_name (const char *name)
5483 {
5484   const bfd_mach_o_xlat_name *x;
5485
5486   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5487     if (strcmp (x->name, name) == 0)
5488       return x->val;
5489   return (unsigned int)-1;
5490 }
5491
5492 int
5493 bfd_mach_o_core_fetch_environment (bfd *abfd,
5494                                    unsigned char **rbuf,
5495                                    unsigned int *rlen)
5496 {
5497   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5498   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
5499   bfd_mach_o_load_command *cmd;
5500
5501   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5502     {
5503       bfd_mach_o_segment_command *seg;
5504
5505       if (cmd->type != BFD_MACH_O_LC_SEGMENT)
5506         continue;
5507
5508       seg = &cmd->command.segment;
5509
5510       if ((seg->vmaddr + seg->vmsize) == stackaddr)
5511         {
5512           unsigned long start = seg->fileoff;
5513           unsigned long end = seg->fileoff + seg->filesize;
5514           unsigned char *buf = bfd_malloc (1024);
5515           unsigned long size = 1024;
5516
5517           for (;;)
5518             {
5519               bfd_size_type nread = 0;
5520               unsigned long offset;
5521               int found_nonnull = 0;
5522
5523               if (size > (end - start))
5524                 size = (end - start);
5525
5526               buf = bfd_realloc_or_free (buf, size);
5527               if (buf == NULL)
5528                 return -1;
5529
5530               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
5531                 {
5532                   free (buf);
5533                   return -1;
5534                 }
5535
5536               nread = bfd_bread (buf, size, abfd);
5537
5538               if (nread != size)
5539                 {
5540                   free (buf);
5541                   return -1;
5542                 }
5543
5544               for (offset = 4; offset <= size; offset += 4)
5545                 {
5546                   unsigned long val;
5547
5548                   val = *((unsigned long *) (buf + size - offset));
5549                   if (! found_nonnull)
5550                     {
5551                       if (val != 0)
5552                         found_nonnull = 1;
5553                     }
5554                   else if (val == 0x0)
5555                     {
5556                       unsigned long bottom;
5557                       unsigned long top;
5558
5559                       bottom = seg->fileoff + seg->filesize - offset;
5560                       top = seg->fileoff + seg->filesize - 4;
5561                       *rbuf = bfd_malloc (top - bottom);
5562                       *rlen = top - bottom;
5563
5564                       memcpy (*rbuf, buf + size - *rlen, *rlen);
5565                       free (buf);
5566                       return 0;
5567                     }
5568                 }
5569
5570               if (size == (end - start))
5571                 break;
5572
5573               size *= 2;
5574             }
5575
5576           free (buf);
5577         }
5578     }
5579
5580   return -1;
5581 }
5582
5583 char *
5584 bfd_mach_o_core_file_failing_command (bfd *abfd)
5585 {
5586   unsigned char *buf = NULL;
5587   unsigned int len = 0;
5588   int ret;
5589
5590   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5591   if (ret < 0)
5592     return NULL;
5593
5594   return (char *) buf;
5595 }
5596
5597 int
5598 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
5599 {
5600   return 0;
5601 }
5602
5603 static bfd_mach_o_uuid_command *
5604 bfd_mach_o_lookup_uuid_command (bfd *abfd)
5605 {
5606   bfd_mach_o_load_command *uuid_cmd;
5607   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
5608   if (ncmd != 1)
5609     return FALSE;
5610   return &uuid_cmd->command.uuid;
5611 }
5612
5613 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5614
5615 static bfd_boolean
5616 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
5617 {
5618   bfd_mach_o_uuid_command *dsym_uuid_cmd;
5619
5620   BFD_ASSERT (abfd);
5621   BFD_ASSERT (uuid_cmd);
5622
5623   if (!bfd_check_format (abfd, bfd_object))
5624     return FALSE;
5625
5626   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
5627       || bfd_mach_o_get_data (abfd) == NULL
5628       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
5629     return FALSE;
5630
5631   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5632   if (dsym_uuid_cmd == NULL)
5633     return FALSE;
5634
5635   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
5636               sizeof (uuid_cmd->uuid)) != 0)
5637     return FALSE;
5638
5639   return TRUE;
5640 }
5641
5642 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5643    The caller is responsible for closing the returned BFD object and
5644    its my_archive if the returned BFD is in a fat dSYM. */
5645
5646 static bfd *
5647 bfd_mach_o_find_dsym (const char *dsym_filename,
5648                       const bfd_mach_o_uuid_command *uuid_cmd,
5649                       const bfd_arch_info_type *arch)
5650 {
5651   bfd *base_dsym_bfd, *dsym_bfd;
5652
5653   BFD_ASSERT (uuid_cmd);
5654
5655   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
5656   if (base_dsym_bfd == NULL)
5657     return NULL;
5658
5659   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
5660   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
5661     return dsym_bfd;
5662
5663   bfd_close (dsym_bfd);
5664   if (base_dsym_bfd != dsym_bfd)
5665     bfd_close (base_dsym_bfd);
5666
5667   return NULL;
5668 }
5669
5670 /* Return a BFD created from a dSYM file for ABFD.
5671    The caller is responsible for closing the returned BFD object, its
5672    filename, and its my_archive if the returned BFD is in a fat dSYM. */
5673
5674 static bfd *
5675 bfd_mach_o_follow_dsym (bfd *abfd)
5676 {
5677   char *dsym_filename;
5678   bfd_mach_o_uuid_command *uuid_cmd;
5679   bfd *dsym_bfd, *base_bfd = abfd;
5680   const char *base_basename;
5681
5682   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
5683     return NULL;
5684
5685   if (abfd->my_archive)
5686     base_bfd = abfd->my_archive;
5687   /* BFD may have been opened from a stream. */
5688   if (base_bfd->filename == NULL)
5689     {
5690       bfd_set_error (bfd_error_invalid_operation);
5691       return NULL;
5692     }
5693   base_basename = lbasename (base_bfd->filename);
5694
5695   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5696   if (uuid_cmd == NULL)
5697     return NULL;
5698
5699   /* TODO: We assume the DWARF file has the same as the binary's.
5700      It seems apple's GDB checks all files in the dSYM bundle directory.
5701      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5702   */
5703   dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
5704                                        + strlen (dsym_subdir) + 1
5705                                        + strlen (base_basename) + 1);
5706   sprintf (dsym_filename, "%s%s/%s",
5707            base_bfd->filename, dsym_subdir, base_basename);
5708
5709   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
5710                                    bfd_get_arch_info (abfd));
5711   if (dsym_bfd == NULL)
5712     free (dsym_filename);
5713
5714   return dsym_bfd;
5715 }
5716
5717 bfd_boolean
5718 bfd_mach_o_find_nearest_line (bfd *abfd,
5719                               asymbol **symbols,
5720                               asection *section,
5721                               bfd_vma offset,
5722                               const char **filename_ptr,
5723                               const char **functionname_ptr,
5724                               unsigned int *line_ptr,
5725                               unsigned int *discriminator_ptr)
5726 {
5727   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5728   if (mdata == NULL)
5729     return FALSE;
5730   switch (mdata->header.filetype)
5731     {
5732     case BFD_MACH_O_MH_OBJECT:
5733       break;
5734     case BFD_MACH_O_MH_EXECUTE:
5735     case BFD_MACH_O_MH_DYLIB:
5736     case BFD_MACH_O_MH_BUNDLE:
5737     case BFD_MACH_O_MH_KEXT_BUNDLE:
5738       if (mdata->dwarf2_find_line_info == NULL)
5739         {
5740           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5741           /* When we couldn't find dSYM for this binary, we look for
5742              the debug information in the binary itself. In this way,
5743              we won't try finding separated dSYM again because
5744              mdata->dwarf2_find_line_info will be filled. */
5745           if (! mdata->dsym_bfd)
5746             break;
5747           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5748                                               dwarf_debug_sections, symbols,
5749                                               &mdata->dwarf2_find_line_info,
5750                                               FALSE))
5751             return FALSE;
5752         }
5753       break;
5754     default:
5755       return FALSE;
5756     }
5757   return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
5758                                         filename_ptr, functionname_ptr,
5759                                         line_ptr, discriminator_ptr,
5760                                         dwarf_debug_sections, 0,
5761                                         &mdata->dwarf2_find_line_info);
5762 }
5763
5764 bfd_boolean
5765 bfd_mach_o_close_and_cleanup (bfd *abfd)
5766 {
5767   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5768   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5769     {
5770       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5771       bfd_mach_o_free_cached_info (abfd);
5772       if (mdata->dsym_bfd != NULL)
5773         {
5774           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5775           char *dsym_filename = (char *)(fat_bfd
5776                                          ? fat_bfd->filename
5777                                          : mdata->dsym_bfd->filename);
5778           bfd_close (mdata->dsym_bfd);
5779           mdata->dsym_bfd = NULL;
5780           if (fat_bfd)
5781             bfd_close (fat_bfd);
5782           free (dsym_filename);
5783         }
5784     }
5785
5786   if (bfd_get_format (abfd) == bfd_archive
5787       && abfd->xvec == &mach_o_fat_vec)
5788     return TRUE;
5789   return _bfd_generic_close_and_cleanup (abfd);
5790 }
5791
5792 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5793 {
5794   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5795   asection *asect;
5796   free (mdata->dyn_reloc_cache);
5797   mdata->dyn_reloc_cache = NULL;
5798   for (asect = abfd->sections; asect != NULL; asect = asect->next)
5799     {
5800       free (asect->relocation);
5801       asect->relocation = NULL;
5802     }
5803
5804   return TRUE;
5805 }
5806
5807 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5808 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5809
5810 #define bfd_mach_o_swap_reloc_in NULL
5811 #define bfd_mach_o_swap_reloc_out NULL
5812 #define bfd_mach_o_print_thread NULL
5813 #define bfd_mach_o_tgt_seg_table NULL
5814 #define bfd_mach_o_section_type_valid_for_tgt NULL
5815
5816 #define TARGET_NAME             mach_o_be_vec
5817 #define TARGET_STRING           "mach-o-be"
5818 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5819 #define TARGET_PAGESIZE         1
5820 #define TARGET_BIG_ENDIAN       1
5821 #define TARGET_ARCHIVE          0
5822 #define TARGET_PRIORITY         1
5823 #include "mach-o-target.c"
5824
5825 #undef TARGET_NAME
5826 #undef TARGET_STRING
5827 #undef TARGET_ARCHITECTURE
5828 #undef TARGET_PAGESIZE
5829 #undef TARGET_BIG_ENDIAN
5830 #undef TARGET_ARCHIVE
5831 #undef TARGET_PRIORITY
5832
5833 #define TARGET_NAME             mach_o_le_vec
5834 #define TARGET_STRING           "mach-o-le"
5835 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5836 #define TARGET_PAGESIZE         1
5837 #define TARGET_BIG_ENDIAN       0
5838 #define TARGET_ARCHIVE          0
5839 #define TARGET_PRIORITY         1
5840
5841 #include "mach-o-target.c"
5842
5843 #undef TARGET_NAME
5844 #undef TARGET_STRING
5845 #undef TARGET_ARCHITECTURE
5846 #undef TARGET_PAGESIZE
5847 #undef TARGET_BIG_ENDIAN
5848 #undef TARGET_ARCHIVE
5849 #undef TARGET_PRIORITY
5850
5851 /* Not yet handled: creating an archive.  */
5852 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
5853
5854 /* Not used.  */
5855 #define bfd_mach_o_read_ar_hdr                    _bfd_noarchive_read_ar_hdr
5856 #define bfd_mach_o_write_ar_hdr                   _bfd_noarchive_write_ar_hdr
5857 #define bfd_mach_o_slurp_armap                    _bfd_noarchive_slurp_armap
5858 #define bfd_mach_o_slurp_extended_name_table      _bfd_noarchive_slurp_extended_name_table
5859 #define bfd_mach_o_construct_extended_name_table  _bfd_noarchive_construct_extended_name_table
5860 #define bfd_mach_o_truncate_arname                _bfd_noarchive_truncate_arname
5861 #define bfd_mach_o_write_armap                    _bfd_noarchive_write_armap
5862 #define bfd_mach_o_get_elt_at_index               _bfd_noarchive_get_elt_at_index
5863 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
5864 #define bfd_mach_o_update_armap_timestamp         _bfd_noarchive_update_armap_timestamp
5865
5866 #define TARGET_NAME             mach_o_fat_vec
5867 #define TARGET_STRING           "mach-o-fat"
5868 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5869 #define TARGET_PAGESIZE         1
5870 #define TARGET_BIG_ENDIAN       1
5871 #define TARGET_ARCHIVE          1
5872 #define TARGET_PRIORITY         0
5873
5874 #include "mach-o-target.c"
5875
5876 #undef TARGET_NAME
5877 #undef TARGET_STRING
5878 #undef TARGET_ARCHITECTURE
5879 #undef TARGET_PAGESIZE
5880 #undef TARGET_BIG_ENDIAN
5881 #undef TARGET_ARCHIVE
5882 #undef TARGET_PRIORITY