bfd/mach-o.c

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