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