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   else
2526     header->reserved = 0;
2527
2528   return TRUE;
2529 }
2530
2531 bfd_boolean
2532 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2533 {
2534   bfd_mach_o_section *s;
2535   unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2536
2537   s = bfd_mach_o_get_mach_o_section (sec);
2538   if (s == NULL)
2539     {
2540       flagword bfd_flags;
2541       static const mach_o_section_name_xlat * xlat;
2542
2543       s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2544       if (s == NULL)
2545         return FALSE;
2546       sec->used_by_bfd = s;
2547       s->bfdsection = sec;
2548
2549       /* Create the Darwin seg/sect name pair from the bfd name.
2550          If this is a canonical name for which a specific paiting exists
2551          there will also be defined flags, type, attribute and alignment
2552          values.  */
2553       xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2554       if (xlat != NULL)
2555         {
2556           s->flags = xlat->macho_sectype | xlat->macho_secattr;
2557           s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2558                                                 : bfdalign;
2559           bfd_set_section_alignment (abfd, sec, s->align);
2560           bfd_flags = bfd_get_section_flags (abfd, sec);
2561           if (bfd_flags == SEC_NO_FLAGS)
2562             bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2563         }
2564       else
2565         /* Create default flags.  */
2566         bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2567     }
2568
2569   return _bfd_generic_new_section_hook (abfd, sec);
2570 }
2571
2572 static void
2573 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2574                                      unsigned long prot)
2575 {
2576   flagword flags;
2577   bfd_mach_o_section *section;
2578
2579   flags = bfd_get_section_flags (abfd, sec);
2580   section = bfd_mach_o_get_mach_o_section (sec);
2581
2582   /* TODO: see if we should use the xlat system for doing this by
2583      preference and fall back to this for unknown sections.  */
2584
2585   if (flags == SEC_NO_FLAGS)
2586     {
2587       /* Try to guess flags.  */
2588       if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2589         flags = SEC_DEBUGGING;
2590       else
2591         {
2592           flags = SEC_ALLOC;
2593           if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2594               != BFD_MACH_O_S_ZEROFILL)
2595             {
2596               flags |= SEC_LOAD;
2597               if (prot & BFD_MACH_O_PROT_EXECUTE)
2598                 flags |= SEC_CODE;
2599               if (prot & BFD_MACH_O_PROT_WRITE)
2600                 flags |= SEC_DATA;
2601               else if (prot & BFD_MACH_O_PROT_READ)
2602                 flags |= SEC_READONLY;
2603             }
2604         }
2605     }
2606   else
2607     {
2608       if ((flags & SEC_DEBUGGING) == 0)
2609         flags |= SEC_ALLOC;
2610     }
2611
2612   if (section->offset != 0)
2613     flags |= SEC_HAS_CONTENTS;
2614   if (section->nreloc != 0)
2615     flags |= SEC_RELOC;
2616
2617   bfd_set_section_flags (abfd, sec, flags);
2618
2619   sec->vma = section->addr;
2620   sec->lma = section->addr;
2621   sec->size = section->size;
2622   sec->filepos = section->offset;
2623   sec->alignment_power = section->align;
2624   sec->segment_mark = 0;
2625   sec->reloc_count = section->nreloc;
2626   sec->rel_filepos = section->reloff;
2627 }
2628
2629 static asection *
2630 bfd_mach_o_make_bfd_section (bfd *abfd,
2631                              const unsigned char *segname,
2632                              const unsigned char *sectname)
2633 {
2634   const char *sname;
2635   flagword flags;
2636
2637   bfd_mach_o_convert_section_name_to_bfd
2638     (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2639   if (sname == NULL)
2640     return NULL;
2641
2642   return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2643 }
2644
2645 static asection *
2646 bfd_mach_o_read_section_32 (bfd *abfd,
2647                             unsigned int offset,
2648                             unsigned long prot)
2649 {
2650   struct mach_o_section_32_external raw;
2651   asection *sec;
2652   bfd_mach_o_section *section;
2653
2654   if (bfd_seek (abfd, offset, SEEK_SET) != 0
2655       || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2656           != BFD_MACH_O_SECTION_SIZE))
2657     return NULL;
2658
2659   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2660   if (sec == NULL)
2661     return NULL;
2662
2663   section = bfd_mach_o_get_mach_o_section (sec);
2664   memcpy (section->segname, raw.segname, sizeof (raw.segname));
2665   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2666   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2667   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2668   section->addr = bfd_h_get_32 (abfd, raw.addr);
2669   section->size = bfd_h_get_32 (abfd, raw.size);
2670   section->offset = bfd_h_get_32 (abfd, raw.offset);
2671   section->align = bfd_h_get_32 (abfd, raw.align);
2672   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2673   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2674   section->flags = bfd_h_get_32 (abfd, raw.flags);
2675   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2676   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2677   section->reserved3 = 0;
2678
2679   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2680
2681   return sec;
2682 }
2683
2684 static asection *
2685 bfd_mach_o_read_section_64 (bfd *abfd,
2686                             unsigned int offset,
2687                             unsigned long prot)
2688 {
2689   struct mach_o_section_64_external raw;
2690   asection *sec;
2691   bfd_mach_o_section *section;
2692
2693   if (bfd_seek (abfd, offset, SEEK_SET) != 0
2694       || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2695           != BFD_MACH_O_SECTION_64_SIZE))
2696     return NULL;
2697
2698   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2699   if (sec == NULL)
2700     return NULL;
2701
2702   section = bfd_mach_o_get_mach_o_section (sec);
2703   memcpy (section->segname, raw.segname, sizeof (raw.segname));
2704   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2705   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2706   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2707   section->addr = bfd_h_get_64 (abfd, raw.addr);
2708   section->size = bfd_h_get_64 (abfd, raw.size);
2709   section->offset = bfd_h_get_32 (abfd, raw.offset);
2710   section->align = bfd_h_get_32 (abfd, raw.align);
2711   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2712   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2713   section->flags = bfd_h_get_32 (abfd, raw.flags);
2714   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2715   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2716   section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2717
2718   bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2719
2720   return sec;
2721 }
2722
2723 static asection *
2724 bfd_mach_o_read_section (bfd *abfd,
2725                          unsigned int offset,
2726                          unsigned long prot,
2727                          unsigned int wide)
2728 {
2729   if (wide)
2730     return bfd_mach_o_read_section_64 (abfd, offset, prot);
2731   else
2732     return bfd_mach_o_read_section_32 (abfd, offset, prot);
2733 }
2734
2735 static bfd_boolean
2736 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2737                                bfd_mach_o_symtab_command *sym,
2738                                bfd_mach_o_asymbol *s,
2739                                unsigned long i)
2740 {
2741   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2742   unsigned int wide = mach_o_wide_p (&mdata->header);
2743   unsigned int symwidth =
2744     wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2745   unsigned int symoff = sym->symoff + (i * symwidth);
2746   struct mach_o_nlist_64_external raw;
2747   unsigned char type = -1;
2748   unsigned char section = -1;
2749   short desc = -1;
2750   symvalue value = -1;
2751   unsigned long stroff = -1;
2752   unsigned int symtype = -1;
2753
2754   BFD_ASSERT (sym->strtab != NULL);
2755
2756   if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2757       || bfd_bread (&raw, symwidth, abfd) != symwidth)
2758     {
2759       (*_bfd_error_handler)
2760         (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2761          symwidth, (unsigned long) symoff);
2762       return FALSE;
2763     }
2764
2765   stroff = bfd_h_get_32 (abfd, raw.n_strx);
2766   type = bfd_h_get_8 (abfd, raw.n_type);
2767   symtype = type & BFD_MACH_O_N_TYPE;
2768   section = bfd_h_get_8 (abfd, raw.n_sect);
2769   desc = bfd_h_get_16 (abfd, raw.n_desc);
2770   if (wide)
2771     value = bfd_h_get_64 (abfd, raw.n_value);
2772   else
2773     value = bfd_h_get_32 (abfd, raw.n_value);
2774
2775   if (stroff >= sym->strsize)
2776     {
2777       (*_bfd_error_handler)
2778         (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2779          (unsigned long) stroff,
2780          (unsigned long) sym->strsize);
2781       return FALSE;
2782     }
2783
2784   s->symbol.the_bfd = abfd;
2785   s->symbol.name = sym->strtab + stroff;
2786   s->symbol.value = value;
2787   s->symbol.flags = 0x0;
2788   s->symbol.udata.i = i;
2789   s->n_type = type;
2790   s->n_sect = section;
2791   s->n_desc = desc;
2792
2793   if (type & BFD_MACH_O_N_STAB)
2794     {
2795       s->symbol.flags |= BSF_DEBUGGING;
2796       s->symbol.section = bfd_und_section_ptr;
2797       switch (type)
2798         {
2799         case N_FUN:
2800         case N_STSYM:
2801         case N_LCSYM:
2802         case N_BNSYM:
2803         case N_SLINE:
2804         case N_ENSYM:
2805         case N_ECOMM:
2806         case N_ECOML:
2807         case N_GSYM:
2808           if ((section > 0) && (section <= mdata->nsects))
2809             {
2810               s->symbol.section = mdata->sections[section - 1]->bfdsection;
2811               s->symbol.value =
2812                 s->symbol.value - mdata->sections[section - 1]->addr;
2813             }
2814           break;
2815         }
2816     }
2817   else
2818     {
2819       if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2820         s->symbol.flags |= BSF_GLOBAL;
2821       else
2822         s->symbol.flags |= BSF_LOCAL;
2823
2824       switch (symtype)
2825         {
2826         case BFD_MACH_O_N_UNDF:
2827           if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2828               && s->symbol.value != 0)
2829             {
2830               /* A common symbol.  */
2831               s->symbol.section = bfd_com_section_ptr;
2832               s->symbol.flags = BSF_NO_FLAGS;
2833             }
2834           else
2835             {
2836               s->symbol.section = bfd_und_section_ptr;
2837               if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2838                 s->symbol.flags |= BSF_WEAK;
2839             }
2840           break;
2841         case BFD_MACH_O_N_PBUD:
2842           s->symbol.section = bfd_und_section_ptr;
2843           break;
2844         case BFD_MACH_O_N_ABS:
2845           s->symbol.section = bfd_abs_section_ptr;
2846           break;
2847         case BFD_MACH_O_N_SECT:
2848           if ((section > 0) && (section <= mdata->nsects))
2849             {
2850               s->symbol.section = mdata->sections[section - 1]->bfdsection;
2851               s->symbol.value =
2852                 s->symbol.value - mdata->sections[section - 1]->addr;
2853             }
2854           else
2855             {
2856               /* Mach-O uses 0 to mean "no section"; not an error.  */
2857               if (section != 0)
2858                 {
2859                   (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2860                                            "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2861                                          s->symbol.name, section, mdata->nsects);
2862                 }
2863               s->symbol.section = bfd_und_section_ptr;
2864             }
2865           break;
2866         case BFD_MACH_O_N_INDR:
2867           /* FIXME: we don't follow the BFD convention as this indirect symbol
2868              won't be followed by the referenced one.  This looks harmless
2869              unless we start using the linker.  */
2870           s->symbol.flags |= BSF_INDIRECT;
2871           s->symbol.section = bfd_ind_section_ptr;
2872           s->symbol.value = 0;
2873           break;
2874         default:
2875           (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2876                                    "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2877                                  s->symbol.name, symtype);
2878           s->symbol.section = bfd_und_section_ptr;
2879           break;
2880         }
2881     }
2882
2883   return TRUE;
2884 }
2885
2886 bfd_boolean
2887 bfd_mach_o_read_symtab_strtab (bfd *abfd)
2888 {
2889   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2890   bfd_mach_o_symtab_command *sym = mdata->symtab;
2891
2892   /* Fail if there is no symtab.  */
2893   if (sym == NULL)
2894     return FALSE;
2895
2896   /* Success if already loaded.  */
2897   if (sym->strtab)
2898     return TRUE;
2899
2900   if (abfd->flags & BFD_IN_MEMORY)
2901     {
2902       struct bfd_in_memory *b;
2903
2904       b = (struct bfd_in_memory *) abfd->iostream;
2905
2906       if ((sym->stroff + sym->strsize) > b->size)
2907         {
2908           bfd_set_error (bfd_error_file_truncated);
2909           return FALSE;
2910         }
2911       sym->strtab = (char *) b->buffer + sym->stroff;
2912     }
2913   else
2914     {
2915       sym->strtab = bfd_alloc (abfd, sym->strsize);
2916       if (sym->strtab == NULL)
2917         return FALSE;
2918
2919       if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
2920           || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
2921         {
2922           bfd_set_error (bfd_error_file_truncated);
2923           return FALSE;
2924         }
2925     }
2926
2927   return TRUE;
2928 }
2929
2930 bfd_boolean
2931 bfd_mach_o_read_symtab_symbols (bfd *abfd)
2932 {
2933   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2934   bfd_mach_o_symtab_command *sym = mdata->symtab;
2935   unsigned long i;
2936
2937   if (sym == NULL || sym->symbols)
2938     {
2939       /* Return now if there are no symbols or if already loaded.  */
2940       return TRUE;
2941     }
2942
2943   sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
2944
2945   if (sym->symbols == NULL)
2946     {
2947       (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2948       return FALSE;
2949     }
2950
2951   if (!bfd_mach_o_read_symtab_strtab (abfd))
2952     return FALSE;
2953
2954   for (i = 0; i < sym->nsyms; i++)
2955     {
2956       if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
2957         return FALSE;
2958     }
2959
2960   return TRUE;
2961 }
2962
2963 static const char *
2964 bfd_mach_o_i386_flavour_string (unsigned int flavour)
2965 {
2966   switch ((int) flavour)
2967     {
2968     case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
2969     case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
2970     case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
2971     case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
2972     case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
2973     case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
2974     case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
2975     case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
2976     case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
2977     case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
2978     case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
2979     case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
2980     case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
2981     default: return "UNKNOWN";
2982     }
2983 }
2984
2985 static const char *
2986 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
2987 {
2988   switch ((int) flavour)
2989     {
2990     case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
2991     case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
2992     case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
2993     case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
2994     case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
2995     case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
2996     default: return "UNKNOWN";
2997     }
2998 }
2999
3000 static int
3001 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3002 {
3003   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3004   struct mach_o_str_command_external raw;
3005   unsigned int nameoff;
3006
3007   BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
3008               || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
3009
3010   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3011       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3012     return -1;
3013
3014   nameoff = bfd_h_get_32 (abfd, raw.str);
3015
3016   cmd->name_offset = command->offset + nameoff;
3017   cmd->name_len = command->len - nameoff;
3018   cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3019   if (cmd->name_str == NULL)
3020     return -1;
3021   if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3022       || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3023     return -1;
3024   return 0;
3025 }
3026
3027 static int
3028 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3029 {
3030   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3031   struct mach_o_dylib_command_external raw;
3032   unsigned int nameoff;
3033
3034   switch (command->type)
3035     {
3036     case BFD_MACH_O_LC_LOAD_DYLIB:
3037     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3038     case BFD_MACH_O_LC_ID_DYLIB:
3039     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3040     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3041       break;
3042     default:
3043       BFD_FAIL ();
3044       return -1;
3045     }
3046
3047   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3048       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3049     return -1;
3050
3051   nameoff = bfd_h_get_32 (abfd, raw.name);
3052   cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3053   cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3054   cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3055
3056   cmd->name_offset = command->offset + nameoff;
3057   cmd->name_len = command->len - nameoff;
3058   cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3059   if (cmd->name_str == NULL)
3060     return -1;
3061   if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3062       || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3063     return -1;
3064   return 0;
3065 }
3066
3067 static int
3068 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
3069                                 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3070 {
3071   /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3072
3073   BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3074   return 0;
3075 }
3076
3077 static int
3078 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3079 {
3080   bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3081   struct mach_o_fvmlib_command_external raw;
3082   unsigned int nameoff;
3083
3084   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3085       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3086     return -1;
3087
3088   nameoff = bfd_h_get_32 (abfd, raw.name);
3089   fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3090   fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3091
3092   fvm->name_offset = command->offset + nameoff;
3093   fvm->name_len = command->len - nameoff;
3094   fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3095   if (fvm->name_str == NULL)
3096     return -1;
3097   if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3098       || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3099     return -1;
3100   return 0;
3101 }
3102
3103 static int
3104 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3105 {
3106   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3107   bfd_mach_o_thread_command *cmd = &command->command.thread;
3108   unsigned int offset;
3109   unsigned int nflavours;
3110   unsigned int i;
3111
3112   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3113               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3114
3115   /* Count the number of threads.  */
3116   offset = 8;
3117   nflavours = 0;
3118   while (offset != command->len)
3119     {
3120       struct mach_o_thread_command_external raw;
3121
3122       if (offset >= command->len)
3123         return -1;
3124
3125       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3126           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3127         return -1;
3128
3129       offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3130       nflavours++;
3131     }
3132
3133   /* Allocate threads.  */
3134   cmd->flavours = bfd_alloc
3135     (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3136   if (cmd->flavours == NULL)
3137     return -1;
3138   cmd->nflavours = nflavours;
3139
3140   offset = 8;
3141   nflavours = 0;
3142   while (offset != command->len)
3143     {
3144       struct mach_o_thread_command_external raw;
3145
3146       if (offset >= command->len)
3147         return -1;
3148
3149       if (nflavours >= cmd->nflavours)
3150         return -1;
3151
3152       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3153           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3154         return -1;
3155
3156       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3157       cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3158       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3159       offset += cmd->flavours[nflavours].size + sizeof (raw);
3160       nflavours++;
3161     }
3162
3163   for (i = 0; i < nflavours; i++)
3164     {
3165       asection *bfdsec;
3166       unsigned int snamelen;
3167       char *sname;
3168       const char *flavourstr;
3169       const char *prefix = "LC_THREAD";
3170       unsigned int j = 0;
3171
3172       switch (mdata->header.cputype)
3173         {
3174         case BFD_MACH_O_CPU_TYPE_POWERPC:
3175         case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3176           flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3177           break;
3178         case BFD_MACH_O_CPU_TYPE_I386:
3179         case BFD_MACH_O_CPU_TYPE_X86_64:
3180           flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3181           break;
3182         default:
3183           flavourstr = "UNKNOWN_ARCHITECTURE";
3184           break;
3185         }
3186
3187       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3188       sname = bfd_alloc (abfd, snamelen);
3189       if (sname == NULL)
3190         return -1;
3191
3192       for (;;)
3193         {
3194           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3195           if (bfd_get_section_by_name (abfd, sname) == NULL)
3196             break;
3197           j++;
3198         }
3199
3200       bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3201
3202       bfdsec->vma = 0;
3203       bfdsec->lma = 0;
3204       bfdsec->size = cmd->flavours[i].size;
3205       bfdsec->filepos = cmd->flavours[i].offset;
3206       bfdsec->alignment_power = 0x0;
3207
3208       cmd->section = bfdsec;
3209     }
3210
3211   return 0;
3212 }
3213
3214 static int
3215 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3216 {
3217   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3218   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3219
3220   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3221
3222   {
3223     struct mach_o_dysymtab_command_external raw;
3224
3225     if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3226         || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3227       return -1;
3228
3229     cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3230     cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3231     cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3232     cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3233     cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3234     cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3235     cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3236     cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3237     cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3238     cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3239     cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3240     cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3241     cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3242     cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3243     cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3244     cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3245     cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3246     cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3247   }
3248
3249   if (cmd->nmodtab != 0)
3250     {
3251       unsigned int i;
3252       int wide = bfd_mach_o_wide_p (abfd);
3253       unsigned int module_len = wide ? 56 : 52;
3254
3255       cmd->dylib_module =
3256         bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3257       if (cmd->dylib_module == NULL)
3258         return -1;
3259
3260       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3261         return -1;
3262
3263       for (i = 0; i < cmd->nmodtab; i++)
3264         {
3265           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3266           unsigned long v;
3267           unsigned char buf[56];
3268
3269           if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3270             return -1;
3271
3272           module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3273           module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3274           module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3275           module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3276           module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3277           module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3278           module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3279           module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3280           module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3281           v = bfd_h_get_32 (abfd, buf +36);
3282           module->iinit = v & 0xffff;
3283           module->iterm = (v >> 16) & 0xffff;
3284           v = bfd_h_get_32 (abfd, buf + 40);
3285           module->ninit = v & 0xffff;
3286           module->nterm = (v >> 16) & 0xffff;
3287           if (wide)
3288             {
3289               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3290               module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3291             }
3292           else
3293             {
3294               module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3295               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3296             }
3297         }
3298     }
3299
3300   if (cmd->ntoc != 0)
3301     {
3302       unsigned int i;
3303
3304       cmd->dylib_toc = bfd_alloc
3305         (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3306       if (cmd->dylib_toc == NULL)
3307         return -1;
3308
3309       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3310         return -1;
3311
3312       for (i = 0; i < cmd->ntoc; i++)
3313         {
3314           struct mach_o_dylib_table_of_contents_external raw;
3315           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3316
3317           if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3318             return -1;
3319
3320           toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3321           toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3322         }
3323     }
3324
3325   if (cmd->nindirectsyms != 0)
3326     {
3327       unsigned int i;
3328
3329       cmd->indirect_syms = bfd_alloc
3330         (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3331       if (cmd->indirect_syms == NULL)
3332         return -1;
3333
3334       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3335         return -1;
3336
3337       for (i = 0; i < cmd->nindirectsyms; i++)
3338         {
3339           unsigned char raw[4];
3340           unsigned int *is = &cmd->indirect_syms[i];
3341
3342           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3343             return -1;
3344
3345           *is = bfd_h_get_32 (abfd, raw);
3346         }
3347     }
3348
3349   if (cmd->nextrefsyms != 0)
3350     {
3351       unsigned long v;
3352       unsigned int i;
3353
3354       cmd->ext_refs = bfd_alloc
3355         (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3356       if (cmd->ext_refs == NULL)
3357         return -1;
3358
3359       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3360         return -1;
3361
3362       for (i = 0; i < cmd->nextrefsyms; i++)
3363         {
3364           unsigned char raw[4];
3365           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3366
3367           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3368             return -1;
3369
3370           /* Fields isym and flags are written as bit-fields, thus we need
3371              a specific processing for endianness.  */
3372           v = bfd_h_get_32 (abfd, raw);
3373           if (bfd_big_endian (abfd))
3374             {
3375               ref->isym = (v >> 8) & 0xffffff;
3376               ref->flags = v & 0xff;
3377             }
3378           else
3379             {
3380               ref->isym = v & 0xffffff;
3381               ref->flags = (v >> 24) & 0xff;
3382             }
3383         }
3384     }
3385
3386   if (mdata->dysymtab)
3387     return -1;
3388   mdata->dysymtab = cmd;
3389
3390   return 0;
3391 }
3392
3393 static int
3394 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3395 {
3396   bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3397   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3398   struct mach_o_symtab_command_external raw;
3399
3400   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3401
3402   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3403       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3404     return -1;
3405
3406   symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3407   symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3408   symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3409   symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3410   symtab->symbols = NULL;
3411   symtab->strtab = NULL;
3412
3413   if (symtab->nsyms != 0)
3414     abfd->flags |= HAS_SYMS;
3415
3416   if (mdata->symtab)
3417     return -1;
3418   mdata->symtab = symtab;
3419   return 0;
3420 }
3421
3422 static int
3423 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3424 {
3425   bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3426
3427   BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3428
3429   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3430       || bfd_bread (cmd->uuid, 16, abfd) != 16)
3431     return -1;
3432
3433   return 0;
3434 }
3435
3436 static int
3437 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3438 {
3439   bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3440   struct mach_o_linkedit_data_command_external raw;
3441
3442   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3443       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3444     return -1;
3445
3446   cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3447   cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3448   return 0;
3449 }
3450
3451 static int
3452 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3453 {
3454   bfd_mach_o_str_command *cmd = &command->command.str;
3455   struct mach_o_str_command_external raw;
3456   unsigned long off;
3457
3458   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3459       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3460     return -1;
3461
3462   off = bfd_get_32 (abfd, raw.str);
3463   cmd->stroff = command->offset + off;
3464   cmd->str_len = command->len - off;
3465   cmd->str = bfd_alloc (abfd, cmd->str_len);
3466   if (cmd->str == NULL)
3467     return -1;
3468   if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3469       || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3470     return -1;
3471   return 0;
3472 }
3473
3474 static int
3475 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3476 {
3477   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3478   struct mach_o_dyld_info_command_external raw;
3479
3480   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3481       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3482     return -1;
3483
3484   cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3485   cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3486   cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3487   cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3488   cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3489   cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3490   cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3491   cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3492   cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3493   cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3494   return 0;
3495 }
3496
3497 static bfd_boolean
3498 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3499 {
3500   bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3501   struct mach_o_version_min_command_external raw;
3502   unsigned int ver;
3503
3504   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3505       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3506     return FALSE;
3507
3508   ver = bfd_get_32 (abfd, raw.version);
3509   cmd->rel = ver >> 16;
3510   cmd->maj = ver >> 8;
3511   cmd->min = ver;
3512   cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3513   return TRUE;
3514 }
3515
3516 static bfd_boolean
3517 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3518 {
3519   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3520   struct mach_o_encryption_info_command_external raw;
3521
3522   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3523       || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3524     return FALSE;
3525
3526   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3527   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3528   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3529   return TRUE;
3530 }
3531
3532 static int
3533 bfd_mach_o_read_segment (bfd *abfd,
3534                          bfd_mach_o_load_command *command,
3535                          unsigned int wide)
3536 {
3537   bfd_mach_o_segment_command *seg = &command->command.segment;
3538   unsigned long i;
3539
3540   if (wide)
3541     {
3542       struct mach_o_segment_command_64_external raw;
3543
3544       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3545
3546       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3547           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3548         return -1;
3549
3550       memcpy (seg->segname, raw.segname, 16);
3551       seg->segname[16] = '\0';
3552
3553       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3554       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3555       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3556       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3557       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3558       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3559       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3560       seg->flags = bfd_h_get_32 (abfd, raw.flags);
3561     }
3562   else
3563     {
3564       struct mach_o_segment_command_32_external raw;
3565
3566       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3567
3568       if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3569           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3570         return -1;
3571
3572       memcpy (seg->segname, raw.segname, 16);
3573       seg->segname[16] = '\0';
3574
3575       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3576       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3577       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3578       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3579       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3580       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3581       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3582       seg->flags = bfd_h_get_32 (abfd, raw.flags);
3583     }
3584   seg->sect_head = NULL;
3585   seg->sect_tail = NULL;
3586
3587   for (i = 0; i < seg->nsects; i++)
3588     {
3589       bfd_vma segoff;
3590       asection *sec;
3591
3592       if (wide)
3593         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3594           + (i * BFD_MACH_O_SECTION_64_SIZE);
3595       else
3596         segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3597           + (i * BFD_MACH_O_SECTION_SIZE);
3598
3599       sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3600       if (sec == NULL)
3601         return -1;
3602
3603       bfd_mach_o_append_section_to_segment (seg, sec);
3604     }
3605
3606   return 0;
3607 }
3608
3609 static int
3610 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3611 {
3612   return bfd_mach_o_read_segment (abfd, command, 0);
3613 }
3614
3615 static int
3616 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3617 {
3618   return bfd_mach_o_read_segment (abfd, command, 1);
3619 }
3620
3621 static int
3622 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3623 {
3624   struct mach_o_load_command_external raw;
3625   unsigned int cmd;
3626
3627   /* Read command type and length.  */
3628   if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3629       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3630     return -1;
3631
3632   cmd = bfd_h_get_32 (abfd, raw.cmd);
3633   command->type =  cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3634   command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3635   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3636
3637   switch (command->type)
3638     {
3639     case BFD_MACH_O_LC_SEGMENT:
3640       if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3641         return -1;
3642       break;
3643     case BFD_MACH_O_LC_SEGMENT_64:
3644       if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3645         return -1;
3646       break;
3647     case BFD_MACH_O_LC_SYMTAB:
3648       if (bfd_mach_o_read_symtab (abfd, command) != 0)
3649         return -1;
3650       break;
3651     case BFD_MACH_O_LC_SYMSEG:
3652       break;
3653     case BFD_MACH_O_LC_THREAD:
3654     case BFD_MACH_O_LC_UNIXTHREAD:
3655       if (bfd_mach_o_read_thread (abfd, command) != 0)
3656         return -1;
3657       break;
3658     case BFD_MACH_O_LC_LOAD_DYLINKER:
3659     case BFD_MACH_O_LC_ID_DYLINKER:
3660       if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3661         return -1;
3662       break;
3663     case BFD_MACH_O_LC_LOAD_DYLIB:
3664     case BFD_MACH_O_LC_ID_DYLIB:
3665     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3666     case BFD_MACH_O_LC_REEXPORT_DYLIB:
3667     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3668       if (bfd_mach_o_read_dylib (abfd, command) != 0)
3669         return -1;
3670       break;
3671     case BFD_MACH_O_LC_PREBOUND_DYLIB:
3672       if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3673         return -1;
3674       break;
3675     case BFD_MACH_O_LC_LOADFVMLIB:
3676     case BFD_MACH_O_LC_IDFVMLIB:
3677       if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3678         return -1;
3679       break;
3680     case BFD_MACH_O_LC_IDENT:
3681     case BFD_MACH_O_LC_FVMFILE:
3682     case BFD_MACH_O_LC_PREPAGE:
3683     case BFD_MACH_O_LC_ROUTINES:
3684     case BFD_MACH_O_LC_ROUTINES_64:
3685       break;
3686     case BFD_MACH_O_LC_SUB_FRAMEWORK:
3687     case BFD_MACH_O_LC_SUB_UMBRELLA:
3688     case BFD_MACH_O_LC_SUB_LIBRARY:
3689     case BFD_MACH_O_LC_SUB_CLIENT:
3690     case BFD_MACH_O_LC_RPATH:
3691       if (bfd_mach_o_read_str (abfd, command) != 0)
3692         return -1;
3693       break;
3694     case BFD_MACH_O_LC_DYSYMTAB:
3695       if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3696         return -1;
3697       break;
3698     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3699     case BFD_MACH_O_LC_PREBIND_CKSUM:
3700       break;
3701     case BFD_MACH_O_LC_UUID:
3702       if (bfd_mach_o_read_uuid (abfd, command) != 0)
3703         return -1;
3704       break;
3705     case BFD_MACH_O_LC_CODE_SIGNATURE:
3706     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3707     case BFD_MACH_O_LC_FUNCTION_STARTS:
3708       if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3709         return -1;
3710       break;
3711     case BFD_MACH_O_LC_ENCRYPTION_INFO:
3712       if (!bfd_mach_o_read_encryption_info (abfd, command))
3713         return -1;
3714       break;
3715     case BFD_MACH_O_LC_DYLD_INFO:
3716       if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3717         return -1;
3718       break;
3719     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3720     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3721       if (!bfd_mach_o_read_version_min (abfd, command))
3722         return -1;
3723       break;
3724     default:
3725       (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3726          abfd, (unsigned long) command->type);
3727       break;
3728     }
3729
3730   return 0;
3731 }
3732
3733 static void
3734 bfd_mach_o_flatten_sections (bfd *abfd)
3735 {
3736   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3737   long csect = 0;
3738   unsigned long i;
3739
3740   /* Count total number of sections.  */
3741   mdata->nsects = 0;
3742
3743   for (i = 0; i < mdata->header.ncmds; i++)
3744     {
3745       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3746           || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3747         {
3748           bfd_mach_o_segment_command *seg;
3749
3750           seg = &mdata->commands[i].command.segment;
3751           mdata->nsects += seg->nsects;
3752         }
3753     }
3754
3755   /* Allocate sections array.  */
3756   mdata->sections = bfd_alloc (abfd,
3757                                mdata->nsects * sizeof (bfd_mach_o_section *));
3758
3759   /* Fill the array.  */
3760   csect = 0;
3761
3762   for (i = 0; i < mdata->header.ncmds; i++)
3763     {
3764       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3765           || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3766         {
3767           bfd_mach_o_segment_command *seg;
3768           bfd_mach_o_section *sec;
3769
3770           seg = &mdata->commands[i].command.segment;
3771           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3772
3773           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3774             mdata->sections[csect++] = sec;
3775         }
3776     }
3777 }
3778
3779 static bfd_boolean
3780 bfd_mach_o_scan_start_address (bfd *abfd)
3781 {
3782   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3783   bfd_mach_o_thread_command *cmd = NULL;
3784   unsigned long i;
3785
3786   for (i = 0; i < mdata->header.ncmds; i++)
3787     if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3788         (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3789       {
3790         cmd = &mdata->commands[i].command.thread;
3791         break;
3792       }
3793
3794   if (cmd == NULL)
3795     return FALSE;
3796
3797   /* FIXME: create a subtarget hook ?  */
3798   for (i = 0; i < cmd->nflavours; i++)
3799     {
3800       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
3801           && (cmd->flavours[i].flavour
3802               == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
3803         {
3804           unsigned char buf[4];
3805
3806           if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
3807               || bfd_bread (buf, 4, abfd) != 4)
3808             return FALSE;
3809
3810           abfd->start_address = bfd_h_get_32 (abfd, buf);
3811         }
3812       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
3813                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
3814         {
3815           unsigned char buf[4];
3816
3817           if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3818               || bfd_bread (buf, 4, abfd) != 4)
3819             return FALSE;
3820
3821           abfd->start_address = bfd_h_get_32 (abfd, buf);
3822         }
3823       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
3824                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
3825         {
3826           unsigned char buf[8];
3827
3828           if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3829               || bfd_bread (buf, 8, abfd) != 8)
3830             return FALSE;
3831
3832           abfd->start_address = bfd_h_get_64 (abfd, buf);
3833         }
3834       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
3835                && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
3836         {
3837           unsigned char buf[8];
3838
3839           if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
3840               || bfd_bread (buf, 8, abfd) != 8)
3841             return FALSE;
3842
3843           abfd->start_address = bfd_h_get_64 (abfd, buf);
3844         }
3845     }
3846
3847   return TRUE;
3848 }
3849
3850 bfd_boolean
3851 bfd_mach_o_set_arch_mach (bfd *abfd,
3852                           enum bfd_architecture arch,
3853                           unsigned long machine)
3854 {
3855   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
3856
3857   /* If this isn't the right architecture for this backend, and this
3858      isn't the generic backend, fail.  */
3859   if (arch != bed->arch
3860       && arch != bfd_arch_unknown
3861       && bed->arch != bfd_arch_unknown)
3862     return FALSE;
3863
3864   return bfd_default_set_arch_mach (abfd, arch, machine);
3865 }
3866
3867 static bfd_boolean
3868 bfd_mach_o_scan (bfd *abfd,
3869                  bfd_mach_o_header *header,
3870                  bfd_mach_o_data_struct *mdata)
3871 {
3872   unsigned int i;
3873   enum bfd_architecture cputype;
3874   unsigned long cpusubtype;
3875   unsigned int hdrsize;
3876
3877   hdrsize = mach_o_wide_p (header) ?
3878     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3879
3880   mdata->header = *header;
3881
3882   abfd->flags = abfd->flags & BFD_IN_MEMORY;
3883   switch (header->filetype)
3884     {
3885     case BFD_MACH_O_MH_OBJECT:
3886       abfd->flags |= HAS_RELOC;
3887       break;
3888     case BFD_MACH_O_MH_EXECUTE:
3889       abfd->flags |= EXEC_P;
3890       break;
3891     case BFD_MACH_O_MH_DYLIB:
3892     case BFD_MACH_O_MH_BUNDLE:
3893       abfd->flags |= DYNAMIC;
3894       break;
3895     }
3896
3897   abfd->tdata.mach_o_data = mdata;
3898
3899   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
3900                                    &cputype, &cpusubtype);
3901   if (cputype == bfd_arch_unknown)
3902     {
3903       (*_bfd_error_handler)
3904         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3905          header->cputype, header->cpusubtype);
3906       return FALSE;
3907     }
3908
3909   bfd_set_arch_mach (abfd, cputype, cpusubtype);
3910
3911   if (header->ncmds != 0)
3912     {
3913       mdata->commands = bfd_alloc
3914         (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
3915       if (mdata->commands == NULL)
3916         return FALSE;
3917
3918       for (i = 0; i < header->ncmds; i++)
3919         {
3920           bfd_mach_o_load_command *cur = &mdata->commands[i];
3921
3922           if (i == 0)
3923             cur->offset = hdrsize;
3924           else
3925             {
3926               bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
3927               cur->offset = prev->offset + prev->len;
3928             }
3929
3930           if (bfd_mach_o_read_command (abfd, cur) < 0)
3931             return FALSE;
3932         }
3933     }
3934
3935   if (bfd_mach_o_scan_start_address (abfd) < 0)
3936     return FALSE;
3937
3938   bfd_mach_o_flatten_sections (abfd);
3939   return TRUE;
3940 }
3941
3942 bfd_boolean
3943 bfd_mach_o_mkobject_init (bfd *abfd)
3944 {
3945   bfd_mach_o_data_struct *mdata = NULL;
3946
3947   mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
3948   if (mdata == NULL)
3949     return FALSE;
3950   abfd->tdata.mach_o_data = mdata;
3951
3952   mdata->header.magic = 0;
3953   mdata->header.cputype = 0;
3954   mdata->header.cpusubtype = 0;
3955   mdata->header.filetype = 0;
3956   mdata->header.ncmds = 0;
3957   mdata->header.sizeofcmds = 0;
3958   mdata->header.flags = 0;
3959   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
3960   mdata->commands = NULL;
3961   mdata->nsects = 0;
3962   mdata->sections = NULL;
3963   mdata->dyn_reloc_cache = NULL;
3964
3965   return TRUE;
3966 }
3967
3968 static bfd_boolean
3969 bfd_mach_o_gen_mkobject (bfd *abfd)
3970 {
3971   bfd_mach_o_data_struct *mdata;
3972
3973   if (!bfd_mach_o_mkobject_init (abfd))
3974     return FALSE;
3975
3976   mdata = bfd_mach_o_get_data (abfd);
3977   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
3978   mdata->header.cputype = 0;
3979   mdata->header.cpusubtype = 0;
3980   mdata->header.byteorder = abfd->xvec->byteorder;
3981   mdata->header.version = 1;
3982
3983   return TRUE;
3984 }
3985
3986 const bfd_target *
3987 bfd_mach_o_header_p (bfd *abfd,
3988                      bfd_mach_o_filetype filetype,
3989                      bfd_mach_o_cpu_type cputype)
3990 {
3991   struct bfd_preserve preserve;
3992   bfd_mach_o_header header;
3993
3994   preserve.marker = NULL;
3995   if (!bfd_mach_o_read_header (abfd, &header))
3996     goto wrong;
3997
3998   if (! (header.byteorder == BFD_ENDIAN_BIG
3999          || header.byteorder == BFD_ENDIAN_LITTLE))
4000     {
4001       (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4002                              (unsigned long) header.byteorder);
4003       goto wrong;
4004     }
4005
4006   if (! ((header.byteorder == BFD_ENDIAN_BIG
4007           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4008           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4009          || (header.byteorder == BFD_ENDIAN_LITTLE
4010              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4011              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4012     goto wrong;
4013
4014   /* Check cputype and filetype.
4015      In case of wildcard, do not accept magics that are handled by existing
4016      targets.  */
4017   if (cputype)
4018     {
4019       if (header.cputype != cputype)
4020         goto wrong;
4021     }
4022
4023   if (filetype)
4024     {
4025       if (header.filetype != filetype)
4026         goto wrong;
4027     }
4028   else
4029     {
4030       switch (header.filetype)
4031         {
4032         case BFD_MACH_O_MH_CORE:
4033           /* Handled by core_p */
4034           goto wrong;
4035         default:
4036           break;
4037         }
4038     }
4039
4040   preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4041   if (preserve.marker == NULL
4042       || !bfd_preserve_save (abfd, &preserve))
4043     goto fail;
4044
4045   if (!bfd_mach_o_scan (abfd, &header,
4046                         (bfd_mach_o_data_struct *) preserve.marker))
4047     goto wrong;
4048
4049   bfd_preserve_finish (abfd, &preserve);
4050   return abfd->xvec;
4051
4052  wrong:
4053   bfd_set_error (bfd_error_wrong_format);
4054
4055  fail:
4056   if (preserve.marker != NULL)
4057     bfd_preserve_restore (abfd, &preserve);
4058   return NULL;
4059 }
4060
4061 static const bfd_target *
4062 bfd_mach_o_gen_object_p (bfd *abfd)
4063 {
4064   return bfd_mach_o_header_p (abfd, 0, 0);
4065 }
4066
4067 static const bfd_target *
4068 bfd_mach_o_gen_core_p (bfd *abfd)
4069 {
4070   return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4071 }
4072
4073 typedef struct mach_o_fat_archentry
4074 {
4075   unsigned long cputype;
4076   unsigned long cpusubtype;
4077   unsigned long offset;
4078   unsigned long size;
4079   unsigned long align;
4080 } mach_o_fat_archentry;
4081
4082 typedef struct mach_o_fat_data_struct
4083 {
4084   unsigned long magic;
4085   unsigned long nfat_arch;
4086   mach_o_fat_archentry *archentries;
4087 } mach_o_fat_data_struct;
4088
4089 const bfd_target *
4090 bfd_mach_o_archive_p (bfd *abfd)
4091 {
4092   mach_o_fat_data_struct *adata = NULL;
4093   struct mach_o_fat_header_external hdr;
4094   unsigned long i;
4095
4096   if (bfd_seek (abfd, 0, SEEK_SET) != 0
4097       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4098     goto error;
4099
4100   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4101   if (adata == NULL)
4102     goto error;
4103
4104   adata->magic = bfd_getb32 (hdr.magic);
4105   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4106   if (adata->magic != 0xcafebabe)
4107     goto error;
4108   /* Avoid matching Java bytecode files, which have the same magic number.
4109      In the Java bytecode file format this field contains the JVM version,
4110      which starts at 43.0.  */
4111   if (adata->nfat_arch > 30)
4112     goto error;
4113
4114   adata->archentries =
4115     bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4116   if (adata->archentries == NULL)
4117     goto error;
4118
4119   for (i = 0; i < adata->nfat_arch; i++)
4120     {
4121       struct mach_o_fat_arch_external arch;
4122       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4123         goto error;
4124       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4125       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4126       adata->archentries[i].offset = bfd_getb32 (arch.offset);
4127       adata->archentries[i].size = bfd_getb32 (arch.size);
4128       adata->archentries[i].align = bfd_getb32 (arch.align);
4129     }
4130
4131   abfd->tdata.mach_o_fat_data = adata;
4132   return abfd->xvec;
4133
4134  error:
4135   if (adata != NULL)
4136     bfd_release (abfd, adata);
4137   bfd_set_error (bfd_error_wrong_format);
4138   return NULL;
4139 }
4140
4141 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4142    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4143    Set arelt_data and origin fields too.  */
4144
4145 static void
4146 bfd_mach_o_fat_member_init (bfd *abfd,
4147                             enum bfd_architecture arch_type,
4148                             unsigned long arch_subtype,
4149                             mach_o_fat_archentry *entry)
4150 {
4151   struct areltdata *areltdata;
4152   /* Create the member filename. Use ARCH_NAME.  */
4153   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4154
4155   if (ap)
4156     {
4157       /* Use the architecture name if known.  */
4158       abfd->filename = ap->printable_name;
4159     }
4160   else
4161     {
4162       /* Forge a uniq id.  */
4163       const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4164       char *name = bfd_alloc (abfd, namelen);
4165       snprintf (name, namelen, "0x%lx-0x%lx",
4166                 entry->cputype, entry->cpusubtype);
4167       abfd->filename = name;
4168     }
4169
4170   areltdata = bfd_zalloc (abfd, sizeof (struct areltdata));
4171   areltdata->parsed_size = entry->size;
4172   abfd->arelt_data = areltdata;
4173   abfd->iostream = NULL;
4174   abfd->origin = entry->offset;
4175 }
4176
4177 bfd *
4178 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4179 {
4180   mach_o_fat_data_struct *adata;
4181   mach_o_fat_archentry *entry = NULL;
4182   unsigned long i;
4183   bfd *nbfd;
4184   enum bfd_architecture arch_type;
4185   unsigned long arch_subtype;
4186
4187   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4188   BFD_ASSERT (adata != NULL);
4189
4190   /* Find index of previous entry.  */
4191   if (prev == NULL)
4192     {
4193       /* Start at first one.  */
4194       i = 0;
4195     }
4196   else
4197     {
4198       /* Find index of PREV.  */
4199       for (i = 0; i < adata->nfat_arch; i++)
4200         {
4201           if (adata->archentries[i].offset == prev->origin)
4202             break;
4203         }
4204
4205       if (i == adata->nfat_arch)
4206         {
4207           /* Not found.  */
4208           bfd_set_error (bfd_error_bad_value);
4209           return NULL;
4210         }
4211
4212       /* Get next entry.  */
4213       i++;
4214     }
4215
4216   if (i >= adata->nfat_arch)
4217     {
4218       bfd_set_error (bfd_error_no_more_archived_files);
4219       return NULL;
4220     }
4221
4222   entry = &adata->archentries[i];
4223   nbfd = _bfd_new_bfd_contained_in (archive);
4224   if (nbfd == NULL)
4225     return NULL;
4226
4227   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4228                                    &arch_type, &arch_subtype);
4229
4230   bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4231
4232   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4233
4234   return nbfd;
4235 }
4236
4237 /* Analogous to stat call.  */
4238
4239 static int
4240 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4241 {
4242   if (abfd->arelt_data == NULL)
4243     {
4244       bfd_set_error (bfd_error_invalid_operation);
4245       return -1;
4246     }
4247
4248   buf->st_mtime = 0;
4249   buf->st_uid = 0;
4250   buf->st_gid = 0;
4251   buf->st_mode = 0644;
4252   buf->st_size = arelt_size (abfd);
4253
4254   return 0;
4255 }
4256
4257 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4258    If ABFD is a fat image containing a member that corresponds to FORMAT
4259    and ARCH, returns it.
4260    In other case, returns NULL.
4261    This function allows transparent uses of fat images.  */
4262
4263 bfd *
4264 bfd_mach_o_fat_extract (bfd *abfd,
4265                         bfd_format format,
4266                         const bfd_arch_info_type *arch)
4267 {
4268   bfd *res;
4269   mach_o_fat_data_struct *adata;
4270   unsigned int i;
4271
4272   if (bfd_check_format (abfd, format))
4273     {
4274       if (bfd_get_arch_info (abfd) == arch)
4275         return abfd;
4276       return NULL;
4277     }
4278   if (!bfd_check_format (abfd, bfd_archive)
4279       || abfd->xvec != &mach_o_fat_vec)
4280     return NULL;
4281
4282   /* This is a Mach-O fat image.  */
4283   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4284   BFD_ASSERT (adata != NULL);
4285
4286   for (i = 0; i < adata->nfat_arch; i++)
4287     {
4288       struct mach_o_fat_archentry *e = &adata->archentries[i];
4289       enum bfd_architecture cpu_type;
4290       unsigned long cpu_subtype;
4291
4292       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4293                                        &cpu_type, &cpu_subtype);
4294       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4295         continue;
4296
4297       /* The architecture is found.  */
4298       res = _bfd_new_bfd_contained_in (abfd);
4299       if (res == NULL)
4300         return NULL;
4301
4302       bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4303
4304       if (bfd_check_format (res, format))
4305         {
4306           BFD_ASSERT (bfd_get_arch_info (res) == arch);
4307           return res;
4308         }
4309       bfd_close (res);
4310       return NULL;
4311     }
4312
4313   return NULL;
4314 }
4315
4316 int
4317 bfd_mach_o_lookup_command (bfd *abfd,
4318                            bfd_mach_o_load_command_type type,
4319                            bfd_mach_o_load_command **mcommand)
4320 {
4321   struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4322   bfd_mach_o_load_command *ncmd = NULL;
4323   unsigned int i, num;
4324
4325   BFD_ASSERT (md != NULL);
4326   BFD_ASSERT (mcommand != NULL);
4327
4328   num = 0;
4329   for (i = 0; i < md->header.ncmds; i++)
4330     {
4331       struct bfd_mach_o_load_command *cmd = &md->commands[i];
4332
4333       if (cmd->type != type)
4334         continue;
4335
4336       if (num == 0)
4337         ncmd = cmd;
4338       num++;
4339     }
4340
4341   *mcommand = ncmd;
4342   return num;
4343 }
4344
4345 unsigned long
4346 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4347 {
4348   switch (type)
4349     {
4350     case BFD_MACH_O_CPU_TYPE_MC680x0:
4351       return 0x04000000;
4352     case BFD_MACH_O_CPU_TYPE_MC88000:
4353       return 0xffffe000;
4354     case BFD_MACH_O_CPU_TYPE_POWERPC:
4355       return 0xc0000000;
4356     case BFD_MACH_O_CPU_TYPE_I386:
4357       return 0xc0000000;
4358     case BFD_MACH_O_CPU_TYPE_SPARC:
4359       return 0xf0000000;
4360     case BFD_MACH_O_CPU_TYPE_I860:
4361       return 0;
4362     case BFD_MACH_O_CPU_TYPE_HPPA:
4363       return 0xc0000000 - 0x04000000;
4364     default:
4365       return 0;
4366     }
4367 }
4368
4369 /* The following two tables should be kept, as far as possible, in order of
4370    most frequently used entries to optimize their use from gas.  */
4371
4372 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4373 {
4374   { "regular", BFD_MACH_O_S_REGULAR},
4375   { "coalesced", BFD_MACH_O_S_COALESCED},
4376   { "zerofill", BFD_MACH_O_S_ZEROFILL},
4377   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4378   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4379   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4380   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4381   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4382   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4383   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4384   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4385   { "interposing", BFD_MACH_O_S_INTERPOSING},
4386   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4387   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4388   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4389   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4390   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4391   { NULL, 0}
4392 };
4393
4394 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4395 {
4396   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4397   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4398   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4399   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4400   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4401   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4402   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4403   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4404   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4405   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4406   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4407   { NULL, 0}
4408 };
4409
4410 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
4411
4412 unsigned int
4413 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4414 {
4415   const bfd_mach_o_xlat_name *x;
4416   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4417
4418   for (x = bfd_mach_o_section_type_name; x->name; x++)
4419     if (strcmp (x->name, name) == 0)
4420       {
4421         /* We found it... does the target support it?  */
4422         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4423             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4424           return x->val; /* OK.  */
4425         else
4426           break; /* Not supported.  */
4427       }
4428   /* Maximum section ID = 0xff.  */
4429   return 256;
4430 }
4431
4432 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
4433
4434 unsigned int
4435 bfd_mach_o_get_section_attribute_from_name (const char *name)
4436 {
4437   const bfd_mach_o_xlat_name *x;
4438
4439   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4440     if (strcmp (x->name, name) == 0)
4441       return x->val;
4442   return (unsigned int)-1;
4443 }
4444
4445 int
4446 bfd_mach_o_core_fetch_environment (bfd *abfd,
4447                                    unsigned char **rbuf,
4448                                    unsigned int *rlen)
4449 {
4450   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4451   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4452   unsigned int i = 0;
4453
4454   for (i = 0; i < mdata->header.ncmds; i++)
4455     {
4456       bfd_mach_o_load_command *cur = &mdata->commands[i];
4457       bfd_mach_o_segment_command *seg = NULL;
4458
4459       if (cur->type != BFD_MACH_O_LC_SEGMENT)
4460         continue;
4461
4462       seg = &cur->command.segment;
4463
4464       if ((seg->vmaddr + seg->vmsize) == stackaddr)
4465         {
4466           unsigned long start = seg->fileoff;
4467           unsigned long end = seg->fileoff + seg->filesize;
4468           unsigned char *buf = bfd_malloc (1024);
4469           unsigned long size = 1024;
4470
4471           for (;;)
4472             {
4473               bfd_size_type nread = 0;
4474               unsigned long offset;
4475               int found_nonnull = 0;
4476
4477               if (size > (end - start))
4478                 size = (end - start);
4479
4480               buf = bfd_realloc_or_free (buf, size);
4481               if (buf == NULL)
4482                 return -1;
4483
4484               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4485                 {
4486                   free (buf);
4487                   return -1;
4488                 }
4489
4490               nread = bfd_bread (buf, size, abfd);
4491
4492               if (nread != size)
4493                 {
4494                   free (buf);
4495                   return -1;
4496                 }
4497
4498               for (offset = 4; offset <= size; offset += 4)
4499                 {
4500                   unsigned long val;
4501
4502                   val = *((unsigned long *) (buf + size - offset));
4503                   if (! found_nonnull)
4504                     {
4505                       if (val != 0)
4506                         found_nonnull = 1;
4507                     }
4508                   else if (val == 0x0)
4509                     {
4510                       unsigned long bottom;
4511                       unsigned long top;
4512
4513                       bottom = seg->fileoff + seg->filesize - offset;
4514                       top = seg->fileoff + seg->filesize - 4;
4515                       *rbuf = bfd_malloc (top - bottom);
4516                       *rlen = top - bottom;
4517
4518                       memcpy (*rbuf, buf + size - *rlen, *rlen);
4519                       free (buf);
4520                       return 0;
4521                     }
4522                 }
4523
4524               if (size == (end - start))
4525                 break;
4526
4527               size *= 2;
4528             }
4529
4530           free (buf);
4531         }
4532     }
4533
4534   return -1;
4535 }
4536
4537 char *
4538 bfd_mach_o_core_file_failing_command (bfd *abfd)
4539 {
4540   unsigned char *buf = NULL;
4541   unsigned int len = 0;
4542   int ret = -1;
4543
4544   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4545   if (ret < 0)
4546     return NULL;
4547
4548   return (char *) buf;
4549 }
4550
4551 int
4552 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4553 {
4554   return 0;
4555 }
4556
4557 static bfd_mach_o_uuid_command *
4558 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4559 {
4560   bfd_mach_o_load_command *uuid_cmd;
4561   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4562   if (ncmd != 1)
4563     return FALSE;
4564   return &uuid_cmd->command.uuid;
4565 }
4566
4567 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4568
4569 static bfd_boolean
4570 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4571 {
4572   bfd_mach_o_uuid_command *dsym_uuid_cmd;
4573
4574   BFD_ASSERT (abfd);
4575   BFD_ASSERT (uuid_cmd);
4576
4577   if (!bfd_check_format (abfd, bfd_object))
4578     return FALSE;
4579
4580   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4581       || bfd_mach_o_get_data (abfd) == NULL
4582       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4583     return FALSE;
4584
4585   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4586   if (dsym_uuid_cmd == NULL)
4587     return FALSE;
4588
4589   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4590               sizeof (uuid_cmd->uuid)) != 0)
4591     return FALSE;
4592
4593   return TRUE;
4594 }
4595
4596 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4597    The caller is responsible for closing the returned BFD object and
4598    its my_archive if the returned BFD is in a fat dSYM. */
4599
4600 static bfd *
4601 bfd_mach_o_find_dsym (const char *dsym_filename,
4602                       const bfd_mach_o_uuid_command *uuid_cmd,
4603                       const bfd_arch_info_type *arch)
4604 {
4605   bfd *base_dsym_bfd, *dsym_bfd;
4606
4607   BFD_ASSERT (uuid_cmd);
4608
4609   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4610   if (base_dsym_bfd == NULL)
4611     return NULL;
4612
4613   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4614   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4615     return dsym_bfd;
4616
4617   bfd_close (dsym_bfd);
4618   if (base_dsym_bfd != dsym_bfd)
4619     bfd_close (base_dsym_bfd);
4620
4621   return NULL;
4622 }
4623
4624 /* Return a BFD created from a dSYM file for ABFD.
4625    The caller is responsible for closing the returned BFD object, its
4626    filename, and its my_archive if the returned BFD is in a fat dSYM. */
4627
4628 static bfd *
4629 bfd_mach_o_follow_dsym (bfd *abfd)
4630 {
4631   char *dsym_filename;
4632   bfd_mach_o_uuid_command *uuid_cmd;
4633   bfd *dsym_bfd, *base_bfd = abfd;
4634   const char *base_basename;
4635
4636   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4637     return NULL;
4638
4639   if (abfd->my_archive)
4640     base_bfd = abfd->my_archive;
4641   /* BFD may have been opened from a stream. */
4642   if (base_bfd->filename == NULL)
4643     {
4644       bfd_set_error (bfd_error_invalid_operation);
4645       return NULL;
4646     }
4647   base_basename = lbasename (base_bfd->filename);
4648
4649   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4650   if (uuid_cmd == NULL)
4651     return NULL;
4652
4653   /* TODO: We assume the DWARF file has the same as the binary's.
4654      It seems apple's GDB checks all files in the dSYM bundle directory.
4655      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4656   */
4657   dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4658                                        + strlen (dsym_subdir) + 1
4659                                        + strlen (base_basename) + 1);
4660   sprintf (dsym_filename, "%s%s/%s",
4661            base_bfd->filename, dsym_subdir, base_basename);
4662
4663   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4664                                    bfd_get_arch_info (abfd));
4665   if (dsym_bfd == NULL)
4666     free (dsym_filename);
4667
4668   return dsym_bfd;
4669 }
4670
4671 bfd_boolean
4672 bfd_mach_o_find_nearest_line (bfd *abfd,
4673                               asection *section,
4674                               asymbol **symbols,
4675                               bfd_vma offset,
4676                               const char **filename_ptr,
4677                               const char **functionname_ptr,
4678                               unsigned int *line_ptr)
4679 {
4680   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4681   if (mdata == NULL)
4682     return FALSE;
4683   switch (mdata->header.filetype)
4684     {
4685     case BFD_MACH_O_MH_OBJECT:
4686       break;
4687     case BFD_MACH_O_MH_EXECUTE:
4688     case BFD_MACH_O_MH_DYLIB:
4689     case BFD_MACH_O_MH_BUNDLE:
4690     case BFD_MACH_O_MH_KEXT_BUNDLE:
4691       if (mdata->dwarf2_find_line_info == NULL)
4692         {
4693           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4694           /* When we couldn't find dSYM for this binary, we look for
4695              the debug information in the binary itself. In this way,
4696              we won't try finding separated dSYM again because
4697              mdata->dwarf2_find_line_info will be filled. */
4698           if (! mdata->dsym_bfd)
4699             break;
4700           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4701                                               dwarf_debug_sections, symbols,
4702                                               &mdata->dwarf2_find_line_info))
4703             return FALSE;
4704         }
4705       break;
4706     default:
4707       return FALSE;
4708     }
4709   if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4710                                      section, symbols, offset,
4711                                      filename_ptr, functionname_ptr,
4712                                      line_ptr, 0,
4713                                      &mdata->dwarf2_find_line_info))
4714     return TRUE;
4715   return FALSE;
4716 }
4717
4718 bfd_boolean
4719 bfd_mach_o_close_and_cleanup (bfd *abfd)
4720 {
4721   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4722   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4723     {
4724       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4725       bfd_mach_o_free_cached_info (abfd);
4726       if (mdata->dsym_bfd != NULL)
4727         {
4728           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4729           char *dsym_filename = (char *)(fat_bfd
4730                                          ? fat_bfd->filename
4731                                          : mdata->dsym_bfd->filename);
4732           bfd_close (mdata->dsym_bfd);
4733           mdata->dsym_bfd = NULL;
4734           if (fat_bfd)
4735             bfd_close (fat_bfd);
4736           free (dsym_filename);
4737         }
4738     }
4739
4740   return _bfd_generic_close_and_cleanup (abfd);
4741 }
4742
4743 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4744 {
4745   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4746   asection *asect;
4747   free (mdata->dyn_reloc_cache);
4748   mdata->dyn_reloc_cache = NULL;
4749   for (asect = abfd->sections; asect != NULL; asect = asect->next)
4750     {
4751       free (asect->relocation);
4752       asect->relocation = NULL;
4753     }
4754
4755   return TRUE;
4756 }
4757
4758 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4759 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4760
4761 #define bfd_mach_o_swap_reloc_in NULL
4762 #define bfd_mach_o_swap_reloc_out NULL
4763 #define bfd_mach_o_print_thread NULL
4764 #define bfd_mach_o_tgt_seg_table NULL
4765 #define bfd_mach_o_section_type_valid_for_tgt NULL
4766
4767 #define TARGET_NAME             mach_o_be_vec
4768 #define TARGET_STRING           "mach-o-be"
4769 #define TARGET_ARCHITECTURE     bfd_arch_unknown
4770 #define TARGET_BIG_ENDIAN       1
4771 #define TARGET_ARCHIVE          0
4772 #define TARGET_PRIORITY         1
4773 #include "mach-o-target.c"
4774
4775 #undef TARGET_NAME
4776 #undef TARGET_STRING
4777 #undef TARGET_ARCHITECTURE
4778 #undef TARGET_BIG_ENDIAN
4779 #undef TARGET_ARCHIVE
4780 #undef TARGET_PRIORITY
4781
4782 #define TARGET_NAME             mach_o_le_vec
4783 #define TARGET_STRING           "mach-o-le"
4784 #define TARGET_ARCHITECTURE     bfd_arch_unknown
4785 #define TARGET_BIG_ENDIAN       0
4786 #define TARGET_ARCHIVE          0
4787 #define TARGET_PRIORITY         1
4788
4789 #include "mach-o-target.c"
4790
4791 #undef TARGET_NAME
4792 #undef TARGET_STRING
4793 #undef TARGET_ARCHITECTURE
4794 #undef TARGET_BIG_ENDIAN
4795 #undef TARGET_ARCHIVE
4796 #undef TARGET_PRIORITY
4797
4798 /* Not yet handled: creating an archive.  */
4799 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
4800
4801 /* Not used.  */
4802 #define bfd_mach_o_read_ar_hdr                    _bfd_noarchive_read_ar_hdr
4803 #define bfd_mach_o_write_ar_hdr                   _bfd_noarchive_write_ar_hdr
4804 #define bfd_mach_o_slurp_armap                    _bfd_noarchive_slurp_armap
4805 #define bfd_mach_o_slurp_extended_name_table      _bfd_noarchive_slurp_extended_name_table
4806 #define bfd_mach_o_construct_extended_name_table  _bfd_noarchive_construct_extended_name_table
4807 #define bfd_mach_o_truncate_arname                _bfd_noarchive_truncate_arname
4808 #define bfd_mach_o_write_armap                    _bfd_noarchive_write_armap
4809 #define bfd_mach_o_get_elt_at_index               _bfd_noarchive_get_elt_at_index
4810 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
4811 #define bfd_mach_o_update_armap_timestamp         _bfd_noarchive_update_armap_timestamp
4812
4813 #define TARGET_NAME             mach_o_fat_vec
4814 #define TARGET_STRING           "mach-o-fat"
4815 #define TARGET_ARCHITECTURE     bfd_arch_unknown
4816 #define TARGET_BIG_ENDIAN       1
4817 #define TARGET_ARCHIVE          1
4818 #define TARGET_PRIORITY         0
4819
4820 #include "mach-o-target.c"
4821
4822 #undef TARGET_NAME
4823 #undef TARGET_STRING
4824 #undef TARGET_ARCHITECTURE
4825 #undef TARGET_BIG_ENDIAN
4826 #undef TARGET_ARCHIVE
4827 #undef TARGET_PRIORITY