bfd/mach-o.c

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