bfd/mach-o.c

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