bfd/mach-o.c

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