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