bfd/mach-o.c

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