bfd/mach-o.c

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