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