bfd/mach-o.c

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