bfd/mach-o.c

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