bfd/mach-o.c

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