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