bfd/mach-o.c

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