bfd/mach-o.c

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