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
3496         (_("bfd_mach_o_read_section_32: overlarge alignment value: 0x%x, "
3497            "using 32 instead"), section->align);
3498       section->align = 32;
3499     }
3500   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3501   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3502   section->flags = bfd_h_get_32 (abfd, raw.flags);
3503   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3504   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3505   section->reserved3 = 0;
3506
3507   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3508
3509   return sec;
3510 }
3511
3512 static asection *
3513 bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
3514 {
3515   struct mach_o_section_64_external raw;
3516   asection *sec;
3517   bfd_mach_o_section *section;
3518
3519   if (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3520       != BFD_MACH_O_SECTION_64_SIZE)
3521     return NULL;
3522
3523   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3524   if (sec == NULL)
3525     return NULL;
3526
3527   section = bfd_mach_o_get_mach_o_section (sec);
3528   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3529   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3530   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3531   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3532   section->addr = bfd_h_get_64 (abfd, raw.addr);
3533   section->size = bfd_h_get_64 (abfd, raw.size);
3534   section->offset = bfd_h_get_32 (abfd, raw.offset);
3535   section->align = bfd_h_get_32 (abfd, raw.align);
3536   if (section->align > 64)
3537     {
3538       _bfd_error_handler
3539         (_("bfd_mach_o_read_section_64: overlarge alignment value: 0x%x, "
3540            "using 32 instead"), section->align);
3541       section->align = 32;
3542     }
3543   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3544   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3545   section->flags = bfd_h_get_32 (abfd, raw.flags);
3546   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3547   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3548   section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3549
3550   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3551
3552   return sec;
3553 }
3554
3555 static asection *
3556 bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
3557 {
3558   if (wide)
3559     return bfd_mach_o_read_section_64 (abfd, prot);
3560   else
3561     return bfd_mach_o_read_section_32 (abfd, prot);
3562 }
3563
3564 static bfd_boolean
3565 bfd_mach_o_read_symtab_symbol (bfd *abfd,
3566                                bfd_mach_o_symtab_command *sym,
3567                                bfd_mach_o_asymbol *s,
3568                                unsigned long i)
3569 {
3570   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3571   unsigned int wide = mach_o_wide_p (&mdata->header);
3572   unsigned int symwidth =
3573     wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3574   unsigned int symoff = sym->symoff + (i * symwidth);
3575   struct mach_o_nlist_64_external raw;
3576   unsigned char type = -1;
3577   unsigned char section = -1;
3578   short desc = -1;
3579   symvalue value = -1;
3580   unsigned long stroff = -1;
3581   unsigned int symtype = -1;
3582
3583   BFD_ASSERT (sym->strtab != NULL);
3584
3585   if (bfd_seek (abfd, symoff, SEEK_SET) != 0
3586       || bfd_bread (&raw, symwidth, abfd) != symwidth)
3587     {
3588       _bfd_error_handler
3589         (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3590          symwidth, (unsigned long) symoff);
3591       return FALSE;
3592     }
3593
3594   stroff = bfd_h_get_32 (abfd, raw.n_strx);
3595   type = bfd_h_get_8 (abfd, raw.n_type);
3596   symtype = type & BFD_MACH_O_N_TYPE;
3597   section = bfd_h_get_8 (abfd, raw.n_sect);
3598   desc = bfd_h_get_16 (abfd, raw.n_desc);
3599   if (wide)
3600     value = bfd_h_get_64 (abfd, raw.n_value);
3601   else
3602     value = bfd_h_get_32 (abfd, raw.n_value);
3603
3604   if (stroff >= sym->strsize)
3605     {
3606       _bfd_error_handler
3607         (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3608          (unsigned long) stroff,
3609          (unsigned long) sym->strsize);
3610       return FALSE;
3611     }
3612
3613   s->symbol.the_bfd = abfd;
3614   s->symbol.name = sym->strtab + stroff;
3615   s->symbol.value = value;
3616   s->symbol.flags = 0x0;
3617   s->symbol.udata.i = i;
3618   s->n_type = type;
3619   s->n_sect = section;
3620   s->n_desc = desc;
3621
3622   if (type & BFD_MACH_O_N_STAB)
3623     {
3624       s->symbol.flags |= BSF_DEBUGGING;
3625       s->symbol.section = bfd_und_section_ptr;
3626       switch (type)
3627         {
3628         case N_FUN:
3629         case N_STSYM:
3630         case N_LCSYM:
3631         case N_BNSYM:
3632         case N_SLINE:
3633         case N_ENSYM:
3634         case N_ECOMM:
3635         case N_ECOML:
3636         case N_GSYM:
3637           if ((section > 0) && (section <= mdata->nsects))
3638             {
3639               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3640               s->symbol.value =
3641                 s->symbol.value - mdata->sections[section - 1]->addr;
3642             }
3643           break;
3644         }
3645     }
3646   else
3647     {
3648       if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
3649         s->symbol.flags |= BSF_GLOBAL;
3650       else
3651         s->symbol.flags |= BSF_LOCAL;
3652
3653       switch (symtype)
3654         {
3655         case BFD_MACH_O_N_UNDF:
3656           if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3657               && s->symbol.value != 0)
3658             {
3659               /* A common symbol.  */
3660               s->symbol.section = bfd_com_section_ptr;
3661               s->symbol.flags = BSF_NO_FLAGS;
3662             }
3663           else
3664             {
3665               s->symbol.section = bfd_und_section_ptr;
3666               if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3667                 s->symbol.flags |= BSF_WEAK;
3668             }
3669           break;
3670         case BFD_MACH_O_N_PBUD:
3671           s->symbol.section = bfd_und_section_ptr;
3672           break;
3673         case BFD_MACH_O_N_ABS:
3674           s->symbol.section = bfd_abs_section_ptr;
3675           break;
3676         case BFD_MACH_O_N_SECT:
3677           if ((section > 0) && (section <= mdata->nsects))
3678             {
3679               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3680               s->symbol.value =
3681                 s->symbol.value - mdata->sections[section - 1]->addr;
3682             }
3683           else
3684             {
3685               /* Mach-O uses 0 to mean "no section"; not an error.  */
3686               if (section != 0)
3687                 {
3688                   _bfd_error_handler
3689                     (_("bfd_mach_o_read_symtab_symbol: "
3690                        "symbol \"%s\" specified invalid section %d (max %lu): "
3691                        "setting to undefined"),
3692                      s->symbol.name, section, mdata->nsects);
3693                 }
3694               s->symbol.section = bfd_und_section_ptr;
3695             }
3696           break;
3697         case BFD_MACH_O_N_INDR:
3698           /* FIXME: we don't follow the BFD convention as this indirect symbol
3699              won't be followed by the referenced one.  This looks harmless
3700              unless we start using the linker.  */
3701           s->symbol.flags |= BSF_INDIRECT;
3702           s->symbol.section = bfd_ind_section_ptr;
3703           s->symbol.value = 0;
3704           break;
3705         default:
3706           _bfd_error_handler
3707             (_("bfd_mach_o_read_symtab_symbol: "
3708                "symbol \"%s\" specified invalid type field 0x%x: "
3709                "setting to undefined"), s->symbol.name, symtype);
3710           s->symbol.section = bfd_und_section_ptr;
3711           break;
3712         }
3713     }
3714
3715   return TRUE;
3716 }
3717
3718 bfd_boolean
3719 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3720 {
3721   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3722   bfd_mach_o_symtab_command *sym = mdata->symtab;
3723
3724   /* Fail if there is no symtab.  */
3725   if (sym == NULL)
3726     return FALSE;
3727
3728   /* Success if already loaded.  */
3729   if (sym->strtab)
3730     return TRUE;
3731
3732   if (abfd->flags & BFD_IN_MEMORY)
3733     {
3734       struct bfd_in_memory *b;
3735
3736       b = (struct bfd_in_memory *) abfd->iostream;
3737
3738       if ((sym->stroff + sym->strsize) > b->size)
3739         {
3740           bfd_set_error (bfd_error_file_truncated);
3741           return FALSE;
3742         }
3743       sym->strtab = (char *) b->buffer + sym->stroff;
3744     }
3745   else
3746     {
3747       sym->strtab = bfd_alloc (abfd, sym->strsize + 1);
3748       if (sym->strtab == NULL)
3749         return FALSE;
3750
3751       if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3752           || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3753         {
3754           /* PR 17512: file: 10888-1609-0.004.  */
3755           bfd_release (abfd, sym->strtab);
3756           sym->strtab = NULL;
3757           bfd_set_error (bfd_error_file_truncated);
3758           return FALSE;
3759         }
3760       /* Zero terminate the string table.  */
3761       sym->strtab[sym->strsize] = 0;
3762     }
3763
3764   return TRUE;
3765 }
3766
3767 bfd_boolean
3768 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3769 {
3770   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3771   bfd_mach_o_symtab_command *sym = mdata->symtab;
3772   unsigned long i;
3773
3774   if (sym == NULL || sym->symbols)
3775     /* Return now if there are no symbols or if already loaded.  */
3776     return TRUE;
3777
3778   sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
3779   if (sym->symbols == NULL)
3780     {
3781       _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
3782                             "unable to allocate memory for symbols"));
3783       sym->nsyms = 0;
3784       return FALSE;
3785     }
3786
3787   if (!bfd_mach_o_read_symtab_strtab (abfd))
3788     goto fail;
3789
3790   for (i = 0; i < sym->nsyms; i++)
3791     if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3792       goto fail;
3793
3794   return TRUE;
3795
3796  fail:
3797   bfd_release (abfd, sym->symbols);
3798   sym->symbols = NULL;
3799   sym->nsyms = 0;
3800   return FALSE;
3801 }
3802
3803 static const char *
3804 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3805 {
3806   switch ((int) flavour)
3807     {
3808     case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
3809     case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
3810     case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3811     case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
3812     case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
3813     case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3814     case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
3815     case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
3816     case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
3817     case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
3818     case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
3819     case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
3820     case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3821     default: return "UNKNOWN";
3822     }
3823 }
3824
3825 static const char *
3826 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3827 {
3828   switch ((int) flavour)
3829     {
3830     case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
3831     case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
3832     case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
3833     case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
3834     case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
3835     case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3836     default: return "UNKNOWN";
3837     }
3838 }
3839
3840 static bfd_boolean
3841 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3842 {
3843   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3844   struct mach_o_str_command_external raw;
3845   unsigned int nameoff;
3846   unsigned int namelen;
3847
3848   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3849     return FALSE;
3850
3851   nameoff = bfd_h_get_32 (abfd, raw.str);
3852
3853   cmd->name_offset = nameoff;
3854   namelen = command->len - nameoff;
3855   nameoff += command->offset;
3856   cmd->name_str = bfd_alloc (abfd, namelen);
3857   if (cmd->name_str == NULL)
3858     return FALSE;
3859   if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
3860       || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3861     return FALSE;
3862   return TRUE;
3863 }
3864
3865 static bfd_boolean
3866 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3867 {
3868   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3869   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3870   struct mach_o_dylib_command_external raw;
3871   unsigned int nameoff;
3872   unsigned int namelen;
3873
3874   switch (command->type)
3875     {
3876     case BFD_MACH_O_LC_LOAD_DYLIB:
3877     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3878     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3879     case BFD_MACH_O_LC_ID_DYLIB:
3880     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3881     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3882       break;
3883     default:
3884       BFD_FAIL ();
3885       return FALSE;
3886     }
3887
3888   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3889     return FALSE;
3890
3891   nameoff = bfd_h_get_32 (abfd, raw.name);
3892   cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3893   cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3894   cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3895
3896   cmd->name_offset = command->offset + nameoff;
3897   namelen = command->len - nameoff;
3898   cmd->name_str = bfd_alloc (abfd, namelen);
3899   if (cmd->name_str == NULL)
3900     return FALSE;
3901   if (bfd_seek (abfd, mdata->hdr_offset + cmd->name_offset, SEEK_SET) != 0
3902       || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3903     return FALSE;
3904   return TRUE;
3905 }
3906
3907 static bfd_boolean
3908 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3909                                 bfd_mach_o_load_command *command)
3910 {
3911   bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3912   struct mach_o_prebound_dylib_command_external raw;
3913   unsigned int nameoff;
3914   unsigned int modoff;
3915   unsigned int str_len;
3916   unsigned char *str;
3917
3918   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3919     return FALSE;
3920
3921   nameoff = bfd_h_get_32 (abfd, raw.name);
3922   modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3923   if (nameoff > command->len || modoff > command->len)
3924     return FALSE;
3925
3926   str_len = command->len - sizeof (raw);
3927   str = bfd_alloc (abfd, str_len);
3928   if (str == NULL)
3929     return FALSE;
3930   if (bfd_bread (str, str_len, abfd) != str_len)
3931     return FALSE;
3932
3933   cmd->name_offset = command->offset + nameoff;
3934   cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3935   cmd->linked_modules_offset = command->offset + modoff;
3936
3937   cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3938   cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3939   return TRUE;
3940 }
3941
3942 static bfd_boolean
3943 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3944                                bfd_mach_o_load_command *command)
3945 {
3946   bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3947   struct mach_o_prebind_cksum_command_external raw;
3948
3949   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3950     return FALSE;
3951
3952   cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3953   return TRUE;
3954 }
3955
3956 static bfd_boolean
3957 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3958                                 bfd_mach_o_load_command *command)
3959 {
3960   bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3961   struct mach_o_twolevel_hints_command_external raw;
3962
3963   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3964     return FALSE;
3965
3966   cmd->offset = bfd_get_32 (abfd, raw.offset);
3967   cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3968   return TRUE;
3969 }
3970
3971 static bfd_boolean
3972 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3973 {
3974   bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3975   struct mach_o_fvmlib_command_external raw;
3976   unsigned int nameoff;
3977   unsigned int namelen;
3978
3979   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3980     return FALSE;
3981
3982   nameoff = bfd_h_get_32 (abfd, raw.name);
3983   fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3984   fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3985
3986   fvm->name_offset = command->offset + nameoff;
3987   namelen = command->len - nameoff;
3988   fvm->name_str = bfd_alloc (abfd, namelen);
3989   if (fvm->name_str == NULL)
3990     return FALSE;
3991   if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3992       || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
3993     return FALSE;
3994   return TRUE;
3995 }
3996
3997 static bfd_boolean
3998 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3999 {
4000   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4001   bfd_mach_o_thread_command *cmd = &command->command.thread;
4002   unsigned int offset;
4003   unsigned int nflavours;
4004   unsigned int i;
4005
4006   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
4007               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
4008
4009   /* Count the number of threads.  */
4010   offset = 8;
4011   nflavours = 0;
4012   while (offset != command->len)
4013     {
4014       struct mach_o_thread_command_external raw;
4015
4016       if (offset >= command->len)
4017         return FALSE;
4018
4019       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4020           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4021         return FALSE;
4022
4023       offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
4024       nflavours++;
4025     }
4026
4027   /* Allocate threads.  */
4028   cmd->flavours = bfd_alloc2
4029     (abfd, nflavours, sizeof (bfd_mach_o_thread_flavour));
4030   if (cmd->flavours == NULL)
4031     return FALSE;
4032   cmd->nflavours = nflavours;
4033
4034   offset = 8;
4035   nflavours = 0;
4036   while (offset != command->len)
4037     {
4038       struct mach_o_thread_command_external raw;
4039
4040       if (offset >= command->len)
4041         return FALSE;
4042
4043       if (nflavours >= cmd->nflavours)
4044         return FALSE;
4045
4046       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4047           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4048         return FALSE;
4049
4050       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4051       cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4052       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4053       offset += cmd->flavours[nflavours].size + sizeof (raw);
4054       nflavours++;
4055     }
4056
4057   for (i = 0; i < nflavours; i++)
4058     {
4059       asection *bfdsec;
4060       unsigned int snamelen;
4061       char *sname;
4062       const char *flavourstr;
4063       const char *prefix = "LC_THREAD";
4064       unsigned int j = 0;
4065
4066       switch (mdata->header.cputype)
4067         {
4068         case BFD_MACH_O_CPU_TYPE_POWERPC:
4069         case BFD_MACH_O_CPU_TYPE_POWERPC_64:
4070           flavourstr =
4071             bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
4072           break;
4073         case BFD_MACH_O_CPU_TYPE_I386:
4074         case BFD_MACH_O_CPU_TYPE_X86_64:
4075           flavourstr =
4076             bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
4077           break;
4078         default:
4079           flavourstr = "UNKNOWN_ARCHITECTURE";
4080           break;
4081         }
4082
4083       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
4084       sname = bfd_alloc (abfd, snamelen);
4085       if (sname == NULL)
4086         return FALSE;
4087
4088       for (;;)
4089         {
4090           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4091           if (bfd_get_section_by_name (abfd, sname) == NULL)
4092             break;
4093           j++;
4094         }
4095
4096       bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
4097
4098       bfdsec->vma = 0;
4099       bfdsec->lma = 0;
4100       bfdsec->size = cmd->flavours[i].size;
4101       bfdsec->filepos = cmd->flavours[i].offset;
4102       bfdsec->alignment_power = 0x0;
4103
4104       cmd->section = bfdsec;
4105     }
4106
4107   return TRUE;
4108 }
4109
4110 static bfd_boolean
4111 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
4112 {
4113   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
4114   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4115
4116   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4117
4118   {
4119     struct mach_o_dysymtab_command_external raw;
4120
4121     if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4122       return FALSE;
4123
4124     cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4125     cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4126     cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4127     cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4128     cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4129     cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4130     cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4131     cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4132     cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4133     cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4134     cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4135     cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4136     cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4137     cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4138     cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4139     cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4140     cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4141     cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4142   }
4143
4144   if (cmd->nmodtab != 0)
4145     {
4146       unsigned int i;
4147       int wide = bfd_mach_o_wide_p (abfd);
4148       unsigned int module_len = wide ? 56 : 52;
4149
4150       cmd->dylib_module =
4151         bfd_alloc2 (abfd, cmd->nmodtab, sizeof (bfd_mach_o_dylib_module));
4152       if (cmd->dylib_module == NULL)
4153         return FALSE;
4154
4155       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
4156         return FALSE;
4157
4158       for (i = 0; i < cmd->nmodtab; i++)
4159         {
4160           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4161           unsigned long v;
4162           unsigned char buf[56];
4163
4164           if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4165             return FALSE;
4166
4167           module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4168           module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4169           module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4170           module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4171           module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4172           module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4173           module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4174           module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4175           module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4176           v = bfd_h_get_32 (abfd, buf +36);
4177           module->iinit = v & 0xffff;
4178           module->iterm = (v >> 16) & 0xffff;
4179           v = bfd_h_get_32 (abfd, buf + 40);
4180           module->ninit = v & 0xffff;
4181           module->nterm = (v >> 16) & 0xffff;
4182           if (wide)
4183             {
4184               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4185               module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4186             }
4187           else
4188             {
4189               module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4190               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4191             }
4192         }
4193     }
4194
4195   if (cmd->ntoc != 0)
4196     {
4197       unsigned long i;
4198
4199       cmd->dylib_toc = bfd_alloc2
4200         (abfd, cmd->ntoc, sizeof (bfd_mach_o_dylib_table_of_content));
4201       if (cmd->dylib_toc == NULL)
4202         return FALSE;
4203
4204       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
4205         return FALSE;
4206
4207       for (i = 0; i < cmd->ntoc; i++)
4208         {
4209           struct mach_o_dylib_table_of_contents_external raw;
4210           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
4211
4212           if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4213             return FALSE;
4214
4215           toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4216           toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4217         }
4218     }
4219
4220   if (cmd->nindirectsyms != 0)
4221     {
4222       unsigned int i;
4223
4224       cmd->indirect_syms = bfd_alloc2
4225         (abfd, cmd->nindirectsyms, sizeof (unsigned int));
4226       if (cmd->indirect_syms == NULL)
4227         return FALSE;
4228
4229       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
4230         return FALSE;
4231
4232       for (i = 0; i < cmd->nindirectsyms; i++)
4233         {
4234           unsigned char raw[4];
4235           unsigned int *is = &cmd->indirect_syms[i];
4236
4237           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4238             return FALSE;
4239
4240           *is = bfd_h_get_32 (abfd, raw);
4241         }
4242     }
4243
4244   if (cmd->nextrefsyms != 0)
4245     {
4246       unsigned long v;
4247       unsigned int i;
4248
4249       cmd->ext_refs = bfd_alloc2
4250         (abfd, cmd->nextrefsyms, sizeof (bfd_mach_o_dylib_reference));
4251       if (cmd->ext_refs == NULL)
4252         return FALSE;
4253
4254       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
4255         return FALSE;
4256
4257       for (i = 0; i < cmd->nextrefsyms; i++)
4258         {
4259           unsigned char raw[4];
4260           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4261
4262           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4263             return FALSE;
4264
4265           /* Fields isym and flags are written as bit-fields, thus we need
4266              a specific processing for endianness.  */
4267           v = bfd_h_get_32 (abfd, raw);
4268           if (bfd_big_endian (abfd))
4269             {
4270               ref->isym = (v >> 8) & 0xffffff;
4271               ref->flags = v & 0xff;
4272             }
4273           else
4274             {
4275               ref->isym = v & 0xffffff;
4276               ref->flags = (v >> 24) & 0xff;
4277             }
4278         }
4279     }
4280
4281   if (mdata->dysymtab)
4282     return FALSE;
4283   mdata->dysymtab = cmd;
4284
4285   return TRUE;
4286 }
4287
4288 static bfd_boolean
4289 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
4290 {
4291   bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4292   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4293   struct mach_o_symtab_command_external raw;
4294
4295   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4296
4297   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4298     return FALSE;
4299
4300   symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4301   symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4302   symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4303   symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
4304   symtab->symbols = NULL;
4305   symtab->strtab = NULL;
4306
4307   if (symtab->nsyms != 0)
4308     abfd->flags |= HAS_SYMS;
4309
4310   if (mdata->symtab)
4311     return FALSE;
4312   mdata->symtab = symtab;
4313   return TRUE;
4314 }
4315
4316 static bfd_boolean
4317 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
4318 {
4319   bfd_mach_o_uuid_command *cmd = &command->command.uuid;
4320
4321   BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4322
4323   if (bfd_bread (cmd->uuid, 16, abfd) != 16)
4324     return FALSE;
4325
4326   return TRUE;
4327 }
4328
4329 static bfd_boolean
4330 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
4331 {
4332   bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
4333   struct mach_o_linkedit_data_command_external raw;
4334
4335   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4336     return FALSE;
4337
4338   cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4339   cmd->datasize = bfd_get_32 (abfd, raw.datasize);
4340   return TRUE;
4341 }
4342
4343 static bfd_boolean
4344 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
4345 {
4346   bfd_mach_o_str_command *cmd = &command->command.str;
4347   struct mach_o_str_command_external raw;
4348   unsigned long off;
4349
4350   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4351     return FALSE;
4352
4353   off = bfd_get_32 (abfd, raw.str);
4354   cmd->stroff = command->offset + off;
4355   cmd->str_len = command->len - off;
4356   cmd->str = bfd_alloc (abfd, cmd->str_len);
4357   if (cmd->str == NULL)
4358     return FALSE;
4359   if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
4360       || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
4361     return FALSE;
4362   return TRUE;
4363 }
4364
4365 static unsigned char *
4366 bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
4367 {
4368   unsigned char *buf;
4369
4370   buf = bfd_alloc (abfd, size);
4371   if (buf == NULL)
4372     return NULL;
4373   if (bfd_seek (abfd, off, SEEK_SET) != 0
4374       || bfd_bread (buf, size, abfd) != size)
4375     return NULL;
4376   return buf;
4377 }
4378
4379 static bfd_boolean
4380 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4381 {
4382   /* Read rebase content.  */
4383   if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4384     {
4385       cmd->rebase_content =
4386         bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4387       if (cmd->rebase_content == NULL)
4388         return FALSE;
4389     }
4390
4391   /* Read bind content.  */
4392   if (cmd->bind_content == NULL && cmd->bind_size != 0)
4393     {
4394       cmd->bind_content =
4395         bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4396       if (cmd->bind_content == NULL)
4397         return FALSE;
4398     }
4399
4400   /* Read weak bind content.  */
4401   if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4402     {
4403       cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4404         (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4405       if (cmd->weak_bind_content == NULL)
4406         return FALSE;
4407     }
4408
4409   /* Read lazy bind content.  */
4410   if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4411     {
4412       cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4413         (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4414       if (cmd->lazy_bind_content == NULL)
4415         return FALSE;
4416     }
4417
4418   /* Read export content.  */
4419   if (cmd->export_content == NULL && cmd->export_size != 0)
4420     {
4421       cmd->export_content = bfd_mach_o_alloc_and_read
4422         (abfd, cmd->export_off, cmd->export_size);
4423       if (cmd->export_content == NULL)
4424         return FALSE;
4425     }
4426
4427   return TRUE;
4428 }
4429
4430 static bfd_boolean
4431 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
4432 {
4433   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
4434   struct mach_o_dyld_info_command_external raw;
4435
4436   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4437     return FALSE;
4438
4439   cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4440   cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
4441   cmd->rebase_content = NULL;
4442   cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4443   cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
4444   cmd->bind_content = NULL;
4445   cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4446   cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
4447   cmd->weak_bind_content = NULL;
4448   cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4449   cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
4450   cmd->lazy_bind_content = NULL;
4451   cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4452   cmd->export_size = bfd_get_32 (abfd, raw.export_size);
4453   cmd->export_content = NULL;
4454   return TRUE;
4455 }
4456
4457 static bfd_boolean
4458 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4459 {
4460   bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4461   struct mach_o_version_min_command_external raw;
4462   unsigned int ver;
4463
4464   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4465     return FALSE;
4466
4467   ver = bfd_get_32 (abfd, raw.version);
4468   cmd->rel = ver >> 16;
4469   cmd->maj = ver >> 8;
4470   cmd->min = ver;
4471   cmd->reserved = bfd_get_32 (abfd, raw.reserved);
4472   return TRUE;
4473 }
4474
4475 static bfd_boolean
4476 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4477 {
4478   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4479   struct mach_o_encryption_info_command_external raw;
4480
4481   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4482     return FALSE;
4483
4484   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4485   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4486   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4487   return TRUE;
4488 }
4489
4490 static bfd_boolean
4491 bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
4492 {
4493   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4494   struct mach_o_encryption_info_64_command_external raw;
4495
4496   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4497     return FALSE;
4498
4499   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4500   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4501   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4502   return TRUE;
4503 }
4504
4505 static bfd_boolean
4506 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4507 {
4508   bfd_mach_o_main_command *cmd = &command->command.main;
4509   struct mach_o_entry_point_command_external raw;
4510
4511   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4512     return FALSE;
4513
4514   cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4515   cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4516   return TRUE;
4517 }
4518
4519 static bfd_boolean
4520 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4521 {
4522   bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4523   struct mach_o_source_version_command_external raw;
4524   bfd_uint64_t ver;
4525
4526   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4527     return FALSE;
4528
4529   ver = bfd_get_64 (abfd, raw.version);
4530   /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4531      generates warnings) in case of the host doesn't support 64 bit
4532      integers.  */
4533   cmd->e = ver & 0x3ff;
4534   ver >>= 10;
4535   cmd->d = ver & 0x3ff;
4536   ver >>= 10;
4537   cmd->c = ver & 0x3ff;
4538   ver >>= 10;
4539   cmd->b = ver & 0x3ff;
4540   ver >>= 10;
4541   cmd->a = ver & 0xffffff;
4542   return TRUE;
4543 }
4544
4545 static bfd_boolean
4546 bfd_mach_o_read_segment (bfd *abfd,
4547                          bfd_mach_o_load_command *command,
4548                          unsigned int wide)
4549 {
4550   bfd_mach_o_segment_command *seg = &command->command.segment;
4551   unsigned long i;
4552
4553   if (wide)
4554     {
4555       struct mach_o_segment_command_64_external raw;
4556
4557       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
4558
4559       if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4560         return FALSE;
4561
4562       memcpy (seg->segname, raw.segname, 16);
4563       seg->segname[16] = '\0';
4564
4565       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4566       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4567       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4568       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4569       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4570       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4571       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4572       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4573     }
4574   else
4575     {
4576       struct mach_o_segment_command_32_external raw;
4577
4578       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4579
4580       if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4581         return FALSE;
4582
4583       memcpy (seg->segname, raw.segname, 16);
4584       seg->segname[16] = '\0';
4585
4586       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4587       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4588       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4589       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4590       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4591       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4592       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4593       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4594     }
4595   seg->sect_head = NULL;
4596   seg->sect_tail = NULL;
4597
4598   for (i = 0; i < seg->nsects; i++)
4599     {
4600       asection *sec;
4601
4602       sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
4603       if (sec == NULL)
4604         return FALSE;
4605
4606       bfd_mach_o_append_section_to_segment
4607         (seg, bfd_mach_o_get_mach_o_section (sec));
4608     }
4609
4610   return TRUE;
4611 }
4612
4613 static bfd_boolean
4614 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
4615 {
4616   return bfd_mach_o_read_segment (abfd, command, 0);
4617 }
4618
4619 static bfd_boolean
4620 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
4621 {
4622   return bfd_mach_o_read_segment (abfd, command, 1);
4623 }
4624
4625 static bfd_boolean
4626 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
4627 {
4628   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4629   struct mach_o_load_command_external raw;
4630   unsigned int cmd;
4631
4632   /* Read command type and length.  */
4633   if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
4634       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
4635     return FALSE;
4636
4637   cmd = bfd_h_get_32 (abfd, raw.cmd);
4638   command->type =  cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4639   command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
4640   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
4641
4642   switch (command->type)
4643     {
4644     case BFD_MACH_O_LC_SEGMENT:
4645       if (!bfd_mach_o_read_segment_32 (abfd, command))
4646         return FALSE;
4647       break;
4648     case BFD_MACH_O_LC_SEGMENT_64:
4649       if (!bfd_mach_o_read_segment_64 (abfd, command))
4650         return FALSE;
4651       break;
4652     case BFD_MACH_O_LC_SYMTAB:
4653       if (!bfd_mach_o_read_symtab (abfd, command))
4654         return FALSE;
4655       break;
4656     case BFD_MACH_O_LC_SYMSEG:
4657       break;
4658     case BFD_MACH_O_LC_THREAD:
4659     case BFD_MACH_O_LC_UNIXTHREAD:
4660       if (!bfd_mach_o_read_thread (abfd, command))
4661         return FALSE;
4662       break;
4663     case BFD_MACH_O_LC_LOAD_DYLINKER:
4664     case BFD_MACH_O_LC_ID_DYLINKER:
4665     case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
4666       if (!bfd_mach_o_read_dylinker (abfd, command))
4667         return FALSE;
4668       break;
4669     case BFD_MACH_O_LC_LOAD_DYLIB:
4670     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4671     case BFD_MACH_O_LC_ID_DYLIB:
4672     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4673     case BFD_MACH_O_LC_REEXPORT_DYLIB:
4674     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4675       if (!bfd_mach_o_read_dylib (abfd, command))
4676         return FALSE;
4677       break;
4678     case BFD_MACH_O_LC_PREBOUND_DYLIB:
4679       if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4680         return FALSE;
4681       break;
4682     case BFD_MACH_O_LC_LOADFVMLIB:
4683     case BFD_MACH_O_LC_IDFVMLIB:
4684       if (!bfd_mach_o_read_fvmlib (abfd, command))
4685         return FALSE;
4686       break;
4687     case BFD_MACH_O_LC_IDENT:
4688     case BFD_MACH_O_LC_FVMFILE:
4689     case BFD_MACH_O_LC_PREPAGE:
4690     case BFD_MACH_O_LC_ROUTINES:
4691     case BFD_MACH_O_LC_ROUTINES_64:
4692       break;
4693     case BFD_MACH_O_LC_SUB_FRAMEWORK:
4694     case BFD_MACH_O_LC_SUB_UMBRELLA:
4695     case BFD_MACH_O_LC_SUB_LIBRARY:
4696     case BFD_MACH_O_LC_SUB_CLIENT:
4697     case BFD_MACH_O_LC_RPATH:
4698       if (!bfd_mach_o_read_str (abfd, command))
4699         return FALSE;
4700       break;
4701     case BFD_MACH_O_LC_DYSYMTAB:
4702       if (!bfd_mach_o_read_dysymtab (abfd, command))
4703         return FALSE;
4704       break;
4705     case BFD_MACH_O_LC_PREBIND_CKSUM:
4706       if (!bfd_mach_o_read_prebind_cksum (abfd, command))
4707         return FALSE;
4708       break;
4709     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
4710       if (!bfd_mach_o_read_twolevel_hints (abfd, command))
4711         return FALSE;
4712       break;
4713     case BFD_MACH_O_LC_UUID:
4714       if (!bfd_mach_o_read_uuid (abfd, command))
4715         return FALSE;
4716       break;
4717     case BFD_MACH_O_LC_CODE_SIGNATURE:
4718     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
4719     case BFD_MACH_O_LC_FUNCTION_STARTS:
4720     case BFD_MACH_O_LC_DATA_IN_CODE:
4721     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
4722     case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
4723       if (!bfd_mach_o_read_linkedit (abfd, command))
4724         return FALSE;
4725       break;
4726     case BFD_MACH_O_LC_ENCRYPTION_INFO:
4727       if (!bfd_mach_o_read_encryption_info (abfd, command))
4728         return FALSE;
4729       break;
4730     case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
4731       if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
4732         return FALSE;
4733       break;
4734     case BFD_MACH_O_LC_DYLD_INFO:
4735       if (!bfd_mach_o_read_dyld_info (abfd, command))
4736         return FALSE;
4737       break;
4738     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
4739     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
4740     case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
4741       if (!bfd_mach_o_read_version_min (abfd, command))
4742         return FALSE;
4743       break;
4744     case BFD_MACH_O_LC_MAIN:
4745       if (!bfd_mach_o_read_main (abfd, command))
4746         return FALSE;
4747       break;
4748     case BFD_MACH_O_LC_SOURCE_VERSION:
4749       if (!bfd_mach_o_read_source_version (abfd, command))
4750         return FALSE;
4751       break;
4752     default:
4753       command->len = 0;
4754       _bfd_error_handler (_("%B: unknown load command 0x%lx"),
4755                           abfd, (unsigned long) command->type);
4756       return FALSE;
4757     }
4758
4759   return TRUE;
4760 }
4761
4762 static void
4763 bfd_mach_o_flatten_sections (bfd *abfd)
4764 {
4765   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4766   bfd_mach_o_load_command *cmd;
4767   long csect = 0;
4768
4769   /* Count total number of sections.  */
4770   mdata->nsects = 0;
4771
4772   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4773     {
4774       if (cmd->type == BFD_MACH_O_LC_SEGMENT
4775           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4776         {
4777           bfd_mach_o_segment_command *seg = &cmd->command.segment;
4778
4779           mdata->nsects += seg->nsects;
4780         }
4781     }
4782
4783   /* Allocate sections array.  */
4784   mdata->sections = bfd_alloc2 (abfd,
4785                                 mdata->nsects, sizeof (bfd_mach_o_section *));
4786
4787   /* Fill the array.  */
4788   csect = 0;
4789
4790   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4791     {
4792       if (cmd->type == BFD_MACH_O_LC_SEGMENT
4793           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4794         {
4795           bfd_mach_o_segment_command *seg = &cmd->command.segment;
4796           bfd_mach_o_section *sec;
4797
4798           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4799
4800           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4801             mdata->sections[csect++] = sec;
4802         }
4803     }
4804 }
4805
4806 static bfd_boolean
4807 bfd_mach_o_scan_start_address (bfd *abfd)
4808 {
4809   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4810   bfd_mach_o_thread_command *thr = NULL;
4811   bfd_mach_o_load_command *cmd;
4812   unsigned long i;
4813
4814   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4815     if (cmd->type == BFD_MACH_O_LC_THREAD
4816         || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
4817       {
4818         thr = &cmd->command.thread;
4819         break;
4820       }
4821     else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
4822       {
4823         bfd_mach_o_main_command *main_cmd = &cmd->command.main;
4824         bfd_mach_o_section *text_sect = mdata->sections[0];
4825
4826         if (text_sect)
4827           {
4828             abfd->start_address = main_cmd->entryoff
4829               + (text_sect->addr - text_sect->offset);
4830             return TRUE;
4831           }
4832       }
4833
4834   /* An object file has no start address, so do not fail if not found.  */
4835   if (thr == NULL)
4836     return TRUE;
4837
4838   /* FIXME: create a subtarget hook ?  */
4839   for (i = 0; i < thr->nflavours; i++)
4840     {
4841       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4842           && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
4843         {
4844           unsigned char buf[4];
4845
4846           if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
4847               || bfd_bread (buf, 4, abfd) != 4)
4848             return FALSE;
4849
4850           abfd->start_address = bfd_h_get_32 (abfd, buf);
4851         }
4852       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4853                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4854         {
4855           unsigned char buf[4];
4856
4857           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4858               || bfd_bread (buf, 4, abfd) != 4)
4859             return FALSE;
4860
4861           abfd->start_address = bfd_h_get_32 (abfd, buf);
4862         }
4863       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4864                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4865         {
4866           unsigned char buf[8];
4867
4868           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4869               || bfd_bread (buf, 8, abfd) != 8)
4870             return FALSE;
4871
4872           abfd->start_address = bfd_h_get_64 (abfd, buf);
4873         }
4874       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4875                && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4876         {
4877           unsigned char buf[8];
4878
4879           if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4880               || bfd_bread (buf, 8, abfd) != 8)
4881             return FALSE;
4882
4883           abfd->start_address = bfd_h_get_64 (abfd, buf);
4884         }
4885     }
4886
4887   return TRUE;
4888 }
4889
4890 bfd_boolean
4891 bfd_mach_o_set_arch_mach (bfd *abfd,
4892                           enum bfd_architecture arch,
4893                           unsigned long machine)
4894 {
4895   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4896
4897   /* If this isn't the right architecture for this backend, and this
4898      isn't the generic backend, fail.  */
4899   if (arch != bed->arch
4900       && arch != bfd_arch_unknown
4901       && bed->arch != bfd_arch_unknown)
4902     return FALSE;
4903
4904   return bfd_default_set_arch_mach (abfd, arch, machine);
4905 }
4906
4907 static bfd_boolean
4908 bfd_mach_o_scan (bfd *abfd,
4909                  bfd_mach_o_header *header,
4910                  bfd_mach_o_data_struct *mdata)
4911 {
4912   unsigned int i;
4913   enum bfd_architecture cputype;
4914   unsigned long cpusubtype;
4915   unsigned int hdrsize;
4916
4917   hdrsize = mach_o_wide_p (header) ?
4918     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4919
4920   mdata->header = *header;
4921
4922   abfd->flags = abfd->flags & BFD_IN_MEMORY;
4923   switch (header->filetype)
4924     {
4925     case BFD_MACH_O_MH_OBJECT:
4926       abfd->flags |= HAS_RELOC;
4927       break;
4928     case BFD_MACH_O_MH_EXECUTE:
4929       abfd->flags |= EXEC_P;
4930       break;
4931     case BFD_MACH_O_MH_DYLIB:
4932     case BFD_MACH_O_MH_BUNDLE:
4933       abfd->flags |= DYNAMIC;
4934       break;
4935     }
4936
4937   abfd->tdata.mach_o_data = mdata;
4938
4939   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4940                                    &cputype, &cpusubtype);
4941   if (cputype == bfd_arch_unknown)
4942     {
4943       _bfd_error_handler
4944         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4945          header->cputype, header->cpusubtype);
4946       return FALSE;
4947     }
4948
4949   bfd_set_arch_mach (abfd, cputype, cpusubtype);
4950
4951   if (header->ncmds != 0)
4952     {
4953       bfd_mach_o_load_command *cmd;
4954
4955       mdata->first_command = NULL;
4956       mdata->last_command = NULL;
4957
4958       cmd = bfd_alloc2 (abfd, header->ncmds, sizeof (bfd_mach_o_load_command));
4959       if (cmd == NULL)
4960         return FALSE;
4961
4962       for (i = 0; i < header->ncmds; i++)
4963         {
4964           bfd_mach_o_load_command *cur = &cmd[i];
4965
4966           bfd_mach_o_append_command (abfd, cur);
4967
4968           if (i == 0)
4969             cur->offset = hdrsize;
4970           else
4971             {
4972               bfd_mach_o_load_command *prev = &cmd[i - 1];
4973               cur->offset = prev->offset + prev->len;
4974             }
4975
4976           if (!bfd_mach_o_read_command (abfd, cur))
4977             return FALSE;
4978         }
4979     }
4980
4981   /* Sections should be flatten before scanning start address.  */
4982   bfd_mach_o_flatten_sections (abfd);
4983   if (!bfd_mach_o_scan_start_address (abfd))
4984     return FALSE;
4985
4986   return TRUE;
4987 }
4988
4989 bfd_boolean
4990 bfd_mach_o_mkobject_init (bfd *abfd)
4991 {
4992   bfd_mach_o_data_struct *mdata = NULL;
4993
4994   mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4995   if (mdata == NULL)
4996     return FALSE;
4997   abfd->tdata.mach_o_data = mdata;
4998
4999   mdata->header.magic = 0;
5000   mdata->header.cputype = 0;
5001   mdata->header.cpusubtype = 0;
5002   mdata->header.filetype = 0;
5003   mdata->header.ncmds = 0;
5004   mdata->header.sizeofcmds = 0;
5005   mdata->header.flags = 0;
5006   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
5007   mdata->first_command = NULL;
5008   mdata->last_command = NULL;
5009   mdata->nsects = 0;
5010   mdata->sections = NULL;
5011   mdata->dyn_reloc_cache = NULL;
5012
5013   return TRUE;
5014 }
5015
5016 static bfd_boolean
5017 bfd_mach_o_gen_mkobject (bfd *abfd)
5018 {
5019   bfd_mach_o_data_struct *mdata;
5020
5021   if (!bfd_mach_o_mkobject_init (abfd))
5022     return FALSE;
5023
5024   mdata = bfd_mach_o_get_data (abfd);
5025   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
5026   mdata->header.cputype = 0;
5027   mdata->header.cpusubtype = 0;
5028   mdata->header.byteorder = abfd->xvec->byteorder;
5029   mdata->header.version = 1;
5030
5031   return TRUE;
5032 }
5033
5034 const bfd_target *
5035 bfd_mach_o_header_p (bfd *abfd,
5036                      file_ptr hdr_off,
5037                      bfd_mach_o_filetype filetype,
5038                      bfd_mach_o_cpu_type cputype)
5039 {
5040   bfd_mach_o_header header;
5041   bfd_mach_o_data_struct *mdata;
5042
5043   if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
5044     goto wrong;
5045
5046   if (! (header.byteorder == BFD_ENDIAN_BIG
5047          || header.byteorder == BFD_ENDIAN_LITTLE))
5048     {
5049       _bfd_error_handler (_("unknown header byte-order value 0x%lx"),
5050                           (unsigned long) header.byteorder);
5051       goto wrong;
5052     }
5053
5054   if (! ((header.byteorder == BFD_ENDIAN_BIG
5055           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5056           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5057          || (header.byteorder == BFD_ENDIAN_LITTLE
5058              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5059              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5060     goto wrong;
5061
5062   /* Check cputype and filetype.
5063      In case of wildcard, do not accept magics that are handled by existing
5064      targets.  */
5065   if (cputype)
5066     {
5067       if (header.cputype != cputype)
5068         goto wrong;
5069     }
5070   else
5071     {
5072 #ifndef BFD64
5073       /* Do not recognize 64 architectures if not configured for 64bit targets.
5074          This could happen only for generic targets.  */
5075       if (mach_o_wide_p (&header))
5076          goto wrong;
5077 #endif
5078     }
5079
5080   if (filetype)
5081     {
5082       if (header.filetype != filetype)
5083         goto wrong;
5084     }
5085   else
5086     {
5087       switch (header.filetype)
5088         {
5089         case BFD_MACH_O_MH_CORE:
5090           /* Handled by core_p */
5091           goto wrong;
5092         default:
5093           break;
5094         }
5095     }
5096
5097   mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5098   if (mdata == NULL)
5099     goto fail;
5100   mdata->hdr_offset = hdr_off;
5101
5102   if (!bfd_mach_o_scan (abfd, &header, mdata))
5103     goto wrong;
5104
5105   return abfd->xvec;
5106
5107  wrong:
5108   bfd_set_error (bfd_error_wrong_format);
5109
5110  fail:
5111   return NULL;
5112 }
5113
5114 static const bfd_target *
5115 bfd_mach_o_gen_object_p (bfd *abfd)
5116 {
5117   return bfd_mach_o_header_p (abfd, 0, 0, 0);
5118 }
5119
5120 static const bfd_target *
5121 bfd_mach_o_gen_core_p (bfd *abfd)
5122 {
5123   return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
5124 }
5125
5126 /* Return the base address of ABFD, ie the address at which the image is
5127    mapped.  The possible initial pagezero is ignored.  */
5128
5129 bfd_vma
5130 bfd_mach_o_get_base_address (bfd *abfd)
5131 {
5132   bfd_mach_o_data_struct *mdata;
5133   bfd_mach_o_load_command *cmd;
5134
5135   /* Check for Mach-O.  */
5136   if (!bfd_mach_o_valid (abfd))
5137     return 0;
5138   mdata = bfd_mach_o_get_data (abfd);
5139
5140   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5141     {
5142       if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5143            || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5144         {
5145           struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5146
5147           if (segcmd->initprot != 0)
5148             return segcmd->vmaddr;
5149         }
5150     }
5151   return 0;
5152 }
5153
5154 typedef struct mach_o_fat_archentry
5155 {
5156   unsigned long cputype;
5157   unsigned long cpusubtype;
5158   unsigned long offset;
5159   unsigned long size;
5160   unsigned long align;
5161 } mach_o_fat_archentry;
5162
5163 typedef struct mach_o_fat_data_struct
5164 {
5165   unsigned long magic;
5166   unsigned long nfat_arch;
5167   mach_o_fat_archentry *archentries;
5168 } mach_o_fat_data_struct;
5169
5170 const bfd_target *
5171 bfd_mach_o_fat_archive_p (bfd *abfd)
5172 {
5173   mach_o_fat_data_struct *adata = NULL;
5174   struct mach_o_fat_header_external hdr;
5175   unsigned long i;
5176
5177   if (bfd_seek (abfd, 0, SEEK_SET) != 0
5178       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
5179     goto error;
5180
5181   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
5182   if (adata == NULL)
5183     goto error;
5184
5185   adata->magic = bfd_getb32 (hdr.magic);
5186   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
5187   if (adata->magic != 0xcafebabe)
5188     goto error;
5189   /* Avoid matching Java bytecode files, which have the same magic number.
5190      In the Java bytecode file format this field contains the JVM version,
5191      which starts at 43.0.  */
5192   if (adata->nfat_arch > 30)
5193     goto error;
5194
5195   adata->archentries =
5196     bfd_alloc2 (abfd, adata->nfat_arch, sizeof (mach_o_fat_archentry));
5197   if (adata->archentries == NULL)
5198     goto error;
5199
5200   for (i = 0; i < adata->nfat_arch; i++)
5201     {
5202       struct mach_o_fat_arch_external arch;
5203       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
5204         goto error;
5205       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5206       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5207       adata->archentries[i].offset = bfd_getb32 (arch.offset);
5208       adata->archentries[i].size = bfd_getb32 (arch.size);
5209       adata->archentries[i].align = bfd_getb32 (arch.align);
5210     }
5211
5212   abfd->tdata.mach_o_fat_data = adata;
5213
5214   return abfd->xvec;
5215
5216  error:
5217   if (adata != NULL)
5218     bfd_release (abfd, adata);
5219   bfd_set_error (bfd_error_wrong_format);
5220   return NULL;
5221 }
5222
5223 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5224    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5225    Set arelt_data and origin fields too.  */
5226
5227 static void
5228 bfd_mach_o_fat_member_init (bfd *abfd,
5229                             enum bfd_architecture arch_type,
5230                             unsigned long arch_subtype,
5231                             mach_o_fat_archentry *entry)
5232 {
5233   struct areltdata *areltdata;
5234   /* Create the member filename. Use ARCH_NAME.  */
5235   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5236
5237   if (ap)
5238     {
5239       /* Use the architecture name if known.  */
5240       abfd->filename = xstrdup (ap->printable_name);
5241     }
5242   else
5243     {
5244       /* Forge a uniq id.  */
5245       const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
5246       char *name = xmalloc (namelen);
5247       snprintf (name, namelen, "0x%lx-0x%lx",
5248                 entry->cputype, entry->cpusubtype);
5249       abfd->filename = name;
5250     }
5251
5252   areltdata = bfd_zmalloc (sizeof (struct areltdata));
5253   areltdata->parsed_size = entry->size;
5254   abfd->arelt_data = areltdata;
5255   abfd->iostream = NULL;
5256   abfd->origin = entry->offset;
5257 }
5258
5259 bfd *
5260 bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
5261 {
5262   mach_o_fat_data_struct *adata;
5263   mach_o_fat_archentry *entry = NULL;
5264   unsigned long i;
5265   bfd *nbfd;
5266   enum bfd_architecture arch_type;
5267   unsigned long arch_subtype;
5268
5269   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
5270   BFD_ASSERT (adata != NULL);
5271
5272   /* Find index of previous entry.  */
5273   if (prev == NULL)
5274     {
5275       /* Start at first one.  */
5276       i = 0;
5277     }
5278   else
5279     {
5280       /* Find index of PREV.  */
5281       for (i = 0; i < adata->nfat_arch; i++)
5282         {
5283           if (adata->archentries[i].offset == prev->origin)
5284             break;
5285         }
5286
5287       if (i == adata->nfat_arch)
5288         {
5289           /* Not found.  */
5290           bfd_set_error (bfd_error_bad_value);
5291           return NULL;
5292         }
5293
5294       /* Get next entry.  */
5295       i++;
5296     }
5297
5298   if (i >= adata->nfat_arch)
5299     {
5300       bfd_set_error (bfd_error_no_more_archived_files);
5301       return NULL;
5302     }
5303
5304   entry = &adata->archentries[i];
5305   nbfd = _bfd_new_bfd_contained_in (archive);
5306   if (nbfd == NULL)
5307     return NULL;
5308
5309   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5310                                    &arch_type, &arch_subtype);
5311
5312   bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
5313
5314   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
5315
5316   return nbfd;
5317 }
5318
5319 /* Analogous to stat call.  */
5320
5321 static int
5322 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5323 {
5324   if (abfd->arelt_data == NULL)
5325     {
5326       bfd_set_error (bfd_error_invalid_operation);
5327       return -1;
5328     }
5329
5330   buf->st_mtime = 0;
5331   buf->st_uid = 0;
5332   buf->st_gid = 0;
5333   buf->st_mode = 0644;
5334   buf->st_size = arelt_size (abfd);
5335
5336   return 0;
5337 }
5338
5339 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5340    If ABFD is a fat image containing a member that corresponds to FORMAT
5341    and ARCH, returns it.
5342    In other case, returns NULL.
5343    This function allows transparent uses of fat images.  */
5344
5345 bfd *
5346 bfd_mach_o_fat_extract (bfd *abfd,
5347                         bfd_format format,
5348                         const bfd_arch_info_type *arch)
5349 {
5350   bfd *res;
5351   mach_o_fat_data_struct *adata;
5352   unsigned int i;
5353
5354   if (bfd_check_format (abfd, format))
5355     {
5356       if (bfd_get_arch_info (abfd) == arch)
5357         return abfd;
5358       return NULL;
5359     }
5360   if (!bfd_check_format (abfd, bfd_archive)
5361       || abfd->xvec != &mach_o_fat_vec)
5362     return NULL;
5363
5364   /* This is a Mach-O fat image.  */
5365   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5366   BFD_ASSERT (adata != NULL);
5367
5368   for (i = 0; i < adata->nfat_arch; i++)
5369     {
5370       struct mach_o_fat_archentry *e = &adata->archentries[i];
5371       enum bfd_architecture cpu_type;
5372       unsigned long cpu_subtype;
5373
5374       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5375                                        &cpu_type, &cpu_subtype);
5376       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5377         continue;
5378
5379       /* The architecture is found.  */
5380       res = _bfd_new_bfd_contained_in (abfd);
5381       if (res == NULL)
5382         return NULL;
5383
5384       bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
5385
5386       if (bfd_check_format (res, format))
5387         {
5388           BFD_ASSERT (bfd_get_arch_info (res) == arch);
5389           return res;
5390         }
5391       bfd_close (res);
5392       return NULL;
5393     }
5394
5395   return NULL;
5396 }
5397
5398 int
5399 bfd_mach_o_lookup_command (bfd *abfd,
5400                            bfd_mach_o_load_command_type type,
5401                            bfd_mach_o_load_command **mcommand)
5402 {
5403   struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5404   struct bfd_mach_o_load_command *cmd;
5405   unsigned int num;
5406
5407   BFD_ASSERT (mdata != NULL);
5408   BFD_ASSERT (mcommand != NULL);
5409
5410   num = 0;
5411   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5412     {
5413       if (cmd->type != type)
5414         continue;
5415
5416       if (num == 0)
5417         *mcommand = cmd;
5418       num++;
5419     }
5420
5421   return num;
5422 }
5423
5424 unsigned long
5425 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
5426 {
5427   switch (type)
5428     {
5429     case BFD_MACH_O_CPU_TYPE_MC680x0:
5430       return 0x04000000;
5431     case BFD_MACH_O_CPU_TYPE_MC88000:
5432       return 0xffffe000;
5433     case BFD_MACH_O_CPU_TYPE_POWERPC:
5434       return 0xc0000000;
5435     case BFD_MACH_O_CPU_TYPE_I386:
5436       return 0xc0000000;
5437     case BFD_MACH_O_CPU_TYPE_SPARC:
5438       return 0xf0000000;
5439     case BFD_MACH_O_CPU_TYPE_I860:
5440       return 0;
5441     case BFD_MACH_O_CPU_TYPE_HPPA:
5442       return 0xc0000000 - 0x04000000;
5443     default:
5444       return 0;
5445     }
5446 }
5447
5448 /* The following two tables should be kept, as far as possible, in order of
5449    most frequently used entries to optimize their use from gas.  */
5450
5451 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
5452 {
5453   { "regular", BFD_MACH_O_S_REGULAR},
5454   { "coalesced", BFD_MACH_O_S_COALESCED},
5455   { "zerofill", BFD_MACH_O_S_ZEROFILL},
5456   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5457   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5458   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
5459   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
5460   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
5461   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5462   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
5463   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5464   { "interposing", BFD_MACH_O_S_INTERPOSING},
5465   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
5466   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5467   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
5468   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
5469   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5470   { NULL, 0}
5471 };
5472
5473 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
5474 {
5475   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5476   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
5477   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5478   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
5479   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
5480   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5481   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5482   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5483   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
5484   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5485   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5486   { NULL, 0}
5487 };
5488
5489 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
5490
5491 unsigned int
5492 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
5493 {
5494   const bfd_mach_o_xlat_name *x;
5495   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5496
5497   for (x = bfd_mach_o_section_type_name; x->name; x++)
5498     if (strcmp (x->name, name) == 0)
5499       {
5500         /* We found it... does the target support it?  */
5501         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5502             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5503           return x->val; /* OK.  */
5504         else
5505           break; /* Not supported.  */
5506       }
5507   /* Maximum section ID = 0xff.  */
5508   return 256;
5509 }
5510
5511 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
5512
5513 unsigned int
5514 bfd_mach_o_get_section_attribute_from_name (const char *name)
5515 {
5516   const bfd_mach_o_xlat_name *x;
5517
5518   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5519     if (strcmp (x->name, name) == 0)
5520       return x->val;
5521   return (unsigned int)-1;
5522 }
5523
5524 int
5525 bfd_mach_o_core_fetch_environment (bfd *abfd,
5526                                    unsigned char **rbuf,
5527                                    unsigned int *rlen)
5528 {
5529   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5530   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
5531   bfd_mach_o_load_command *cmd;
5532
5533   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5534     {
5535       bfd_mach_o_segment_command *seg;
5536
5537       if (cmd->type != BFD_MACH_O_LC_SEGMENT)
5538         continue;
5539
5540       seg = &cmd->command.segment;
5541
5542       if ((seg->vmaddr + seg->vmsize) == stackaddr)
5543         {
5544           unsigned long start = seg->fileoff;
5545           unsigned long end = seg->fileoff + seg->filesize;
5546           unsigned char *buf = bfd_malloc (1024);
5547           unsigned long size = 1024;
5548
5549           for (;;)
5550             {
5551               bfd_size_type nread = 0;
5552               unsigned long offset;
5553               int found_nonnull = 0;
5554
5555               if (size > (end - start))
5556                 size = (end - start);
5557
5558               buf = bfd_realloc_or_free (buf, size);
5559               if (buf == NULL)
5560                 return -1;
5561
5562               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
5563                 {
5564                   free (buf);
5565                   return -1;
5566                 }
5567
5568               nread = bfd_bread (buf, size, abfd);
5569
5570               if (nread != size)
5571                 {
5572                   free (buf);
5573                   return -1;
5574                 }
5575
5576               for (offset = 4; offset <= size; offset += 4)
5577                 {
5578                   unsigned long val;
5579
5580                   val = *((unsigned long *) (buf + size - offset));
5581                   if (! found_nonnull)
5582                     {
5583                       if (val != 0)
5584                         found_nonnull = 1;
5585                     }
5586                   else if (val == 0x0)
5587                     {
5588                       unsigned long bottom;
5589                       unsigned long top;
5590
5591                       bottom = seg->fileoff + seg->filesize - offset;
5592                       top = seg->fileoff + seg->filesize - 4;
5593                       *rbuf = bfd_malloc (top - bottom);
5594                       *rlen = top - bottom;
5595
5596                       memcpy (*rbuf, buf + size - *rlen, *rlen);
5597                       free (buf);
5598                       return 0;
5599                     }
5600                 }
5601
5602               if (size == (end - start))
5603                 break;
5604
5605               size *= 2;
5606             }
5607
5608           free (buf);
5609         }
5610     }
5611
5612   return -1;
5613 }
5614
5615 char *
5616 bfd_mach_o_core_file_failing_command (bfd *abfd)
5617 {
5618   unsigned char *buf = NULL;
5619   unsigned int len = 0;
5620   int ret;
5621
5622   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5623   if (ret < 0)
5624     return NULL;
5625
5626   return (char *) buf;
5627 }
5628
5629 int
5630 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
5631 {
5632   return 0;
5633 }
5634
5635 static bfd_mach_o_uuid_command *
5636 bfd_mach_o_lookup_uuid_command (bfd *abfd)
5637 {
5638   bfd_mach_o_load_command *uuid_cmd;
5639   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
5640   if (ncmd != 1)
5641     return FALSE;
5642   return &uuid_cmd->command.uuid;
5643 }
5644
5645 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5646
5647 static bfd_boolean
5648 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
5649 {
5650   bfd_mach_o_uuid_command *dsym_uuid_cmd;
5651
5652   BFD_ASSERT (abfd);
5653   BFD_ASSERT (uuid_cmd);
5654
5655   if (!bfd_check_format (abfd, bfd_object))
5656     return FALSE;
5657
5658   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
5659       || bfd_mach_o_get_data (abfd) == NULL
5660       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
5661     return FALSE;
5662
5663   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5664   if (dsym_uuid_cmd == NULL)
5665     return FALSE;
5666
5667   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
5668               sizeof (uuid_cmd->uuid)) != 0)
5669     return FALSE;
5670
5671   return TRUE;
5672 }
5673
5674 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5675    The caller is responsible for closing the returned BFD object and
5676    its my_archive if the returned BFD is in a fat dSYM. */
5677
5678 static bfd *
5679 bfd_mach_o_find_dsym (const char *dsym_filename,
5680                       const bfd_mach_o_uuid_command *uuid_cmd,
5681                       const bfd_arch_info_type *arch)
5682 {
5683   bfd *base_dsym_bfd, *dsym_bfd;
5684
5685   BFD_ASSERT (uuid_cmd);
5686
5687   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
5688   if (base_dsym_bfd == NULL)
5689     return NULL;
5690
5691   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
5692   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
5693     return dsym_bfd;
5694
5695   bfd_close (dsym_bfd);
5696   if (base_dsym_bfd != dsym_bfd)
5697     bfd_close (base_dsym_bfd);
5698
5699   return NULL;
5700 }
5701
5702 /* Return a BFD created from a dSYM file for ABFD.
5703    The caller is responsible for closing the returned BFD object, its
5704    filename, and its my_archive if the returned BFD is in a fat dSYM. */
5705
5706 static bfd *
5707 bfd_mach_o_follow_dsym (bfd *abfd)
5708 {
5709   char *dsym_filename;
5710   bfd_mach_o_uuid_command *uuid_cmd;
5711   bfd *dsym_bfd, *base_bfd = abfd;
5712   const char *base_basename;
5713
5714   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
5715     return NULL;
5716
5717   if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
5718     base_bfd = abfd->my_archive;
5719   /* BFD may have been opened from a stream. */
5720   if (base_bfd->filename == NULL)
5721     {
5722       bfd_set_error (bfd_error_invalid_operation);
5723       return NULL;
5724     }
5725   base_basename = lbasename (base_bfd->filename);
5726
5727   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5728   if (uuid_cmd == NULL)
5729     return NULL;
5730
5731   /* TODO: We assume the DWARF file has the same as the binary's.
5732      It seems apple's GDB checks all files in the dSYM bundle directory.
5733      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5734   */
5735   dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
5736                                        + strlen (dsym_subdir) + 1
5737                                        + strlen (base_basename) + 1);
5738   sprintf (dsym_filename, "%s%s/%s",
5739            base_bfd->filename, dsym_subdir, base_basename);
5740
5741   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
5742                                    bfd_get_arch_info (abfd));
5743   if (dsym_bfd == NULL)
5744     free (dsym_filename);
5745
5746   return dsym_bfd;
5747 }
5748
5749 bfd_boolean
5750 bfd_mach_o_find_nearest_line (bfd *abfd,
5751                               asymbol **symbols,
5752                               asection *section,
5753                               bfd_vma offset,
5754                               const char **filename_ptr,
5755                               const char **functionname_ptr,
5756                               unsigned int *line_ptr,
5757                               unsigned int *discriminator_ptr)
5758 {
5759   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5760   if (mdata == NULL)
5761     return FALSE;
5762   switch (mdata->header.filetype)
5763     {
5764     case BFD_MACH_O_MH_OBJECT:
5765       break;
5766     case BFD_MACH_O_MH_EXECUTE:
5767     case BFD_MACH_O_MH_DYLIB:
5768     case BFD_MACH_O_MH_BUNDLE:
5769     case BFD_MACH_O_MH_KEXT_BUNDLE:
5770       if (mdata->dwarf2_find_line_info == NULL)
5771         {
5772           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5773           /* When we couldn't find dSYM for this binary, we look for
5774              the debug information in the binary itself. In this way,
5775              we won't try finding separated dSYM again because
5776              mdata->dwarf2_find_line_info will be filled. */
5777           if (! mdata->dsym_bfd)
5778             break;
5779           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5780                                               dwarf_debug_sections, symbols,
5781                                               &mdata->dwarf2_find_line_info,
5782                                               FALSE))
5783             return FALSE;
5784         }
5785       break;
5786     default:
5787       return FALSE;
5788     }
5789   return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
5790                                         filename_ptr, functionname_ptr,
5791                                         line_ptr, discriminator_ptr,
5792                                         dwarf_debug_sections, 0,
5793                                         &mdata->dwarf2_find_line_info);
5794 }
5795
5796 bfd_boolean
5797 bfd_mach_o_close_and_cleanup (bfd *abfd)
5798 {
5799   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5800   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5801     {
5802       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5803       bfd_mach_o_free_cached_info (abfd);
5804       if (mdata->dsym_bfd != NULL)
5805         {
5806           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5807 #if 0
5808           /* FIXME: PR 19435: This calculation to find the memory allocated by
5809              bfd_mach_o_follow_dsym for the filename does not always end up
5810              selecting the correct pointer.  Unfortunately this problem is
5811              very hard to reproduce on a non Mach-O native system, so until it
5812              can be traced and fixed on such a system, this code will remain
5813              commented out.  This does mean that there will be a memory leak,
5814              but it is small, and happens when we are closing down, so it
5815              should not matter too much.  */
5816           char *dsym_filename = (char *)(fat_bfd
5817                                          ? fat_bfd->filename
5818                                          : mdata->dsym_bfd->filename);
5819 #endif
5820           bfd_close (mdata->dsym_bfd);
5821           mdata->dsym_bfd = NULL;
5822           if (fat_bfd)
5823             bfd_close (fat_bfd);
5824 #if 0
5825           free (dsym_filename);
5826 #endif
5827         }
5828     }
5829
5830   return _bfd_generic_close_and_cleanup (abfd);
5831 }
5832
5833 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5834 {
5835   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5836   asection *asect;
5837   free (mdata->dyn_reloc_cache);
5838   mdata->dyn_reloc_cache = NULL;
5839   for (asect = abfd->sections; asect != NULL; asect = asect->next)
5840     {
5841       free (asect->relocation);
5842       asect->relocation = NULL;
5843     }
5844
5845   return TRUE;
5846 }
5847
5848 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5849 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5850
5851 #define bfd_mach_o_canonicalize_one_reloc NULL
5852 #define bfd_mach_o_swap_reloc_out NULL
5853 #define bfd_mach_o_print_thread NULL
5854 #define bfd_mach_o_tgt_seg_table NULL
5855 #define bfd_mach_o_section_type_valid_for_tgt NULL
5856
5857 #define TARGET_NAME             mach_o_be_vec
5858 #define TARGET_STRING           "mach-o-be"
5859 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5860 #define TARGET_PAGESIZE         1
5861 #define TARGET_BIG_ENDIAN       1
5862 #define TARGET_ARCHIVE          0
5863 #define TARGET_PRIORITY         1
5864 #include "mach-o-target.c"
5865
5866 #undef TARGET_NAME
5867 #undef TARGET_STRING
5868 #undef TARGET_ARCHITECTURE
5869 #undef TARGET_PAGESIZE
5870 #undef TARGET_BIG_ENDIAN
5871 #undef TARGET_ARCHIVE
5872 #undef TARGET_PRIORITY
5873
5874 #define TARGET_NAME             mach_o_le_vec
5875 #define TARGET_STRING           "mach-o-le"
5876 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5877 #define TARGET_PAGESIZE         1
5878 #define TARGET_BIG_ENDIAN       0
5879 #define TARGET_ARCHIVE          0
5880 #define TARGET_PRIORITY         1
5881
5882 #include "mach-o-target.c"
5883
5884 #undef TARGET_NAME
5885 #undef TARGET_STRING
5886 #undef TARGET_ARCHITECTURE
5887 #undef TARGET_PAGESIZE
5888 #undef TARGET_BIG_ENDIAN
5889 #undef TARGET_ARCHIVE
5890 #undef TARGET_PRIORITY
5891
5892 /* Not yet handled: creating an archive.  */
5893 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
5894
5895 #define bfd_mach_o_close_and_cleanup              bfd_true
5896
5897 /* Not used.  */
5898 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
5899 #define bfd_mach_o_openr_next_archived_file       bfd_mach_o_fat_openr_next_archived_file
5900 #define bfd_mach_o_archive_p    bfd_mach_o_fat_archive_p
5901
5902 #define TARGET_NAME             mach_o_fat_vec
5903 #define TARGET_STRING           "mach-o-fat"
5904 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5905 #define TARGET_PAGESIZE         1
5906 #define TARGET_BIG_ENDIAN       1
5907 #define TARGET_ARCHIVE          1
5908 #define TARGET_PRIORITY         0
5909
5910 #include "mach-o-target.c"
5911
5912 #undef TARGET_NAME
5913 #undef TARGET_STRING
5914 #undef TARGET_ARCHITECTURE
5915 #undef TARGET_PAGESIZE
5916 #undef TARGET_BIG_ENDIAN
5917 #undef TARGET_ARCHIVE
5918 #undef TARGET_PRIORITY