bfd/mach-o.c

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