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