bfd/mach-o.c

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