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