bfd/mach-o.c

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