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