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