bfd/mach-o.c

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