bfd/mach-o.c

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