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