bfd/mach-o.c

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