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 bfd_boolean
3670 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3671 {
3672   bfd_mach_o_main_command *cmd = &command->command.main;
3673   struct mach_o_entry_point_command_external raw;
3674
3675   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3676       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3677     return FALSE;
3678
3679   cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3680   cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3681   return TRUE;
3682 }
3683
3684 static bfd_boolean
3685 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3686 {
3687   bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3688   struct mach_o_source_version_command_external raw;
3689   bfd_uint64_t ver;
3690
3691   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3692       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3693     return FALSE;
3694
3695   ver = bfd_get_64 (abfd, raw.version);
3696   /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3697      generates warnings) in case of the host doesn't support 64 bit
3698      integers.  */
3699   cmd->e = ver & 0x3ff;
3700   ver >>= 10;
3701   cmd->d = ver & 0x3ff;
3702   ver >>= 10;
3703   cmd->c = ver & 0x3ff;
3704   ver >>= 10;
3705   cmd->b = ver & 0x3ff;
3706   ver >>= 10;
3707   cmd->a = ver & 0xffffff;
3708   return TRUE;
3709 }
3710
3711 static int
3712 bfd_mach_o_read_segment (bfd *abfd,
3713                          bfd_mach_o_load_command *command,
3714                          unsigned int wide)
3715 {
3716   bfd_mach_o_segment_command *seg = &command->command.segment;
3717   unsigned long i;
3718
3719   if (wide)
3720     {
3721       struct mach_o_segment_command_64_external raw;
3722
3723       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3724
3725       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3726           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3727         return -1;
3728
3729       memcpy (seg->segname, raw.segname, 16);
3730       seg->segname[16] = '\0';
3731
3732       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3733       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3734       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3735       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3736       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3737       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3738       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3739       seg->flags = bfd_h_get_32 (abfd, raw.flags);
3740     }
3741   else
3742     {
3743       struct mach_o_segment_command_32_external raw;
3744
3745       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3746
3747       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3748           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3749         return -1;
3750
3751       memcpy (seg->segname, raw.segname, 16);
3752       seg->segname[16] = '\0';
3753
3754       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3755       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3756       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3757       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3758       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3759       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3760       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3761       seg->flags = bfd_h_get_32 (abfd, raw.flags);
3762     }
3763   seg->sect_head = NULL;
3764   seg->sect_tail = NULL;
3765
3766   for (i = 0; i < seg->nsects; i++)
3767     {
3768       bfd_vma segoff;
3769       asection *sec;
3770
3771       if (wide)
3772         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3773           + (i * BFD_MACH_O_SECTION_64_SIZE);
3774       else
3775         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3776           + (i * BFD_MACH_O_SECTION_SIZE);
3777
3778       sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3779       if (sec == NULL)
3780         return -1;
3781
3782       bfd_mach_o_append_section_to_segment (seg, sec);
3783     }
3784
3785   return 0;
3786 }
3787
3788 static int
3789 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3790 {
3791   return bfd_mach_o_read_segment (abfd, command, 0);
3792 }
3793
3794 static int
3795 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3796 {
3797   return bfd_mach_o_read_segment (abfd, command, 1);
3798 }
3799
3800 static int
3801 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3802 {
3803   struct mach_o_load_command_external raw;
3804   unsigned int cmd;
3805
3806   /* Read command type and length.  */
3807   if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3808       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3809     return -1;
3810
3811   cmd = bfd_h_get_32 (abfd, raw.cmd);
3812   command->type =  cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3813   command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3814   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3815
3816   switch (command->type)
3817     {
3818     case BFD_MACH_O_LC_SEGMENT:
3819       if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3820         return -1;
3821       break;
3822     case BFD_MACH_O_LC_SEGMENT_64:
3823       if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3824         return -1;
3825       break;
3826     case BFD_MACH_O_LC_SYMTAB:
3827       if (bfd_mach_o_read_symtab (abfd, command) != 0)
3828         return -1;
3829       break;
3830     case BFD_MACH_O_LC_SYMSEG:
3831       break;
3832     case BFD_MACH_O_LC_THREAD:
3833     case BFD_MACH_O_LC_UNIXTHREAD:
3834       if (bfd_mach_o_read_thread (abfd, command) != 0)
3835         return -1;
3836       break;
3837     case BFD_MACH_O_LC_LOAD_DYLINKER:
3838     case BFD_MACH_O_LC_ID_DYLINKER:
3839       if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3840         return -1;
3841       break;
3842     case BFD_MACH_O_LC_LOAD_DYLIB:
3843     case BFD_MACH_O_LC_ID_DYLIB:
3844     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3845     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3846     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3847       if (bfd_mach_o_read_dylib (abfd, command) != 0)
3848         return -1;
3849       break;
3850     case BFD_MACH_O_LC_PREBOUND_DYLIB:
3851       if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3852         return -1;
3853       break;
3854     case BFD_MACH_O_LC_LOADFVMLIB:
3855     case BFD_MACH_O_LC_IDFVMLIB:
3856       if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3857         return -1;
3858       break;
3859     case BFD_MACH_O_LC_IDENT:
3860     case BFD_MACH_O_LC_FVMFILE:
3861     case BFD_MACH_O_LC_PREPAGE:
3862     case BFD_MACH_O_LC_ROUTINES:
3863     case BFD_MACH_O_LC_ROUTINES_64:
3864       break;
3865     case BFD_MACH_O_LC_SUB_FRAMEWORK:
3866     case BFD_MACH_O_LC_SUB_UMBRELLA:
3867     case BFD_MACH_O_LC_SUB_LIBRARY:
3868     case BFD_MACH_O_LC_SUB_CLIENT:
3869     case BFD_MACH_O_LC_RPATH:
3870       if (bfd_mach_o_read_str (abfd, command) != 0)
3871         return -1;
3872       break;
3873     case BFD_MACH_O_LC_DYSYMTAB:
3874       if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3875         return -1;
3876       break;
3877     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3878     case BFD_MACH_O_LC_PREBIND_CKSUM:
3879       break;
3880     case BFD_MACH_O_LC_UUID:
3881       if (bfd_mach_o_read_uuid (abfd, command) != 0)
3882         return -1;
3883       break;
3884     case BFD_MACH_O_LC_CODE_SIGNATURE:
3885     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3886     case BFD_MACH_O_LC_FUNCTION_STARTS:
3887     case BFD_MACH_O_LC_DATA_IN_CODE:
3888     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3889       if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3890         return -1;
3891       break;
3892     case BFD_MACH_O_LC_ENCRYPTION_INFO:
3893       if (!bfd_mach_o_read_encryption_info (abfd, command))
3894         return -1;
3895       break;
3896     case BFD_MACH_O_LC_DYLD_INFO:
3897       if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3898         return -1;
3899       break;
3900     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3901     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3902       if (!bfd_mach_o_read_version_min (abfd, command))
3903         return -1;
3904       break;
3905     case BFD_MACH_O_LC_MAIN:
3906       if (!bfd_mach_o_read_main (abfd, command))
3907         return -1;
3908       break;
3909     case BFD_MACH_O_LC_SOURCE_VERSION:
3910       if (!bfd_mach_o_read_source_version (abfd, command))
3911         return -1;
3912       break;
3913     default:
3914       (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3915          abfd, (unsigned long) command->type);
3916       break;
3917     }
3918
3919   return 0;
3920 }
3921
3922 static void
3923 bfd_mach_o_flatten_sections (bfd *abfd)
3924 {
3925   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3926   long csect = 0;
3927   unsigned long i;
3928
3929   /* Count total number of sections.  */
3930   mdata->nsects = 0;
3931
3932   for (i = 0; i < mdata->header.ncmds; i++)
3933     {
3934       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3935           || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3936         {
3937           bfd_mach_o_segment_command *seg;
3938
3939           seg = &mdata->commands[i].command.segment;
3940           mdata->nsects += seg->nsects;
3941         }
3942     }
3943
3944   /* Allocate sections array.  */
3945   mdata->sections = bfd_alloc (abfd,
3946                                mdata->nsects * sizeof (bfd_mach_o_section *));
3947
3948   /* Fill the array.  */
3949   csect = 0;
3950
3951   for (i = 0; i < mdata->header.ncmds; i++)
3952     {
3953       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3954           || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3955         {
3956           bfd_mach_o_segment_command *seg;
3957           bfd_mach_o_section *sec;
3958
3959           seg = &mdata->commands[i].command.segment;
3960           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3961
3962           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3963             mdata->sections[csect++] = sec;
3964         }
3965     }
3966 }
3967
3968 static bfd_boolean
3969 bfd_mach_o_scan_start_address (bfd *abfd)
3970 {
3971   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3972   bfd_mach_o_thread_command *cmd = NULL;
3973   unsigned long i;
3974
3975   for (i = 0; i < mdata->header.ncmds; i++)
3976     if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3977         (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3978       {
3979         cmd = &mdata->commands[i].command.thread;
3980         break;
3981       }
3982
3983   if (cmd == NULL)
3984     return FALSE;
3985
3986   /* FIXME: create a subtarget hook ?  */
3987   for (i = 0; i < cmd->nflavours; i++)
3988     {
3989       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
3990           && (cmd->flavours[i].flavour
3991               == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
3992         {
3993           unsigned char buf[4];
3994
3995           if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
3996               || bfd_bread (buf, 4, abfd) != 4)
3997             return FALSE;
3998
3999           abfd->start_address = bfd_h_get_32 (abfd, buf);
4000         }
4001       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4002                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4003         {
4004           unsigned char buf[4];
4005
4006           if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4007               || bfd_bread (buf, 4, abfd) != 4)
4008             return FALSE;
4009
4010           abfd->start_address = bfd_h_get_32 (abfd, buf);
4011         }
4012       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4013                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4014         {
4015           unsigned char buf[8];
4016
4017           if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4018               || bfd_bread (buf, 8, abfd) != 8)
4019             return FALSE;
4020
4021           abfd->start_address = bfd_h_get_64 (abfd, buf);
4022         }
4023       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4024                && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4025         {
4026           unsigned char buf[8];
4027
4028           if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4029               || bfd_bread (buf, 8, abfd) != 8)
4030             return FALSE;
4031
4032           abfd->start_address = bfd_h_get_64 (abfd, buf);
4033         }
4034     }
4035
4036   return TRUE;
4037 }
4038
4039 bfd_boolean
4040 bfd_mach_o_set_arch_mach (bfd *abfd,
4041                           enum bfd_architecture arch,
4042                           unsigned long machine)
4043 {
4044   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4045
4046   /* If this isn't the right architecture for this backend, and this
4047      isn't the generic backend, fail.  */
4048   if (arch != bed->arch
4049       && arch != bfd_arch_unknown
4050       && bed->arch != bfd_arch_unknown)
4051     return FALSE;
4052
4053   return bfd_default_set_arch_mach (abfd, arch, machine);
4054 }
4055
4056 static bfd_boolean
4057 bfd_mach_o_scan (bfd *abfd,
4058                  bfd_mach_o_header *header,
4059                  bfd_mach_o_data_struct *mdata)
4060 {
4061   unsigned int i;
4062   enum bfd_architecture cputype;
4063   unsigned long cpusubtype;
4064   unsigned int hdrsize;
4065
4066   hdrsize = mach_o_wide_p (header) ?
4067     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4068
4069   mdata->header = *header;
4070
4071   abfd->flags = abfd->flags & BFD_IN_MEMORY;
4072   switch (header->filetype)
4073     {
4074     case BFD_MACH_O_MH_OBJECT:
4075       abfd->flags |= HAS_RELOC;
4076       break;
4077     case BFD_MACH_O_MH_EXECUTE:
4078       abfd->flags |= EXEC_P;
4079       break;
4080     case BFD_MACH_O_MH_DYLIB:
4081     case BFD_MACH_O_MH_BUNDLE:
4082       abfd->flags |= DYNAMIC;
4083       break;
4084     }
4085
4086   abfd->tdata.mach_o_data = mdata;
4087
4088   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4089                                    &cputype, &cpusubtype);
4090   if (cputype == bfd_arch_unknown)
4091     {
4092       (*_bfd_error_handler)
4093         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4094          header->cputype, header->cpusubtype);
4095       return FALSE;
4096     }
4097
4098   bfd_set_arch_mach (abfd, cputype, cpusubtype);
4099
4100   if (header->ncmds != 0)
4101     {
4102       mdata->commands = bfd_alloc
4103         (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4104       if (mdata->commands == NULL)
4105         return FALSE;
4106
4107       for (i = 0; i < header->ncmds; i++)
4108         {
4109           bfd_mach_o_load_command *cur = &mdata->commands[i];
4110
4111           if (i == 0)
4112             cur->offset = hdrsize;
4113           else
4114             {
4115               bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4116               cur->offset = prev->offset + prev->len;
4117             }
4118
4119           if (bfd_mach_o_read_command (abfd, cur) < 0)
4120             return FALSE;
4121         }
4122     }
4123
4124   if (bfd_mach_o_scan_start_address (abfd) < 0)
4125     return FALSE;
4126
4127   bfd_mach_o_flatten_sections (abfd);
4128   return TRUE;
4129 }
4130
4131 bfd_boolean
4132 bfd_mach_o_mkobject_init (bfd *abfd)
4133 {
4134   bfd_mach_o_data_struct *mdata = NULL;
4135
4136   mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
4137   if (mdata == NULL)
4138     return FALSE;
4139   abfd->tdata.mach_o_data = mdata;
4140
4141   mdata->header.magic = 0;
4142   mdata->header.cputype = 0;
4143   mdata->header.cpusubtype = 0;
4144   mdata->header.filetype = 0;
4145   mdata->header.ncmds = 0;
4146   mdata->header.sizeofcmds = 0;
4147   mdata->header.flags = 0;
4148   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4149   mdata->commands = NULL;
4150   mdata->nsects = 0;
4151   mdata->sections = NULL;
4152   mdata->dyn_reloc_cache = NULL;
4153
4154   return TRUE;
4155 }
4156
4157 static bfd_boolean
4158 bfd_mach_o_gen_mkobject (bfd *abfd)
4159 {
4160   bfd_mach_o_data_struct *mdata;
4161
4162   if (!bfd_mach_o_mkobject_init (abfd))
4163     return FALSE;
4164
4165   mdata = bfd_mach_o_get_data (abfd);
4166   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4167   mdata->header.cputype = 0;
4168   mdata->header.cpusubtype = 0;
4169   mdata->header.byteorder = abfd->xvec->byteorder;
4170   mdata->header.version = 1;
4171
4172   return TRUE;
4173 }
4174
4175 const bfd_target *
4176 bfd_mach_o_header_p (bfd *abfd,
4177                      bfd_mach_o_filetype filetype,
4178                      bfd_mach_o_cpu_type cputype)
4179 {
4180   struct bfd_preserve preserve;
4181   bfd_mach_o_header header;
4182
4183   preserve.marker = NULL;
4184   if (!bfd_mach_o_read_header (abfd, &header))
4185     goto wrong;
4186
4187   if (! (header.byteorder == BFD_ENDIAN_BIG
4188          || header.byteorder == BFD_ENDIAN_LITTLE))
4189     {
4190       (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4191                              (unsigned long) header.byteorder);
4192       goto wrong;
4193     }
4194
4195   if (! ((header.byteorder == BFD_ENDIAN_BIG
4196           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4197           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4198          || (header.byteorder == BFD_ENDIAN_LITTLE
4199              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4200              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4201     goto wrong;
4202
4203   /* Check cputype and filetype.
4204      In case of wildcard, do not accept magics that are handled by existing
4205      targets.  */
4206   if (cputype)
4207     {
4208       if (header.cputype != cputype)
4209         goto wrong;
4210     }
4211
4212   if (filetype)
4213     {
4214       if (header.filetype != filetype)
4215         goto wrong;
4216     }
4217   else
4218     {
4219       switch (header.filetype)
4220         {
4221         case BFD_MACH_O_MH_CORE:
4222           /* Handled by core_p */
4223           goto wrong;
4224         default:
4225           break;
4226         }
4227     }
4228
4229   preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4230   if (preserve.marker == NULL
4231       || !bfd_preserve_save (abfd, &preserve))
4232     goto fail;
4233
4234   if (!bfd_mach_o_scan (abfd, &header,
4235                         (bfd_mach_o_data_struct *) preserve.marker))
4236     goto wrong;
4237
4238   bfd_preserve_finish (abfd, &preserve);
4239   return abfd->xvec;
4240
4241  wrong:
4242   bfd_set_error (bfd_error_wrong_format);
4243
4244  fail:
4245   if (preserve.marker != NULL)
4246     bfd_preserve_restore (abfd, &preserve);
4247   return NULL;
4248 }
4249
4250 static const bfd_target *
4251 bfd_mach_o_gen_object_p (bfd *abfd)
4252 {
4253   return bfd_mach_o_header_p (abfd, 0, 0);
4254 }
4255
4256 static const bfd_target *
4257 bfd_mach_o_gen_core_p (bfd *abfd)
4258 {
4259   return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4260 }
4261
4262 typedef struct mach_o_fat_archentry
4263 {
4264   unsigned long cputype;
4265   unsigned long cpusubtype;
4266   unsigned long offset;
4267   unsigned long size;
4268   unsigned long align;
4269 } mach_o_fat_archentry;
4270
4271 typedef struct mach_o_fat_data_struct
4272 {
4273   unsigned long magic;
4274   unsigned long nfat_arch;
4275   mach_o_fat_archentry *archentries;
4276 } mach_o_fat_data_struct;
4277
4278 const bfd_target *
4279 bfd_mach_o_archive_p (bfd *abfd)
4280 {
4281   mach_o_fat_data_struct *adata = NULL;
4282   struct mach_o_fat_header_external hdr;
4283   unsigned long i;
4284
4285   if (bfd_seek (abfd, 0, SEEK_SET) != 0
4286       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4287     goto error;
4288
4289   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4290   if (adata == NULL)
4291     goto error;
4292
4293   adata->magic = bfd_getb32 (hdr.magic);
4294   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4295   if (adata->magic != 0xcafebabe)
4296     goto error;
4297   /* Avoid matching Java bytecode files, which have the same magic number.
4298      In the Java bytecode file format this field contains the JVM version,
4299      which starts at 43.0.  */
4300   if (adata->nfat_arch > 30)
4301     goto error;
4302
4303   adata->archentries =
4304     bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4305   if (adata->archentries == NULL)
4306     goto error;
4307
4308   for (i = 0; i < adata->nfat_arch; i++)
4309     {
4310       struct mach_o_fat_arch_external arch;
4311       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4312         goto error;
4313       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4314       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4315       adata->archentries[i].offset = bfd_getb32 (arch.offset);
4316       adata->archentries[i].size = bfd_getb32 (arch.size);
4317       adata->archentries[i].align = bfd_getb32 (arch.align);
4318     }
4319
4320   abfd->tdata.mach_o_fat_data = adata;
4321   return abfd->xvec;
4322
4323  error:
4324   if (adata != NULL)
4325     bfd_release (abfd, adata);
4326   bfd_set_error (bfd_error_wrong_format);
4327   return NULL;
4328 }
4329
4330 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4331    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4332    Set arelt_data and origin fields too.  */
4333
4334 static void
4335 bfd_mach_o_fat_member_init (bfd *abfd,
4336                             enum bfd_architecture arch_type,
4337                             unsigned long arch_subtype,
4338                             mach_o_fat_archentry *entry)
4339 {
4340   struct areltdata *areltdata;
4341   /* Create the member filename. Use ARCH_NAME.  */
4342   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4343
4344   if (ap)
4345     {
4346       /* Use the architecture name if known.  */
4347       abfd->filename = ap->printable_name;
4348     }
4349   else
4350     {
4351       /* Forge a uniq id.  */
4352       const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4353       char *name = bfd_alloc (abfd, namelen);
4354       snprintf (name, namelen, "0x%lx-0x%lx",
4355                 entry->cputype, entry->cpusubtype);
4356       abfd->filename = name;
4357     }
4358
4359   areltdata = bfd_zmalloc (sizeof (struct areltdata));
4360   areltdata->parsed_size = entry->size;
4361   abfd->arelt_data = areltdata;
4362   abfd->iostream = NULL;
4363   abfd->origin = entry->offset;
4364 }
4365
4366 bfd *
4367 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4368 {
4369   mach_o_fat_data_struct *adata;
4370   mach_o_fat_archentry *entry = NULL;
4371   unsigned long i;
4372   bfd *nbfd;
4373   enum bfd_architecture arch_type;
4374   unsigned long arch_subtype;
4375
4376   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4377   BFD_ASSERT (adata != NULL);
4378
4379   /* Find index of previous entry.  */
4380   if (prev == NULL)
4381     {
4382       /* Start at first one.  */
4383       i = 0;
4384     }
4385   else
4386     {
4387       /* Find index of PREV.  */
4388       for (i = 0; i < adata->nfat_arch; i++)
4389         {
4390           if (adata->archentries[i].offset == prev->origin)
4391             break;
4392         }
4393
4394       if (i == adata->nfat_arch)
4395         {
4396           /* Not found.  */
4397           bfd_set_error (bfd_error_bad_value);
4398           return NULL;
4399         }
4400
4401       /* Get next entry.  */
4402       i++;
4403     }
4404
4405   if (i >= adata->nfat_arch)
4406     {
4407       bfd_set_error (bfd_error_no_more_archived_files);
4408       return NULL;
4409     }
4410
4411   entry = &adata->archentries[i];
4412   nbfd = _bfd_new_bfd_contained_in (archive);
4413   if (nbfd == NULL)
4414     return NULL;
4415
4416   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4417                                    &arch_type, &arch_subtype);
4418
4419   bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4420
4421   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4422
4423   return nbfd;
4424 }
4425
4426 /* Analogous to stat call.  */
4427
4428 static int
4429 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4430 {
4431   if (abfd->arelt_data == NULL)
4432     {
4433       bfd_set_error (bfd_error_invalid_operation);
4434       return -1;
4435     }
4436
4437   buf->st_mtime = 0;
4438   buf->st_uid = 0;
4439   buf->st_gid = 0;
4440   buf->st_mode = 0644;
4441   buf->st_size = arelt_size (abfd);
4442
4443   return 0;
4444 }
4445
4446 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4447    If ABFD is a fat image containing a member that corresponds to FORMAT
4448    and ARCH, returns it.
4449    In other case, returns NULL.
4450    This function allows transparent uses of fat images.  */
4451
4452 bfd *
4453 bfd_mach_o_fat_extract (bfd *abfd,
4454                         bfd_format format,
4455                         const bfd_arch_info_type *arch)
4456 {
4457   bfd *res;
4458   mach_o_fat_data_struct *adata;
4459   unsigned int i;
4460
4461   if (bfd_check_format (abfd, format))
4462     {
4463       if (bfd_get_arch_info (abfd) == arch)
4464         return abfd;
4465       return NULL;
4466     }
4467   if (!bfd_check_format (abfd, bfd_archive)
4468       || abfd->xvec != &mach_o_fat_vec)
4469     return NULL;
4470
4471   /* This is a Mach-O fat image.  */
4472   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4473   BFD_ASSERT (adata != NULL);
4474
4475   for (i = 0; i < adata->nfat_arch; i++)
4476     {
4477       struct mach_o_fat_archentry *e = &adata->archentries[i];
4478       enum bfd_architecture cpu_type;
4479       unsigned long cpu_subtype;
4480
4481       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4482                                        &cpu_type, &cpu_subtype);
4483       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4484         continue;
4485
4486       /* The architecture is found.  */
4487       res = _bfd_new_bfd_contained_in (abfd);
4488       if (res == NULL)
4489         return NULL;
4490
4491       bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4492
4493       if (bfd_check_format (res, format))
4494         {
4495           BFD_ASSERT (bfd_get_arch_info (res) == arch);
4496           return res;
4497         }
4498       bfd_close (res);
4499       return NULL;
4500     }
4501
4502   return NULL;
4503 }
4504
4505 int
4506 bfd_mach_o_lookup_command (bfd *abfd,
4507                            bfd_mach_o_load_command_type type,
4508                            bfd_mach_o_load_command **mcommand)
4509 {
4510   struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4511   bfd_mach_o_load_command *ncmd = NULL;
4512   unsigned int i, num;
4513
4514   BFD_ASSERT (md != NULL);
4515   BFD_ASSERT (mcommand != NULL);
4516
4517   num = 0;
4518   for (i = 0; i < md->header.ncmds; i++)
4519     {
4520       struct bfd_mach_o_load_command *cmd = &md->commands[i];
4521
4522       if (cmd->type != type)
4523         continue;
4524
4525       if (num == 0)
4526         ncmd = cmd;
4527       num++;
4528     }
4529
4530   *mcommand = ncmd;
4531   return num;
4532 }
4533
4534 unsigned long
4535 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4536 {
4537   switch (type)
4538     {
4539     case BFD_MACH_O_CPU_TYPE_MC680x0:
4540       return 0x04000000;
4541     case BFD_MACH_O_CPU_TYPE_MC88000:
4542       return 0xffffe000;
4543     case BFD_MACH_O_CPU_TYPE_POWERPC:
4544       return 0xc0000000;
4545     case BFD_MACH_O_CPU_TYPE_I386:
4546       return 0xc0000000;
4547     case BFD_MACH_O_CPU_TYPE_SPARC:
4548       return 0xf0000000;
4549     case BFD_MACH_O_CPU_TYPE_I860:
4550       return 0;
4551     case BFD_MACH_O_CPU_TYPE_HPPA:
4552       return 0xc0000000 - 0x04000000;
4553     default:
4554       return 0;
4555     }
4556 }
4557
4558 /* The following two tables should be kept, as far as possible, in order of
4559    most frequently used entries to optimize their use from gas.  */
4560
4561 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4562 {
4563   { "regular", BFD_MACH_O_S_REGULAR},
4564   { "coalesced", BFD_MACH_O_S_COALESCED},
4565   { "zerofill", BFD_MACH_O_S_ZEROFILL},
4566   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4567   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4568   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4569   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4570   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4571   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4572   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4573   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4574   { "interposing", BFD_MACH_O_S_INTERPOSING},
4575   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4576   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4577   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4578   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4579   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4580   { NULL, 0}
4581 };
4582
4583 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4584 {
4585   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4586   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4587   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4588   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4589   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4590   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4591   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4592   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4593   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4594   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4595   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4596   { NULL, 0}
4597 };
4598
4599 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
4600
4601 unsigned int
4602 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4603 {
4604   const bfd_mach_o_xlat_name *x;
4605   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4606
4607   for (x = bfd_mach_o_section_type_name; x->name; x++)
4608     if (strcmp (x->name, name) == 0)
4609       {
4610         /* We found it... does the target support it?  */
4611         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4612             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4613           return x->val; /* OK.  */
4614         else
4615           break; /* Not supported.  */
4616       }
4617   /* Maximum section ID = 0xff.  */
4618   return 256;
4619 }
4620
4621 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
4622
4623 unsigned int
4624 bfd_mach_o_get_section_attribute_from_name (const char *name)
4625 {
4626   const bfd_mach_o_xlat_name *x;
4627
4628   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4629     if (strcmp (x->name, name) == 0)
4630       return x->val;
4631   return (unsigned int)-1;
4632 }
4633
4634 int
4635 bfd_mach_o_core_fetch_environment (bfd *abfd,
4636                                    unsigned char **rbuf,
4637                                    unsigned int *rlen)
4638 {
4639   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4640   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4641   unsigned int i = 0;
4642
4643   for (i = 0; i < mdata->header.ncmds; i++)
4644     {
4645       bfd_mach_o_load_command *cur = &mdata->commands[i];
4646       bfd_mach_o_segment_command *seg = NULL;
4647
4648       if (cur->type != BFD_MACH_O_LC_SEGMENT)
4649         continue;
4650
4651       seg = &cur->command.segment;
4652
4653       if ((seg->vmaddr + seg->vmsize) == stackaddr)
4654         {
4655           unsigned long start = seg->fileoff;
4656           unsigned long end = seg->fileoff + seg->filesize;
4657           unsigned char *buf = bfd_malloc (1024);
4658           unsigned long size = 1024;
4659
4660           for (;;)
4661             {
4662               bfd_size_type nread = 0;
4663               unsigned long offset;
4664               int found_nonnull = 0;
4665
4666               if (size > (end - start))
4667                 size = (end - start);
4668
4669               buf = bfd_realloc_or_free (buf, size);
4670               if (buf == NULL)
4671                 return -1;
4672
4673               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4674                 {
4675                   free (buf);
4676                   return -1;
4677                 }
4678
4679               nread = bfd_bread (buf, size, abfd);
4680
4681               if (nread != size)
4682                 {
4683                   free (buf);
4684                   return -1;
4685                 }
4686
4687               for (offset = 4; offset <= size; offset += 4)
4688                 {
4689                   unsigned long val;
4690
4691                   val = *((unsigned long *) (buf + size - offset));
4692                   if (! found_nonnull)
4693                     {
4694                       if (val != 0)
4695                         found_nonnull = 1;
4696                     }
4697                   else if (val == 0x0)
4698                     {
4699                       unsigned long bottom;
4700                       unsigned long top;
4701
4702                       bottom = seg->fileoff + seg->filesize - offset;
4703                       top = seg->fileoff + seg->filesize - 4;
4704                       *rbuf = bfd_malloc (top - bottom);
4705                       *rlen = top - bottom;
4706
4707                       memcpy (*rbuf, buf + size - *rlen, *rlen);
4708                       free (buf);
4709                       return 0;
4710                     }
4711                 }
4712
4713               if (size == (end - start))
4714                 break;
4715
4716               size *= 2;
4717             }
4718
4719           free (buf);
4720         }
4721     }
4722
4723   return -1;
4724 }
4725
4726 char *
4727 bfd_mach_o_core_file_failing_command (bfd *abfd)
4728 {
4729   unsigned char *buf = NULL;
4730   unsigned int len = 0;
4731   int ret = -1;
4732
4733   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4734   if (ret < 0)
4735     return NULL;
4736
4737   return (char *) buf;
4738 }
4739
4740 int
4741 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4742 {
4743   return 0;
4744 }
4745
4746 static bfd_mach_o_uuid_command *
4747 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4748 {
4749   bfd_mach_o_load_command *uuid_cmd;
4750   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4751   if (ncmd != 1)
4752     return FALSE;
4753   return &uuid_cmd->command.uuid;
4754 }
4755
4756 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4757
4758 static bfd_boolean
4759 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4760 {
4761   bfd_mach_o_uuid_command *dsym_uuid_cmd;
4762
4763   BFD_ASSERT (abfd);
4764   BFD_ASSERT (uuid_cmd);
4765
4766   if (!bfd_check_format (abfd, bfd_object))
4767     return FALSE;
4768
4769   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4770       || bfd_mach_o_get_data (abfd) == NULL
4771       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4772     return FALSE;
4773
4774   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4775   if (dsym_uuid_cmd == NULL)
4776     return FALSE;
4777
4778   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4779               sizeof (uuid_cmd->uuid)) != 0)
4780     return FALSE;
4781
4782   return TRUE;
4783 }
4784
4785 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4786    The caller is responsible for closing the returned BFD object and
4787    its my_archive if the returned BFD is in a fat dSYM. */
4788
4789 static bfd *
4790 bfd_mach_o_find_dsym (const char *dsym_filename,
4791                       const bfd_mach_o_uuid_command *uuid_cmd,
4792                       const bfd_arch_info_type *arch)
4793 {
4794   bfd *base_dsym_bfd, *dsym_bfd;
4795
4796   BFD_ASSERT (uuid_cmd);
4797
4798   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4799   if (base_dsym_bfd == NULL)
4800     return NULL;
4801
4802   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4803   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4804     return dsym_bfd;
4805
4806   bfd_close (dsym_bfd);
4807   if (base_dsym_bfd != dsym_bfd)
4808     bfd_close (base_dsym_bfd);
4809
4810   return NULL;
4811 }
4812
4813 /* Return a BFD created from a dSYM file for ABFD.
4814    The caller is responsible for closing the returned BFD object, its
4815    filename, and its my_archive if the returned BFD is in a fat dSYM. */
4816
4817 static bfd *
4818 bfd_mach_o_follow_dsym (bfd *abfd)
4819 {
4820   char *dsym_filename;
4821   bfd_mach_o_uuid_command *uuid_cmd;
4822   bfd *dsym_bfd, *base_bfd = abfd;
4823   const char *base_basename;
4824
4825   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4826     return NULL;
4827
4828   if (abfd->my_archive)
4829     base_bfd = abfd->my_archive;
4830   /* BFD may have been opened from a stream. */
4831   if (base_bfd->filename == NULL)
4832     {
4833       bfd_set_error (bfd_error_invalid_operation);
4834       return NULL;
4835     }
4836   base_basename = lbasename (base_bfd->filename);
4837
4838   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4839   if (uuid_cmd == NULL)
4840     return NULL;
4841
4842   /* TODO: We assume the DWARF file has the same as the binary's.
4843      It seems apple's GDB checks all files in the dSYM bundle directory.
4844      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4845   */
4846   dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4847                                        + strlen (dsym_subdir) + 1
4848                                        + strlen (base_basename) + 1);
4849   sprintf (dsym_filename, "%s%s/%s",
4850            base_bfd->filename, dsym_subdir, base_basename);
4851
4852   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4853                                    bfd_get_arch_info (abfd));
4854   if (dsym_bfd == NULL)
4855     free (dsym_filename);
4856
4857   return dsym_bfd;
4858 }
4859
4860 bfd_boolean
4861 bfd_mach_o_find_nearest_line (bfd *abfd,
4862                               asection *section,
4863                               asymbol **symbols,
4864                               bfd_vma offset,
4865                               const char **filename_ptr,
4866                               const char **functionname_ptr,
4867                               unsigned int *line_ptr)
4868 {
4869   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4870   if (mdata == NULL)
4871     return FALSE;
4872   switch (mdata->header.filetype)
4873     {
4874     case BFD_MACH_O_MH_OBJECT:
4875       break;
4876     case BFD_MACH_O_MH_EXECUTE:
4877     case BFD_MACH_O_MH_DYLIB:
4878     case BFD_MACH_O_MH_BUNDLE:
4879     case BFD_MACH_O_MH_KEXT_BUNDLE:
4880       if (mdata->dwarf2_find_line_info == NULL)
4881         {
4882           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4883           /* When we couldn't find dSYM for this binary, we look for
4884              the debug information in the binary itself. In this way,
4885              we won't try finding separated dSYM again because
4886              mdata->dwarf2_find_line_info will be filled. */
4887           if (! mdata->dsym_bfd)
4888             break;
4889           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4890                                               dwarf_debug_sections, symbols,
4891                                               &mdata->dwarf2_find_line_info))
4892             return FALSE;
4893         }
4894       break;
4895     default:
4896       return FALSE;
4897     }
4898   if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4899                                      section, symbols, offset,
4900                                      filename_ptr, functionname_ptr,
4901                                      line_ptr, NULL, 0,
4902                                      &mdata->dwarf2_find_line_info))
4903     return TRUE;
4904   return FALSE;
4905 }
4906
4907 bfd_boolean
4908 bfd_mach_o_close_and_cleanup (bfd *abfd)
4909 {
4910   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4911   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4912     {
4913       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4914       bfd_mach_o_free_cached_info (abfd);
4915       if (mdata->dsym_bfd != NULL)
4916         {
4917           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4918           char *dsym_filename = (char *)(fat_bfd
4919                                          ? fat_bfd->filename
4920                                          : mdata->dsym_bfd->filename);
4921           bfd_close (mdata->dsym_bfd);
4922           mdata->dsym_bfd = NULL;
4923           if (fat_bfd)
4924             bfd_close (fat_bfd);
4925           free (dsym_filename);
4926         }
4927     }
4928
4929   if (bfd_get_format (abfd) == bfd_archive
4930       && abfd->xvec == &mach_o_fat_vec)
4931     return TRUE;
4932   return _bfd_generic_close_and_cleanup (abfd);
4933 }
4934
4935 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4936 {
4937   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4938   asection *asect;
4939   free (mdata->dyn_reloc_cache);
4940   mdata->dyn_reloc_cache = NULL;
4941   for (asect = abfd->sections; asect != NULL; asect = asect->next)
4942     {
4943       free (asect->relocation);
4944       asect->relocation = NULL;
4945     }
4946
4947   return TRUE;
4948 }
4949
4950 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4951 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4952
4953 #define bfd_mach_o_swap_reloc_in NULL
4954 #define bfd_mach_o_swap_reloc_out NULL
4955 #define bfd_mach_o_print_thread NULL
4956 #define bfd_mach_o_tgt_seg_table NULL
4957 #define bfd_mach_o_section_type_valid_for_tgt NULL
4958
4959 #define TARGET_NAME             mach_o_be_vec
4960 #define TARGET_STRING           "mach-o-be"
4961 #define TARGET_ARCHITECTURE     bfd_arch_unknown
4962 #define TARGET_BIG_ENDIAN       1
4963 #define TARGET_ARCHIVE          0
4964 #define TARGET_PRIORITY         1
4965 #include "mach-o-target.c"
4966
4967 #undef TARGET_NAME
4968 #undef TARGET_STRING
4969 #undef TARGET_ARCHITECTURE
4970 #undef TARGET_BIG_ENDIAN
4971 #undef TARGET_ARCHIVE
4972 #undef TARGET_PRIORITY
4973
4974 #define TARGET_NAME             mach_o_le_vec
4975 #define TARGET_STRING           "mach-o-le"
4976 #define TARGET_ARCHITECTURE     bfd_arch_unknown
4977 #define TARGET_BIG_ENDIAN       0
4978 #define TARGET_ARCHIVE          0
4979 #define TARGET_PRIORITY         1
4980
4981 #include "mach-o-target.c"
4982
4983 #undef TARGET_NAME
4984 #undef TARGET_STRING
4985 #undef TARGET_ARCHITECTURE
4986 #undef TARGET_BIG_ENDIAN
4987 #undef TARGET_ARCHIVE
4988 #undef TARGET_PRIORITY
4989
4990 /* Not yet handled: creating an archive.  */
4991 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
4992
4993 /* Not used.  */
4994 #define bfd_mach_o_read_ar_hdr                    _bfd_noarchive_read_ar_hdr
4995 #define bfd_mach_o_write_ar_hdr                   _bfd_noarchive_write_ar_hdr
4996 #define bfd_mach_o_slurp_armap                    _bfd_noarchive_slurp_armap
4997 #define bfd_mach_o_slurp_extended_name_table      _bfd_noarchive_slurp_extended_name_table
4998 #define bfd_mach_o_construct_extended_name_table  _bfd_noarchive_construct_extended_name_table
4999 #define bfd_mach_o_truncate_arname                _bfd_noarchive_truncate_arname
5000 #define bfd_mach_o_write_armap                    _bfd_noarchive_write_armap
5001 #define bfd_mach_o_get_elt_at_index               _bfd_noarchive_get_elt_at_index
5002 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
5003 #define bfd_mach_o_update_armap_timestamp         _bfd_noarchive_update_armap_timestamp
5004
5005 #define TARGET_NAME             mach_o_fat_vec
5006 #define TARGET_STRING           "mach-o-fat"
5007 #define TARGET_ARCHITECTURE     bfd_arch_unknown
5008 #define TARGET_BIG_ENDIAN       1
5009 #define TARGET_ARCHIVE          1
5010 #define TARGET_PRIORITY         0
5011
5012 #include "mach-o-target.c"
5013
5014 #undef TARGET_NAME
5015 #undef TARGET_STRING
5016 #undef TARGET_ARCHITECTURE
5017 #undef TARGET_BIG_ENDIAN
5018 #undef TARGET_ARCHIVE
5019 #undef TARGET_PRIORITY