bfd/mach-o.c

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