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