bfd/mach-o.c

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