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