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