bfd/mach-o.c

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