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,
3211                                 bfd_mach_o_load_command *command)
3212 {
3213   bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3214   struct mach_o_prebound_dylib_command_external raw;
3215   unsigned int nameoff;
3216   unsigned int modoff;
3217   unsigned int str_len;
3218   unsigned char *str;
3219
3220   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3221       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3222     return -1;
3223
3224   nameoff = bfd_h_get_32 (abfd, raw.name);
3225   modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3226   if (nameoff > command->len || modoff > command->len)
3227     return -1;
3228
3229   str_len = command->len - sizeof (raw);
3230   str = bfd_alloc (abfd, str_len);
3231   if (str == NULL)
3232     return -1;
3233   if (bfd_bread (str, str_len, abfd) != str_len)
3234     return -1;
3235
3236   cmd->name_offset = command->offset + nameoff;
3237   cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3238   cmd->linked_modules_offset = command->offset + modoff;
3239
3240   cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3241   cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3242   return 0;
3243 }
3244
3245 static int
3246 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3247                                bfd_mach_o_load_command *command)
3248 {
3249   bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3250   struct mach_o_prebind_cksum_command_external raw;
3251
3252   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3253       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3254     return -1;
3255
3256   cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3257   return 0;
3258 }
3259
3260 static int
3261 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3262                                 bfd_mach_o_load_command *command)
3263 {
3264   bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3265   struct mach_o_twolevel_hints_command_external raw;
3266
3267   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3268       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3269     return -1;
3270
3271   cmd->offset = bfd_get_32 (abfd, raw.offset);
3272   cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3273   return 0;
3274 }
3275
3276 static int
3277 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3278 {
3279   bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3280   struct mach_o_fvmlib_command_external raw;
3281   unsigned int nameoff;
3282
3283   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3284       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3285     return -1;
3286
3287   nameoff = bfd_h_get_32 (abfd, raw.name);
3288   fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3289   fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3290
3291   fvm->name_offset = command->offset + nameoff;
3292   fvm->name_len = command->len - nameoff;
3293   fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3294   if (fvm->name_str == NULL)
3295     return -1;
3296   if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3297       || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3298     return -1;
3299   return 0;
3300 }
3301
3302 static int
3303 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3304 {
3305   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3306   bfd_mach_o_thread_command *cmd = &command->command.thread;
3307   unsigned int offset;
3308   unsigned int nflavours;
3309   unsigned int i;
3310
3311   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3312               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3313
3314   /* Count the number of threads.  */
3315   offset = 8;
3316   nflavours = 0;
3317   while (offset != command->len)
3318     {
3319       struct mach_o_thread_command_external raw;
3320
3321       if (offset >= command->len)
3322         return -1;
3323
3324       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3325           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3326         return -1;
3327
3328       offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3329       nflavours++;
3330     }
3331
3332   /* Allocate threads.  */
3333   cmd->flavours = bfd_alloc
3334     (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3335   if (cmd->flavours == NULL)
3336     return -1;
3337   cmd->nflavours = nflavours;
3338
3339   offset = 8;
3340   nflavours = 0;
3341   while (offset != command->len)
3342     {
3343       struct mach_o_thread_command_external raw;
3344
3345       if (offset >= command->len)
3346         return -1;
3347
3348       if (nflavours >= cmd->nflavours)
3349         return -1;
3350
3351       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3352           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3353         return -1;
3354
3355       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3356       cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3357       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3358       offset += cmd->flavours[nflavours].size + sizeof (raw);
3359       nflavours++;
3360     }
3361
3362   for (i = 0; i < nflavours; i++)
3363     {
3364       asection *bfdsec;
3365       unsigned int snamelen;
3366       char *sname;
3367       const char *flavourstr;
3368       const char *prefix = "LC_THREAD";
3369       unsigned int j = 0;
3370
3371       switch (mdata->header.cputype)
3372         {
3373         case BFD_MACH_O_CPU_TYPE_POWERPC:
3374         case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3375           flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3376           break;
3377         case BFD_MACH_O_CPU_TYPE_I386:
3378         case BFD_MACH_O_CPU_TYPE_X86_64:
3379           flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3380           break;
3381         default:
3382           flavourstr = "UNKNOWN_ARCHITECTURE";
3383           break;
3384         }
3385
3386       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3387       sname = bfd_alloc (abfd, snamelen);
3388       if (sname == NULL)
3389         return -1;
3390
3391       for (;;)
3392         {
3393           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3394           if (bfd_get_section_by_name (abfd, sname) == NULL)
3395             break;
3396           j++;
3397         }
3398
3399       bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3400
3401       bfdsec->vma = 0;
3402       bfdsec->lma = 0;
3403       bfdsec->size = cmd->flavours[i].size;
3404       bfdsec->filepos = cmd->flavours[i].offset;
3405       bfdsec->alignment_power = 0x0;
3406
3407       cmd->section = bfdsec;
3408     }
3409
3410   return 0;
3411 }
3412
3413 static int
3414 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3415 {
3416   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3417   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3418
3419   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3420
3421   {
3422     struct mach_o_dysymtab_command_external raw;
3423
3424     if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3425         || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3426       return -1;
3427
3428     cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3429     cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3430     cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3431     cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3432     cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3433     cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3434     cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3435     cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3436     cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3437     cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3438     cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3439     cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3440     cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3441     cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3442     cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3443     cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3444     cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3445     cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3446   }
3447
3448   if (cmd->nmodtab != 0)
3449     {
3450       unsigned int i;
3451       int wide = bfd_mach_o_wide_p (abfd);
3452       unsigned int module_len = wide ? 56 : 52;
3453
3454       cmd->dylib_module =
3455         bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3456       if (cmd->dylib_module == NULL)
3457         return -1;
3458
3459       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3460         return -1;
3461
3462       for (i = 0; i < cmd->nmodtab; i++)
3463         {
3464           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3465           unsigned long v;
3466           unsigned char buf[56];
3467
3468           if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3469             return -1;
3470
3471           module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3472           module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3473           module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3474           module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3475           module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3476           module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3477           module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3478           module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3479           module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3480           v = bfd_h_get_32 (abfd, buf +36);
3481           module->iinit = v & 0xffff;
3482           module->iterm = (v >> 16) & 0xffff;
3483           v = bfd_h_get_32 (abfd, buf + 40);
3484           module->ninit = v & 0xffff;
3485           module->nterm = (v >> 16) & 0xffff;
3486           if (wide)
3487             {
3488               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3489               module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3490             }
3491           else
3492             {
3493               module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3494               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3495             }
3496         }
3497     }
3498
3499   if (cmd->ntoc != 0)
3500     {
3501       unsigned int i;
3502
3503       cmd->dylib_toc = bfd_alloc
3504         (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3505       if (cmd->dylib_toc == NULL)
3506         return -1;
3507
3508       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3509         return -1;
3510
3511       for (i = 0; i < cmd->ntoc; i++)
3512         {
3513           struct mach_o_dylib_table_of_contents_external raw;
3514           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3515
3516           if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3517             return -1;
3518
3519           toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3520           toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3521         }
3522     }
3523
3524   if (cmd->nindirectsyms != 0)
3525     {
3526       unsigned int i;
3527
3528       cmd->indirect_syms = bfd_alloc
3529         (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3530       if (cmd->indirect_syms == NULL)
3531         return -1;
3532
3533       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3534         return -1;
3535
3536       for (i = 0; i < cmd->nindirectsyms; i++)
3537         {
3538           unsigned char raw[4];
3539           unsigned int *is = &cmd->indirect_syms[i];
3540
3541           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3542             return -1;
3543
3544           *is = bfd_h_get_32 (abfd, raw);
3545         }
3546     }
3547
3548   if (cmd->nextrefsyms != 0)
3549     {
3550       unsigned long v;
3551       unsigned int i;
3552
3553       cmd->ext_refs = bfd_alloc
3554         (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3555       if (cmd->ext_refs == NULL)
3556         return -1;
3557
3558       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3559         return -1;
3560
3561       for (i = 0; i < cmd->nextrefsyms; i++)
3562         {
3563           unsigned char raw[4];
3564           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3565
3566           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3567             return -1;
3568
3569           /* Fields isym and flags are written as bit-fields, thus we need
3570              a specific processing for endianness.  */
3571           v = bfd_h_get_32 (abfd, raw);
3572           if (bfd_big_endian (abfd))
3573             {
3574               ref->isym = (v >> 8) & 0xffffff;
3575               ref->flags = v & 0xff;
3576             }
3577           else
3578             {
3579               ref->isym = v & 0xffffff;
3580               ref->flags = (v >> 24) & 0xff;
3581             }
3582         }
3583     }
3584
3585   if (mdata->dysymtab)
3586     return -1;
3587   mdata->dysymtab = cmd;
3588
3589   return 0;
3590 }
3591
3592 static int
3593 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3594 {
3595   bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3596   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3597   struct mach_o_symtab_command_external raw;
3598
3599   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3600
3601   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3602       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3603     return -1;
3604
3605   symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3606   symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3607   symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3608   symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3609   symtab->symbols = NULL;
3610   symtab->strtab = NULL;
3611
3612   if (symtab->nsyms != 0)
3613     abfd->flags |= HAS_SYMS;
3614
3615   if (mdata->symtab)
3616     return -1;
3617   mdata->symtab = symtab;
3618   return 0;
3619 }
3620
3621 static int
3622 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3623 {
3624   bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3625
3626   BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3627
3628   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3629       || bfd_bread (cmd->uuid, 16, abfd) != 16)
3630     return -1;
3631
3632   return 0;
3633 }
3634
3635 static int
3636 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3637 {
3638   bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3639   struct mach_o_linkedit_data_command_external raw;
3640
3641   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3642       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3643     return -1;
3644
3645   cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3646   cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3647   return 0;
3648 }
3649
3650 static int
3651 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3652 {
3653   bfd_mach_o_str_command *cmd = &command->command.str;
3654   struct mach_o_str_command_external raw;
3655   unsigned long off;
3656
3657   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3658       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3659     return -1;
3660
3661   off = bfd_get_32 (abfd, raw.str);
3662   cmd->stroff = command->offset + off;
3663   cmd->str_len = command->len - off;
3664   cmd->str = bfd_alloc (abfd, cmd->str_len);
3665   if (cmd->str == NULL)
3666     return -1;
3667   if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3668       || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3669     return -1;
3670   return 0;
3671 }
3672
3673 static int
3674 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3675 {
3676   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3677   struct mach_o_dyld_info_command_external raw;
3678
3679   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3680       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3681     return -1;
3682
3683   cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3684   cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3685   cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3686   cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3687   cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3688   cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3689   cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3690   cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3691   cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3692   cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3693   return 0;
3694 }
3695
3696 static bfd_boolean
3697 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3698 {
3699   bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3700   struct mach_o_version_min_command_external raw;
3701   unsigned int ver;
3702
3703   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3704       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3705     return FALSE;
3706
3707   ver = bfd_get_32 (abfd, raw.version);
3708   cmd->rel = ver >> 16;
3709   cmd->maj = ver >> 8;
3710   cmd->min = ver;
3711   cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3712   return TRUE;
3713 }
3714
3715 static bfd_boolean
3716 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3717 {
3718   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3719   struct mach_o_encryption_info_command_external raw;
3720
3721   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3722       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3723     return FALSE;
3724
3725   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3726   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3727   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3728   return TRUE;
3729 }
3730
3731 static bfd_boolean
3732 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3733 {
3734   bfd_mach_o_main_command *cmd = &command->command.main;
3735   struct mach_o_entry_point_command_external raw;
3736
3737   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3738       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3739     return FALSE;
3740
3741   cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3742   cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3743   return TRUE;
3744 }
3745
3746 static bfd_boolean
3747 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3748 {
3749   bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3750   struct mach_o_source_version_command_external raw;
3751   bfd_uint64_t ver;
3752
3753   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3754       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3755     return FALSE;
3756
3757   ver = bfd_get_64 (abfd, raw.version);
3758   /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3759      generates warnings) in case of the host doesn't support 64 bit
3760      integers.  */
3761   cmd->e = ver & 0x3ff;
3762   ver >>= 10;
3763   cmd->d = ver & 0x3ff;
3764   ver >>= 10;
3765   cmd->c = ver & 0x3ff;
3766   ver >>= 10;
3767   cmd->b = ver & 0x3ff;
3768   ver >>= 10;
3769   cmd->a = ver & 0xffffff;
3770   return TRUE;
3771 }
3772
3773 static int
3774 bfd_mach_o_read_segment (bfd *abfd,
3775                          bfd_mach_o_load_command *command,
3776                          unsigned int wide)
3777 {
3778   bfd_mach_o_segment_command *seg = &command->command.segment;
3779   unsigned long i;
3780
3781   if (wide)
3782     {
3783       struct mach_o_segment_command_64_external raw;
3784
3785       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3786
3787       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3788           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3789         return -1;
3790
3791       memcpy (seg->segname, raw.segname, 16);
3792       seg->segname[16] = '\0';
3793
3794       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3795       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3796       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3797       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3798       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3799       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3800       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3801       seg->flags = bfd_h_get_32 (abfd, raw.flags);
3802     }
3803   else
3804     {
3805       struct mach_o_segment_command_32_external raw;
3806
3807       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3808
3809       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3810           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3811         return -1;
3812
3813       memcpy (seg->segname, raw.segname, 16);
3814       seg->segname[16] = '\0';
3815
3816       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3817       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3818       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3819       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3820       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3821       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3822       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3823       seg->flags = bfd_h_get_32 (abfd, raw.flags);
3824     }
3825   seg->sect_head = NULL;
3826   seg->sect_tail = NULL;
3827
3828   for (i = 0; i < seg->nsects; i++)
3829     {
3830       bfd_vma segoff;
3831       asection *sec;
3832
3833       if (wide)
3834         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3835           + (i * BFD_MACH_O_SECTION_64_SIZE);
3836       else
3837         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3838           + (i * BFD_MACH_O_SECTION_SIZE);
3839
3840       sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3841       if (sec == NULL)
3842         return -1;
3843
3844       bfd_mach_o_append_section_to_segment (seg, sec);
3845     }
3846
3847   return 0;
3848 }
3849
3850 static int
3851 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3852 {
3853   return bfd_mach_o_read_segment (abfd, command, 0);
3854 }
3855
3856 static int
3857 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3858 {
3859   return bfd_mach_o_read_segment (abfd, command, 1);
3860 }
3861
3862 static int
3863 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3864 {
3865   struct mach_o_load_command_external raw;
3866   unsigned int cmd;
3867
3868   /* Read command type and length.  */
3869   if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3870       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3871     return -1;
3872
3873   cmd = bfd_h_get_32 (abfd, raw.cmd);
3874   command->type =  cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3875   command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3876   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3877
3878   switch (command->type)
3879     {
3880     case BFD_MACH_O_LC_SEGMENT:
3881       if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3882         return -1;
3883       break;
3884     case BFD_MACH_O_LC_SEGMENT_64:
3885       if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3886         return -1;
3887       break;
3888     case BFD_MACH_O_LC_SYMTAB:
3889       if (bfd_mach_o_read_symtab (abfd, command) != 0)
3890         return -1;
3891       break;
3892     case BFD_MACH_O_LC_SYMSEG:
3893       break;
3894     case BFD_MACH_O_LC_THREAD:
3895     case BFD_MACH_O_LC_UNIXTHREAD:
3896       if (bfd_mach_o_read_thread (abfd, command) != 0)
3897         return -1;
3898       break;
3899     case BFD_MACH_O_LC_LOAD_DYLINKER:
3900     case BFD_MACH_O_LC_ID_DYLINKER:
3901     case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
3902       if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3903         return -1;
3904       break;
3905     case BFD_MACH_O_LC_LOAD_DYLIB:
3906     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3907     case BFD_MACH_O_LC_ID_DYLIB:
3908     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3909     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3910     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3911       if (bfd_mach_o_read_dylib (abfd, command) != 0)
3912         return -1;
3913       break;
3914     case BFD_MACH_O_LC_PREBOUND_DYLIB:
3915       if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3916         return -1;
3917       break;
3918     case BFD_MACH_O_LC_LOADFVMLIB:
3919     case BFD_MACH_O_LC_IDFVMLIB:
3920       if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3921         return -1;
3922       break;
3923     case BFD_MACH_O_LC_IDENT:
3924     case BFD_MACH_O_LC_FVMFILE:
3925     case BFD_MACH_O_LC_PREPAGE:
3926     case BFD_MACH_O_LC_ROUTINES:
3927     case BFD_MACH_O_LC_ROUTINES_64:
3928       break;
3929     case BFD_MACH_O_LC_SUB_FRAMEWORK:
3930     case BFD_MACH_O_LC_SUB_UMBRELLA:
3931     case BFD_MACH_O_LC_SUB_LIBRARY:
3932     case BFD_MACH_O_LC_SUB_CLIENT:
3933     case BFD_MACH_O_LC_RPATH:
3934       if (bfd_mach_o_read_str (abfd, command) != 0)
3935         return -1;
3936       break;
3937     case BFD_MACH_O_LC_DYSYMTAB:
3938       if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3939         return -1;
3940       break;
3941     case BFD_MACH_O_LC_PREBIND_CKSUM:
3942       if (bfd_mach_o_read_prebind_cksum (abfd, command) != 0)
3943         return -1;
3944       break;
3945     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3946       if (bfd_mach_o_read_twolevel_hints (abfd, command) != 0)
3947         return -1;
3948       break;
3949     case BFD_MACH_O_LC_UUID:
3950       if (bfd_mach_o_read_uuid (abfd, command) != 0)
3951         return -1;
3952       break;
3953     case BFD_MACH_O_LC_CODE_SIGNATURE:
3954     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3955     case BFD_MACH_O_LC_FUNCTION_STARTS:
3956     case BFD_MACH_O_LC_DATA_IN_CODE:
3957     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3958       if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3959         return -1;
3960       break;
3961     case BFD_MACH_O_LC_ENCRYPTION_INFO:
3962       if (!bfd_mach_o_read_encryption_info (abfd, command))
3963         return -1;
3964       break;
3965     case BFD_MACH_O_LC_DYLD_INFO:
3966       if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3967         return -1;
3968       break;
3969     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3970     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3971       if (!bfd_mach_o_read_version_min (abfd, command))
3972         return -1;
3973       break;
3974     case BFD_MACH_O_LC_MAIN:
3975       if (!bfd_mach_o_read_main (abfd, command))
3976         return -1;
3977       break;
3978     case BFD_MACH_O_LC_SOURCE_VERSION:
3979       if (!bfd_mach_o_read_source_version (abfd, command))
3980         return -1;
3981       break;
3982     default:
3983       (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3984          abfd, (unsigned long) command->type);
3985       break;
3986     }
3987
3988   return 0;
3989 }
3990
3991 static void
3992 bfd_mach_o_flatten_sections (bfd *abfd)
3993 {
3994   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3995   long csect = 0;
3996   unsigned long i;
3997
3998   /* Count total number of sections.  */
3999   mdata->nsects = 0;
4000
4001   for (i = 0; i < mdata->header.ncmds; i++)
4002     {
4003       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4004           || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4005         {
4006           bfd_mach_o_segment_command *seg;
4007
4008           seg = &mdata->commands[i].command.segment;
4009           mdata->nsects += seg->nsects;
4010         }
4011     }
4012
4013   /* Allocate sections array.  */
4014   mdata->sections = bfd_alloc (abfd,
4015                                mdata->nsects * sizeof (bfd_mach_o_section *));
4016
4017   /* Fill the array.  */
4018   csect = 0;
4019
4020   for (i = 0; i < mdata->header.ncmds; i++)
4021     {
4022       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4023           || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4024         {
4025           bfd_mach_o_segment_command *seg;
4026           bfd_mach_o_section *sec;
4027
4028           seg = &mdata->commands[i].command.segment;
4029           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4030
4031           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4032             mdata->sections[csect++] = sec;
4033         }
4034     }
4035 }
4036
4037 static bfd_boolean
4038 bfd_mach_o_scan_start_address (bfd *abfd)
4039 {
4040   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4041   bfd_mach_o_thread_command *cmd = NULL;
4042   unsigned long i;
4043
4044   for (i = 0; i < mdata->header.ncmds; i++)
4045     if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
4046         (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
4047       {
4048         cmd = &mdata->commands[i].command.thread;
4049         break;
4050       }
4051     else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
4052              && mdata->nsects > 1)
4053       {
4054         bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
4055         bfd_mach_o_section *text_sect = mdata->sections[0];
4056         if (text_sect)
4057           {
4058             abfd->start_address = main_cmd->entryoff
4059               + (text_sect->addr - text_sect->offset);
4060             return TRUE;
4061           }
4062       }
4063
4064   /* An object file has no start address, so do not fail if not found.  */
4065   if (cmd == NULL)
4066     return TRUE;
4067
4068   /* FIXME: create a subtarget hook ?  */
4069   for (i = 0; i < cmd->nflavours; i++)
4070     {
4071       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4072           && (cmd->flavours[i].flavour
4073               == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4074         {
4075           unsigned char buf[4];
4076
4077           if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4078               || bfd_bread (buf, 4, abfd) != 4)
4079             return FALSE;
4080
4081           abfd->start_address = bfd_h_get_32 (abfd, buf);
4082         }
4083       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4084                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4085         {
4086           unsigned char buf[4];
4087
4088           if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4089               || bfd_bread (buf, 4, abfd) != 4)
4090             return FALSE;
4091
4092           abfd->start_address = bfd_h_get_32 (abfd, buf);
4093         }
4094       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4095                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4096         {
4097           unsigned char buf[8];
4098
4099           if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4100               || bfd_bread (buf, 8, abfd) != 8)
4101             return FALSE;
4102
4103           abfd->start_address = bfd_h_get_64 (abfd, buf);
4104         }
4105       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4106                && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4107         {
4108           unsigned char buf[8];
4109
4110           if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4111               || bfd_bread (buf, 8, abfd) != 8)
4112             return FALSE;
4113
4114           abfd->start_address = bfd_h_get_64 (abfd, buf);
4115         }
4116     }
4117
4118   return TRUE;
4119 }
4120
4121 bfd_boolean
4122 bfd_mach_o_set_arch_mach (bfd *abfd,
4123                           enum bfd_architecture arch,
4124                           unsigned long machine)
4125 {
4126   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4127
4128   /* If this isn't the right architecture for this backend, and this
4129      isn't the generic backend, fail.  */
4130   if (arch != bed->arch
4131       && arch != bfd_arch_unknown
4132       && bed->arch != bfd_arch_unknown)
4133     return FALSE;
4134
4135   return bfd_default_set_arch_mach (abfd, arch, machine);
4136 }
4137
4138 static bfd_boolean
4139 bfd_mach_o_scan (bfd *abfd,
4140                  bfd_mach_o_header *header,
4141                  bfd_mach_o_data_struct *mdata)
4142 {
4143   unsigned int i;
4144   enum bfd_architecture cputype;
4145   unsigned long cpusubtype;
4146   unsigned int hdrsize;
4147
4148   hdrsize = mach_o_wide_p (header) ?
4149     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4150
4151   mdata->header = *header;
4152
4153   abfd->flags = abfd->flags & BFD_IN_MEMORY;
4154   switch (header->filetype)
4155     {
4156     case BFD_MACH_O_MH_OBJECT:
4157       abfd->flags |= HAS_RELOC;
4158       break;
4159     case BFD_MACH_O_MH_EXECUTE:
4160       abfd->flags |= EXEC_P;
4161       break;
4162     case BFD_MACH_O_MH_DYLIB:
4163     case BFD_MACH_O_MH_BUNDLE:
4164       abfd->flags |= DYNAMIC;
4165       break;
4166     }
4167
4168   abfd->tdata.mach_o_data = mdata;
4169
4170   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4171                                    &cputype, &cpusubtype);
4172   if (cputype == bfd_arch_unknown)
4173     {
4174       (*_bfd_error_handler)
4175         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4176          header->cputype, header->cpusubtype);
4177       return FALSE;
4178     }
4179
4180   bfd_set_arch_mach (abfd, cputype, cpusubtype);
4181
4182   if (header->ncmds != 0)
4183     {
4184       mdata->commands = bfd_alloc
4185         (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4186       if (mdata->commands == NULL)
4187         return FALSE;
4188
4189       for (i = 0; i < header->ncmds; i++)
4190         {
4191           bfd_mach_o_load_command *cur = &mdata->commands[i];
4192
4193           if (i == 0)
4194             cur->offset = hdrsize;
4195           else
4196             {
4197               bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4198               cur->offset = prev->offset + prev->len;
4199             }
4200
4201           if (bfd_mach_o_read_command (abfd, cur) < 0)
4202             return FALSE;
4203         }
4204     }
4205
4206   /* Sections should be flatten before scanning start address.  */
4207   bfd_mach_o_flatten_sections (abfd);
4208   if (!bfd_mach_o_scan_start_address (abfd))
4209     return FALSE;
4210
4211   return TRUE;
4212 }
4213
4214 bfd_boolean
4215 bfd_mach_o_mkobject_init (bfd *abfd)
4216 {
4217   bfd_mach_o_data_struct *mdata = NULL;
4218
4219   mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4220   if (mdata == NULL)
4221     return FALSE;
4222   abfd->tdata.mach_o_data = mdata;
4223
4224   mdata->header.magic = 0;
4225   mdata->header.cputype = 0;
4226   mdata->header.cpusubtype = 0;
4227   mdata->header.filetype = 0;
4228   mdata->header.ncmds = 0;
4229   mdata->header.sizeofcmds = 0;
4230   mdata->header.flags = 0;
4231   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4232   mdata->commands = NULL;
4233   mdata->nsects = 0;
4234   mdata->sections = NULL;
4235   mdata->dyn_reloc_cache = NULL;
4236
4237   return TRUE;
4238 }
4239
4240 static bfd_boolean
4241 bfd_mach_o_gen_mkobject (bfd *abfd)
4242 {
4243   bfd_mach_o_data_struct *mdata;
4244
4245   if (!bfd_mach_o_mkobject_init (abfd))
4246     return FALSE;
4247
4248   mdata = bfd_mach_o_get_data (abfd);
4249   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4250   mdata->header.cputype = 0;
4251   mdata->header.cpusubtype = 0;
4252   mdata->header.byteorder = abfd->xvec->byteorder;
4253   mdata->header.version = 1;
4254
4255   return TRUE;
4256 }
4257
4258 const bfd_target *
4259 bfd_mach_o_header_p (bfd *abfd,
4260                      bfd_mach_o_filetype filetype,
4261                      bfd_mach_o_cpu_type cputype)
4262 {
4263   bfd_mach_o_header header;
4264   bfd_mach_o_data_struct *mdata;
4265
4266   if (!bfd_mach_o_read_header (abfd, &header))
4267     goto wrong;
4268
4269   if (! (header.byteorder == BFD_ENDIAN_BIG
4270          || header.byteorder == BFD_ENDIAN_LITTLE))
4271     {
4272       (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4273                              (unsigned long) header.byteorder);
4274       goto wrong;
4275     }
4276
4277   if (! ((header.byteorder == BFD_ENDIAN_BIG
4278           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4279           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4280          || (header.byteorder == BFD_ENDIAN_LITTLE
4281              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4282              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4283     goto wrong;
4284
4285   /* Check cputype and filetype.
4286      In case of wildcard, do not accept magics that are handled by existing
4287      targets.  */
4288   if (cputype)
4289     {
4290       if (header.cputype != cputype)
4291         goto wrong;
4292     }
4293
4294   if (filetype)
4295     {
4296       if (header.filetype != filetype)
4297         goto wrong;
4298     }
4299   else
4300     {
4301       switch (header.filetype)
4302         {
4303         case BFD_MACH_O_MH_CORE:
4304           /* Handled by core_p */
4305           goto wrong;
4306         default:
4307           break;
4308         }
4309     }
4310
4311   mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4312   if (mdata == NULL)
4313     goto fail;
4314
4315   if (!bfd_mach_o_scan (abfd, &header, mdata))
4316     goto wrong;
4317
4318   return abfd->xvec;
4319
4320  wrong:
4321   bfd_set_error (bfd_error_wrong_format);
4322
4323  fail:
4324   return NULL;
4325 }
4326
4327 static const bfd_target *
4328 bfd_mach_o_gen_object_p (bfd *abfd)
4329 {
4330   return bfd_mach_o_header_p (abfd, 0, 0);
4331 }
4332
4333 static const bfd_target *
4334 bfd_mach_o_gen_core_p (bfd *abfd)
4335 {
4336   return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4337 }
4338
4339 /* Return the base address of ABFD, ie the address at which the image is
4340    mapped.  The possible initial pagezero is ignored.  */
4341
4342 bfd_vma
4343 bfd_mach_o_get_base_address (bfd *abfd)
4344 {
4345   bfd_mach_o_data_struct *mdata;
4346   unsigned int i;
4347
4348   /* Check for Mach-O.  */
4349   if (!bfd_mach_o_valid (abfd))
4350     return 0;
4351   mdata = bfd_mach_o_get_data (abfd);
4352
4353   for (i = 0; i < mdata->header.ncmds; i++)
4354     {
4355       bfd_mach_o_load_command *cmd = &mdata->commands[i];
4356       if ((cmd->type == BFD_MACH_O_LC_SEGMENT
4357            || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
4358         {
4359           struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
4360
4361           if (segcmd->initprot != 0)
4362             return segcmd->vmaddr;
4363         }
4364     }
4365   return 0;
4366 }
4367
4368 typedef struct mach_o_fat_archentry
4369 {
4370   unsigned long cputype;
4371   unsigned long cpusubtype;
4372   unsigned long offset;
4373   unsigned long size;
4374   unsigned long align;
4375 } mach_o_fat_archentry;
4376
4377 typedef struct mach_o_fat_data_struct
4378 {
4379   unsigned long magic;
4380   unsigned long nfat_arch;
4381   mach_o_fat_archentry *archentries;
4382 } mach_o_fat_data_struct;
4383
4384 const bfd_target *
4385 bfd_mach_o_archive_p (bfd *abfd)
4386 {
4387   mach_o_fat_data_struct *adata = NULL;
4388   struct mach_o_fat_header_external hdr;
4389   unsigned long i;
4390
4391   if (bfd_seek (abfd, 0, SEEK_SET) != 0
4392       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4393     goto error;
4394
4395   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4396   if (adata == NULL)
4397     goto error;
4398
4399   adata->magic = bfd_getb32 (hdr.magic);
4400   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4401   if (adata->magic != 0xcafebabe)
4402     goto error;
4403   /* Avoid matching Java bytecode files, which have the same magic number.
4404      In the Java bytecode file format this field contains the JVM version,
4405      which starts at 43.0.  */
4406   if (adata->nfat_arch > 30)
4407     goto error;
4408
4409   adata->archentries =
4410     bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4411   if (adata->archentries == NULL)
4412     goto error;
4413
4414   for (i = 0; i < adata->nfat_arch; i++)
4415     {
4416       struct mach_o_fat_arch_external arch;
4417       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4418         goto error;
4419       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4420       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4421       adata->archentries[i].offset = bfd_getb32 (arch.offset);
4422       adata->archentries[i].size = bfd_getb32 (arch.size);
4423       adata->archentries[i].align = bfd_getb32 (arch.align);
4424     }
4425
4426   abfd->tdata.mach_o_fat_data = adata;
4427   return abfd->xvec;
4428
4429  error:
4430   if (adata != NULL)
4431     bfd_release (abfd, adata);
4432   bfd_set_error (bfd_error_wrong_format);
4433   return NULL;
4434 }
4435
4436 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4437    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4438    Set arelt_data and origin fields too.  */
4439
4440 static void
4441 bfd_mach_o_fat_member_init (bfd *abfd,
4442                             enum bfd_architecture arch_type,
4443                             unsigned long arch_subtype,
4444                             mach_o_fat_archentry *entry)
4445 {
4446   struct areltdata *areltdata;
4447   /* Create the member filename. Use ARCH_NAME.  */
4448   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4449
4450   if (ap)
4451     {
4452       /* Use the architecture name if known.  */
4453       abfd->filename = xstrdup (ap->printable_name);
4454     }
4455   else
4456     {
4457       /* Forge a uniq id.  */
4458       const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4459       char *name = xmalloc (namelen);
4460       snprintf (name, namelen, "0x%lx-0x%lx",
4461                 entry->cputype, entry->cpusubtype);
4462       abfd->filename = name;
4463     }
4464
4465   areltdata = bfd_zmalloc (sizeof (struct areltdata));
4466   areltdata->parsed_size = entry->size;
4467   abfd->arelt_data = areltdata;
4468   abfd->iostream = NULL;
4469   abfd->origin = entry->offset;
4470 }
4471
4472 bfd *
4473 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4474 {
4475   mach_o_fat_data_struct *adata;
4476   mach_o_fat_archentry *entry = NULL;
4477   unsigned long i;
4478   bfd *nbfd;
4479   enum bfd_architecture arch_type;
4480   unsigned long arch_subtype;
4481
4482   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4483   BFD_ASSERT (adata != NULL);
4484
4485   /* Find index of previous entry.  */
4486   if (prev == NULL)
4487     {
4488       /* Start at first one.  */
4489       i = 0;
4490     }
4491   else
4492     {
4493       /* Find index of PREV.  */
4494       for (i = 0; i < adata->nfat_arch; i++)
4495         {
4496           if (adata->archentries[i].offset == prev->origin)
4497             break;
4498         }
4499
4500       if (i == adata->nfat_arch)
4501         {
4502           /* Not found.  */
4503           bfd_set_error (bfd_error_bad_value);
4504           return NULL;
4505         }
4506
4507       /* Get next entry.  */
4508       i++;
4509     }
4510
4511   if (i >= adata->nfat_arch)
4512     {
4513       bfd_set_error (bfd_error_no_more_archived_files);
4514       return NULL;
4515     }
4516
4517   entry = &adata->archentries[i];
4518   nbfd = _bfd_new_bfd_contained_in (archive);
4519   if (nbfd == NULL)
4520     return NULL;
4521
4522   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4523                                    &arch_type, &arch_subtype);
4524
4525   bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4526
4527   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4528
4529   return nbfd;
4530 }
4531
4532 /* Analogous to stat call.  */
4533
4534 static int
4535 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4536 {
4537   if (abfd->arelt_data == NULL)
4538     {
4539       bfd_set_error (bfd_error_invalid_operation);
4540       return -1;
4541     }
4542
4543   buf->st_mtime = 0;
4544   buf->st_uid = 0;
4545   buf->st_gid = 0;
4546   buf->st_mode = 0644;
4547   buf->st_size = arelt_size (abfd);
4548
4549   return 0;
4550 }
4551
4552 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4553    If ABFD is a fat image containing a member that corresponds to FORMAT
4554    and ARCH, returns it.
4555    In other case, returns NULL.
4556    This function allows transparent uses of fat images.  */
4557
4558 bfd *
4559 bfd_mach_o_fat_extract (bfd *abfd,
4560                         bfd_format format,
4561                         const bfd_arch_info_type *arch)
4562 {
4563   bfd *res;
4564   mach_o_fat_data_struct *adata;
4565   unsigned int i;
4566
4567   if (bfd_check_format (abfd, format))
4568     {
4569       if (bfd_get_arch_info (abfd) == arch)
4570         return abfd;
4571       return NULL;
4572     }
4573   if (!bfd_check_format (abfd, bfd_archive)
4574       || abfd->xvec != &mach_o_fat_vec)
4575     return NULL;
4576
4577   /* This is a Mach-O fat image.  */
4578   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4579   BFD_ASSERT (adata != NULL);
4580
4581   for (i = 0; i < adata->nfat_arch; i++)
4582     {
4583       struct mach_o_fat_archentry *e = &adata->archentries[i];
4584       enum bfd_architecture cpu_type;
4585       unsigned long cpu_subtype;
4586
4587       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4588                                        &cpu_type, &cpu_subtype);
4589       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4590         continue;
4591
4592       /* The architecture is found.  */
4593       res = _bfd_new_bfd_contained_in (abfd);
4594       if (res == NULL)
4595         return NULL;
4596
4597       bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4598
4599       if (bfd_check_format (res, format))
4600         {
4601           BFD_ASSERT (bfd_get_arch_info (res) == arch);
4602           return res;
4603         }
4604       bfd_close (res);
4605       return NULL;
4606     }
4607
4608   return NULL;
4609 }
4610
4611 int
4612 bfd_mach_o_lookup_command (bfd *abfd,
4613                            bfd_mach_o_load_command_type type,
4614                            bfd_mach_o_load_command **mcommand)
4615 {
4616   struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4617   bfd_mach_o_load_command *ncmd = NULL;
4618   unsigned int i, num;
4619
4620   BFD_ASSERT (md != NULL);
4621   BFD_ASSERT (mcommand != NULL);
4622
4623   num = 0;
4624   for (i = 0; i < md->header.ncmds; i++)
4625     {
4626       struct bfd_mach_o_load_command *cmd = &md->commands[i];
4627
4628       if (cmd->type != type)
4629         continue;
4630
4631       if (num == 0)
4632         ncmd = cmd;
4633       num++;
4634     }
4635
4636   *mcommand = ncmd;
4637   return num;
4638 }
4639
4640 unsigned long
4641 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4642 {
4643   switch (type)
4644     {
4645     case BFD_MACH_O_CPU_TYPE_MC680x0:
4646       return 0x04000000;
4647     case BFD_MACH_O_CPU_TYPE_MC88000:
4648       return 0xffffe000;
4649     case BFD_MACH_O_CPU_TYPE_POWERPC:
4650       return 0xc0000000;
4651     case BFD_MACH_O_CPU_TYPE_I386:
4652       return 0xc0000000;
4653     case BFD_MACH_O_CPU_TYPE_SPARC:
4654       return 0xf0000000;
4655     case BFD_MACH_O_CPU_TYPE_I860:
4656       return 0;
4657     case BFD_MACH_O_CPU_TYPE_HPPA:
4658       return 0xc0000000 - 0x04000000;
4659     default:
4660       return 0;
4661     }
4662 }
4663
4664 /* The following two tables should be kept, as far as possible, in order of
4665    most frequently used entries to optimize their use from gas.  */
4666
4667 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4668 {
4669   { "regular", BFD_MACH_O_S_REGULAR},
4670   { "coalesced", BFD_MACH_O_S_COALESCED},
4671   { "zerofill", BFD_MACH_O_S_ZEROFILL},
4672   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4673   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4674   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4675   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4676   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4677   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4678   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4679   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4680   { "interposing", BFD_MACH_O_S_INTERPOSING},
4681   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4682   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4683   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4684   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4685   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4686   { NULL, 0}
4687 };
4688
4689 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4690 {
4691   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4692   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4693   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4694   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4695   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4696   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4697   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4698   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4699   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4700   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4701   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4702   { NULL, 0}
4703 };
4704
4705 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
4706
4707 unsigned int
4708 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4709 {
4710   const bfd_mach_o_xlat_name *x;
4711   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4712
4713   for (x = bfd_mach_o_section_type_name; x->name; x++)
4714     if (strcmp (x->name, name) == 0)
4715       {
4716         /* We found it... does the target support it?  */
4717         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4718             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4719           return x->val; /* OK.  */
4720         else
4721           break; /* Not supported.  */
4722       }
4723   /* Maximum section ID = 0xff.  */
4724   return 256;
4725 }
4726
4727 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
4728
4729 unsigned int
4730 bfd_mach_o_get_section_attribute_from_name (const char *name)
4731 {
4732   const bfd_mach_o_xlat_name *x;
4733
4734   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4735     if (strcmp (x->name, name) == 0)
4736       return x->val;
4737   return (unsigned int)-1;
4738 }
4739
4740 int
4741 bfd_mach_o_core_fetch_environment (bfd *abfd,
4742                                    unsigned char **rbuf,
4743                                    unsigned int *rlen)
4744 {
4745   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4746   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4747   unsigned int i = 0;
4748
4749   for (i = 0; i < mdata->header.ncmds; i++)
4750     {
4751       bfd_mach_o_load_command *cur = &mdata->commands[i];
4752       bfd_mach_o_segment_command *seg = NULL;
4753
4754       if (cur->type != BFD_MACH_O_LC_SEGMENT)
4755         continue;
4756
4757       seg = &cur->command.segment;
4758
4759       if ((seg->vmaddr + seg->vmsize) == stackaddr)
4760         {
4761           unsigned long start = seg->fileoff;
4762           unsigned long end = seg->fileoff + seg->filesize;
4763           unsigned char *buf = bfd_malloc (1024);
4764           unsigned long size = 1024;
4765
4766           for (;;)
4767             {
4768               bfd_size_type nread = 0;
4769               unsigned long offset;
4770               int found_nonnull = 0;
4771
4772               if (size > (end - start))
4773                 size = (end - start);
4774
4775               buf = bfd_realloc_or_free (buf, size);
4776               if (buf == NULL)
4777                 return -1;
4778
4779               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4780                 {
4781                   free (buf);
4782                   return -1;
4783                 }
4784
4785               nread = bfd_bread (buf, size, abfd);
4786
4787               if (nread != size)
4788                 {
4789                   free (buf);
4790                   return -1;
4791                 }
4792
4793               for (offset = 4; offset <= size; offset += 4)
4794                 {
4795                   unsigned long val;
4796
4797                   val = *((unsigned long *) (buf + size - offset));
4798                   if (! found_nonnull)
4799                     {
4800                       if (val != 0)
4801                         found_nonnull = 1;
4802                     }
4803                   else if (val == 0x0)
4804                     {
4805                       unsigned long bottom;
4806                       unsigned long top;
4807
4808                       bottom = seg->fileoff + seg->filesize - offset;
4809                       top = seg->fileoff + seg->filesize - 4;
4810                       *rbuf = bfd_malloc (top - bottom);
4811                       *rlen = top - bottom;
4812
4813                       memcpy (*rbuf, buf + size - *rlen, *rlen);
4814                       free (buf);
4815                       return 0;
4816                     }
4817                 }
4818
4819               if (size == (end - start))
4820                 break;
4821
4822               size *= 2;
4823             }
4824
4825           free (buf);
4826         }
4827     }
4828
4829   return -1;
4830 }
4831
4832 char *
4833 bfd_mach_o_core_file_failing_command (bfd *abfd)
4834 {
4835   unsigned char *buf = NULL;
4836   unsigned int len = 0;
4837   int ret = -1;
4838
4839   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4840   if (ret < 0)
4841     return NULL;
4842
4843   return (char *) buf;
4844 }
4845
4846 int
4847 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4848 {
4849   return 0;
4850 }
4851
4852 static bfd_mach_o_uuid_command *
4853 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4854 {
4855   bfd_mach_o_load_command *uuid_cmd;
4856   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4857   if (ncmd != 1)
4858     return FALSE;
4859   return &uuid_cmd->command.uuid;
4860 }
4861
4862 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4863
4864 static bfd_boolean
4865 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4866 {
4867   bfd_mach_o_uuid_command *dsym_uuid_cmd;
4868
4869   BFD_ASSERT (abfd);
4870   BFD_ASSERT (uuid_cmd);
4871
4872   if (!bfd_check_format (abfd, bfd_object))
4873     return FALSE;
4874
4875   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4876       || bfd_mach_o_get_data (abfd) == NULL
4877       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4878     return FALSE;
4879
4880   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4881   if (dsym_uuid_cmd == NULL)
4882     return FALSE;
4883
4884   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4885               sizeof (uuid_cmd->uuid)) != 0)
4886     return FALSE;
4887
4888   return TRUE;
4889 }
4890
4891 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4892    The caller is responsible for closing the returned BFD object and
4893    its my_archive if the returned BFD is in a fat dSYM. */
4894
4895 static bfd *
4896 bfd_mach_o_find_dsym (const char *dsym_filename,
4897                       const bfd_mach_o_uuid_command *uuid_cmd,
4898                       const bfd_arch_info_type *arch)
4899 {
4900   bfd *base_dsym_bfd, *dsym_bfd;
4901
4902   BFD_ASSERT (uuid_cmd);
4903
4904   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4905   if (base_dsym_bfd == NULL)
4906     return NULL;
4907
4908   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4909   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4910     return dsym_bfd;
4911
4912   bfd_close (dsym_bfd);
4913   if (base_dsym_bfd != dsym_bfd)
4914     bfd_close (base_dsym_bfd);
4915
4916   return NULL;
4917 }
4918
4919 /* Return a BFD created from a dSYM file for ABFD.
4920    The caller is responsible for closing the returned BFD object, its
4921    filename, and its my_archive if the returned BFD is in a fat dSYM. */
4922
4923 static bfd *
4924 bfd_mach_o_follow_dsym (bfd *abfd)
4925 {
4926   char *dsym_filename;
4927   bfd_mach_o_uuid_command *uuid_cmd;
4928   bfd *dsym_bfd, *base_bfd = abfd;
4929   const char *base_basename;
4930
4931   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4932     return NULL;
4933
4934   if (abfd->my_archive)
4935     base_bfd = abfd->my_archive;
4936   /* BFD may have been opened from a stream. */
4937   if (base_bfd->filename == NULL)
4938     {
4939       bfd_set_error (bfd_error_invalid_operation);
4940       return NULL;
4941     }
4942   base_basename = lbasename (base_bfd->filename);
4943
4944   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4945   if (uuid_cmd == NULL)
4946     return NULL;
4947
4948   /* TODO: We assume the DWARF file has the same as the binary's.
4949      It seems apple's GDB checks all files in the dSYM bundle directory.
4950      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4951   */
4952   dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4953                                        + strlen (dsym_subdir) + 1
4954                                        + strlen (base_basename) + 1);
4955   sprintf (dsym_filename, "%s%s/%s",
4956            base_bfd->filename, dsym_subdir, base_basename);
4957
4958   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4959                                    bfd_get_arch_info (abfd));
4960   if (dsym_bfd == NULL)
4961     free (dsym_filename);
4962
4963   return dsym_bfd;
4964 }
4965
4966 bfd_boolean
4967 bfd_mach_o_find_nearest_line (bfd *abfd,
4968                               asection *section,
4969                               asymbol **symbols,
4970                               bfd_vma offset,
4971                               const char **filename_ptr,
4972                               const char **functionname_ptr,
4973                               unsigned int *line_ptr)
4974 {
4975   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4976   if (mdata == NULL)
4977     return FALSE;
4978   switch (mdata->header.filetype)
4979     {
4980     case BFD_MACH_O_MH_OBJECT:
4981       break;
4982     case BFD_MACH_O_MH_EXECUTE:
4983     case BFD_MACH_O_MH_DYLIB:
4984     case BFD_MACH_O_MH_BUNDLE:
4985     case BFD_MACH_O_MH_KEXT_BUNDLE:
4986       if (mdata->dwarf2_find_line_info == NULL)
4987         {
4988           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4989           /* When we couldn't find dSYM for this binary, we look for
4990              the debug information in the binary itself. In this way,
4991              we won't try finding separated dSYM again because
4992              mdata->dwarf2_find_line_info will be filled. */
4993           if (! mdata->dsym_bfd)
4994             break;
4995           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4996                                               dwarf_debug_sections, symbols,
4997                                               &mdata->dwarf2_find_line_info))
4998             return FALSE;
4999         }
5000       break;
5001     default:
5002       return FALSE;
5003     }
5004   if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
5005                                      section, symbols, offset,
5006                                      filename_ptr, functionname_ptr,
5007                                      line_ptr, NULL, 0,
5008                                      &mdata->dwarf2_find_line_info))
5009     return TRUE;
5010   return FALSE;
5011 }
5012
5013 bfd_boolean
5014 bfd_mach_o_close_and_cleanup (bfd *abfd)
5015 {
5016   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5017   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5018     {
5019       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5020       bfd_mach_o_free_cached_info (abfd);
5021       if (mdata->dsym_bfd != NULL)
5022         {
5023           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5024           char *dsym_filename = (char *)(fat_bfd
5025                                          ? fat_bfd->filename
5026                                          : mdata->dsym_bfd->filename);
5027           bfd_close (mdata->dsym_bfd);
5028           mdata->dsym_bfd = NULL;
5029           if (fat_bfd)
5030             bfd_close (fat_bfd);
5031           free (dsym_filename);
5032         }
5033     }
5034
5035   if (bfd_get_format (abfd) == bfd_archive
5036       && abfd->xvec == &mach_o_fat_vec)
5037     return TRUE;
5038   return _bfd_generic_close_and_cleanup (abfd);
5039 }
5040
5041 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5042 {
5043   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5044   asection *asect;
5045   free (mdata->dyn_reloc_cache);
5046   mdata->dyn_reloc_cache = NULL;
5047   for (asect = abfd->sections; asect != NULL; asect = asect->next)
5048     {
5049       free (asect->relocation);
5050       asect->relocation = NULL;
5051     }
5052
5053   return TRUE;
5054 }
5055
5056 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5057 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5058
5059 #define bfd_mach_o_swap_reloc_in NULL
5060 #define bfd_mach_o_swap_reloc_out NULL
5061 #define bfd_mach_o_print_thread NULL
5062 #define bfd_mach_o_tgt_seg_table NULL
5063 #define bfd_mach_o_section_type_valid_for_tgt NULL
5064
5065 #define TARGET_NAME             mach_o_be_vec
5066 #define TARGET_STRING           "mach-o-be"
5067 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5068 #define TARGET_BIG_ENDIAN       1
5069 #define TARGET_ARCHIVE          0
5070 #define TARGET_PRIORITY         1
5071 #include "mach-o-target.c"
5072
5073 #undef TARGET_NAME
5074 #undef TARGET_STRING
5075 #undef TARGET_ARCHITECTURE
5076 #undef TARGET_BIG_ENDIAN
5077 #undef TARGET_ARCHIVE
5078 #undef TARGET_PRIORITY
5079
5080 #define TARGET_NAME             mach_o_le_vec
5081 #define TARGET_STRING           "mach-o-le"
5082 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5083 #define TARGET_BIG_ENDIAN       0
5084 #define TARGET_ARCHIVE          0
5085 #define TARGET_PRIORITY         1
5086
5087 #include "mach-o-target.c"
5088
5089 #undef TARGET_NAME
5090 #undef TARGET_STRING
5091 #undef TARGET_ARCHITECTURE
5092 #undef TARGET_BIG_ENDIAN
5093 #undef TARGET_ARCHIVE
5094 #undef TARGET_PRIORITY
5095
5096 /* Not yet handled: creating an archive.  */
5097 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
5098
5099 /* Not used.  */
5100 #define bfd_mach_o_read_ar_hdr                    _bfd_noarchive_read_ar_hdr
5101 #define bfd_mach_o_write_ar_hdr                   _bfd_noarchive_write_ar_hdr
5102 #define bfd_mach_o_slurp_armap                    _bfd_noarchive_slurp_armap
5103 #define bfd_mach_o_slurp_extended_name_table      _bfd_noarchive_slurp_extended_name_table
5104 #define bfd_mach_o_construct_extended_name_table  _bfd_noarchive_construct_extended_name_table
5105 #define bfd_mach_o_truncate_arname                _bfd_noarchive_truncate_arname
5106 #define bfd_mach_o_write_armap                    _bfd_noarchive_write_armap
5107 #define bfd_mach_o_get_elt_at_index               _bfd_noarchive_get_elt_at_index
5108 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
5109 #define bfd_mach_o_update_armap_timestamp         _bfd_noarchive_update_armap_timestamp
5110
5111 #define TARGET_NAME             mach_o_fat_vec
5112 #define TARGET_STRING           "mach-o-fat"
5113 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5114 #define TARGET_BIG_ENDIAN       1
5115 #define TARGET_ARCHIVE          1
5116 #define TARGET_PRIORITY         0
5117
5118 #include "mach-o-target.c"
5119
5120 #undef TARGET_NAME
5121 #undef TARGET_STRING
5122 #undef TARGET_ARCHITECTURE
5123 #undef TARGET_BIG_ENDIAN
5124 #undef TARGET_ARCHIVE
5125 #undef TARGET_PRIORITY