bfd/mach-o.c

   1 /* Mach-O support for BFD.
   2    Copyright (C) 1999-2016 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))
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) != TRUE)
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 0x%lx"),
2532            (unsigned long) 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 0x%lx"),
2637              (unsigned long) 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             (_("section address (%lx) below start of segment (%lx)"),
2820                (unsigned long) s->addr, (unsigned long) vma);
2821           return FALSE;
2822         }
2823
2824       vma = s->addr + s->size;
2825     }
2826
2827   /* Set segment file offset: make it page aligned.  */
2828   vma = seg->sect_head->addr;
2829   seg->vmaddr = vma & ~pagemask;
2830   if ((mdata->filelen & pagemask) > (vma & pagemask))
2831     mdata->filelen += pagemask + 1;
2832   seg->fileoff = mdata->filelen & ~pagemask;
2833   mdata->filelen = seg->fileoff + (vma & pagemask);
2834
2835   /* Set section file offset.  */
2836   for (s = seg->sect_head; s != NULL; s = s->next)
2837     {
2838       asection *sec = s->bfdsection;
2839       flagword flags = bfd_get_section_flags (abfd, sec);
2840
2841       /* Adjust segment size.  */
2842       seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2843       seg->vmsize += s->size;
2844
2845       /* File offset and length.  */
2846       seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2847
2848       if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
2849           && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2850               != BFD_MACH_O_S_GB_ZEROFILL))
2851         {
2852           mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2853
2854           s->offset = mdata->filelen;
2855           s->bfdsection->filepos = s->offset;
2856
2857           seg->filesize += s->size;
2858           mdata->filelen += s->size;
2859         }
2860       else
2861         {
2862           s->offset = 0;
2863           s->bfdsection->filepos = 0;
2864         }
2865
2866       /* Set protection.  */
2867       if (flags & SEC_LOAD)
2868         {
2869           if (flags & SEC_CODE)
2870             seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
2871           if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
2872             seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
2873         }
2874
2875       /* Relocs shouldn't appear in non-object files.  */
2876       if (s->bfdsection->reloc_count != 0)
2877         return FALSE;
2878     }
2879
2880   /* Set maxprot.  */
2881   if (seg->initprot != 0)
2882     seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2883                  | BFD_MACH_O_PROT_EXECUTE;
2884   else
2885     seg->maxprot = 0;
2886
2887   /* Round segment size (and file size).  */
2888   seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
2889   seg->filesize = (seg->filesize + pagemask) & ~pagemask;
2890   mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
2891
2892   return TRUE;
2893 }
2894
2895 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2896    fields in header.  */
2897
2898 static bfd_boolean
2899 bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
2900 {
2901   unsigned wide = mach_o_wide_p (&mdata->header);
2902   unsigned int hdrlen;
2903   ufile_ptr offset;
2904   bfd_mach_o_load_command *cmd;
2905   unsigned int align;
2906   bfd_boolean ret = TRUE;
2907
2908   hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2909   align = wide ? 8 - 1 : 4 - 1;
2910   offset = hdrlen;
2911   mdata->header.ncmds = 0;
2912
2913   for (cmd = mdata->first_command; cmd; cmd = cmd->next)
2914     {
2915       mdata->header.ncmds++;
2916       cmd->offset = offset;
2917
2918       switch (cmd->type)
2919         {
2920         case BFD_MACH_O_LC_SEGMENT_64:
2921           cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2922             + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
2923           break;
2924         case BFD_MACH_O_LC_SEGMENT:
2925           cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2926             + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
2927           break;
2928         case BFD_MACH_O_LC_SYMTAB:
2929           cmd->len = sizeof (struct mach_o_symtab_command_external)
2930             + BFD_MACH_O_LC_SIZE;
2931           break;
2932         case BFD_MACH_O_LC_DYSYMTAB:
2933           cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2934                  + BFD_MACH_O_LC_SIZE;
2935           break;
2936         case BFD_MACH_O_LC_LOAD_DYLIB:
2937           cmd->len = sizeof (struct mach_o_dylib_command_external)
2938                  + BFD_MACH_O_LC_SIZE;
2939           cmd->command.dylib.name_offset = cmd->len;
2940           cmd->len += strlen (cmd->command.dylib.name_str);
2941           cmd->len = (cmd->len + align) & ~align;
2942           break;
2943         case BFD_MACH_O_LC_LOAD_DYLINKER:
2944           cmd->len = sizeof (struct mach_o_str_command_external)
2945                  + BFD_MACH_O_LC_SIZE;
2946           cmd->command.dylinker.name_offset = cmd->len;
2947           cmd->len += strlen (cmd->command.dylinker.name_str);
2948           cmd->len = (cmd->len + align) & ~align;
2949           break;
2950         case BFD_MACH_O_LC_MAIN:
2951           cmd->len = sizeof (struct mach_o_entry_point_command_external)
2952                  + BFD_MACH_O_LC_SIZE;
2953           break;
2954         case BFD_MACH_O_LC_DYLD_INFO:
2955           cmd->len = sizeof (struct mach_o_dyld_info_command_external)
2956                  + BFD_MACH_O_LC_SIZE;
2957           break;
2958         default:
2959           (*_bfd_error_handler)
2960             (_("unable to layout unknown load command 0x%lx"),
2961              (unsigned long) cmd->type);
2962           ret = FALSE;
2963           break;
2964         }
2965
2966       BFD_ASSERT (cmd->len % (align + 1) == 0);
2967       offset += cmd->len;
2968     }
2969   mdata->header.sizeofcmds = offset - hdrlen;
2970   mdata->filelen = offset;
2971
2972   return ret;
2973 }
2974
2975 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2976    segment.  */
2977
2978 static void
2979 bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
2980                          bfd_mach_o_load_command *cmd,
2981                          const char *segname, unsigned int nbr_sect)
2982 {
2983   bfd_mach_o_segment_command *seg = &cmd->command.segment;
2984   unsigned wide = mach_o_wide_p (&mdata->header);
2985
2986   /* Init segment command.  */
2987   cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
2988   cmd->type_required = FALSE;
2989
2990   strcpy (seg->segname, segname);
2991   seg->nsects = nbr_sect;
2992
2993   seg->vmaddr = 0;
2994   seg->vmsize = 0;
2995
2996   seg->fileoff = 0;
2997   seg->filesize = 0;
2998   seg->maxprot = 0;
2999   seg->initprot = 0;
3000   seg->flags = 0;
3001   seg->sect_head = NULL;
3002   seg->sect_tail = NULL;
3003 }
3004
3005 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3006    TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3007    and copy functionality.  */
3008
3009 bfd_boolean
3010 bfd_mach_o_build_commands (bfd *abfd)
3011 {
3012   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3013   unsigned wide = mach_o_wide_p (&mdata->header);
3014   unsigned int nbr_segcmd = 0;
3015   bfd_mach_o_load_command *commands;
3016   unsigned int nbr_commands;
3017   int symtab_idx = -1;
3018   int dysymtab_idx = -1;
3019   int main_idx = -1;
3020   unsigned int i;
3021
3022   /* Return now if already built.  */
3023   if (mdata->header.ncmds != 0)
3024     return TRUE;
3025
3026   /* Fill in the file type, if not already set.  */
3027   if (mdata->header.filetype == 0)
3028     {
3029       if (abfd->flags & EXEC_P)
3030         mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
3031       else if (abfd->flags & DYNAMIC)
3032         mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
3033       else
3034         mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
3035     }
3036
3037   /* If hasn't already been done, flatten sections list, and sort
3038      if/when required.  Must be done before the symbol table is adjusted,
3039      since that depends on properly numbered sections.  */
3040   if (mdata->nsects == 0 || mdata->sections == NULL)
3041     if (! bfd_mach_o_mangle_sections (abfd, mdata))
3042       return FALSE;
3043
3044   /* Order the symbol table, fill-in/check mach-o specific fields and
3045      partition out any indirect symbols.  */
3046   if (!bfd_mach_o_mangle_symbols (abfd))
3047     return FALSE;
3048
3049   /* Segment commands.  */
3050   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3051     {
3052       /* Only one segment for all the sections.  But the segment is
3053          optional if there is no sections.  */
3054       nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
3055     }
3056   else
3057     {
3058       bfd_mach_o_section *prev_sect = NULL;
3059
3060       /* One pagezero segment and one linkedit segment.  */
3061       nbr_segcmd = 2;
3062
3063       /* Create one segment for associated segment name in sections.
3064          Assume that sections with the same segment name are consecutive.  */
3065       for (i = 0; i < mdata->nsects; i++)
3066         {
3067           bfd_mach_o_section *this_sect = mdata->sections[i];
3068
3069           if (prev_sect == NULL
3070               || strcmp (prev_sect->segname, this_sect->segname) != 0)
3071             {
3072               nbr_segcmd++;
3073               prev_sect = this_sect;
3074             }
3075         }
3076     }
3077
3078   nbr_commands = nbr_segcmd;
3079
3080   /* One command for the symbol table (only if there are symbols.  */
3081   if (bfd_get_symcount (abfd) > 0)
3082     symtab_idx = nbr_commands++;
3083
3084   /* FIXME:
3085      This is a rather crude test for whether we should build a dysymtab.  */
3086   if (bfd_mach_o_should_emit_dysymtab ()
3087       && bfd_get_symcount (abfd))
3088     {
3089       /* If there should be a case where a dysymtab could be emitted without
3090          a symtab (seems improbable), this would need amending.  */
3091       dysymtab_idx = nbr_commands++;
3092     }
3093
3094   /* Add an entry point command.  */
3095   if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3096       && bfd_get_start_address (abfd) != 0)
3097     main_idx = nbr_commands++;
3098
3099   /* Well, we must have a header, at least.  */
3100   mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3101
3102   /* A bit unusual, but no content is valid;
3103      as -n empty.s -o empty.o  */
3104   if (nbr_commands == 0)
3105     {
3106       /* Layout commands (well none...) and set headers command fields.  */
3107       return bfd_mach_o_layout_commands (mdata);
3108     }
3109
3110   /* Create commands for segments (and symtabs), prepend them.  */
3111   commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3112   if (commands == NULL)
3113     return FALSE;
3114   for (i = 0; i < nbr_commands - 1; i++)
3115     commands[i].next = &commands[i + 1];
3116   commands[nbr_commands - 1].next = mdata->first_command;
3117   if (mdata->first_command == NULL)
3118     mdata->last_command = &commands[nbr_commands - 1];
3119   mdata->first_command = &commands[0];
3120
3121   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3122     {
3123       /* For object file, there is only one segment.  */
3124       bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3125     }
3126   else if (nbr_segcmd != 0)
3127     {
3128       bfd_mach_o_load_command *cmd;
3129
3130       BFD_ASSERT (nbr_segcmd >= 2);
3131
3132       /* The pagezero.  */
3133       cmd = &commands[0];
3134       bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3135
3136       /* Segments from sections.  */
3137       cmd++;
3138       for (i = 0; i < mdata->nsects;)
3139         {
3140           const char *segname = mdata->sections[i]->segname;
3141           unsigned int nbr_sect = 1;
3142
3143           /* Count number of sections for this segment.  */
3144           for (i++; i < mdata->nsects; i++)
3145             if (strcmp (mdata->sections[i]->segname, segname) == 0)
3146               nbr_sect++;
3147             else
3148               break;
3149
3150           bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3151           cmd++;
3152         }
3153
3154       /* The linkedit.  */
3155       bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
3156     }
3157
3158   if (symtab_idx >= 0)
3159     {
3160       /* Init symtab command.  */
3161       bfd_mach_o_load_command *cmd = &commands[symtab_idx];
3162
3163       cmd->type = BFD_MACH_O_LC_SYMTAB;
3164       cmd->type_required = FALSE;
3165     }
3166
3167   /* If required, setup symtab command, see comment above about the quality
3168      of this test.  */
3169   if (dysymtab_idx >= 0)
3170     {
3171       bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
3172
3173       cmd->type = BFD_MACH_O_LC_DYSYMTAB;
3174       cmd->type_required = FALSE;
3175     }
3176
3177   /* Create the main command.  */
3178   if (main_idx >= 0)
3179     {
3180       bfd_mach_o_load_command *cmd = &commands[main_idx];
3181
3182       cmd->type = BFD_MACH_O_LC_MAIN;
3183       cmd->type_required = TRUE;
3184
3185       cmd->command.main.entryoff = 0;
3186       cmd->command.main.stacksize = 0;
3187     }
3188
3189   /* Layout commands.  */
3190   if (! bfd_mach_o_layout_commands (mdata))
3191     return FALSE;
3192
3193   /* So, now we have sized the commands and the filelen set to that.
3194      Now we can build the segment command and set the section file offsets.  */
3195   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3196     {
3197       for (i = 0; i < nbr_segcmd; i++)
3198         if (!bfd_mach_o_build_obj_seg_command
3199             (abfd, &commands[i].command.segment))
3200           return FALSE;
3201     }
3202   else
3203     {
3204       bfd_vma maxvma = 0;
3205
3206       /* Skip pagezero and linkedit segments.  */
3207       for (i = 1; i < nbr_segcmd - 1; i++)
3208         {
3209           bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3210
3211           if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3212             return FALSE;
3213
3214           if (seg->vmaddr + seg->vmsize > maxvma)
3215             maxvma = seg->vmaddr + seg->vmsize;
3216         }
3217
3218       /* Set the size of __PAGEZERO.  */
3219       commands[0].command.segment.vmsize =
3220         commands[1].command.segment.vmaddr;
3221
3222       /* Set the vma and fileoff of __LINKEDIT.  */
3223       commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3224       commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3225
3226       /* Set entry point (once segments have been laid out).  */
3227       if (main_idx >= 0)
3228         commands[main_idx].command.main.entryoff =
3229           bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3230     }
3231
3232   return TRUE;
3233 }
3234
3235 /* Set the contents of a section.  */
3236
3237 bfd_boolean
3238 bfd_mach_o_set_section_contents (bfd *abfd,
3239                                  asection *section,
3240                                  const void * location,
3241                                  file_ptr offset,
3242                                  bfd_size_type count)
3243 {
3244   file_ptr pos;
3245
3246   /* Trying to write the first section contents will trigger the creation of
3247      the load commands if they are not already present.  */
3248   if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
3249     return FALSE;
3250
3251   if (count == 0)
3252     return TRUE;
3253
3254   pos = section->filepos + offset;
3255   if (bfd_seek (abfd, pos, SEEK_SET) != 0
3256       || bfd_bwrite (location, count, abfd) != count)
3257     return FALSE;
3258
3259   return TRUE;
3260 }
3261
3262 int
3263 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
3264                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
3265 {
3266   return 0;
3267 }
3268
3269 /* Make an empty symbol.  This is required only because
3270    bfd_make_section_anyway wants to create a symbol for the section.  */
3271
3272 asymbol *
3273 bfd_mach_o_make_empty_symbol (bfd *abfd)
3274 {
3275   asymbol *new_symbol;
3276
3277   new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3278   if (new_symbol == NULL)
3279     return new_symbol;
3280   new_symbol->the_bfd = abfd;
3281   new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
3282   return new_symbol;
3283 }
3284
3285 static bfd_boolean
3286 bfd_mach_o_read_header (bfd *abfd, file_ptr hdr_off, bfd_mach_o_header *header)
3287 {
3288   struct mach_o_header_external raw;
3289   unsigned int size;
3290   bfd_vma (*get32) (const void *) = NULL;
3291
3292   /* Just read the magic number.  */
3293   if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
3294       || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
3295     return FALSE;
3296
3297   if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3298     {
3299       header->byteorder = BFD_ENDIAN_BIG;
3300       header->magic = BFD_MACH_O_MH_MAGIC;
3301       header->version = 1;
3302       get32 = bfd_getb32;
3303     }
3304   else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3305     {
3306       header->byteorder = BFD_ENDIAN_LITTLE;
3307       header->magic = BFD_MACH_O_MH_MAGIC;
3308       header->version = 1;
3309       get32 = bfd_getl32;
3310     }
3311   else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3312     {
3313       header->byteorder = BFD_ENDIAN_BIG;
3314       header->magic = BFD_MACH_O_MH_MAGIC_64;
3315       header->version = 2;
3316       get32 = bfd_getb32;
3317     }
3318   else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3319     {
3320       header->byteorder = BFD_ENDIAN_LITTLE;
3321       header->magic = BFD_MACH_O_MH_MAGIC_64;
3322       header->version = 2;
3323       get32 = bfd_getl32;
3324     }
3325   else
3326     {
3327       header->byteorder = BFD_ENDIAN_UNKNOWN;
3328       return FALSE;
3329     }
3330
3331   /* Once the size of the header is known, read the full header.  */
3332   size = mach_o_wide_p (header) ?
3333     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3334
3335   if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
3336       || bfd_bread (&raw, size, abfd) != size)
3337     return FALSE;
3338
3339   header->cputype = (*get32) (raw.cputype);
3340   header->cpusubtype = (*get32) (raw.cpusubtype);
3341   header->filetype = (*get32) (raw.filetype);
3342   header->ncmds = (*get32) (raw.ncmds);
3343   header->sizeofcmds = (*get32) (raw.sizeofcmds);
3344   header->flags = (*get32) (raw.flags);
3345
3346   if (mach_o_wide_p (header))
3347     header->reserved = (*get32) (raw.reserved);
3348   else
3349     header->reserved = 0;
3350
3351   return TRUE;
3352 }
3353
3354 bfd_boolean
3355 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3356 {
3357   bfd_mach_o_section *s;
3358   unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
3359
3360   s = bfd_mach_o_get_mach_o_section (sec);
3361   if (s == NULL)
3362     {
3363       flagword bfd_flags;
3364       static const mach_o_section_name_xlat * xlat;
3365
3366       s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3367       if (s == NULL)
3368         return FALSE;
3369       sec->used_by_bfd = s;
3370       s->bfdsection = sec;
3371
3372       /* Create the Darwin seg/sect name pair from the bfd name.
3373          If this is a canonical name for which a specific paiting exists
3374          there will also be defined flags, type, attribute and alignment
3375          values.  */
3376       xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3377       if (xlat != NULL)
3378         {
3379           s->flags = xlat->macho_sectype | xlat->macho_secattr;
3380           s->align = xlat->sectalign > bfdalign ? xlat->sectalign
3381                                                 : bfdalign;
3382           (void) bfd_set_section_alignment (abfd, sec, s->align);
3383           bfd_flags = bfd_get_section_flags (abfd, sec);
3384           if (bfd_flags == SEC_NO_FLAGS)
3385             bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
3386         }
3387       else
3388         /* Create default flags.  */
3389         bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
3390     }
3391
3392   return _bfd_generic_new_section_hook (abfd, sec);
3393 }
3394
3395 static void
3396 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
3397                                      unsigned long prot)
3398 {
3399   flagword flags;
3400   bfd_mach_o_section *section;
3401
3402   flags = bfd_get_section_flags (abfd, sec);
3403   section = bfd_mach_o_get_mach_o_section (sec);
3404
3405   /* TODO: see if we should use the xlat system for doing this by
3406      preference and fall back to this for unknown sections.  */
3407
3408   if (flags == SEC_NO_FLAGS)
3409     {
3410       /* Try to guess flags.  */
3411       if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
3412         flags = SEC_DEBUGGING;
3413       else
3414         {
3415           flags = SEC_ALLOC;
3416           if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3417               != BFD_MACH_O_S_ZEROFILL)
3418             {
3419               flags |= SEC_LOAD;
3420               if (prot & BFD_MACH_O_PROT_EXECUTE)
3421                 flags |= SEC_CODE;
3422               if (prot & BFD_MACH_O_PROT_WRITE)
3423                 flags |= SEC_DATA;
3424               else if (prot & BFD_MACH_O_PROT_READ)
3425                 flags |= SEC_READONLY;
3426             }
3427         }
3428     }
3429   else
3430     {
3431       if ((flags & SEC_DEBUGGING) == 0)
3432         flags |= SEC_ALLOC;
3433     }
3434
3435   if (section->offset != 0)
3436     flags |= SEC_HAS_CONTENTS;
3437   if (section->nreloc != 0)
3438     flags |= SEC_RELOC;
3439
3440   bfd_set_section_flags (abfd, sec, flags);
3441
3442   sec->vma = section->addr;
3443   sec->lma = section->addr;
3444   sec->size = section->size;
3445   sec->filepos = section->offset;
3446   sec->alignment_power = section->align;
3447   sec->segment_mark = 0;
3448   sec->reloc_count = section->nreloc;
3449   sec->rel_filepos = section->reloff;
3450 }
3451
3452 static asection *
3453 bfd_mach_o_make_bfd_section (bfd *abfd,
3454                              const unsigned char *segname,
3455                              const unsigned char *sectname)
3456 {
3457   const char *sname;
3458   flagword flags;
3459
3460   bfd_mach_o_convert_section_name_to_bfd
3461     (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3462   if (sname == NULL)
3463     return NULL;
3464
3465   return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3466 }
3467
3468 static asection *
3469 bfd_mach_o_read_section_32 (bfd *abfd, unsigned long prot)
3470 {
3471   struct mach_o_section_32_external raw;
3472   asection *sec;
3473   bfd_mach_o_section *section;
3474
3475   if (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3476       != BFD_MACH_O_SECTION_SIZE)
3477     return NULL;
3478
3479   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3480   if (sec == NULL)
3481     return NULL;
3482
3483   section = bfd_mach_o_get_mach_o_section (sec);
3484   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3485   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3486   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3487   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3488   section->addr = bfd_h_get_32 (abfd, raw.addr);
3489   section->size = bfd_h_get_32 (abfd, raw.size);
3490   section->offset = bfd_h_get_32 (abfd, raw.offset);
3491   section->align = bfd_h_get_32 (abfd, raw.align);
3492   /* PR 17512: file: 0017eb76.  */
3493   if (section->align > 64)
3494     {
3495       (*_bfd_error_handler) (_("bfd_mach_o_read_section_32: overlarge alignment value: 0x%x, using 32 instead"),
3496                              section->align);
3497       section->align = 32;
3498     }
3499   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3500   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3501   section->flags = bfd_h_get_32 (abfd, raw.flags);
3502   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3503   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3504   section->reserved3 = 0;
3505
3506   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3507
3508   return sec;
3509 }
3510
3511 static asection *
3512 bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
3513 {
3514   struct mach_o_section_64_external raw;
3515   asection *sec;
3516   bfd_mach_o_section *section;
3517
3518   if (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3519       != BFD_MACH_O_SECTION_64_SIZE)
3520     return NULL;
3521
3522   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3523   if (sec == NULL)
3524     return NULL;
3525
3526   section = bfd_mach_o_get_mach_o_section (sec);
3527   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3528   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3529   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3530   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3531   section->addr = bfd_h_get_64 (abfd, raw.addr);
3532   section->size = bfd_h_get_64 (abfd, raw.size);
3533   section->offset = bfd_h_get_32 (abfd, raw.offset);
3534   section->align = bfd_h_get_32 (abfd, raw.align);
3535   if (section->align > 64)
3536     {
3537       (*_bfd_error_handler) (_("bfd_mach_o_read_section_64: overlarge alignment value: 0x%x, using 32 instead"),
3538                              section->align);
3539       section->align = 32;
3540     }
3541   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3542   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3543   section->flags = bfd_h_get_32 (abfd, raw.flags);
3544   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3545   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3546   section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3547
3548   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3549
3550   return sec;
3551 }
3552
3553 static asection *
3554 bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
3555 {
3556   if (wide)
3557     return bfd_mach_o_read_section_64 (abfd, prot);
3558   else
3559     return bfd_mach_o_read_section_32 (abfd, prot);
3560 }
3561
3562 static bfd_boolean
3563 bfd_mach_o_read_symtab_symbol (bfd *abfd,
3564                                bfd_mach_o_symtab_command *sym,
3565                                bfd_mach_o_asymbol *s,
3566                                unsigned long i)
3567 {
3568   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3569   unsigned int wide = mach_o_wide_p (&mdata->header);
3570   unsigned int symwidth =
3571     wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3572   unsigned int symoff = sym->symoff + (i * symwidth);
3573   struct mach_o_nlist_64_external raw;
3574   unsigned char type = -1;
3575   unsigned char section = -1;
3576   short desc = -1;
3577   symvalue value = -1;
3578   unsigned long stroff = -1;
3579   unsigned int symtype = -1;
3580
3581   BFD_ASSERT (sym->strtab != NULL);
3582
3583   if (bfd_seek (abfd, symoff, SEEK_SET) != 0
3584       || bfd_bread (&raw, symwidth, abfd) != symwidth)
3585     {
3586       (*_bfd_error_handler)
3587         (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3588          symwidth, (unsigned long) symoff);
3589       return FALSE;
3590     }
3591
3592   stroff = bfd_h_get_32 (abfd, raw.n_strx);
3593   type = bfd_h_get_8 (abfd, raw.n_type);
3594   symtype = type & BFD_MACH_O_N_TYPE;
3595   section = bfd_h_get_8 (abfd, raw.n_sect);
3596   desc = bfd_h_get_16 (abfd, raw.n_desc);
3597   if (wide)
3598     value = bfd_h_get_64 (abfd, raw.n_value);
3599   else
3600     value = bfd_h_get_32 (abfd, raw.n_value);
3601
3602   if (stroff >= sym->strsize)
3603     {
3604       (*_bfd_error_handler)
3605         (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3606          (unsigned long) stroff,
3607          (unsigned long) sym->strsize);
3608       return FALSE;
3609     }
3610
3611   s->symbol.the_bfd = abfd;
3612   s->symbol.name = sym->strtab + stroff;
3613   s->symbol.value = value;
3614   s->symbol.flags = 0x0;
3615   s->symbol.udata.i = i;
3616   s->n_type = type;
3617   s->n_sect = section;
3618   s->n_desc = desc;
3619
3620   if (type & BFD_MACH_O_N_STAB)
3621     {
3622       s->symbol.flags |= BSF_DEBUGGING;
3623       s->symbol.section = bfd_und_section_ptr;
3624       switch (type)
3625         {
3626         case N_FUN:
3627         case N_STSYM:
3628         case N_LCSYM:
3629         case N_BNSYM:
3630         case N_SLINE:
3631         case N_ENSYM:
3632         case N_ECOMM:
3633         case N_ECOML:
3634         case N_GSYM:
3635           if ((section > 0) && (section <= mdata->nsects))
3636             {
3637               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3638               s->symbol.value =
3639                 s->symbol.value - mdata->sections[section - 1]->addr;
3640             }
3641           break;
3642         }
3643     }
3644   else
3645     {
3646       if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
3647         s->symbol.flags |= BSF_GLOBAL;
3648       else
3649         s->symbol.flags |= BSF_LOCAL;
3650
3651       switch (symtype)
3652         {
3653         case BFD_MACH_O_N_UNDF:
3654           if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3655               && s->symbol.value != 0)
3656             {
3657               /* A common symbol.  */
3658               s->symbol.section = bfd_com_section_ptr;
3659               s->symbol.flags = BSF_NO_FLAGS;
3660             }
3661           else
3662             {
3663               s->symbol.section = bfd_und_section_ptr;
3664               if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3665                 s->symbol.flags |= BSF_WEAK;
3666             }
3667           break;
3668         case BFD_MACH_O_N_PBUD:
3669           s->symbol.section = bfd_und_section_ptr;
3670           break;
3671         case BFD_MACH_O_N_ABS:
3672           s->symbol.section = bfd_abs_section_ptr;
3673           break;
3674         case BFD_MACH_O_N_SECT:
3675           if ((section > 0) && (section <= mdata->nsects))
3676             {
3677               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3678               s->symbol.value =
3679                 s->symbol.value - mdata->sections[section - 1]->addr;
3680             }
3681           else
3682             {
3683               /* Mach-O uses 0 to mean "no section"; not an error.  */
3684               if (section != 0)
3685                 {
3686                   (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3687                                            "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3688                                          s->symbol.name, section, mdata->nsects);
3689                 }
3690               s->symbol.section = bfd_und_section_ptr;
3691             }
3692           break;
3693         case BFD_MACH_O_N_INDR:
3694           /* FIXME: we don't follow the BFD convention as this indirect symbol
3695              won't be followed by the referenced one.  This looks harmless
3696              unless we start using the linker.  */
3697           s->symbol.flags |= BSF_INDIRECT;
3698           s->symbol.section = bfd_ind_section_ptr;
3699           s->symbol.value = 0;
3700           break;
3701         default:
3702           (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3703                                    "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3704                                  s->symbol.name, symtype);
3705           s->symbol.section = bfd_und_section_ptr;
3706           break;
3707         }
3708     }
3709
3710   return TRUE;
3711 }
3712
3713 bfd_boolean
3714 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3715 {
3716   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3717   bfd_mach_o_symtab_command *sym = mdata->symtab;
3718
3719   /* Fail if there is no symtab.  */
3720   if (sym == NULL)
3721     return FALSE;
3722
3723   /* Success if already loaded.  */
3724   if (sym->strtab)
3725     return TRUE;
3726
3727   if (abfd->flags & BFD_IN_MEMORY)
3728     {
3729       struct bfd_in_memory *b;
3730
3731       b = (struct bfd_in_memory *) abfd->iostream;
3732
3733       if ((sym->stroff + sym->strsize) > b->size)
3734         {
3735           bfd_set_error (bfd_error_file_truncated);
3736           return FALSE;
3737         }
3738       sym->strtab = (char *) b->buffer + sym->stroff;
3739     }
3740   else
3741     {
3742       sym->strtab = bfd_alloc (abfd, sym->strsize + 1);
3743       if (sym->strtab == NULL)
3744         return FALSE;
3745
3746       if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3747           || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3748         {
3749           /* PR 17512: file: 10888-1609-0.004.  */
3750           bfd_release (abfd, sym->strtab);
3751           sym->strtab = NULL;
3752           bfd_set_error (bfd_error_file_truncated);
3753           return FALSE;
3754         }
3755       /* Zero terminate the string table.  */
3756       sym->strtab[sym->strsize] = 0;
3757     }
3758
3759   return TRUE;
3760 }
3761
3762 bfd_boolean
3763 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3764 {
3765   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3766   bfd_mach_o_symtab_command *sym = mdata->symtab;
3767   unsigned long i;
3768
3769   if (sym == NULL || sym->symbols)
3770     /* Return now if there are no symbols or if already loaded.  */
3771     return TRUE;
3772
3773   sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
3774   if (sym->symbols == NULL)
3775     {
3776       (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3777       sym->nsyms = 0;
3778       return FALSE;
3779     }
3780
3781   if (!bfd_mach_o_read_symtab_strtab (abfd))
3782     goto fail;
3783
3784   for (i = 0; i < sym->nsyms; i++)
3785     if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3786       goto fail;
3787
3788   return TRUE;
3789
3790  fail:
3791   bfd_release (abfd, sym->symbols);
3792   sym->symbols = NULL;
3793   sym->nsyms = 0;
3794   return FALSE;
3795 }
3796
3797 static const char *
3798 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3799 {
3800   switch ((int) flavour)
3801     {
3802     case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
3803     case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
3804     case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3805     case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
3806     case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
3807     case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3808     case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
3809     case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
3810     case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
3811     case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
3812     case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
3813     case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
3814     case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3815     default: return "UNKNOWN";
3816     }
3817 }
3818
3819 static const char *
3820 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3821 {
3822   switch ((int) flavour)
3823     {
3824     case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
3825     case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
3826     case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
3827     case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
3828     case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
3829     case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3830     default: return "UNKNOWN";
3831     }
3832 }
3833
3834 static bfd_boolean
3835 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3836 {
3837   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3838   struct mach_o_str_command_external raw;
3839   unsigned int nameoff;
3840   unsigned int namelen;
3841
3842   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3843     return FALSE;
3844
3845   nameoff = bfd_h_get_32 (abfd, raw.str);
3846
3847   cmd->name_offset = nameoff;
3848   namelen = command->len - nameoff;
3849   nameoff += command->offset;
3850   cmd->name_str = bfd_alloc (abfd, namelen);
3851   if (cmd->name_str == NULL)
3852     return FALSE;
3853   if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
3854       || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3855     return FALSE;
3856   return TRUE;
3857 }
3858
3859 static bfd_boolean
3860 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3861 {
3862   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3863   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3864   struct mach_o_dylib_command_external raw;
3865   unsigned int nameoff;
3866   unsigned int namelen;
3867
3868   switch (command->type)
3869     {
3870     case BFD_MACH_O_LC_LOAD_DYLIB:
3871     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3872     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3873     case BFD_MACH_O_LC_ID_DYLIB:
3874     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3875     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3876       break;
3877     default:
3878       BFD_FAIL ();
3879       return FALSE;
3880     }
3881
3882   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3883     return FALSE;
3884
3885   nameoff = bfd_h_get_32 (abfd, raw.name);
3886   cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3887   cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3888   cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3889
3890   cmd->name_offset = command->offset + nameoff;
3891   namelen = command->len - nameoff;
3892   cmd->name_str = bfd_alloc (abfd, namelen);
3893   if (cmd->name_str == NULL)
3894     return FALSE;
3895   if (bfd_seek (abfd, mdata->hdr_offset + cmd->name_offset, SEEK_SET) != 0
3896       || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3897     return FALSE;
3898   return TRUE;
3899 }
3900
3901 static bfd_boolean
3902 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3903                                 bfd_mach_o_load_command *command)
3904 {
3905   bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3906   struct mach_o_prebound_dylib_command_external raw;
3907   unsigned int nameoff;
3908   unsigned int modoff;
3909   unsigned int str_len;
3910   unsigned char *str;
3911
3912   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3913     return FALSE;
3914
3915   nameoff = bfd_h_get_32 (abfd, raw.name);
3916   modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3917   if (nameoff > command->len || modoff > command->len)
3918     return FALSE;
3919
3920   str_len = command->len - sizeof (raw);
3921   str = bfd_alloc (abfd, str_len);
3922   if (str == NULL)
3923     return FALSE;
3924   if (bfd_bread (str, str_len, abfd) != str_len)
3925     return FALSE;
3926
3927   cmd->name_offset = command->offset + nameoff;
3928   cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3929   cmd->linked_modules_offset = command->offset + modoff;
3930
3931   cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3932   cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3933   return TRUE;
3934 }
3935
3936 static bfd_boolean
3937 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3938                                bfd_mach_o_load_command *command)
3939 {
3940   bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3941   struct mach_o_prebind_cksum_command_external raw;
3942
3943   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3944     return FALSE;
3945
3946   cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3947   return TRUE;
3948 }
3949
3950 static bfd_boolean
3951 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3952                                 bfd_mach_o_load_command *command)
3953 {
3954   bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3955   struct mach_o_twolevel_hints_command_external raw;
3956
3957   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3958     return FALSE;
3959
3960   cmd->offset = bfd_get_32 (abfd, raw.offset);
3961   cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3962   return TRUE;
3963 }
3964
3965 static bfd_boolean
3966 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3967 {
3968   bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3969   struct mach_o_fvmlib_command_external raw;
3970   unsigned int nameoff;
3971   unsigned int namelen;
3972
3973   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3974     return FALSE;
3975
3976   nameoff = bfd_h_get_32 (abfd, raw.name);
3977   fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3978   fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3979
3980   fvm->name_offset = command->offset + nameoff;
3981   namelen = command->len - nameoff;
3982   fvm->name_str = bfd_alloc (abfd, namelen);
3983   if (fvm->name_str == NULL)
3984     return FALSE;
3985   if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3986       || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
3987     return FALSE;
3988   return TRUE;
3989 }
3990
3991 static bfd_boolean
3992 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3993 {
3994   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3995   bfd_mach_o_thread_command *cmd = &command->command.thread;
3996   unsigned int offset;
3997   unsigned int nflavours;
3998   unsigned int i;
3999
4000   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
4001               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
4002
4003   /* Count the number of threads.  */
4004   offset = 8;
4005   nflavours = 0;
4006   while (offset != command->len)
4007     {
4008       struct mach_o_thread_command_external raw;
4009
4010       if (offset >= command->len)
4011         return FALSE;
4012
4013       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4014           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4015         return FALSE;
4016
4017       offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
4018       nflavours++;
4019     }
4020
4021   /* Allocate threads.  */
4022   cmd->flavours = bfd_alloc2
4023     (abfd, nflavours, sizeof (bfd_mach_o_thread_flavour));
4024   if (cmd->flavours == NULL)
4025     return FALSE;
4026   cmd->nflavours = nflavours;
4027
4028   offset = 8;
4029   nflavours = 0;
4030   while (offset != command->len)
4031     {
4032       struct mach_o_thread_command_external raw;
4033
4034       if (offset >= command->len)
4035         return FALSE;
4036
4037       if (nflavours >= cmd->nflavours)
4038         return FALSE;
4039
4040       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4041           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4042         return FALSE;
4043
4044       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4045       cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4046       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4047       offset += cmd->flavours[nflavours].size + sizeof (raw);
4048       nflavours++;
4049     }
4050
4051   for (i = 0; i < nflavours; i++)
4052     {
4053       asection *bfdsec;
4054       unsigned int snamelen;
4055       char *sname;
4056       const char *flavourstr;
4057       const char *prefix = "LC_THREAD";
4058       unsigned int j = 0;
4059
4060       switch (mdata->header.cputype)
4061         {
4062         case BFD_MACH_O_CPU_TYPE_POWERPC:
4063         case BFD_MACH_O_CPU_TYPE_POWERPC_64:
4064           flavourstr =
4065             bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
4066           break;
4067         case BFD_MACH_O_CPU_TYPE_I386:
4068         case BFD_MACH_O_CPU_TYPE_X86_64:
4069           flavourstr =
4070             bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
4071           break;
4072         default:
4073           flavourstr = "UNKNOWN_ARCHITECTURE";
4074           break;
4075         }
4076
4077       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
4078       sname = bfd_alloc (abfd, snamelen);
4079       if (sname == NULL)
4080         return FALSE;
4081
4082       for (;;)
4083         {
4084           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4085           if (bfd_get_section_by_name (abfd, sname) == NULL)
4086             break;
4087           j++;
4088         }
4089
4090       bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
4091
4092       bfdsec->vma = 0;
4093       bfdsec->lma = 0;
4094       bfdsec->size = cmd->flavours[i].size;
4095       bfdsec->filepos = cmd->flavours[i].offset;
4096       bfdsec->alignment_power = 0x0;
4097
4098       cmd->section = bfdsec;
4099     }
4100
4101   return TRUE;
4102 }
4103
4104 static bfd_boolean
4105 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
4106 {
4107   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
4108   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4109
4110   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4111
4112   {
4113     struct mach_o_dysymtab_command_external raw;
4114
4115     if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4116       return FALSE;
4117
4118     cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4119     cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4120     cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4121     cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4122     cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4123     cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4124     cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4125     cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4126     cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4127     cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4128     cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4129     cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4130     cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4131     cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4132     cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4133     cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4134     cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4135     cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4136   }
4137
4138   if (cmd->nmodtab != 0)
4139     {
4140       unsigned int i;
4141       int wide = bfd_mach_o_wide_p (abfd);
4142       unsigned int module_len = wide ? 56 : 52;
4143
4144       cmd->dylib_module =
4145         bfd_alloc2 (abfd, cmd->nmodtab, sizeof (bfd_mach_o_dylib_module));
4146       if (cmd->dylib_module == NULL)
4147         return FALSE;
4148
4149       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
4150         return FALSE;
4151
4152       for (i = 0; i < cmd->nmodtab; i++)
4153         {
4154           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4155           unsigned long v;
4156           unsigned char buf[56];
4157
4158           if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4159             return FALSE;
4160
4161           module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4162           module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4163           module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4164           module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4165           module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4166           module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4167           module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4168           module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4169           module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4170           v = bfd_h_get_32 (abfd, buf +36);
4171           module->iinit = v & 0xffff;
4172           module->iterm = (v >> 16) & 0xffff;
4173           v = bfd_h_get_32 (abfd, buf + 40);
4174           module->ninit = v & 0xffff;
4175           module->nterm = (v >> 16) & 0xffff;
4176           if (wide)
4177             {
4178               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4179               module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4180             }
4181           else
4182             {
4183               module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4184               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4185             }
4186         }
4187     }
4188
4189   if (cmd->ntoc != 0)
4190     {
4191       unsigned long i;
4192
4193       cmd->dylib_toc = bfd_alloc2
4194         (abfd, cmd->ntoc, sizeof (bfd_mach_o_dylib_table_of_content));
4195       if (cmd->dylib_toc == NULL)
4196         return FALSE;
4197
4198       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
4199         return FALSE;
4200
4201       for (i = 0; i < cmd->ntoc; i++)
4202         {
4203           struct mach_o_dylib_table_of_contents_external raw;
4204           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
4205
4206           if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4207             return FALSE;
4208
4209           toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4210           toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4211         }
4212     }
4213
4214   if (cmd->nindirectsyms != 0)
4215     {
4216       unsigned int i;
4217
4218       cmd->indirect_syms = bfd_alloc2
4219         (abfd, cmd->nindirectsyms, sizeof (unsigned int));
4220       if (cmd->indirect_syms == NULL)
4221         return FALSE;
4222
4223       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
4224         return FALSE;
4225
4226       for (i = 0; i < cmd->nindirectsyms; i++)
4227         {
4228           unsigned char raw[4];
4229           unsigned int *is = &cmd->indirect_syms[i];
4230
4231           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4232             return FALSE;
4233
4234           *is = bfd_h_get_32 (abfd, raw);
4235         }
4236     }
4237
4238   if (cmd->nextrefsyms != 0)
4239     {
4240       unsigned long v;
4241       unsigned int i;
4242
4243       cmd->ext_refs = bfd_alloc2
4244         (abfd, cmd->nextrefsyms, sizeof (bfd_mach_o_dylib_reference));
4245       if (cmd->ext_refs == NULL)
4246         return FALSE;
4247
4248       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
4249         return FALSE;
4250
4251       for (i = 0; i < cmd->nextrefsyms; i++)
4252         {
4253           unsigned char raw[4];
4254           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4255
4256           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4257             return FALSE;
4258
4259           /* Fields isym and flags are written as bit-fields, thus we need
4260              a specific processing for endianness.  */
4261           v = bfd_h_get_32 (abfd, raw);
4262           if (bfd_big_endian (abfd))
4263             {
4264               ref->isym = (v >> 8) & 0xffffff;
4265               ref->flags = v & 0xff;
4266             }
4267           else
4268             {
4269               ref->isym = v & 0xffffff;
4270               ref->flags = (v >> 24) & 0xff;
4271             }
4272         }
4273     }
4274
4275   if (mdata->dysymtab)
4276     return FALSE;
4277   mdata->dysymtab = cmd;
4278
4279   return TRUE;
4280 }
4281
4282 static bfd_boolean
4283 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
4284 {
4285   bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4286   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4287   struct mach_o_symtab_command_external raw;
4288
4289   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4290
4291   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4292     return FALSE;
4293
4294   symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4295   symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4296   symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4297   symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
4298   symtab->symbols = NULL;
4299   symtab->strtab = NULL;
4300
4301   if (symtab->nsyms != 0)
4302     abfd->flags |= HAS_SYMS;
4303
4304   if (mdata->symtab)
4305     return FALSE;
4306   mdata->symtab = symtab;
4307   return TRUE;
4308 }
4309
4310 static bfd_boolean
4311 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
4312 {
4313   bfd_mach_o_uuid_command *cmd = &command->command.uuid;
4314
4315   BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4316
4317   if (bfd_bread (cmd->uuid, 16, abfd) != 16)
4318     return FALSE;
4319
4320   return TRUE;
4321 }
4322
4323 static bfd_boolean
4324 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
4325 {
4326   bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
4327   struct mach_o_linkedit_data_command_external raw;
4328
4329   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4330     return FALSE;
4331
4332   cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4333   cmd->datasize = bfd_get_32 (abfd, raw.datasize);
4334   return TRUE;
4335 }
4336
4337 static bfd_boolean
4338 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
4339 {
4340   bfd_mach_o_str_command *cmd = &command->command.str;
4341   struct mach_o_str_command_external raw;
4342   unsigned long off;
4343
4344   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4345     return FALSE;
4346
4347   off = bfd_get_32 (abfd, raw.str);
4348   cmd->stroff = command->offset + off;
4349   cmd->str_len = command->len - off;
4350   cmd->str = bfd_alloc (abfd, cmd->str_len);
4351   if (cmd->str == NULL)
4352     return FALSE;
4353   if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
4354       || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
4355     return FALSE;
4356   return TRUE;
4357 }
4358
4359 static unsigned char *
4360 bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
4361 {
4362   unsigned char *buf;
4363
4364   buf = bfd_alloc (abfd, size);
4365   if (buf == NULL)
4366     return NULL;
4367   if (bfd_seek (abfd, off, SEEK_SET) != 0
4368       || bfd_bread (buf, size, abfd) != size)
4369     return NULL;
4370   return buf;
4371 }
4372
4373 static bfd_boolean
4374 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4375 {
4376   /* Read rebase content.  */
4377   if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4378     {
4379       cmd->rebase_content =
4380         bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4381       if (cmd->rebase_content == NULL)
4382         return FALSE;
4383     }
4384
4385   /* Read bind content.  */
4386   if (cmd->bind_content == NULL && cmd->bind_size != 0)
4387     {
4388       cmd->bind_content =
4389         bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4390       if (cmd->bind_content == NULL)
4391         return FALSE;
4392     }
4393
4394   /* Read weak bind content.  */
4395   if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4396     {
4397       cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4398         (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4399       if (cmd->weak_bind_content == NULL)
4400         return FALSE;
4401     }
4402
4403   /* Read lazy bind content.  */
4404   if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4405     {
4406       cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4407         (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4408       if (cmd->lazy_bind_content == NULL)
4409         return FALSE;
4410     }
4411
4412   /* Read export content.  */
4413   if (cmd->export_content == NULL && cmd->export_size != 0)
4414     {
4415       cmd->export_content = bfd_mach_o_alloc_and_read
4416         (abfd, cmd->export_off, cmd->export_size);
4417       if (cmd->export_content == NULL)
4418         return FALSE;
4419     }
4420
4421   return TRUE;
4422 }
4423
4424 static bfd_boolean
4425 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
4426 {
4427   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
4428   struct mach_o_dyld_info_command_external raw;
4429
4430   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4431     return FALSE;
4432
4433   cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4434   cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
4435   cmd->rebase_content = NULL;
4436   cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4437   cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
4438   cmd->bind_content = NULL;
4439   cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4440   cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
4441   cmd->weak_bind_content = NULL;
4442   cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4443   cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
4444   cmd->lazy_bind_content = NULL;
4445   cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4446   cmd->export_size = bfd_get_32 (abfd, raw.export_size);
4447   cmd->export_content = NULL;
4448   return TRUE;
4449 }
4450
4451 static bfd_boolean
4452 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4453 {
4454   bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4455   struct mach_o_version_min_command_external raw;
4456   unsigned int ver;
4457
4458   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4459     return FALSE;
4460
4461   ver = bfd_get_32 (abfd, raw.version);
4462   cmd->rel = ver >> 16;
4463   cmd->maj = ver >> 8;
4464   cmd->min = ver;
4465   cmd->reserved = bfd_get_32 (abfd, raw.reserved);
4466   return TRUE;
4467 }
4468
4469 static bfd_boolean
4470 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4471 {
4472   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4473   struct mach_o_encryption_info_command_external raw;
4474
4475   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4476     return FALSE;
4477
4478   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4479   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4480   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4481   return TRUE;
4482 }
4483
4484 static bfd_boolean
4485 bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
4486 {
4487   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4488   struct mach_o_encryption_info_64_command_external raw;
4489
4490   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4491     return FALSE;
4492
4493   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4494   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4495   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4496   return TRUE;
4497 }
4498
4499 static bfd_boolean
4500 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4501 {
4502   bfd_mach_o_main_command *cmd = &command->command.main;
4503   struct mach_o_entry_point_command_external raw;
4504
4505   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4506     return FALSE;
4507
4508   cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4509   cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4510   return TRUE;
4511 }
4512
4513 static bfd_boolean
4514 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4515 {
4516   bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4517   struct mach_o_source_version_command_external raw;
4518   bfd_uint64_t ver;
4519
4520   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4521     return FALSE;
4522
4523   ver = bfd_get_64 (abfd, raw.version);
4524   /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4525      generates warnings) in case of the host doesn't support 64 bit
4526      integers.  */
4527   cmd->e = ver & 0x3ff;
4528   ver >>= 10;
4529   cmd->d = ver & 0x3ff;
4530   ver >>= 10;
4531   cmd->c = ver & 0x3ff;
4532   ver >>= 10;
4533   cmd->b = ver & 0x3ff;
4534   ver >>= 10;
4535   cmd->a = ver & 0xffffff;
4536   return TRUE;
4537 }
4538
4539 static bfd_boolean
4540 bfd_mach_o_read_segment (bfd *abfd,
4541                          bfd_mach_o_load_command *command,
4542                          unsigned int wide)
4543 {
4544   bfd_mach_o_segment_command *seg = &command->command.segment;
4545   unsigned long i;
4546
4547   if (wide)
4548     {
4549       struct mach_o_segment_command_64_external raw;
4550
4551       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
4552
4553       if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4554         return FALSE;
4555
4556       memcpy (seg->segname, raw.segname, 16);
4557       seg->segname[16] = '\0';
4558
4559       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4560       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4561       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4562       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4563       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4564       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4565       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4566       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4567     }
4568   else
4569     {
4570       struct mach_o_segment_command_32_external raw;
4571
4572       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4573
4574       if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4575         return FALSE;
4576
4577       memcpy (seg->segname, raw.segname, 16);
4578       seg->segname[16] = '\0';
4579
4580       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4581       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4582       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4583       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4584       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4585       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4586       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4587       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4588     }
4589   seg->sect_head = NULL;
4590   seg->sect_tail = NULL;
4591
4592   for (i = 0; i < seg->nsects; i++)
4593     {
4594       asection *sec;
4595
4596       sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
4597       if (sec == NULL)
4598         return FALSE;
4599
4600       bfd_mach_o_append_section_to_segment
4601         (seg, bfd_mach_o_get_mach_o_section (sec));
4602     }
4603
4604   return TRUE;
4605 }
4606
4607 static bfd_boolean
4608 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
4609 {
4610   return bfd_mach_o_read_segment (abfd, command, 0);
4611 }
4612
4613 static bfd_boolean
4614 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
4615 {
4616   return bfd_mach_o_read_segment (abfd, command, 1);
4617 }
4618
4619 static bfd_boolean
4620 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
4621 {
4622   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4623   struct mach_o_load_command_external raw;
4624   unsigned int cmd;
4625
4626   /* Read command type and length.  */
4627   if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
4628       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
4629     return FALSE;
4630
4631   cmd = bfd_h_get_32 (abfd, raw.cmd);
4632   command->type =  cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4633   command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
4634   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
4635
4636   switch (command->type)
4637     {
4638     case BFD_MACH_O_LC_SEGMENT:
4639       if (!bfd_mach_o_read_segment_32 (abfd, command))
4640         return FALSE;
4641       break;
4642     case BFD_MACH_O_LC_SEGMENT_64:
4643       if (!bfd_mach_o_read_segment_64 (abfd, command))
4644         return FALSE;
4645       break;
4646     case BFD_MACH_O_LC_SYMTAB:
4647       if (!bfd_mach_o_read_symtab (abfd, command))
4648         return FALSE;
4649       break;
4650     case BFD_MACH_O_LC_SYMSEG:
4651       break;
4652     case BFD_MACH_O_LC_THREAD:
4653     case BFD_MACH_O_LC_UNIXTHREAD:
4654       if (!bfd_mach_o_read_thread (abfd, command))
4655         return FALSE;
4656       break;
4657     case BFD_MACH_O_LC_LOAD_DYLINKER:
4658     case BFD_MACH_O_LC_ID_DYLINKER:
4659     case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
4660       if (!bfd_mach_o_read_dylinker (abfd, command))
4661         return FALSE;
4662       break;
4663     case BFD_MACH_O_LC_LOAD_DYLIB:
4664     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4665     case BFD_MACH_O_LC_ID_DYLIB:
4666     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4667     case BFD_MACH_O_LC_REEXPORT_DYLIB:
4668     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4669       if (!bfd_mach_o_read_dylib (abfd, command))
4670         return FALSE;
4671       break;
4672     case BFD_MACH_O_LC_PREBOUND_DYLIB:
4673       if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4674         return FALSE;
4675       break;
4676     case BFD_MACH_O_LC_LOADFVMLIB:
4677     case BFD_MACH_O_LC_IDFVMLIB:
4678       if (!bfd_mach_o_read_fvmlib (abfd, command))
4679         return FALSE;
4680       break;
4681     case BFD_MACH_O_LC_IDENT:
4682     case BFD_MACH_O_LC_FVMFILE:
4683     case BFD_MACH_O_LC_PREPAGE:
4684     case BFD_MACH_O_LC_ROUTINES:
4685     case BFD_MACH_O_LC_ROUTINES_64:
4686       break;
4687     case BFD_MACH_O_LC_SUB_FRAMEWORK:
4688     case BFD_MACH_O_LC_SUB_UMBRELLA:
4689     case BFD_MACH_O_LC_SUB_LIBRARY:
4690     case BFD_MACH_O_LC_SUB_CLIENT:
4691     case BFD_MACH_O_LC_RPATH:
4692       if (!bfd_mach_o_read_str (abfd, command))
4693         return FALSE;
4694       break;
4695     case BFD_MACH_O_LC_DYSYMTAB:
4696       if (!bfd_mach_o_read_dysymtab (abfd, command))
4697         return FALSE;
4698       break;
4699     case BFD_MACH_O_LC_PREBIND_CKSUM:
4700       if (!bfd_mach_o_read_prebind_cksum (abfd, command))
4701         return FALSE;
4702       break;
4703     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
4704       if (!bfd_mach_o_read_twolevel_hints (abfd, command))
4705         return FALSE;
4706       break;
4707     case BFD_MACH_O_LC_UUID:
4708       if (!bfd_mach_o_read_uuid (abfd, command))
4709         return FALSE;
4710       break;
4711     case BFD_MACH_O_LC_CODE_SIGNATURE:
4712     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
4713     case BFD_MACH_O_LC_FUNCTION_STARTS:
4714     case BFD_MACH_O_LC_DATA_IN_CODE:
4715     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
4716     case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
4717       if (!bfd_mach_o_read_linkedit (abfd, command))
4718         return FALSE;
4719       break;
4720     case BFD_MACH_O_LC_ENCRYPTION_INFO:
4721       if (!bfd_mach_o_read_encryption_info (abfd, command))
4722         return FALSE;
4723       break;
4724     case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
4725       if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
4726         return FALSE;
4727       break;
4728     case BFD_MACH_O_LC_DYLD_INFO:
4729       if (!bfd_mach_o_read_dyld_info (abfd, command))
4730         return FALSE;
4731       break;
4732     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
4733     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
4734     case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
4735       if (!bfd_mach_o_read_version_min (abfd, command))
4736         return FALSE;
4737       break;
4738     case BFD_MACH_O_LC_MAIN:
4739       if (!bfd_mach_o_read_main (abfd, command))
4740         return FALSE;
4741       break;
4742     case BFD_MACH_O_LC_SOURCE_VERSION:
4743       if (!bfd_mach_o_read_source_version (abfd, command))
4744         return FALSE;
4745       break;
4746     default:
4747       command->len = 0;
4748       (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
4749                             abfd, (unsigned long) command->type);
4750       return FALSE;
4751     }
4752
4753   return TRUE;
4754 }
4755
4756 static void
4757 bfd_mach_o_flatten_sections (bfd *abfd)
4758 {
4759   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4760   bfd_mach_o_load_command *cmd;
4761   long csect = 0;
4762
4763   /* Count total number of sections.  */
4764   mdata->nsects = 0;
4765
4766   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4767     {
4768       if (cmd->type == BFD_MACH_O_LC_SEGMENT
4769           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4770         {
4771           bfd_mach_o_segment_command *seg = &cmd->command.segment;
4772
4773           mdata->nsects += seg->nsects;
4774         }
4775     }
4776
4777   /* Allocate sections array.  */
4778   mdata->sections = bfd_alloc2 (abfd,
4779                                 mdata->nsects, sizeof (bfd_mach_o_section *));
4780
4781   /* Fill the array.  */
4782   csect = 0;
4783
4784   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4785     {
4786       if (cmd->type == BFD_MACH_O_LC_SEGMENT
4787           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4788         {
4789           bfd_mach_o_segment_command *seg = &cmd->command.segment;
4790           bfd_mach_o_section *sec;
4791
4792           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4793
4794           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4795             mdata->sections[csect++] = sec;
4796         }
4797     }
4798 }
4799
4800 static bfd_boolean
4801 bfd_mach_o_scan_start_address (bfd *abfd)
4802 {
4803   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4804   bfd_mach_o_thread_command *thr = NULL;
4805   bfd_mach_o_load_command *cmd;
4806   unsigned long i;
4807
4808   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4809     if (cmd->type == BFD_MACH_O_LC_THREAD
4810         || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
4811       {
4812         thr = &cmd->command.thread;
4813         break;
4814       }
4815     else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
4816       {
4817         bfd_mach_o_main_command *main_cmd = &cmd->command.main;
4818         bfd_mach_o_section *text_sect = mdata->sections[0];
4819
4820         if (text_sect)
4821           {
4822             abfd->start_address = main_cmd->entryoff
4823               + (text_sect->addr - text_sect->offset);
4824             return TRUE;
4825           }
4826       }
4827
4828   /* An object file has no start address, so do not fail if not found.  */
4829   if (thr == NULL)
4830     return TRUE;
4831
4832   /* FIXME: create a subtarget hook ?  */
4833   for (i = 0; i < thr->nflavours; i++)
4834     {
4835       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4836           && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
4837         {
4838           unsigned char buf[4];
4839
4840           if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
4841               || bfd_bread (buf, 4, abfd) != 4)
4842             return FALSE;
4843
4844           abfd->start_address = bfd_h_get_32 (abfd, buf);
4845         }
4846       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4847                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4848         {
4849           unsigned char buf[4];
4850
4851           if (bfd_seek (abfd, thr->flavours[i].offset + 0, 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_64)
4858                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4859         {
4860           unsigned char buf[8];
4861
4862           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4863               || bfd_bread (buf, 8, abfd) != 8)
4864             return FALSE;
4865
4866           abfd->start_address = bfd_h_get_64 (abfd, buf);
4867         }
4868       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4869                && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4870         {
4871           unsigned char buf[8];
4872
4873           if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), 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     }
4880
4881   return TRUE;
4882 }
4883
4884 bfd_boolean
4885 bfd_mach_o_set_arch_mach (bfd *abfd,
4886                           enum bfd_architecture arch,
4887                           unsigned long machine)
4888 {
4889   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4890
4891   /* If this isn't the right architecture for this backend, and this
4892      isn't the generic backend, fail.  */
4893   if (arch != bed->arch
4894       && arch != bfd_arch_unknown
4895       && bed->arch != bfd_arch_unknown)
4896     return FALSE;
4897
4898   return bfd_default_set_arch_mach (abfd, arch, machine);
4899 }
4900
4901 static bfd_boolean
4902 bfd_mach_o_scan (bfd *abfd,
4903                  bfd_mach_o_header *header,
4904                  bfd_mach_o_data_struct *mdata)
4905 {
4906   unsigned int i;
4907   enum bfd_architecture cputype;
4908   unsigned long cpusubtype;
4909   unsigned int hdrsize;
4910
4911   hdrsize = mach_o_wide_p (header) ?
4912     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4913
4914   mdata->header = *header;
4915
4916   abfd->flags = abfd->flags & BFD_IN_MEMORY;
4917   switch (header->filetype)
4918     {
4919     case BFD_MACH_O_MH_OBJECT:
4920       abfd->flags |= HAS_RELOC;
4921       break;
4922     case BFD_MACH_O_MH_EXECUTE:
4923       abfd->flags |= EXEC_P;
4924       break;
4925     case BFD_MACH_O_MH_DYLIB:
4926     case BFD_MACH_O_MH_BUNDLE:
4927       abfd->flags |= DYNAMIC;
4928       break;
4929     }
4930
4931   abfd->tdata.mach_o_data = mdata;
4932
4933   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4934                                    &cputype, &cpusubtype);
4935   if (cputype == bfd_arch_unknown)
4936     {
4937       (*_bfd_error_handler)
4938         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4939          header->cputype, header->cpusubtype);
4940       return FALSE;
4941     }
4942
4943   bfd_set_arch_mach (abfd, cputype, cpusubtype);
4944
4945   if (header->ncmds != 0)
4946     {
4947       bfd_mach_o_load_command *cmd;
4948
4949       mdata->first_command = NULL;
4950       mdata->last_command = NULL;
4951
4952       cmd = bfd_alloc2 (abfd, header->ncmds, sizeof (bfd_mach_o_load_command));
4953       if (cmd == NULL)
4954         return FALSE;
4955
4956       for (i = 0; i < header->ncmds; i++)
4957         {
4958           bfd_mach_o_load_command *cur = &cmd[i];
4959
4960           bfd_mach_o_append_command (abfd, cur);
4961
4962           if (i == 0)
4963             cur->offset = hdrsize;
4964           else
4965             {
4966               bfd_mach_o_load_command *prev = &cmd[i - 1];
4967               cur->offset = prev->offset + prev->len;
4968             }
4969
4970           if (!bfd_mach_o_read_command (abfd, cur))
4971             return FALSE;
4972         }
4973     }
4974
4975   /* Sections should be flatten before scanning start address.  */
4976   bfd_mach_o_flatten_sections (abfd);
4977   if (!bfd_mach_o_scan_start_address (abfd))
4978     return FALSE;
4979
4980   return TRUE;
4981 }
4982
4983 bfd_boolean
4984 bfd_mach_o_mkobject_init (bfd *abfd)
4985 {
4986   bfd_mach_o_data_struct *mdata = NULL;
4987
4988   mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4989   if (mdata == NULL)
4990     return FALSE;
4991   abfd->tdata.mach_o_data = mdata;
4992
4993   mdata->header.magic = 0;
4994   mdata->header.cputype = 0;
4995   mdata->header.cpusubtype = 0;
4996   mdata->header.filetype = 0;
4997   mdata->header.ncmds = 0;
4998   mdata->header.sizeofcmds = 0;
4999   mdata->header.flags = 0;
5000   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
5001   mdata->first_command = NULL;
5002   mdata->last_command = NULL;
5003   mdata->nsects = 0;
5004   mdata->sections = NULL;
5005   mdata->dyn_reloc_cache = NULL;
5006
5007   return TRUE;
5008 }
5009
5010 static bfd_boolean
5011 bfd_mach_o_gen_mkobject (bfd *abfd)
5012 {
5013   bfd_mach_o_data_struct *mdata;
5014
5015   if (!bfd_mach_o_mkobject_init (abfd))
5016     return FALSE;
5017
5018   mdata = bfd_mach_o_get_data (abfd);
5019   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
5020   mdata->header.cputype = 0;
5021   mdata->header.cpusubtype = 0;
5022   mdata->header.byteorder = abfd->xvec->byteorder;
5023   mdata->header.version = 1;
5024
5025   return TRUE;
5026 }
5027
5028 const bfd_target *
5029 bfd_mach_o_header_p (bfd *abfd,
5030                      file_ptr hdr_off,
5031                      bfd_mach_o_filetype filetype,
5032                      bfd_mach_o_cpu_type cputype)
5033 {
5034   bfd_mach_o_header header;
5035   bfd_mach_o_data_struct *mdata;
5036
5037   if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
5038     goto wrong;
5039
5040   if (! (header.byteorder == BFD_ENDIAN_BIG
5041          || header.byteorder == BFD_ENDIAN_LITTLE))
5042     {
5043       (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
5044                              (unsigned long) header.byteorder);
5045       goto wrong;
5046     }
5047
5048   if (! ((header.byteorder == BFD_ENDIAN_BIG
5049           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5050           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5051          || (header.byteorder == BFD_ENDIAN_LITTLE
5052              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5053              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5054     goto wrong;
5055
5056   /* Check cputype and filetype.
5057      In case of wildcard, do not accept magics that are handled by existing
5058      targets.  */
5059   if (cputype)
5060     {
5061       if (header.cputype != cputype)
5062         goto wrong;
5063     }
5064   else
5065     {
5066 #ifndef BFD64
5067       /* Do not recognize 64 architectures if not configured for 64bit targets.
5068          This could happen only for generic targets.  */
5069       if (mach_o_wide_p (&header))
5070          goto wrong;
5071 #endif
5072     }
5073
5074   if (filetype)
5075     {
5076       if (header.filetype != filetype)
5077         goto wrong;
5078     }
5079   else
5080     {
5081       switch (header.filetype)
5082         {
5083         case BFD_MACH_O_MH_CORE:
5084           /* Handled by core_p */
5085           goto wrong;
5086         default:
5087           break;
5088         }
5089     }
5090
5091   mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5092   if (mdata == NULL)
5093     goto fail;
5094   mdata->hdr_offset = hdr_off;
5095
5096   if (!bfd_mach_o_scan (abfd, &header, mdata))
5097     goto wrong;
5098
5099   return abfd->xvec;
5100
5101  wrong:
5102   bfd_set_error (bfd_error_wrong_format);
5103
5104  fail:
5105   return NULL;
5106 }
5107
5108 static const bfd_target *
5109 bfd_mach_o_gen_object_p (bfd *abfd)
5110 {
5111   return bfd_mach_o_header_p (abfd, 0, 0, 0);
5112 }
5113
5114 static const bfd_target *
5115 bfd_mach_o_gen_core_p (bfd *abfd)
5116 {
5117   return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
5118 }
5119
5120 /* Return the base address of ABFD, ie the address at which the image is
5121    mapped.  The possible initial pagezero is ignored.  */
5122
5123 bfd_vma
5124 bfd_mach_o_get_base_address (bfd *abfd)
5125 {
5126   bfd_mach_o_data_struct *mdata;
5127   bfd_mach_o_load_command *cmd;
5128
5129   /* Check for Mach-O.  */
5130   if (!bfd_mach_o_valid (abfd))
5131     return 0;
5132   mdata = bfd_mach_o_get_data (abfd);
5133
5134   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5135     {
5136       if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5137            || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5138         {
5139           struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5140
5141           if (segcmd->initprot != 0)
5142             return segcmd->vmaddr;
5143         }
5144     }
5145   return 0;
5146 }
5147
5148 typedef struct mach_o_fat_archentry
5149 {
5150   unsigned long cputype;
5151   unsigned long cpusubtype;
5152   unsigned long offset;
5153   unsigned long size;
5154   unsigned long align;
5155 } mach_o_fat_archentry;
5156
5157 typedef struct mach_o_fat_data_struct
5158 {
5159   unsigned long magic;
5160   unsigned long nfat_arch;
5161   mach_o_fat_archentry *archentries;
5162 } mach_o_fat_data_struct;
5163
5164 const bfd_target *
5165 bfd_mach_o_fat_archive_p (bfd *abfd)
5166 {
5167   mach_o_fat_data_struct *adata = NULL;
5168   struct mach_o_fat_header_external hdr;
5169   unsigned long i;
5170
5171   if (bfd_seek (abfd, 0, SEEK_SET) != 0
5172       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
5173     goto error;
5174
5175   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
5176   if (adata == NULL)
5177     goto error;
5178
5179   adata->magic = bfd_getb32 (hdr.magic);
5180   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
5181   if (adata->magic != 0xcafebabe)
5182     goto error;
5183   /* Avoid matching Java bytecode files, which have the same magic number.
5184      In the Java bytecode file format this field contains the JVM version,
5185      which starts at 43.0.  */
5186   if (adata->nfat_arch > 30)
5187     goto error;
5188
5189   adata->archentries =
5190     bfd_alloc2 (abfd, adata->nfat_arch, sizeof (mach_o_fat_archentry));
5191   if (adata->archentries == NULL)
5192     goto error;
5193
5194   for (i = 0; i < adata->nfat_arch; i++)
5195     {
5196       struct mach_o_fat_arch_external arch;
5197       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
5198         goto error;
5199       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5200       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5201       adata->archentries[i].offset = bfd_getb32 (arch.offset);
5202       adata->archentries[i].size = bfd_getb32 (arch.size);
5203       adata->archentries[i].align = bfd_getb32 (arch.align);
5204     }
5205
5206   abfd->tdata.mach_o_fat_data = adata;
5207
5208   return abfd->xvec;
5209
5210  error:
5211   if (adata != NULL)
5212     bfd_release (abfd, adata);
5213   bfd_set_error (bfd_error_wrong_format);
5214   return NULL;
5215 }
5216
5217 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5218    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5219    Set arelt_data and origin fields too.  */
5220
5221 static void
5222 bfd_mach_o_fat_member_init (bfd *abfd,
5223                             enum bfd_architecture arch_type,
5224                             unsigned long arch_subtype,
5225                             mach_o_fat_archentry *entry)
5226 {
5227   struct areltdata *areltdata;
5228   /* Create the member filename. Use ARCH_NAME.  */
5229   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5230
5231   if (ap)
5232     {
5233       /* Use the architecture name if known.  */
5234       abfd->filename = xstrdup (ap->printable_name);
5235     }
5236   else
5237     {
5238       /* Forge a uniq id.  */
5239       const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
5240       char *name = xmalloc (namelen);
5241       snprintf (name, namelen, "0x%lx-0x%lx",
5242                 entry->cputype, entry->cpusubtype);
5243       abfd->filename = name;
5244     }
5245
5246   areltdata = bfd_zmalloc (sizeof (struct areltdata));
5247   areltdata->parsed_size = entry->size;
5248   abfd->arelt_data = areltdata;
5249   abfd->iostream = NULL;
5250   abfd->origin = entry->offset;
5251 }
5252
5253 bfd *
5254 bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
5255 {
5256   mach_o_fat_data_struct *adata;
5257   mach_o_fat_archentry *entry = NULL;
5258   unsigned long i;
5259   bfd *nbfd;
5260   enum bfd_architecture arch_type;
5261   unsigned long arch_subtype;
5262
5263   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
5264   BFD_ASSERT (adata != NULL);
5265
5266   /* Find index of previous entry.  */
5267   if (prev == NULL)
5268     {
5269       /* Start at first one.  */
5270       i = 0;
5271     }
5272   else
5273     {
5274       /* Find index of PREV.  */
5275       for (i = 0; i < adata->nfat_arch; i++)
5276         {
5277           if (adata->archentries[i].offset == prev->origin)
5278             break;
5279         }
5280
5281       if (i == adata->nfat_arch)
5282         {
5283           /* Not found.  */
5284           bfd_set_error (bfd_error_bad_value);
5285           return NULL;
5286         }
5287
5288       /* Get next entry.  */
5289       i++;
5290     }
5291
5292   if (i >= adata->nfat_arch)
5293     {
5294       bfd_set_error (bfd_error_no_more_archived_files);
5295       return NULL;
5296     }
5297
5298   entry = &adata->archentries[i];
5299   nbfd = _bfd_new_bfd_contained_in (archive);
5300   if (nbfd == NULL)
5301     return NULL;
5302
5303   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5304                                    &arch_type, &arch_subtype);
5305
5306   bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
5307
5308   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
5309
5310   return nbfd;
5311 }
5312
5313 /* Analogous to stat call.  */
5314
5315 static int
5316 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5317 {
5318   if (abfd->arelt_data == NULL)
5319     {
5320       bfd_set_error (bfd_error_invalid_operation);
5321       return -1;
5322     }
5323
5324   buf->st_mtime = 0;
5325   buf->st_uid = 0;
5326   buf->st_gid = 0;
5327   buf->st_mode = 0644;
5328   buf->st_size = arelt_size (abfd);
5329
5330   return 0;
5331 }
5332
5333 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5334    If ABFD is a fat image containing a member that corresponds to FORMAT
5335    and ARCH, returns it.
5336    In other case, returns NULL.
5337    This function allows transparent uses of fat images.  */
5338
5339 bfd *
5340 bfd_mach_o_fat_extract (bfd *abfd,
5341                         bfd_format format,
5342                         const bfd_arch_info_type *arch)
5343 {
5344   bfd *res;
5345   mach_o_fat_data_struct *adata;
5346   unsigned int i;
5347
5348   if (bfd_check_format (abfd, format))
5349     {
5350       if (bfd_get_arch_info (abfd) == arch)
5351         return abfd;
5352       return NULL;
5353     }
5354   if (!bfd_check_format (abfd, bfd_archive)
5355       || abfd->xvec != &mach_o_fat_vec)
5356     return NULL;
5357
5358   /* This is a Mach-O fat image.  */
5359   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5360   BFD_ASSERT (adata != NULL);
5361
5362   for (i = 0; i < adata->nfat_arch; i++)
5363     {
5364       struct mach_o_fat_archentry *e = &adata->archentries[i];
5365       enum bfd_architecture cpu_type;
5366       unsigned long cpu_subtype;
5367
5368       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5369                                        &cpu_type, &cpu_subtype);
5370       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5371         continue;
5372
5373       /* The architecture is found.  */
5374       res = _bfd_new_bfd_contained_in (abfd);
5375       if (res == NULL)
5376         return NULL;
5377
5378       bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
5379
5380       if (bfd_check_format (res, format))
5381         {
5382           BFD_ASSERT (bfd_get_arch_info (res) == arch);
5383           return res;
5384         }
5385       bfd_close (res);
5386       return NULL;
5387     }
5388
5389   return NULL;
5390 }
5391
5392 int
5393 bfd_mach_o_lookup_command (bfd *abfd,
5394                            bfd_mach_o_load_command_type type,
5395                            bfd_mach_o_load_command **mcommand)
5396 {
5397   struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5398   struct bfd_mach_o_load_command *cmd;
5399   unsigned int num;
5400
5401   BFD_ASSERT (mdata != NULL);
5402   BFD_ASSERT (mcommand != NULL);
5403
5404   num = 0;
5405   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5406     {
5407       if (cmd->type != type)
5408         continue;
5409
5410       if (num == 0)
5411         *mcommand = cmd;
5412       num++;
5413     }
5414
5415   return num;
5416 }
5417
5418 unsigned long
5419 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
5420 {
5421   switch (type)
5422     {
5423     case BFD_MACH_O_CPU_TYPE_MC680x0:
5424       return 0x04000000;
5425     case BFD_MACH_O_CPU_TYPE_MC88000:
5426       return 0xffffe000;
5427     case BFD_MACH_O_CPU_TYPE_POWERPC:
5428       return 0xc0000000;
5429     case BFD_MACH_O_CPU_TYPE_I386:
5430       return 0xc0000000;
5431     case BFD_MACH_O_CPU_TYPE_SPARC:
5432       return 0xf0000000;
5433     case BFD_MACH_O_CPU_TYPE_I860:
5434       return 0;
5435     case BFD_MACH_O_CPU_TYPE_HPPA:
5436       return 0xc0000000 - 0x04000000;
5437     default:
5438       return 0;
5439     }
5440 }
5441
5442 /* The following two tables should be kept, as far as possible, in order of
5443    most frequently used entries to optimize their use from gas.  */
5444
5445 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
5446 {
5447   { "regular", BFD_MACH_O_S_REGULAR},
5448   { "coalesced", BFD_MACH_O_S_COALESCED},
5449   { "zerofill", BFD_MACH_O_S_ZEROFILL},
5450   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5451   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5452   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
5453   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
5454   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
5455   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5456   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
5457   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5458   { "interposing", BFD_MACH_O_S_INTERPOSING},
5459   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
5460   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5461   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
5462   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
5463   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5464   { NULL, 0}
5465 };
5466
5467 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
5468 {
5469   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5470   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
5471   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5472   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
5473   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
5474   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5475   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5476   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5477   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
5478   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5479   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5480   { NULL, 0}
5481 };
5482
5483 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
5484
5485 unsigned int
5486 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
5487 {
5488   const bfd_mach_o_xlat_name *x;
5489   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5490
5491   for (x = bfd_mach_o_section_type_name; x->name; x++)
5492     if (strcmp (x->name, name) == 0)
5493       {
5494         /* We found it... does the target support it?  */
5495         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5496             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5497           return x->val; /* OK.  */
5498         else
5499           break; /* Not supported.  */
5500       }
5501   /* Maximum section ID = 0xff.  */
5502   return 256;
5503 }
5504
5505 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
5506
5507 unsigned int
5508 bfd_mach_o_get_section_attribute_from_name (const char *name)
5509 {
5510   const bfd_mach_o_xlat_name *x;
5511
5512   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5513     if (strcmp (x->name, name) == 0)
5514       return x->val;
5515   return (unsigned int)-1;
5516 }
5517
5518 int
5519 bfd_mach_o_core_fetch_environment (bfd *abfd,
5520                                    unsigned char **rbuf,
5521                                    unsigned int *rlen)
5522 {
5523   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5524   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
5525   bfd_mach_o_load_command *cmd;
5526
5527   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5528     {
5529       bfd_mach_o_segment_command *seg;
5530
5531       if (cmd->type != BFD_MACH_O_LC_SEGMENT)
5532         continue;
5533
5534       seg = &cmd->command.segment;
5535
5536       if ((seg->vmaddr + seg->vmsize) == stackaddr)
5537         {
5538           unsigned long start = seg->fileoff;
5539           unsigned long end = seg->fileoff + seg->filesize;
5540           unsigned char *buf = bfd_malloc (1024);
5541           unsigned long size = 1024;
5542
5543           for (;;)
5544             {
5545               bfd_size_type nread = 0;
5546               unsigned long offset;
5547               int found_nonnull = 0;
5548
5549               if (size > (end - start))
5550                 size = (end - start);
5551
5552               buf = bfd_realloc_or_free (buf, size);
5553               if (buf == NULL)
5554                 return -1;
5555
5556               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
5557                 {
5558                   free (buf);
5559                   return -1;
5560                 }
5561
5562               nread = bfd_bread (buf, size, abfd);
5563
5564               if (nread != size)
5565                 {
5566                   free (buf);
5567                   return -1;
5568                 }
5569
5570               for (offset = 4; offset <= size; offset += 4)
5571                 {
5572                   unsigned long val;
5573
5574                   val = *((unsigned long *) (buf + size - offset));
5575                   if (! found_nonnull)
5576                     {
5577                       if (val != 0)
5578                         found_nonnull = 1;
5579                     }
5580                   else if (val == 0x0)
5581                     {
5582                       unsigned long bottom;
5583                       unsigned long top;
5584
5585                       bottom = seg->fileoff + seg->filesize - offset;
5586                       top = seg->fileoff + seg->filesize - 4;
5587                       *rbuf = bfd_malloc (top - bottom);
5588                       *rlen = top - bottom;
5589
5590                       memcpy (*rbuf, buf + size - *rlen, *rlen);
5591                       free (buf);
5592                       return 0;
5593                     }
5594                 }
5595
5596               if (size == (end - start))
5597                 break;
5598
5599               size *= 2;
5600             }
5601
5602           free (buf);
5603         }
5604     }
5605
5606   return -1;
5607 }
5608
5609 char *
5610 bfd_mach_o_core_file_failing_command (bfd *abfd)
5611 {
5612   unsigned char *buf = NULL;
5613   unsigned int len = 0;
5614   int ret;
5615
5616   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5617   if (ret < 0)
5618     return NULL;
5619
5620   return (char *) buf;
5621 }
5622
5623 int
5624 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
5625 {
5626   return 0;
5627 }
5628
5629 static bfd_mach_o_uuid_command *
5630 bfd_mach_o_lookup_uuid_command (bfd *abfd)
5631 {
5632   bfd_mach_o_load_command *uuid_cmd;
5633   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
5634   if (ncmd != 1)
5635     return FALSE;
5636   return &uuid_cmd->command.uuid;
5637 }
5638
5639 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5640
5641 static bfd_boolean
5642 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
5643 {
5644   bfd_mach_o_uuid_command *dsym_uuid_cmd;
5645
5646   BFD_ASSERT (abfd);
5647   BFD_ASSERT (uuid_cmd);
5648
5649   if (!bfd_check_format (abfd, bfd_object))
5650     return FALSE;
5651
5652   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
5653       || bfd_mach_o_get_data (abfd) == NULL
5654       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
5655     return FALSE;
5656
5657   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5658   if (dsym_uuid_cmd == NULL)
5659     return FALSE;
5660
5661   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
5662               sizeof (uuid_cmd->uuid)) != 0)
5663     return FALSE;
5664
5665   return TRUE;
5666 }
5667
5668 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5669    The caller is responsible for closing the returned BFD object and
5670    its my_archive if the returned BFD is in a fat dSYM. */
5671
5672 static bfd *
5673 bfd_mach_o_find_dsym (const char *dsym_filename,
5674                       const bfd_mach_o_uuid_command *uuid_cmd,
5675                       const bfd_arch_info_type *arch)
5676 {
5677   bfd *base_dsym_bfd, *dsym_bfd;
5678
5679   BFD_ASSERT (uuid_cmd);
5680
5681   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
5682   if (base_dsym_bfd == NULL)
5683     return NULL;
5684
5685   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
5686   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
5687     return dsym_bfd;
5688
5689   bfd_close (dsym_bfd);
5690   if (base_dsym_bfd != dsym_bfd)
5691     bfd_close (base_dsym_bfd);
5692
5693   return NULL;
5694 }
5695
5696 /* Return a BFD created from a dSYM file for ABFD.
5697    The caller is responsible for closing the returned BFD object, its
5698    filename, and its my_archive if the returned BFD is in a fat dSYM. */
5699
5700 static bfd *
5701 bfd_mach_o_follow_dsym (bfd *abfd)
5702 {
5703   char *dsym_filename;
5704   bfd_mach_o_uuid_command *uuid_cmd;
5705   bfd *dsym_bfd, *base_bfd = abfd;
5706   const char *base_basename;
5707
5708   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
5709     return NULL;
5710
5711   if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
5712     base_bfd = abfd->my_archive;
5713   /* BFD may have been opened from a stream. */
5714   if (base_bfd->filename == NULL)
5715     {
5716       bfd_set_error (bfd_error_invalid_operation);
5717       return NULL;
5718     }
5719   base_basename = lbasename (base_bfd->filename);
5720
5721   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5722   if (uuid_cmd == NULL)
5723     return NULL;
5724
5725   /* TODO: We assume the DWARF file has the same as the binary's.
5726      It seems apple's GDB checks all files in the dSYM bundle directory.
5727      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5728   */
5729   dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
5730                                        + strlen (dsym_subdir) + 1
5731                                        + strlen (base_basename) + 1);
5732   sprintf (dsym_filename, "%s%s/%s",
5733            base_bfd->filename, dsym_subdir, base_basename);
5734
5735   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
5736                                    bfd_get_arch_info (abfd));
5737   if (dsym_bfd == NULL)
5738     free (dsym_filename);
5739
5740   return dsym_bfd;
5741 }
5742
5743 bfd_boolean
5744 bfd_mach_o_find_nearest_line (bfd *abfd,
5745                               asymbol **symbols,
5746                               asection *section,
5747                               bfd_vma offset,
5748                               const char **filename_ptr,
5749                               const char **functionname_ptr,
5750                               unsigned int *line_ptr,
5751                               unsigned int *discriminator_ptr)
5752 {
5753   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5754   if (mdata == NULL)
5755     return FALSE;
5756   switch (mdata->header.filetype)
5757     {
5758     case BFD_MACH_O_MH_OBJECT:
5759       break;
5760     case BFD_MACH_O_MH_EXECUTE:
5761     case BFD_MACH_O_MH_DYLIB:
5762     case BFD_MACH_O_MH_BUNDLE:
5763     case BFD_MACH_O_MH_KEXT_BUNDLE:
5764       if (mdata->dwarf2_find_line_info == NULL)
5765         {
5766           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5767           /* When we couldn't find dSYM for this binary, we look for
5768              the debug information in the binary itself. In this way,
5769              we won't try finding separated dSYM again because
5770              mdata->dwarf2_find_line_info will be filled. */
5771           if (! mdata->dsym_bfd)
5772             break;
5773           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5774                                               dwarf_debug_sections, symbols,
5775                                               &mdata->dwarf2_find_line_info,
5776                                               FALSE))
5777             return FALSE;
5778         }
5779       break;
5780     default:
5781       return FALSE;
5782     }
5783   return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
5784                                         filename_ptr, functionname_ptr,
5785                                         line_ptr, discriminator_ptr,
5786                                         dwarf_debug_sections, 0,
5787                                         &mdata->dwarf2_find_line_info);
5788 }
5789
5790 bfd_boolean
5791 bfd_mach_o_close_and_cleanup (bfd *abfd)
5792 {
5793   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5794   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5795     {
5796       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5797       bfd_mach_o_free_cached_info (abfd);
5798       if (mdata->dsym_bfd != NULL)
5799         {
5800           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5801 #if 0
5802           /* FIXME: PR 19435: This calculation to find the memory allocated by
5803              bfd_mach_o_follow_dsym for the filename does not always end up
5804              selecting the correct pointer.  Unfortunately this problem is
5805              very hard to reproduce on a non Mach-O native system, so until it
5806              can be traced and fixed on such a system, this code will remain
5807              commented out.  This does mean that there will be a memory leak,
5808              but it is small, and happens when we are closing down, so it
5809              should not matter too much.  */
5810           char *dsym_filename = (char *)(fat_bfd
5811                                          ? fat_bfd->filename
5812                                          : mdata->dsym_bfd->filename);
5813 #endif
5814           bfd_close (mdata->dsym_bfd);
5815           mdata->dsym_bfd = NULL;
5816           if (fat_bfd)
5817             bfd_close (fat_bfd);
5818 #if 0
5819           free (dsym_filename);
5820 #endif
5821         }
5822     }
5823
5824   return _bfd_generic_close_and_cleanup (abfd);
5825 }
5826
5827 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5828 {
5829   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5830   asection *asect;
5831   free (mdata->dyn_reloc_cache);
5832   mdata->dyn_reloc_cache = NULL;
5833   for (asect = abfd->sections; asect != NULL; asect = asect->next)
5834     {
5835       free (asect->relocation);
5836       asect->relocation = NULL;
5837     }
5838
5839   return TRUE;
5840 }
5841
5842 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5843 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5844
5845 #define bfd_mach_o_canonicalize_one_reloc NULL
5846 #define bfd_mach_o_swap_reloc_out NULL
5847 #define bfd_mach_o_print_thread NULL
5848 #define bfd_mach_o_tgt_seg_table NULL
5849 #define bfd_mach_o_section_type_valid_for_tgt NULL
5850
5851 #define TARGET_NAME             mach_o_be_vec
5852 #define TARGET_STRING           "mach-o-be"
5853 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5854 #define TARGET_PAGESIZE         1
5855 #define TARGET_BIG_ENDIAN       1
5856 #define TARGET_ARCHIVE          0
5857 #define TARGET_PRIORITY         1
5858 #include "mach-o-target.c"
5859
5860 #undef TARGET_NAME
5861 #undef TARGET_STRING
5862 #undef TARGET_ARCHITECTURE
5863 #undef TARGET_PAGESIZE
5864 #undef TARGET_BIG_ENDIAN
5865 #undef TARGET_ARCHIVE
5866 #undef TARGET_PRIORITY
5867
5868 #define TARGET_NAME             mach_o_le_vec
5869 #define TARGET_STRING           "mach-o-le"
5870 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5871 #define TARGET_PAGESIZE         1
5872 #define TARGET_BIG_ENDIAN       0
5873 #define TARGET_ARCHIVE          0
5874 #define TARGET_PRIORITY         1
5875
5876 #include "mach-o-target.c"
5877
5878 #undef TARGET_NAME
5879 #undef TARGET_STRING
5880 #undef TARGET_ARCHITECTURE
5881 #undef TARGET_PAGESIZE
5882 #undef TARGET_BIG_ENDIAN
5883 #undef TARGET_ARCHIVE
5884 #undef TARGET_PRIORITY
5885
5886 /* Not yet handled: creating an archive.  */
5887 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
5888
5889 #define bfd_mach_o_close_and_cleanup              bfd_true
5890
5891 /* Not used.  */
5892 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
5893 #define bfd_mach_o_openr_next_archived_file       bfd_mach_o_fat_openr_next_archived_file
5894 #define bfd_mach_o_archive_p    bfd_mach_o_fat_archive_p
5895
5896 #define TARGET_NAME             mach_o_fat_vec
5897 #define TARGET_STRING           "mach-o-fat"
5898 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5899 #define TARGET_PAGESIZE         1
5900 #define TARGET_BIG_ENDIAN       1
5901 #define TARGET_ARCHIVE          1
5902 #define TARGET_PRIORITY         0
5903
5904 #include "mach-o-target.c"
5905
5906 #undef TARGET_NAME
5907 #undef TARGET_STRING
5908 #undef TARGET_ARCHITECTURE
5909 #undef TARGET_PAGESIZE
5910 #undef TARGET_BIG_ENDIAN
5911 #undef TARGET_ARCHIVE
5912 #undef TARGET_PRIORITY