bfd/mach-o.c

   1 /* Mach-O support for BFD.
   2    Copyright (C) 1999-2021 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include <limits.h>
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "libiberty.h"
  26 #include "mach-o.h"
  27 #include "aout/stab_gnu.h"
  28 #include "mach-o/reloc.h"
  29 #include "mach-o/external.h"
  30 #include <ctype.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
  35 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
  36 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
  37
  38 #define FILE_ALIGN(off, algn) \
  39   (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1U << (algn)))
  40
  41 static bool
  42 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd);
  43
  44 unsigned int
  45 bfd_mach_o_version (bfd *abfd)
  46 {
  47   bfd_mach_o_data_struct *mdata = NULL;
  48
  49   BFD_ASSERT (bfd_mach_o_valid (abfd));
  50   mdata = bfd_mach_o_get_data (abfd);
  51
  52   return mdata->header.version;
  53 }
  54
  55 bool
  56 bfd_mach_o_valid (bfd *abfd)
  57 {
  58   if (abfd == NULL || abfd->xvec == NULL)
  59     return false;
  60
  61   if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
  62     return false;
  63
  64   if (bfd_mach_o_get_data (abfd) == NULL)
  65     return false;
  66   return true;
  67 }
  68
  69 static INLINE bool
  70 mach_o_wide_p (bfd_mach_o_header *header)
  71 {
  72   switch (header->version)
  73     {
  74     case 1:
  75       return false;
  76     case 2:
  77       return true;
  78     default:
  79       BFD_FAIL ();
  80       return false;
  81     }
  82 }
  83
  84 static INLINE bool
  85 bfd_mach_o_wide_p (bfd *abfd)
  86 {
  87   return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
  88 }
  89
  90 /* Tables to translate well known Mach-O segment/section names to bfd
  91    names.  Use of canonical names (such as .text or .debug_frame) is required
  92    by gdb.  */
  93
  94 /* __TEXT Segment.  */
  95 static const mach_o_section_name_xlat text_section_names_xlat[] =
  96   {
  97     {   ".text",                                "__text",
  98         SEC_CODE | SEC_LOAD,                    BFD_MACH_O_S_REGULAR,
  99         BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS,    0},
 100     {   ".const",                               "__const",
 101         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_REGULAR,
 102         BFD_MACH_O_S_ATTR_NONE,                 0},
 103     {   ".static_const",                        "__static_const",
 104         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_REGULAR,
 105         BFD_MACH_O_S_ATTR_NONE,                 0},
 106     {   ".cstring",                             "__cstring",
 107         SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
 108                                                 BFD_MACH_O_S_CSTRING_LITERALS,
 109         BFD_MACH_O_S_ATTR_NONE,                 0},
 110     {   ".literal4",                            "__literal4",
 111         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_4BYTE_LITERALS,
 112         BFD_MACH_O_S_ATTR_NONE,                 2},
 113     {   ".literal8",                            "__literal8",
 114         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_8BYTE_LITERALS,
 115         BFD_MACH_O_S_ATTR_NONE,                 3},
 116     {   ".literal16",                           "__literal16",
 117         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_16BYTE_LITERALS,
 118         BFD_MACH_O_S_ATTR_NONE,                 4},
 119     {   ".constructor",                         "__constructor",
 120         SEC_CODE | SEC_LOAD,                    BFD_MACH_O_S_REGULAR,
 121         BFD_MACH_O_S_ATTR_NONE,                 0},
 122     {   ".destructor",                          "__destructor",
 123         SEC_CODE | SEC_LOAD,                    BFD_MACH_O_S_REGULAR,
 124         BFD_MACH_O_S_ATTR_NONE,                 0},
 125     {   ".eh_frame",                            "__eh_frame",
 126         SEC_READONLY | SEC_DATA | SEC_LOAD,     BFD_MACH_O_S_COALESCED,
 127         BFD_MACH_O_S_ATTR_LIVE_SUPPORT
 128         | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
 129         | BFD_MACH_O_S_ATTR_NO_TOC,             2},
 130     { NULL, NULL, 0, 0, 0, 0}
 131   };
 132
 133 /* __DATA Segment.  */
 134 static const mach_o_section_name_xlat data_section_names_xlat[] =
 135   {
 136     {   ".data",                        "__data",
 137         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 138         BFD_MACH_O_S_ATTR_NONE,         0},
 139     {   ".bss",                         "__bss",
 140         SEC_NO_FLAGS,                   BFD_MACH_O_S_ZEROFILL,
 141         BFD_MACH_O_S_ATTR_NONE,         0},
 142     {   ".const_data",                  "__const",
 143         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 144         BFD_MACH_O_S_ATTR_NONE,         0},
 145     {   ".static_data",                 "__static_data",
 146         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 147         BFD_MACH_O_S_ATTR_NONE,         0},
 148     {   ".mod_init_func",               "__mod_init_func",
 149         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
 150         BFD_MACH_O_S_ATTR_NONE,         2},
 151     {   ".mod_term_func",               "__mod_term_func",
 152         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
 153         BFD_MACH_O_S_ATTR_NONE,         2},
 154     {   ".dyld",                        "__dyld",
 155         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 156         BFD_MACH_O_S_ATTR_NONE,         0},
 157     {   ".cfstring",                    "__cfstring",
 158         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 159         BFD_MACH_O_S_ATTR_NONE,         2},
 160     { NULL, NULL, 0, 0, 0, 0}
 161   };
 162
 163 /* __DWARF Segment.  */
 164 static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
 165   {
 166     {   ".debug_frame",                 "__debug_frame",
 167         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 168         BFD_MACH_O_S_ATTR_DEBUG,        0},
 169     {   ".debug_info",                  "__debug_info",
 170         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 171         BFD_MACH_O_S_ATTR_DEBUG,        0},
 172     {   ".debug_abbrev",                "__debug_abbrev",
 173         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 174         BFD_MACH_O_S_ATTR_DEBUG,        0},
 175     {   ".debug_aranges",               "__debug_aranges",
 176         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 177         BFD_MACH_O_S_ATTR_DEBUG,        0},
 178     {   ".debug_macinfo",               "__debug_macinfo",
 179         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 180         BFD_MACH_O_S_ATTR_DEBUG,        0},
 181     {   ".debug_line",                  "__debug_line",
 182         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 183         BFD_MACH_O_S_ATTR_DEBUG,        0},
 184     {   ".debug_loc",                   "__debug_loc",
 185         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 186         BFD_MACH_O_S_ATTR_DEBUG,        0},
 187     {   ".debug_pubnames",              "__debug_pubnames",
 188         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 189         BFD_MACH_O_S_ATTR_DEBUG,        0},
 190     {   ".debug_pubtypes",              "__debug_pubtypes",
 191         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 192         BFD_MACH_O_S_ATTR_DEBUG,        0},
 193     {   ".debug_str",                   "__debug_str",
 194         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 195         BFD_MACH_O_S_ATTR_DEBUG,        0},
 196     {   ".debug_ranges",                "__debug_ranges",
 197         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 198         BFD_MACH_O_S_ATTR_DEBUG,        0},
 199     {   ".debug_macro",                 "__debug_macro",
 200         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 201         BFD_MACH_O_S_ATTR_DEBUG,        0},
 202     {   ".debug_gdb_scripts",           "__debug_gdb_scri",
 203         SEC_DEBUGGING,                  BFD_MACH_O_S_REGULAR,
 204         BFD_MACH_O_S_ATTR_DEBUG,        0},
 205     { NULL, NULL, 0, 0, 0, 0}
 206   };
 207
 208 /* __OBJC Segment.  */
 209 static const mach_o_section_name_xlat objc_section_names_xlat[] =
 210   {
 211     {   ".objc_class",                  "__class",
 212         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 213         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 214     {   ".objc_meta_class",             "__meta_class",
 215         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 216         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 217     {   ".objc_cat_cls_meth",           "__cat_cls_meth",
 218         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 219         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 220     {   ".objc_cat_inst_meth",          "__cat_inst_meth",
 221         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 222         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 223     {   ".objc_protocol",               "__protocol",
 224         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 225         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 226     {   ".objc_string_object",          "__string_object",
 227         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 228         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 229     {   ".objc_cls_meth",               "__cls_meth",
 230         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 231         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 232     {   ".objc_inst_meth",              "__inst_meth",
 233         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 234         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 235     {   ".objc_cls_refs",               "__cls_refs",
 236         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_LITERAL_POINTERS,
 237         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 238     {   ".objc_message_refs",           "__message_refs",
 239         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_LITERAL_POINTERS,
 240         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 241     {   ".objc_symbols",                "__symbols",
 242         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 243         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 244     {   ".objc_category",               "__category",
 245         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 246         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 247     {   ".objc_class_vars",             "__class_vars",
 248         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 249         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 250     {   ".objc_instance_vars",          "__instance_vars",
 251         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 252         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 253     {   ".objc_module_info",            "__module_info",
 254         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 255         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 256     {   ".objc_selector_strs",          "__selector_strs",
 257         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_CSTRING_LITERALS,
 258         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 259     {   ".objc_image_info",             "__image_info",
 260         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 261         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 262     {   ".objc_selector_fixup",         "__sel_fixup",
 263         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 264         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 265     /* Objc V1 */
 266     {   ".objc1_class_ext",             "__class_ext",
 267         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 268         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 269     {   ".objc1_property_list",         "__property",
 270         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 271         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 272     {   ".objc1_protocol_ext",          "__protocol_ext",
 273         SEC_DATA | SEC_LOAD,            BFD_MACH_O_S_REGULAR,
 274         BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
 275     { NULL, NULL, 0, 0, 0, 0}
 276   };
 277
 278 static const mach_o_segment_name_xlat segsec_names_xlat[] =
 279   {
 280     { "__TEXT", text_section_names_xlat },
 281     { "__DATA", data_section_names_xlat },
 282     { "__DWARF", dwarf_section_names_xlat },
 283     { "__OBJC", objc_section_names_xlat },
 284     { NULL, NULL }
 285   };
 286
 287 static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
 288
 289 /* For both cases bfd-name => mach-o name and vice versa, the specific target
 290    is checked before the generic.  This allows a target (e.g. ppc for cstring)
 291    to override the generic definition with a more specific one.  */
 292
 293 /* Fetch the translation from a Mach-O section designation (segment, section)
 294    as a bfd short name, if one exists.  Otherwise return NULL.
 295
 296    Allow the segment and section names to be unterminated 16 byte arrays.  */
 297
 298 const mach_o_section_name_xlat *
 299 bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
 300                                        const char *sectname)
 301 {
 302   const struct mach_o_segment_name_xlat *seg;
 303   const mach_o_section_name_xlat *sec;
 304   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
 305
 306   /* First try any target-specific translations defined...  */
 307   if (bed->segsec_names_xlat)
 308     for (seg = bed->segsec_names_xlat; seg->segname; seg++)
 309       if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
 310         for (sec = seg->sections; sec->mach_o_name; sec++)
 311           if (strncmp (sec->mach_o_name, sectname,
 312                        BFD_MACH_O_SECTNAME_SIZE) == 0)
 313             return sec;
 314
 315   /* ... and then the Mach-O generic ones.  */
 316   for (seg = segsec_names_xlat; seg->segname; seg++)
 317     if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
 318       for (sec = seg->sections; sec->mach_o_name; sec++)
 319         if (strncmp (sec->mach_o_name, sectname,
 320                      BFD_MACH_O_SECTNAME_SIZE) == 0)
 321           return sec;
 322
 323   return NULL;
 324 }
 325
 326 /* If the bfd_name for this section is a 'canonical' form for which we
 327    know the Mach-O data, return the segment name and the data for the
 328    Mach-O equivalent.  Otherwise return NULL.  */
 329
 330 const mach_o_section_name_xlat *
 331 bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
 332                                       const char **segname)
 333 {
 334   const struct mach_o_segment_name_xlat *seg;
 335   const mach_o_section_name_xlat *sec;
 336   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
 337   *segname = NULL;
 338
 339   if (bfd_name[0] != '.')
 340     return NULL;
 341
 342   /* First try any target-specific translations defined...  */
 343   if (bed->segsec_names_xlat)
 344     for (seg = bed->segsec_names_xlat; seg->segname; seg++)
 345       for (sec = seg->sections; sec->bfd_name; sec++)
 346         if (strcmp (bfd_name, sec->bfd_name) == 0)
 347           {
 348             *segname = seg->segname;
 349             return sec;
 350           }
 351
 352   /* ... and then the Mach-O generic ones.  */
 353   for (seg = segsec_names_xlat; seg->segname; seg++)
 354     for (sec = seg->sections; sec->bfd_name; sec++)
 355       if (strcmp (bfd_name, sec->bfd_name) == 0)
 356         {
 357           *segname = seg->segname;
 358           return sec;
 359         }
 360
 361   return NULL;
 362 }
 363
 364 /* Convert Mach-O section name to BFD.
 365
 366    Try to use standard/canonical names, for which we have tables including
 367    default flag settings - which are returned.  Otherwise forge a new name
 368    in the form "<segmentname>.<sectionname>" this will be prefixed with
 369    LC_SEGMENT. if the segment name does not begin with an underscore.
 370
 371    SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
 372    terminated if the name length is exactly 16 bytes - but must be if the name
 373    length is less than 16 characters).  */
 374
 375 void
 376 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
 377                                         const char *secname, const char **name,
 378                                         flagword *flags)
 379 {
 380   const mach_o_section_name_xlat *xlat;
 381   char *res;
 382   unsigned int len;
 383   const char *pfx = "";
 384
 385   *name = NULL;
 386   *flags = SEC_NO_FLAGS;
 387
 388   /* First search for a canonical name...
 389      xlat will be non-null if there is an entry for segname, secname.  */
 390   xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
 391   if (xlat)
 392     {
 393       len = strlen (xlat->bfd_name);
 394       res = bfd_alloc (abfd, len + 1);
 395       if (res == NULL)
 396         return;
 397       memcpy (res, xlat->bfd_name, len+1);
 398       *name = res;
 399       *flags = xlat->bfd_flags;
 400       return;
 401     }
 402
 403   /* ... else we make up a bfd name from the segment concatenated with the
 404      section.  */
 405
 406   len = 16 + 1 + 16 + 1;
 407
 408   /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
 409      with an underscore.  */
 410   if (segname[0] != '_')
 411     {
 412       static const char seg_pfx[] = "LC_SEGMENT.";
 413
 414       pfx = seg_pfx;
 415       len += sizeof (seg_pfx) - 1;
 416     }
 417
 418   res = bfd_alloc (abfd, len);
 419   if (res == NULL)
 420     return;
 421   snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
 422   *name = res;
 423 }
 424
 425 /* Convert a bfd section name to a Mach-O segment + section name.
 426
 427    If the name is a canonical one for which we have a Darwin match
 428    return the translation table - which contains defaults for flags,
 429    type, attribute and default alignment data.
 430
 431    Otherwise, expand the bfd_name (assumed to be in the form
 432    "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL.  */
 433
 434 static const mach_o_section_name_xlat *
 435 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
 436                                            asection *sect,
 437                                            bfd_mach_o_section *section)
 438 {
 439   const mach_o_section_name_xlat *xlat;
 440   const char *name = bfd_section_name (sect);
 441   const char *segname;
 442   const char *dot;
 443   unsigned int len;
 444   unsigned int seglen;
 445   unsigned int seclen;
 446
 447   memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
 448   memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
 449
 450   /* See if is a canonical name ... */
 451   xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
 452   if (xlat)
 453     {
 454       strcpy (section->segname, segname);
 455       strcpy (section->sectname, xlat->mach_o_name);
 456       return xlat;
 457     }
 458
 459   /* .. else we convert our constructed one back to Mach-O.
 460      Strip LC_SEGMENT. prefix, if present.  */
 461   if (strncmp (name, "LC_SEGMENT.", 11) == 0)
 462     name += 11;
 463
 464   /* Find a dot.  */
 465   dot = strchr (name, '.');
 466   len = strlen (name);
 467
 468   /* Try to split name into segment and section names.  */
 469   if (dot && dot != name)
 470     {
 471       seglen = dot - name;
 472       seclen = len - (dot + 1 - name);
 473
 474       if (seglen <= BFD_MACH_O_SEGNAME_SIZE
 475           && seclen <= BFD_MACH_O_SECTNAME_SIZE)
 476         {
 477           memcpy (section->segname, name, seglen);
 478           section->segname[seglen] = 0;
 479           memcpy (section->sectname, dot + 1, seclen);
 480           section->sectname[seclen] = 0;
 481           return NULL;
 482         }
 483     }
 484
 485   /* The segment and section names are both missing - don't make them
 486      into dots.  */
 487   if (dot && dot == name)
 488     return NULL;
 489
 490   /* Just duplicate the name into both segment and section.  */
 491   if (len > 16)
 492     len = 16;
 493   memcpy (section->segname, name, len);
 494   section->segname[len] = 0;
 495   memcpy (section->sectname, name, len);
 496   section->sectname[len] = 0;
 497   return NULL;
 498 }
 499
 500 /* Return the size of an entry for section SEC.
 501    Must be called only for symbol pointer section and symbol stubs
 502    sections.  */
 503
 504 unsigned int
 505 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
 506 {
 507   switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 508     {
 509     case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 510     case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 511       return bfd_mach_o_wide_p (abfd) ? 8 : 4;
 512     case BFD_MACH_O_S_SYMBOL_STUBS:
 513       return sec->reserved2;
 514     default:
 515       BFD_FAIL ();
 516       return 0;
 517     }
 518 }
 519
 520 /* Return the number of indirect symbols for a section.
 521    Must be called only for symbol pointer section and symbol stubs
 522    sections.  */
 523
 524 unsigned int
 525 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
 526 {
 527   unsigned int elsz;
 528
 529   elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
 530   if (elsz == 0)
 531     return 0;
 532   else
 533     return sec->size / elsz;
 534 }
 535
 536 /* Append command CMD to ABFD.  Note that header.ncmds is not updated.  */
 537
 538 static void
 539 bfd_mach_o_append_command (bfd *abfd, bfd_mach_o_load_command *cmd)
 540 {
 541   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 542
 543   if (mdata->last_command != NULL)
 544     mdata->last_command->next = cmd;
 545   else
 546     mdata->first_command = cmd;
 547   mdata->last_command = cmd;
 548   cmd->next = NULL;
 549 }
 550
 551 /* Copy any private info we understand from the input symbol
 552    to the output symbol.  */
 553
 554 bool
 555 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 556                                          asymbol *isymbol,
 557                                          bfd *obfd ATTRIBUTE_UNUSED,
 558                                          asymbol *osymbol)
 559 {
 560   bfd_mach_o_asymbol *os, *is;
 561
 562   os = (bfd_mach_o_asymbol *)osymbol;
 563   is = (bfd_mach_o_asymbol *)isymbol;
 564   os->n_type = is->n_type;
 565   os->n_sect = is->n_sect;
 566   os->n_desc = is->n_desc;
 567   os->symbol.udata.i = is->symbol.udata.i;
 568
 569   return true;
 570 }
 571
 572 /* Copy any private info we understand from the input section
 573    to the output section.  */
 574
 575 bool
 576 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd, asection *isection,
 577                                           bfd *obfd, asection *osection)
 578 {
 579   bfd_mach_o_section *os = bfd_mach_o_get_mach_o_section (osection);
 580   bfd_mach_o_section *is = bfd_mach_o_get_mach_o_section (isection);
 581
 582   if (ibfd->xvec->flavour != bfd_target_mach_o_flavour
 583       || obfd->xvec->flavour != bfd_target_mach_o_flavour)
 584     return true;
 585
 586   BFD_ASSERT (is != NULL && os != NULL);
 587
 588   os->flags = is->flags;
 589   os->reserved1 = is->reserved1;
 590   os->reserved2 = is->reserved2;
 591   os->reserved3 = is->reserved3;
 592
 593   return true;
 594 }
 595
 596 static const char *
 597 cputype (unsigned long value)
 598 {
 599   switch (value)
 600     {
 601     case BFD_MACH_O_CPU_TYPE_VAX: return "VAX";
 602     case BFD_MACH_O_CPU_TYPE_MC680x0: return "MC68k";
 603     case BFD_MACH_O_CPU_TYPE_I386: return "I386";
 604     case BFD_MACH_O_CPU_TYPE_MIPS: return "MIPS";
 605     case BFD_MACH_O_CPU_TYPE_MC98000: return "MC98k";
 606     case BFD_MACH_O_CPU_TYPE_HPPA: return "HPPA";
 607     case BFD_MACH_O_CPU_TYPE_ARM: return "ARM";
 608     case BFD_MACH_O_CPU_TYPE_MC88000: return "MC88K";
 609     case BFD_MACH_O_CPU_TYPE_SPARC: return "SPARC";
 610     case BFD_MACH_O_CPU_TYPE_I860: return "I860";
 611     case BFD_MACH_O_CPU_TYPE_ALPHA: return "ALPHA";
 612     case BFD_MACH_O_CPU_TYPE_POWERPC: return "PPC";
 613     case BFD_MACH_O_CPU_TYPE_POWERPC_64: return "PPC64";
 614     case BFD_MACH_O_CPU_TYPE_X86_64: return "X86_64";
 615     case BFD_MACH_O_CPU_TYPE_ARM64: return "ARM64";
 616     default: return _("<unknown>");
 617     }
 618 }
 619
 620 static const char *
 621 cpusubtype (unsigned long cpu_type, unsigned long cpu_subtype, char *buffer)
 622 {
 623   buffer[0] = 0;
 624   switch (cpu_subtype & BFD_MACH_O_CPU_SUBTYPE_MASK)
 625     {
 626     case 0:
 627       break;
 628     case BFD_MACH_O_CPU_SUBTYPE_LIB64:
 629       sprintf (buffer, " (LIB64)"); break;
 630     default:
 631       sprintf (buffer, _("<unknown mask flags>")); break;
 632     }
 633
 634   cpu_subtype &= ~ BFD_MACH_O_CPU_SUBTYPE_MASK;
 635
 636   switch (cpu_type)
 637     {
 638     case BFD_MACH_O_CPU_TYPE_X86_64:
 639     case BFD_MACH_O_CPU_TYPE_I386:
 640       switch (cpu_subtype)
 641         {
 642         case BFD_MACH_O_CPU_SUBTYPE_X86_ALL:
 643           return strcat (buffer, " (X86_ALL)");
 644         default:
 645           break;
 646         }
 647       break;
 648
 649     case BFD_MACH_O_CPU_TYPE_ARM:
 650       switch (cpu_subtype)
 651         {
 652         case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
 653           return strcat (buffer, " (ARM_ALL)");
 654         case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
 655           return strcat (buffer, " (ARM_V4T)");
 656         case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
 657           return strcat (buffer, " (ARM_V6)");
 658         case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
 659           return strcat (buffer, " (ARM_V5TEJ)");
 660         case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
 661           return strcat (buffer, " (ARM_XSCALE)");
 662         case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
 663           return strcat (buffer, " (ARM_V7)");
 664         default:
 665           break;
 666         }
 667       break;
 668
 669     case BFD_MACH_O_CPU_TYPE_ARM64:
 670       switch (cpu_subtype)
 671         {
 672         case BFD_MACH_O_CPU_SUBTYPE_ARM64_ALL:
 673           return strcat (buffer, " (ARM64_ALL)");
 674         case BFD_MACH_O_CPU_SUBTYPE_ARM64_V8:
 675           return strcat (buffer, " (ARM64_V8)");
 676         default:
 677           break;
 678         }
 679       break;
 680
 681     default:
 682       break;
 683     }
 684
 685   if (cpu_subtype != 0)
 686     return strcat (buffer, _(" (<unknown>)"));
 687
 688   return buffer;
 689 }
 690
 691 bool
 692 bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
 693 {
 694   FILE * file = (FILE *) ptr;
 695   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 696   char buff[128];
 697
 698   fprintf (file, _(" MACH-O header:\n"));
 699   fprintf (file, _("   magic:      %#lx\n"), (long) mdata->header.magic);
 700   fprintf (file, _("   cputype:    %#lx (%s)\n"), (long) mdata->header.cputype,
 701            cputype (mdata->header.cputype));
 702   fprintf (file, _("   cpusubtype: %#lx%s\n"), (long) mdata->header.cpusubtype,
 703            cpusubtype (mdata->header.cputype, mdata->header.cpusubtype, buff));
 704   fprintf (file, _("   filetype:   %#lx\n"), (long) mdata->header.filetype);
 705   fprintf (file, _("   ncmds:      %#lx\n"), (long) mdata->header.ncmds);
 706   fprintf (file, _("   sizeocmds:  %#lx\n"), (long) mdata->header.sizeofcmds);
 707   fprintf (file, _("   flags:      %#lx\n"), (long) mdata->header.flags);
 708   fprintf (file, _("   version:    %x\n"), mdata->header.version);
 709
 710   return true;
 711 }
 712
 713 /* Copy any private info we understand from the input bfd
 714    to the output bfd.  */
 715
 716 bool
 717 bfd_mach_o_bfd_copy_private_header_data (bfd *ibfd, bfd *obfd)
 718 {
 719   bfd_mach_o_data_struct *imdata;
 720   bfd_mach_o_data_struct *omdata;
 721   bfd_mach_o_load_command *icmd;
 722
 723   if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
 724       || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
 725     return true;
 726
 727   BFD_ASSERT (bfd_mach_o_valid (ibfd));
 728   BFD_ASSERT (bfd_mach_o_valid (obfd));
 729
 730   imdata = bfd_mach_o_get_data (ibfd);
 731   omdata = bfd_mach_o_get_data (obfd);
 732
 733   /* Copy header flags.  */
 734   omdata->header.flags = imdata->header.flags;
 735
 736   /* PR 23299.  Copy the cputype.  */
 737   if (imdata->header.cputype != omdata->header.cputype)
 738     {
 739       if (omdata->header.cputype == 0)
 740         omdata->header.cputype = imdata->header.cputype;
 741       else if (imdata->header.cputype != 0)
 742         /* Urg - what has happened ?  */
 743         _bfd_error_handler (_("incompatible cputypes in mach-o files: %ld vs %ld"),
 744                             (long) imdata->header.cputype,
 745                             (long) omdata->header.cputype);
 746     }
 747
 748   /* Copy the cpusubtype.  */
 749   omdata->header.cpusubtype = imdata->header.cpusubtype;
 750
 751   /* Copy commands.  */
 752   for (icmd = imdata->first_command; icmd != NULL; icmd = icmd->next)
 753     {
 754       bfd_mach_o_load_command *ocmd;
 755
 756       switch (icmd->type)
 757         {
 758         case BFD_MACH_O_LC_LOAD_DYLIB:
 759         case BFD_MACH_O_LC_LOAD_DYLINKER:
 760         case BFD_MACH_O_LC_DYLD_INFO:
 761           /* Command is copied.  */
 762           ocmd = bfd_alloc (obfd, sizeof (bfd_mach_o_load_command));
 763           if (ocmd == NULL)
 764             return false;
 765
 766           /* Copy common fields.  */
 767           ocmd->type = icmd->type;
 768           ocmd->type_required = icmd->type_required;
 769           ocmd->offset = 0;
 770           ocmd->len = icmd->len;
 771           break;
 772
 773         default:
 774           /* Command is not copied.  */
 775           continue;
 776           break;
 777         }
 778
 779       switch (icmd->type)
 780         {
 781         case BFD_MACH_O_LC_LOAD_DYLIB:
 782           {
 783             bfd_mach_o_dylib_command *idy = &icmd->command.dylib;
 784             bfd_mach_o_dylib_command *ody = &ocmd->command.dylib;
 785
 786             ody->name_offset = idy->name_offset;
 787             ody->timestamp = idy->timestamp;
 788             ody->current_version = idy->current_version;
 789             ody->compatibility_version = idy->compatibility_version;
 790             ody->name_str = idy->name_str;
 791           }
 792           break;
 793
 794         case BFD_MACH_O_LC_LOAD_DYLINKER:
 795           {
 796             bfd_mach_o_dylinker_command *idy = &icmd->command.dylinker;
 797             bfd_mach_o_dylinker_command *ody = &ocmd->command.dylinker;
 798
 799             ody->name_offset = idy->name_offset;
 800             ody->name_str = idy->name_str;
 801           }
 802           break;
 803
 804         case BFD_MACH_O_LC_DYLD_INFO:
 805           {
 806             bfd_mach_o_dyld_info_command *idy = &icmd->command.dyld_info;
 807             bfd_mach_o_dyld_info_command *ody = &ocmd->command.dyld_info;
 808
 809             if (bfd_mach_o_read_dyld_content (ibfd, idy))
 810               {
 811                 ody->rebase_size = idy->rebase_size;
 812                 ody->rebase_content = idy->rebase_content;
 813
 814                 ody->bind_size = idy->bind_size;
 815                 ody->bind_content = idy->bind_content;
 816
 817                 ody->weak_bind_size = idy->weak_bind_size;
 818                 ody->weak_bind_content = idy->weak_bind_content;
 819
 820                 ody->lazy_bind_size = idy->lazy_bind_size;
 821                 ody->lazy_bind_content = idy->lazy_bind_content;
 822
 823                 ody->export_size = idy->export_size;
 824                 ody->export_content = idy->export_content;
 825               }
 826             /* PR 17512L: file: 730e492d.  */
 827             else
 828               {
 829                 ody->rebase_size =
 830                   ody->bind_size =
 831                   ody->weak_bind_size =
 832                   ody->lazy_bind_size =
 833                   ody->export_size = 0;
 834                 ody->rebase_content =
 835                   ody->bind_content =
 836                   ody->weak_bind_content =
 837                   ody->lazy_bind_content =
 838                   ody->export_content = NULL;
 839               }
 840           }
 841           break;
 842
 843         default:
 844           /* That command should be handled.  */
 845           abort ();
 846         }
 847
 848       /* Insert command.  */
 849       bfd_mach_o_append_command (obfd, ocmd);
 850     }
 851
 852   return true;
 853 }
 854
 855 /* This allows us to set up to 32 bits of flags (unless we invent some
 856    fiendish scheme to subdivide).  For now, we'll just set the file flags
 857    without error checking - just overwrite.  */
 858
 859 bool
 860 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
 861 {
 862   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 863
 864   if (!mdata)
 865     return false;
 866
 867   mdata->header.flags = flags;
 868   return true;
 869 }
 870
 871 /* Count the total number of symbols.  */
 872
 873 static long
 874 bfd_mach_o_count_symbols (bfd *abfd)
 875 {
 876   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 877
 878   if (mdata->symtab == NULL)
 879     return 0;
 880   return mdata->symtab->nsyms;
 881 }
 882
 883 long
 884 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
 885 {
 886   long nsyms = bfd_mach_o_count_symbols (abfd);
 887
 888   return ((nsyms + 1) * sizeof (asymbol *));
 889 }
 890
 891 long
 892 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 893 {
 894   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 895   long nsyms = bfd_mach_o_count_symbols (abfd);
 896   bfd_mach_o_symtab_command *sym = mdata->symtab;
 897   unsigned long j;
 898
 899   if (nsyms < 0)
 900     return nsyms;
 901
 902   if (nsyms == 0)
 903     {
 904       /* Do not try to read symbols if there are none.  */
 905       alocation[0] = NULL;
 906       return 0;
 907     }
 908
 909   if (!bfd_mach_o_read_symtab_symbols (abfd))
 910     {
 911       _bfd_error_handler
 912         (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
 913       return 0;
 914     }
 915
 916   BFD_ASSERT (sym->symbols != NULL);
 917
 918   for (j = 0; j < sym->nsyms; j++)
 919     alocation[j] = &sym->symbols[j].symbol;
 920
 921   alocation[j] = NULL;
 922
 923   return nsyms;
 924 }
 925
 926 /* Create synthetic symbols for indirect symbols.  */
 927
 928 long
 929 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
 930                                  long symcount ATTRIBUTE_UNUSED,
 931                                  asymbol **syms ATTRIBUTE_UNUSED,
 932                                  long dynsymcount ATTRIBUTE_UNUSED,
 933                                  asymbol **dynsyms ATTRIBUTE_UNUSED,
 934                                  asymbol **ret)
 935 {
 936   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
 937   bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
 938   bfd_mach_o_symtab_command *symtab = mdata->symtab;
 939   asymbol *s;
 940   char * s_start;
 941   char * s_end;
 942   unsigned long count, i, j, n;
 943   size_t size;
 944   char *names;
 945   char *nul_name;
 946   const char stub [] = "$stub";
 947
 948   *ret = NULL;
 949
 950   /* Stop now if no symbols or no indirect symbols.  */
 951   if (dysymtab == NULL || dysymtab->nindirectsyms == 0
 952       || symtab == NULL || symtab->symbols == NULL)
 953     return 0;
 954
 955   /* We need to allocate a bfd symbol for every indirect symbol and to
 956      allocate the memory for its name.  */
 957   count = dysymtab->nindirectsyms;
 958   size = count * sizeof (asymbol) + 1;
 959
 960   for (j = 0; j < count; j++)
 961     {
 962       const char * strng;
 963       unsigned int isym = dysymtab->indirect_syms[j];
 964
 965       /* Some indirect symbols are anonymous.  */
 966       if (isym < symtab->nsyms && (strng = symtab->symbols[isym].symbol.name))
 967         /* PR 17512: file: f5b8eeba.  */
 968         size += strnlen (strng, symtab->strsize - (strng - symtab->strtab)) + sizeof (stub);
 969     }
 970
 971   s_start = bfd_malloc (size);
 972   s = *ret = (asymbol *) s_start;
 973   if (s == NULL)
 974     return -1;
 975   names = (char *) (s + count);
 976   nul_name = names;
 977   *names++ = 0;
 978   s_end = s_start + size;
 979
 980   n = 0;
 981   for (i = 0; i < mdata->nsects; i++)
 982     {
 983       bfd_mach_o_section *sec = mdata->sections[i];
 984       unsigned int first, last;
 985       bfd_vma addr;
 986       bfd_vma entry_size;
 987
 988       switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
 989         {
 990         case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
 991         case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
 992         case BFD_MACH_O_S_SYMBOL_STUBS:
 993           /* Only these sections have indirect symbols.  */
 994           first = sec->reserved1;
 995           last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
 996           addr = sec->addr;
 997           entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
 998
 999           /* PR 17512: file: 08e15eec.  */
1000           if (first >= count || last >= count || first > last)
1001             goto fail;
1002
1003           for (j = first; j < last; j++)
1004             {
1005               unsigned int isym = dysymtab->indirect_syms[j];
1006
1007               /* PR 17512: file: 04d64d9b.  */
1008               if (((char *) s) + sizeof (* s) > s_end)
1009                 goto fail;
1010
1011               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
1012               s->section = sec->bfdsection;
1013               s->value = addr - sec->addr;
1014               s->udata.p = NULL;
1015
1016               if (isym < symtab->nsyms
1017                   && symtab->symbols[isym].symbol.name)
1018                 {
1019                   const char *sym = symtab->symbols[isym].symbol.name;
1020                   size_t len;
1021
1022                   s->name = names;
1023                   len = strlen (sym);
1024                   /* PR 17512: file: 47dfd4d2.  */
1025                   if (names + len >= s_end)
1026                     goto fail;
1027                   memcpy (names, sym, len);
1028                   names += len;
1029                   /* PR 17512: file: 18f340a4.  */
1030                   if (names + sizeof (stub) >= s_end)
1031                     goto fail;
1032                   memcpy (names, stub, sizeof (stub));
1033                   names += sizeof (stub);
1034                 }
1035               else
1036                 s->name = nul_name;
1037
1038               addr += entry_size;
1039               s++;
1040               n++;
1041             }
1042           break;
1043         default:
1044           break;
1045         }
1046     }
1047
1048   return n;
1049
1050  fail:
1051   free (s_start);
1052   * ret = NULL;
1053   return -1;
1054 }
1055
1056 void
1057 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1058                             asymbol *symbol,
1059                             symbol_info *ret)
1060 {
1061   bfd_symbol_info (symbol, ret);
1062 }
1063
1064 void
1065 bfd_mach_o_print_symbol (bfd *abfd,
1066                          void * afile,
1067                          asymbol *symbol,
1068                          bfd_print_symbol_type how)
1069 {
1070   FILE *file = (FILE *) afile;
1071   const char *name;
1072   bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
1073
1074   switch (how)
1075     {
1076     case bfd_print_symbol_name:
1077       fprintf (file, "%s", symbol->name);
1078       break;
1079     default:
1080       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1081       if (asym->n_type & BFD_MACH_O_N_STAB)
1082         name = bfd_get_stab_name (asym->n_type);
1083       else
1084         switch (asym->n_type & BFD_MACH_O_N_TYPE)
1085           {
1086           case BFD_MACH_O_N_UNDF:
1087             if (symbol->value == 0)
1088               name = "UND";
1089             else
1090               name = "COM";
1091             break;
1092           case BFD_MACH_O_N_ABS:
1093             name = "ABS";
1094             break;
1095           case BFD_MACH_O_N_INDR:
1096             name = "INDR";
1097             break;
1098           case BFD_MACH_O_N_PBUD:
1099             name = "PBUD";
1100             break;
1101           case BFD_MACH_O_N_SECT:
1102             name = "SECT";
1103             break;
1104           default:
1105             name = "???";
1106             break;
1107           }
1108       if (name == NULL)
1109         name = "";
1110       fprintf (file, " %02x %-6s %02x %04x",
1111                asym->n_type, name, asym->n_sect, asym->n_desc);
1112       if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
1113           && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
1114         fprintf (file, " [%s]", symbol->section->name);
1115       fprintf (file, " %s", symbol->name);
1116     }
1117 }
1118
1119 static void
1120 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
1121                                  bfd_mach_o_cpu_subtype msubtype,
1122                                  enum bfd_architecture *type,
1123                                  unsigned long *subtype)
1124 {
1125   *subtype = bfd_arch_unknown;
1126
1127   switch (mtype)
1128     {
1129     case BFD_MACH_O_CPU_TYPE_VAX:
1130       *type = bfd_arch_vax;
1131       break;
1132     case BFD_MACH_O_CPU_TYPE_MC680x0:
1133       *type = bfd_arch_m68k;
1134       break;
1135     case BFD_MACH_O_CPU_TYPE_I386:
1136       *type = bfd_arch_i386;
1137       *subtype = bfd_mach_i386_i386;
1138       break;
1139     case BFD_MACH_O_CPU_TYPE_X86_64:
1140       *type = bfd_arch_i386;
1141       *subtype = bfd_mach_x86_64;
1142       break;
1143     case BFD_MACH_O_CPU_TYPE_MIPS:
1144       *type = bfd_arch_mips;
1145       break;
1146     case BFD_MACH_O_CPU_TYPE_MC98000:
1147       *type = bfd_arch_m98k;
1148       break;
1149     case BFD_MACH_O_CPU_TYPE_HPPA:
1150       *type = bfd_arch_hppa;
1151       break;
1152     case BFD_MACH_O_CPU_TYPE_ARM:
1153       *type = bfd_arch_arm;
1154       switch (msubtype)
1155         {
1156         case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
1157           *subtype = bfd_mach_arm_4T;
1158           break;
1159         case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
1160           *subtype = bfd_mach_arm_4T;   /* Best fit ?  */
1161           break;
1162         case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
1163           *subtype = bfd_mach_arm_5TE;
1164           break;
1165         case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
1166           *subtype = bfd_mach_arm_XScale;
1167           break;
1168         case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
1169           *subtype = bfd_mach_arm_5TE;  /* Best fit ?  */
1170           break;
1171         case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
1172         default:
1173           break;
1174         }
1175       break;
1176     case BFD_MACH_O_CPU_TYPE_SPARC:
1177       *type = bfd_arch_sparc;
1178       *subtype = bfd_mach_sparc;
1179       break;
1180     case BFD_MACH_O_CPU_TYPE_ALPHA:
1181       *type = bfd_arch_alpha;
1182       break;
1183     case BFD_MACH_O_CPU_TYPE_POWERPC:
1184       *type = bfd_arch_powerpc;
1185       *subtype = bfd_mach_ppc;
1186       break;
1187     case BFD_MACH_O_CPU_TYPE_POWERPC_64:
1188       *type = bfd_arch_powerpc;
1189       *subtype = bfd_mach_ppc64;
1190       break;
1191     case BFD_MACH_O_CPU_TYPE_ARM64:
1192       *type = bfd_arch_aarch64;
1193       *subtype = bfd_mach_aarch64;
1194       break;
1195     default:
1196       *type = bfd_arch_unknown;
1197       break;
1198     }
1199 }
1200
1201 /* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4.  Return the
1202    number of bytes written or -1 in case of error.  */
1203
1204 static int
1205 bfd_mach_o_pad4 (bfd *abfd, unsigned int len)
1206 {
1207   if (len % 4 != 0)
1208     {
1209       char pad[4] = {0,0,0,0};
1210       unsigned int padlen = 4 - (len % 4);
1211
1212       if (bfd_bwrite (pad, padlen, abfd) != padlen)
1213         return -1;
1214
1215       return padlen;
1216     }
1217   else
1218     return 0;
1219 }
1220
1221 /* Likewise, but for a command.  */
1222
1223 static int
1224 bfd_mach_o_pad_command (bfd *abfd, unsigned int len)
1225 {
1226   unsigned int align = bfd_mach_o_wide_p (abfd) ? 8 : 4;
1227
1228   if (len % align != 0)
1229     {
1230       char pad[8] = {0};
1231       unsigned int padlen = align - (len % align);
1232
1233       if (bfd_bwrite (pad, padlen, abfd) != padlen)
1234         return -1;
1235
1236       return padlen;
1237     }
1238   else
1239     return 0;
1240 }
1241
1242 static bool
1243 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
1244 {
1245   struct mach_o_header_external raw;
1246   unsigned int size;
1247
1248   size = mach_o_wide_p (header) ?
1249     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1250
1251   bfd_h_put_32 (abfd, header->magic, raw.magic);
1252   bfd_h_put_32 (abfd, header->cputype, raw.cputype);
1253   bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
1254   bfd_h_put_32 (abfd, header->filetype, raw.filetype);
1255   bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
1256   bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
1257   bfd_h_put_32 (abfd, header->flags, raw.flags);
1258
1259   if (mach_o_wide_p (header))
1260     bfd_h_put_32 (abfd, header->reserved, raw.reserved);
1261
1262   if (bfd_seek (abfd, 0, SEEK_SET) != 0
1263       || bfd_bwrite (&raw, size, abfd) != size)
1264     return false;
1265
1266   return true;
1267 }
1268
1269 static bool
1270 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
1271 {
1272   bfd_mach_o_thread_command *cmd = &command->command.thread;
1273   unsigned int i;
1274   struct mach_o_thread_command_external raw;
1275   unsigned int offset;
1276
1277   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1278               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1279
1280   offset = BFD_MACH_O_LC_SIZE;
1281   for (i = 0; i < cmd->nflavours; i++)
1282     {
1283       BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
1284       BFD_ASSERT (cmd->flavours[i].offset ==
1285                   (command->offset + offset + BFD_MACH_O_LC_SIZE));
1286
1287       bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
1288       bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
1289
1290       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
1291           || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1292         return false;
1293
1294       offset += cmd->flavours[i].size + sizeof (raw);
1295     }
1296
1297   return true;
1298 }
1299
1300 static bool
1301 bfd_mach_o_write_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
1302 {
1303   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1304   struct mach_o_str_command_external raw;
1305   unsigned int namelen;
1306
1307   bfd_h_put_32 (abfd, cmd->name_offset, raw.str);
1308
1309   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1310       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1311     return false;
1312
1313   namelen = strlen (cmd->name_str) + 1;
1314   if (bfd_bwrite (cmd->name_str, namelen, abfd) != namelen)
1315     return false;
1316
1317   if (bfd_mach_o_pad_command (abfd, namelen) < 0)
1318     return false;
1319
1320   return true;
1321 }
1322
1323 static bool
1324 bfd_mach_o_write_dylib (bfd *abfd, bfd_mach_o_load_command *command)
1325 {
1326   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1327   struct mach_o_dylib_command_external raw;
1328   unsigned int namelen;
1329
1330   bfd_h_put_32 (abfd, cmd->name_offset, raw.name);
1331   bfd_h_put_32 (abfd, cmd->timestamp, raw.timestamp);
1332   bfd_h_put_32 (abfd, cmd->current_version, raw.current_version);
1333   bfd_h_put_32 (abfd, cmd->compatibility_version, raw.compatibility_version);
1334
1335   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1336       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1337     return false;
1338
1339   namelen = strlen (cmd->name_str) + 1;
1340   if (bfd_bwrite (cmd->name_str, namelen, abfd) != namelen)
1341     return false;
1342
1343   if (bfd_mach_o_pad_command (abfd, namelen) < 0)
1344     return false;
1345
1346   return true;
1347 }
1348
1349 static bool
1350 bfd_mach_o_write_main (bfd *abfd, bfd_mach_o_load_command *command)
1351 {
1352   bfd_mach_o_main_command *cmd = &command->command.main;
1353   struct mach_o_entry_point_command_external raw;
1354
1355   bfd_h_put_64 (abfd, cmd->entryoff, raw.entryoff);
1356   bfd_h_put_64 (abfd, cmd->stacksize, raw.stacksize);
1357
1358   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1359       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1360     return false;
1361
1362   return true;
1363 }
1364
1365 static bool
1366 bfd_mach_o_write_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
1367 {
1368   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
1369   struct mach_o_dyld_info_command_external raw;
1370
1371   bfd_h_put_32 (abfd, cmd->rebase_off, raw.rebase_off);
1372   bfd_h_put_32 (abfd, cmd->rebase_size, raw.rebase_size);
1373   bfd_h_put_32 (abfd, cmd->bind_off, raw.bind_off);
1374   bfd_h_put_32 (abfd, cmd->bind_size, raw.bind_size);
1375   bfd_h_put_32 (abfd, cmd->weak_bind_off, raw.weak_bind_off);
1376   bfd_h_put_32 (abfd, cmd->weak_bind_size, raw.weak_bind_size);
1377   bfd_h_put_32 (abfd, cmd->lazy_bind_off, raw.lazy_bind_off);
1378   bfd_h_put_32 (abfd, cmd->lazy_bind_size, raw.lazy_bind_size);
1379   bfd_h_put_32 (abfd, cmd->export_off, raw.export_off);
1380   bfd_h_put_32 (abfd, cmd->export_size, raw.export_size);
1381
1382   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1383       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1384     return false;
1385
1386   if (cmd->rebase_size != 0)
1387     if (bfd_seek (abfd, cmd->rebase_off, SEEK_SET) != 0
1388         || (bfd_bwrite (cmd->rebase_content, cmd->rebase_size, abfd) !=
1389             cmd->rebase_size))
1390       return false;
1391
1392   if (cmd->bind_size != 0)
1393     if (bfd_seek (abfd, cmd->bind_off, SEEK_SET) != 0
1394         || (bfd_bwrite (cmd->bind_content, cmd->bind_size, abfd) !=
1395             cmd->bind_size))
1396       return false;
1397
1398   if (cmd->weak_bind_size != 0)
1399     if (bfd_seek (abfd, cmd->weak_bind_off, SEEK_SET) != 0
1400         || (bfd_bwrite (cmd->weak_bind_content, cmd->weak_bind_size, abfd) !=
1401             cmd->weak_bind_size))
1402       return false;
1403
1404   if (cmd->lazy_bind_size != 0)
1405     if (bfd_seek (abfd, cmd->lazy_bind_off, SEEK_SET) != 0
1406         || (bfd_bwrite (cmd->lazy_bind_content, cmd->lazy_bind_size, abfd) !=
1407             cmd->lazy_bind_size))
1408       return false;
1409
1410   if (cmd->export_size != 0)
1411     if (bfd_seek (abfd, cmd->export_off, SEEK_SET) != 0
1412         || (bfd_bwrite (cmd->export_content, cmd->export_size, abfd) !=
1413             cmd->export_size))
1414       return false;
1415
1416   return true;
1417 }
1418
1419 long
1420 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
1421                                   asection *asect)
1422 {
1423 #if SIZEOF_LONG == SIZEOF_INT
1424    if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
1425     {
1426       bfd_set_error (bfd_error_file_too_big);
1427       return -1;
1428     }
1429 #endif
1430  return (asect->reloc_count + 1) * sizeof (arelent *);
1431 }
1432
1433 /* In addition to the need to byte-swap the symbol number, the bit positions
1434    of the fields in the relocation information vary per target endian-ness.  */
1435
1436 void
1437 bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
1438                                         unsigned char *fields)
1439 {
1440   unsigned char info = fields[3];
1441
1442   if (bfd_big_endian (abfd))
1443     {
1444       rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
1445       rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1446       rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
1447       rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
1448                       & BFD_MACH_O_LENGTH_MASK;
1449       rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
1450     }
1451   else
1452     {
1453       rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1454       rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1455       rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1456       rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1457                       & BFD_MACH_O_LENGTH_MASK;
1458       rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1459     }
1460 }
1461
1462 /* Set syms_ptr_ptr and addend of RES.  */
1463
1464 bool
1465 bfd_mach_o_canonicalize_non_scattered_reloc (bfd *abfd,
1466                                              bfd_mach_o_reloc_info *reloc,
1467                                              arelent *res, asymbol **syms)
1468 {
1469   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1470   unsigned int num;
1471   asymbol **sym;
1472
1473   /* Non-scattered relocation.  */
1474   reloc->r_scattered = 0;
1475   res->addend = 0;
1476
1477   num = reloc->r_value;
1478
1479   if (reloc->r_extern)
1480     {
1481       /* PR 17512: file: 8396-1185-0.004.  */
1482       if (num >= (unsigned) bfd_mach_o_count_symbols (abfd))
1483         sym = bfd_und_section_ptr->symbol_ptr_ptr;
1484       else if (syms == NULL)
1485         sym = bfd_und_section_ptr->symbol_ptr_ptr;
1486       else
1487         /* An external symbol number.  */
1488         sym = syms + num;
1489     }
1490   else if (num == 0x00ffffff || num == 0)
1491     {
1492       /* The 'symnum' in a non-scattered PAIR is 0x00ffffff.  But as this
1493          is generic code, we don't know wether this is really a PAIR.
1494          This value is almost certainly not a valid section number, hence
1495          this specific case to avoid an assertion failure.
1496          Target specific swap_reloc_in routine should adjust that.  */
1497       sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1498     }
1499   else
1500     {
1501       /* PR 17512: file: 006-2964-0.004.  */
1502       if (num > mdata->nsects)
1503         {
1504           _bfd_error_handler (_("\
1505 malformed mach-o reloc: section index is greater than the number of sections"));
1506           return false;
1507         }
1508
1509       /* A section number.  */
1510       sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1511       /* For a symbol defined in section S, the addend (stored in the
1512          binary) contains the address of the section.  To comply with
1513          bfd convention, subtract the section address.
1514          Use the address from the header, so that the user can modify
1515              the vma of the section.  */
1516       res->addend = -mdata->sections[num - 1]->addr;
1517     }
1518
1519   /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1520      in the lower 16bits of the address value.  So we have to find the
1521      'symbol' from the preceding reloc.  We do this even though the
1522      section symbol is probably not needed here, because NULL symbol
1523      values cause an assert in generic BFD code.  This must be done in
1524      the PPC swap_reloc_in routine.  */
1525   res->sym_ptr_ptr = sym;
1526
1527   return true;
1528 }
1529
1530 /* Do most of the work for canonicalize_relocs on RAW: create internal
1531    representation RELOC and set most fields of RES using symbol table SYMS.
1532    Each target still has to set the howto of RES and possibly adjust other
1533    fields.
1534    Previously the Mach-O hook point was simply swap_in, but some targets
1535    (like arm64) don't follow the generic rules (symnum is a value for the
1536    non-scattered relocation ADDEND).  */
1537
1538 bool
1539 bfd_mach_o_pre_canonicalize_one_reloc (bfd *abfd,
1540                                        struct mach_o_reloc_info_external *raw,
1541                                        bfd_mach_o_reloc_info *reloc,
1542                                        arelent *res, asymbol **syms)
1543 {
1544   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1545   bfd_vma addr;
1546
1547   addr = bfd_get_32 (abfd, raw->r_address);
1548   res->sym_ptr_ptr = NULL;
1549   res->addend = 0;
1550
1551   if (addr & BFD_MACH_O_SR_SCATTERED)
1552     {
1553       unsigned int j;
1554       bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1555
1556       /* Scattered relocation, can't be extern. */
1557       reloc->r_scattered = 1;
1558       reloc->r_extern = 0;
1559
1560       /*   Extract section and offset from r_value (symnum).  */
1561       reloc->r_value = symnum;
1562       /* FIXME: This breaks when a symbol in a reloc exactly follows the
1563          end of the data for the section (e.g. in a calculation of section
1564          data length).  At present, the symbol will end up associated with
1565          the following section or, if it falls within alignment padding, as
1566          null - which will assert later.  */
1567       for (j = 0; j < mdata->nsects; j++)
1568         {
1569           bfd_mach_o_section *sect = mdata->sections[j];
1570           if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1571             {
1572               res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1573               res->addend = symnum - sect->addr;
1574               break;
1575             }
1576         }
1577
1578       /* Extract the info and address fields from r_address.  */
1579       reloc->r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1580       reloc->r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1581       reloc->r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1582       reloc->r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1583       res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1584     }
1585   else
1586     {
1587       /* Non-scattered relocation.  */
1588       reloc->r_scattered = 0;
1589       reloc->r_address = addr;
1590       res->address = addr;
1591
1592       /* The value and info fields have to be extracted dependent on target
1593          endian-ness.  */
1594       bfd_mach_o_swap_in_non_scattered_reloc (abfd, reloc, raw->r_symbolnum);
1595
1596       if (!bfd_mach_o_canonicalize_non_scattered_reloc (abfd, reloc,
1597                                                         res, syms))
1598         return false;
1599     }
1600
1601   /* We have set up a reloc with all the information present, so the swapper
1602      can modify address, value and addend fields, if necessary, to convey
1603      information in the generic BFD reloc that is mach-o specific.  */
1604
1605   return true;
1606 }
1607
1608 static int
1609 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1610                                 unsigned long count,
1611                                 arelent *res, asymbol **syms)
1612 {
1613   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1614   unsigned long i;
1615   struct mach_o_reloc_info_external *native_relocs = NULL;
1616   size_t native_size;
1617
1618   /* Allocate and read relocs.  */
1619   if (_bfd_mul_overflow (count, BFD_MACH_O_RELENT_SIZE, &native_size))
1620     /* PR 17512: file: 09477b57.  */
1621     goto err;
1622
1623   if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
1624     return -1;
1625   native_relocs = (struct mach_o_reloc_info_external *)
1626     _bfd_malloc_and_read (abfd, native_size, native_size);
1627   if (native_relocs == NULL)
1628     return -1;
1629
1630   for (i = 0; i < count; i++)
1631     {
1632       if (!(*bed->_bfd_mach_o_canonicalize_one_reloc)(abfd, &native_relocs[i],
1633                                                       &res[i], syms, res))
1634         goto err;
1635     }
1636   free (native_relocs);
1637   return i;
1638
1639  err:
1640   free (native_relocs);
1641   if (bfd_get_error () == bfd_error_no_error)
1642     bfd_set_error (bfd_error_invalid_operation);
1643   return -1;
1644 }
1645
1646 long
1647 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1648                                arelent **rels, asymbol **syms)
1649 {
1650   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1651   unsigned long i;
1652   arelent *res;
1653
1654   if (asect->reloc_count == 0)
1655     return 0;
1656
1657   /* No need to go further if we don't know how to read relocs.  */
1658   if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
1659     return 0;
1660
1661   if (asect->relocation == NULL)
1662     {
1663       size_t amt;
1664
1665       if (_bfd_mul_overflow (asect->reloc_count, sizeof (arelent), &amt))
1666         return -1;
1667       res = bfd_malloc (amt);
1668       if (res == NULL)
1669         return -1;
1670
1671       if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1672                                           asect->reloc_count, res, syms) < 0)
1673         {
1674           free (res);
1675           return -1;
1676         }
1677       asect->relocation = res;
1678     }
1679
1680   res = asect->relocation;
1681   for (i = 0; i < asect->reloc_count; i++)
1682     rels[i] = &res[i];
1683   rels[i] = NULL;
1684
1685   return i;
1686 }
1687
1688 long
1689 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1690 {
1691   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1692
1693   if (mdata->dysymtab == NULL)
1694     return 1;
1695   return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1696     * sizeof (arelent *);
1697 }
1698
1699 long
1700 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1701                                        struct bfd_symbol **syms)
1702 {
1703   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1704   bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1705   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1706   unsigned long i;
1707   arelent *res;
1708
1709   if (dysymtab == NULL)
1710     return 0;
1711   if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1712     return 0;
1713
1714   /* No need to go further if we don't know how to read relocs.  */
1715   if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
1716     return 0;
1717
1718   if (mdata->dyn_reloc_cache == NULL)
1719     {
1720       ufile_ptr filesize = bfd_get_file_size (abfd);
1721       size_t amt;
1722
1723       if (filesize != 0)
1724         {
1725           if (dysymtab->extreloff > filesize
1726               || dysymtab->nextrel > ((filesize - dysymtab->extreloff)
1727                                       / BFD_MACH_O_RELENT_SIZE)
1728               || dysymtab->locreloff > filesize
1729               || dysymtab->nlocrel > ((filesize - dysymtab->locreloff)
1730                                       / BFD_MACH_O_RELENT_SIZE))
1731             {
1732               bfd_set_error (bfd_error_file_truncated);
1733               return -1;
1734             }
1735         }
1736       if (_bfd_mul_overflow (dysymtab->nextrel + dysymtab->nlocrel,
1737                              sizeof (arelent), &amt))
1738         {
1739           bfd_set_error (bfd_error_file_too_big);
1740           return -1;
1741         }
1742
1743       res = bfd_malloc (amt);
1744       if (res == NULL)
1745         return -1;
1746
1747       if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1748                                           dysymtab->nextrel, res, syms) < 0)
1749         {
1750           free (res);
1751           return -1;
1752         }
1753
1754       if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1755                                           dysymtab->nlocrel,
1756                                           res + dysymtab->nextrel, syms) < 0)
1757         {
1758           free (res);
1759           return -1;
1760         }
1761
1762       mdata->dyn_reloc_cache = res;
1763     }
1764
1765   res = mdata->dyn_reloc_cache;
1766   for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1767     rels[i] = &res[i];
1768   rels[i] = NULL;
1769   return i;
1770 }
1771
1772 /* In addition to the need to byte-swap the symbol number, the bit positions
1773    of the fields in the relocation information vary per target endian-ness.  */
1774
1775 static void
1776 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1777                                          bfd_mach_o_reloc_info *rel)
1778 {
1779   unsigned char info = 0;
1780
1781   BFD_ASSERT (rel->r_type <= 15);
1782   BFD_ASSERT (rel->r_length <= 3);
1783
1784   if (bfd_big_endian (abfd))
1785     {
1786       fields[0] = (rel->r_value >> 16) & 0xff;
1787       fields[1] = (rel->r_value >> 8) & 0xff;
1788       fields[2] = rel->r_value & 0xff;
1789       info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1790       info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1791       info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1792       info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1793     }
1794   else
1795     {
1796       fields[2] = (rel->r_value >> 16) & 0xff;
1797       fields[1] = (rel->r_value >> 8) & 0xff;
1798       fields[0] = rel->r_value & 0xff;
1799       info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1800       info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1801       info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1802       info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1803     }
1804   fields[3] = info;
1805 }
1806
1807 static bool
1808 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1809 {
1810   unsigned int i;
1811   arelent **entries;
1812   asection *sec;
1813   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1814
1815   sec = section->bfdsection;
1816   if (sec->reloc_count == 0)
1817     return true;
1818
1819   if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1820     return true;
1821
1822   if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1823     return false;
1824
1825   /* Convert and write.  */
1826   entries = section->bfdsection->orelocation;
1827   for (i = 0; i < section->nreloc; i++)
1828     {
1829       arelent *rel = entries[i];
1830       struct mach_o_reloc_info_external raw;
1831       bfd_mach_o_reloc_info info, *pinfo = &info;
1832
1833       /* Convert relocation to an intermediate representation.  */
1834       if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1835         return false;
1836
1837       /* Lower the relocation info.  */
1838       if (pinfo->r_scattered)
1839         {
1840           unsigned long v;
1841
1842           v = BFD_MACH_O_SR_SCATTERED
1843             | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1844             | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
1845             | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
1846             | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
1847           /* Note: scattered relocs have field in reverse order...  */
1848           bfd_put_32 (abfd, v, raw.r_address);
1849           bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1850         }
1851       else
1852         {
1853           bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1854           bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1855                                                    pinfo);
1856         }
1857
1858       if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1859           != BFD_MACH_O_RELENT_SIZE)
1860         return false;
1861     }
1862   return true;
1863 }
1864
1865 static bool
1866 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1867 {
1868   struct mach_o_section_32_external raw;
1869
1870   memcpy (raw.sectname, section->sectname, 16);
1871   memcpy (raw.segname, section->segname, 16);
1872   bfd_h_put_32 (abfd, section->addr, raw.addr);
1873   bfd_h_put_32 (abfd, section->size, raw.size);
1874   bfd_h_put_32 (abfd, section->offset, raw.offset);
1875   bfd_h_put_32 (abfd, section->align, raw.align);
1876   bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1877   bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1878   bfd_h_put_32 (abfd, section->flags, raw.flags);
1879   bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1880   bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1881
1882   if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1883       != BFD_MACH_O_SECTION_SIZE)
1884     return false;
1885
1886   return true;
1887 }
1888
1889 static bool
1890 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1891 {
1892   struct mach_o_section_64_external raw;
1893
1894   memcpy (raw.sectname, section->sectname, 16);
1895   memcpy (raw.segname, section->segname, 16);
1896   bfd_h_put_64 (abfd, section->addr, raw.addr);
1897   bfd_h_put_64 (abfd, section->size, raw.size);
1898   bfd_h_put_32 (abfd, section->offset, raw.offset);
1899   bfd_h_put_32 (abfd, section->align, raw.align);
1900   bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1901   bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1902   bfd_h_put_32 (abfd, section->flags, raw.flags);
1903   bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1904   bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1905   bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1906
1907   if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1908       != BFD_MACH_O_SECTION_64_SIZE)
1909     return false;
1910
1911   return true;
1912 }
1913
1914 static bool
1915 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1916 {
1917   struct mach_o_segment_command_32_external raw;
1918   bfd_mach_o_segment_command *seg = &command->command.segment;
1919   bfd_mach_o_section *sec;
1920
1921   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1922
1923   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1924     if (!bfd_mach_o_write_relocs (abfd, sec))
1925       return false;
1926
1927   memcpy (raw.segname, seg->segname, 16);
1928   bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1929   bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1930   bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1931   bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1932   bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1933   bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1934   bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1935   bfd_h_put_32 (abfd, seg->flags, raw.flags);
1936
1937   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1938       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1939     return false;
1940
1941   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1942     if (!bfd_mach_o_write_section_32 (abfd, sec))
1943       return false;
1944
1945   return true;
1946 }
1947
1948 static bool
1949 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1950 {
1951   struct mach_o_segment_command_64_external raw;
1952   bfd_mach_o_segment_command *seg = &command->command.segment;
1953   bfd_mach_o_section *sec;
1954
1955   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1956
1957   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1958     if (!bfd_mach_o_write_relocs (abfd, sec))
1959       return false;
1960
1961   memcpy (raw.segname, seg->segname, 16);
1962   bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1963   bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1964   bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1965   bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1966   bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1967   bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1968   bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1969   bfd_h_put_32 (abfd, seg->flags, raw.flags);
1970
1971   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1972       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1973     return false;
1974
1975   for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1976     if (!bfd_mach_o_write_section_64 (abfd, sec))
1977       return false;
1978
1979   return true;
1980 }
1981
1982 static bool
1983 bfd_mach_o_write_symtab_content (bfd *abfd, bfd_mach_o_symtab_command *sym)
1984 {
1985   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1986   unsigned long i;
1987   unsigned int wide = bfd_mach_o_wide_p (abfd);
1988   struct bfd_strtab_hash *strtab;
1989   asymbol **symbols = bfd_get_outsymbols (abfd);
1990   int padlen;
1991
1992   /* Write the symbols first.  */
1993   if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1994     return false;
1995
1996   strtab = _bfd_stringtab_init ();
1997   if (strtab == NULL)
1998     return false;
1999
2000   if (sym->nsyms > 0)
2001     /* Although we don't strictly need to do this, for compatibility with
2002        Darwin system tools, actually output an empty string for the index
2003        0 entry.  */
2004     _bfd_stringtab_add (strtab, "", true, false);
2005
2006   for (i = 0; i < sym->nsyms; i++)
2007     {
2008       bfd_size_type str_index;
2009       bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2010
2011       if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
2012         /* An index of 0 always means the empty string.  */
2013         str_index = 0;
2014       else
2015         {
2016           str_index = _bfd_stringtab_add (strtab, s->symbol.name, true, false);
2017
2018           if (str_index == (bfd_size_type) -1)
2019             goto err;
2020         }
2021
2022       if (wide)
2023         {
2024           struct mach_o_nlist_64_external raw;
2025
2026           bfd_h_put_32 (abfd, str_index, raw.n_strx);
2027           bfd_h_put_8 (abfd, s->n_type, raw.n_type);
2028           bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
2029           bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
2030           bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
2031                         raw.n_value);
2032
2033           if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2034             goto err;
2035         }
2036       else
2037         {
2038           struct mach_o_nlist_external raw;
2039
2040           bfd_h_put_32 (abfd, str_index, raw.n_strx);
2041           bfd_h_put_8 (abfd, s->n_type, raw.n_type);
2042           bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
2043           bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
2044           bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
2045                         raw.n_value);
2046
2047           if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2048             goto err;
2049         }
2050     }
2051   sym->strsize = _bfd_stringtab_size (strtab);
2052   sym->stroff = mdata->filelen;
2053   mdata->filelen += sym->strsize;
2054
2055   if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
2056     goto err;
2057
2058   if (!_bfd_stringtab_emit (abfd, strtab))
2059     goto err;
2060
2061   /* Pad string table.  */
2062   padlen = bfd_mach_o_pad4 (abfd, sym->strsize);
2063   if (padlen < 0)
2064     return false;
2065   mdata->filelen += padlen;
2066   sym->strsize += padlen;
2067
2068   return true;
2069
2070  err:
2071   _bfd_stringtab_free (strtab);
2072   sym->strsize = 0;
2073   return false;
2074 }
2075
2076 static bool
2077 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
2078 {
2079   bfd_mach_o_symtab_command *sym = &command->command.symtab;
2080   struct mach_o_symtab_command_external raw;
2081
2082   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
2083
2084   /* The command.  */
2085   bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
2086   bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
2087   bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
2088   bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
2089
2090   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2091       || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2092     return false;
2093
2094   return true;
2095 }
2096
2097 /* Count the number of indirect symbols in the image.
2098    Requires that the sections are in their final order.  */
2099
2100 static unsigned int
2101 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2102 {
2103   unsigned int i;
2104   unsigned int nisyms = 0;
2105
2106   for (i = 0; i < mdata->nsects; ++i)
2107     {
2108       bfd_mach_o_section *sec = mdata->sections[i];
2109
2110       switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2111         {
2112           case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2113           case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2114           case BFD_MACH_O_S_SYMBOL_STUBS:
2115             nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2116             break;
2117           default:
2118             break;
2119         }
2120     }
2121   return nisyms;
2122 }
2123
2124 /* Create the dysymtab.  */
2125
2126 static bool
2127 bfd_mach_o_build_dysymtab (bfd *abfd, bfd_mach_o_dysymtab_command *cmd)
2128 {
2129   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2130
2131   /* TODO:
2132      We are not going to try and fill these in yet and, moreover, we are
2133      going to bail if they are already set.  */
2134   if (cmd->nmodtab != 0
2135       || cmd->ntoc != 0
2136       || cmd->nextrefsyms != 0)
2137     {
2138       _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
2139                             " implemented for dysymtab commands."));
2140       return false;
2141     }
2142
2143   cmd->ilocalsym = 0;
2144
2145   if (bfd_get_symcount (abfd) > 0)
2146     {
2147       asymbol **symbols = bfd_get_outsymbols (abfd);
2148       unsigned long i;
2149
2150        /* Count the number of each kind of symbol.  */
2151       for (i = 0; i < bfd_get_symcount (abfd); ++i)
2152         {
2153           bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2154           if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2155             break;
2156         }
2157       cmd->nlocalsym = i;
2158       cmd->iextdefsym = i;
2159       for (; i < bfd_get_symcount (abfd); ++i)
2160         {
2161           bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2162           if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2163             break;
2164         }
2165       cmd->nextdefsym = i - cmd->nlocalsym;
2166       cmd->iundefsym = cmd->nextdefsym + cmd->iextdefsym;
2167       cmd->nundefsym = bfd_get_symcount (abfd)
2168                         - cmd->nlocalsym
2169                         - cmd->nextdefsym;
2170     }
2171   else
2172     {
2173       cmd->nlocalsym = 0;
2174       cmd->iextdefsym = 0;
2175       cmd->nextdefsym = 0;
2176       cmd->iundefsym = 0;
2177       cmd->nundefsym = 0;
2178     }
2179
2180   cmd->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2181   if (cmd->nindirectsyms > 0)
2182     {
2183       unsigned i;
2184       unsigned n;
2185       size_t amt;
2186
2187       mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2188       cmd->indirectsymoff = mdata->filelen;
2189       if (_bfd_mul_overflow (cmd->nindirectsyms, 4, &amt))
2190         return false;
2191       mdata->filelen += amt;
2192
2193       cmd->indirect_syms = bfd_zalloc (abfd, amt);
2194       if (cmd->indirect_syms == NULL)
2195         return false;
2196
2197       n = 0;
2198       for (i = 0; i < mdata->nsects; ++i)
2199         {
2200           bfd_mach_o_section *sec = mdata->sections[i];
2201
2202           switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2203             {
2204               case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2205               case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2206               case BFD_MACH_O_S_SYMBOL_STUBS:
2207                 {
2208                   unsigned j, num;
2209                   bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2210
2211                   num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2212                   if (isyms == NULL || num == 0)
2213                     break;
2214                   /* Record the starting index in the reserved1 field.  */
2215                   sec->reserved1 = n;
2216                   for (j = 0; j < num; j++, n++)
2217                     {
2218                       if (isyms[j] == NULL)
2219                         cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2220                       else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2221                                && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2222                         cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2223                                                  | BFD_MACH_O_INDIRECT_SYM_ABS;
2224                       else
2225                         cmd->indirect_syms[n] = isyms[j]->symbol.udata.i;
2226                     }
2227                 }
2228                 break;
2229               default:
2230                 break;
2231             }
2232         }
2233     }
2234
2235   return true;
2236 }
2237
2238 /* Write a dysymtab command.
2239    TODO: Possibly coalesce writes of smaller objects.  */
2240
2241 static bool
2242 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2243 {
2244   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2245
2246   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2247
2248   if (cmd->nmodtab != 0)
2249     {
2250       unsigned int i;
2251
2252       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2253         return false;
2254
2255       for (i = 0; i < cmd->nmodtab; i++)
2256         {
2257           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2258           unsigned int iinit;
2259           unsigned int ninit;
2260
2261           iinit = module->iinit & 0xffff;
2262           iinit |= ((module->iterm & 0xffff) << 16);
2263
2264           ninit = module->ninit & 0xffff;
2265           ninit |= ((module->nterm & 0xffff) << 16);
2266
2267           if (bfd_mach_o_wide_p (abfd))
2268             {
2269               struct mach_o_dylib_module_64_external w;
2270
2271               bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
2272               bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
2273               bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
2274               bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
2275               bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
2276               bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
2277               bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
2278               bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
2279               bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
2280               bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
2281               bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
2282               bfd_h_put_64 (abfd, module->objc_module_info_addr,
2283                             &w.objc_module_info_addr);
2284               bfd_h_put_32 (abfd, module->objc_module_info_size,
2285                             &w.objc_module_info_size);
2286
2287               if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
2288                 return false;
2289             }
2290           else
2291             {
2292               struct mach_o_dylib_module_external n;
2293
2294               bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
2295               bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
2296               bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
2297               bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
2298               bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
2299               bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
2300               bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
2301               bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
2302               bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
2303               bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
2304               bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
2305               bfd_h_put_32 (abfd, module->objc_module_info_addr,
2306                             &n.objc_module_info_addr);
2307               bfd_h_put_32 (abfd, module->objc_module_info_size,
2308                             &n.objc_module_info_size);
2309
2310               if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
2311                 return false;
2312             }
2313         }
2314     }
2315
2316   if (cmd->ntoc != 0)
2317     {
2318       unsigned int i;
2319
2320       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2321         return false;
2322
2323       for (i = 0; i < cmd->ntoc; i++)
2324         {
2325           struct mach_o_dylib_table_of_contents_external raw;
2326           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2327
2328           bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
2329           bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
2330
2331           if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2332             return false;
2333         }
2334     }
2335
2336   if (cmd->nindirectsyms > 0)
2337     {
2338       unsigned int i;
2339
2340       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2341         return false;
2342
2343       for (i = 0; i < cmd->nindirectsyms; ++i)
2344         {
2345           unsigned char raw[4];
2346
2347           bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
2348           if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2349             return false;
2350         }
2351     }
2352
2353   if (cmd->nextrefsyms != 0)
2354     {
2355       unsigned int i;
2356
2357       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2358         return false;
2359
2360       for (i = 0; i < cmd->nextrefsyms; i++)
2361         {
2362           unsigned long v;
2363           unsigned char raw[4];
2364           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2365
2366           /* Fields isym and flags are written as bit-fields, thus we need
2367              a specific processing for endianness.  */
2368
2369           if (bfd_big_endian (abfd))
2370             {
2371               v = ((ref->isym & 0xffffff) << 8);
2372               v |= ref->flags & 0xff;
2373             }
2374           else
2375             {
2376               v = ref->isym  & 0xffffff;
2377               v |= ((ref->flags & 0xff) << 24);
2378             }
2379
2380           bfd_h_put_32 (abfd, v, raw);
2381           if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2382             return false;
2383         }
2384     }
2385
2386   /* The command.  */
2387   if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
2388     return false;
2389   else
2390     {
2391       struct mach_o_dysymtab_command_external raw;
2392
2393       bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
2394       bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
2395       bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
2396       bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
2397       bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
2398       bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
2399       bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
2400       bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
2401       bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
2402       bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
2403       bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
2404       bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
2405       bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
2406       bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
2407       bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
2408       bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
2409       bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
2410       bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
2411
2412       if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2413         return false;
2414     }
2415
2416   return true;
2417 }
2418
2419 static unsigned
2420 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
2421 {
2422   unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
2423
2424   /* Just leave debug symbols where they are (pretend they are local, and
2425      then they will just be sorted on position).  */
2426   if (s->n_type & BFD_MACH_O_N_STAB)
2427     return 0;
2428
2429   /* Local (we should never see an undefined local AFAICT).  */
2430   if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
2431     return 0;
2432
2433   /* Common symbols look like undefined externs.  */
2434   if (mtyp == BFD_MACH_O_N_UNDF)
2435     return 2;
2436
2437   /* A defined non-local, non-debug symbol.  */
2438   return 1;
2439 }
2440
2441 static int
2442 bfd_mach_o_cf_symbols (const void *a, const void *b)
2443 {
2444   bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
2445   bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
2446   unsigned int soa, sob;
2447
2448   soa = bfd_mach_o_primary_symbol_sort_key (sa);
2449   sob = bfd_mach_o_primary_symbol_sort_key (sb);
2450   if (soa < sob)
2451     return -1;
2452
2453   if (soa > sob)
2454     return 1;
2455
2456   /* If it's local or stab, just preserve the input order.  */
2457   if (soa == 0)
2458     {
2459       if (sa->symbol.udata.i < sb->symbol.udata.i)
2460         return -1;
2461       if (sa->symbol.udata.i > sb->symbol.udata.i)
2462         return  1;
2463
2464       /* This is probably an error.  */
2465       return 0;
2466     }
2467
2468   /* The second sort key is name.  */
2469   return strcmp (sa->symbol.name, sb->symbol.name);
2470 }
2471
2472 /* Process the symbols.
2473
2474    This should be OK for single-module files - but it is not likely to work
2475    for multi-module shared libraries.
2476
2477    (a) If the application has not filled in the relevant mach-o fields, make
2478        an estimate.
2479
2480    (b) Order them, like this:
2481         (  i) local.
2482                 (unsorted)
2483         ( ii) external defined
2484                 (by name)
2485         (iii) external undefined/common
2486                 (by name)
2487         ( iv) common
2488                 (by name)
2489 */
2490
2491 static bool
2492 bfd_mach_o_mangle_symbols (bfd *abfd)
2493 {
2494   unsigned long i;
2495   asymbol **symbols = bfd_get_outsymbols (abfd);
2496
2497   if (symbols == NULL || bfd_get_symcount (abfd) == 0)
2498     return true;
2499
2500   for (i = 0; i < bfd_get_symcount (abfd); i++)
2501     {
2502       bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2503
2504       /* We use this value, which is out-of-range as a symbol index, to signal
2505          that the mach-o-specific data are not filled in and need to be created
2506          from the bfd values.  It is much preferable for the application to do
2507          this, since more meaningful diagnostics can be made that way.  */
2508
2509       if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
2510         {
2511           /* No symbol information has been set - therefore determine
2512              it from the bfd symbol flags/info.  */
2513           if (s->symbol.section == bfd_abs_section_ptr)
2514             s->n_type = BFD_MACH_O_N_ABS;
2515           else if (s->symbol.section == bfd_und_section_ptr)
2516             {
2517               s->n_type = BFD_MACH_O_N_UNDF;
2518               if (s->symbol.flags & BSF_WEAK)
2519                 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
2520               /* mach-o automatically makes undefined symbols extern.  */
2521               s->n_type |= BFD_MACH_O_N_EXT;
2522               s->symbol.flags |= BSF_GLOBAL;
2523             }
2524           else if (s->symbol.section == bfd_com_section_ptr)
2525             {
2526               s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
2527               s->symbol.flags |= BSF_GLOBAL;
2528             }
2529           else
2530             s->n_type = BFD_MACH_O_N_SECT;
2531         }
2532
2533       /* Update external symbol bit in case objcopy changed it.  */
2534       if (s->symbol.flags & BSF_GLOBAL)
2535         s->n_type |= BFD_MACH_O_N_EXT;
2536       else
2537         s->n_type &= ~BFD_MACH_O_N_EXT;
2538
2539       /* Put the section index in, where required.  */
2540       if ((s->symbol.section != bfd_abs_section_ptr
2541           && s->symbol.section != bfd_und_section_ptr
2542           && s->symbol.section != bfd_com_section_ptr)
2543           || ((s->n_type & BFD_MACH_O_N_STAB) != 0
2544                && s->symbol.name == NULL))
2545         s->n_sect = s->symbol.section->output_section->target_index;
2546
2547       /* Number to preserve order for local and debug syms.  */
2548       s->symbol.udata.i = i;
2549     }
2550
2551   /* Sort the symbols.  */
2552   qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
2553          sizeof (asymbol *), bfd_mach_o_cf_symbols);
2554
2555   for (i = 0; i < bfd_get_symcount (abfd); ++i)
2556     {
2557       bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2558       s->symbol.udata.i = i;  /* renumber.  */
2559     }
2560
2561   return true;
2562 }
2563
2564 /* We build a flat table of sections, which can be re-ordered if necessary.
2565    Fill in the section number and other mach-o-specific data.  */
2566
2567 static bool
2568 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
2569 {
2570   asection *sec;
2571   unsigned target_index;
2572   unsigned nsect;
2573   size_t amt;
2574
2575   nsect = bfd_count_sections (abfd);
2576
2577   /* Don't do it if it's already set - assume the application knows what it's
2578      doing.  */
2579   if (mdata->nsects == nsect
2580       && (mdata->nsects == 0 || mdata->sections != NULL))
2581     return true;
2582
2583   /* We need to check that this can be done...  */
2584   if (nsect > 255)
2585     {
2586       _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2587                             " maximum is 255,\n"), nsect);
2588       return false;
2589     }
2590
2591   mdata->nsects = nsect;
2592   amt = mdata->nsects * sizeof (bfd_mach_o_section *);
2593   mdata->sections = bfd_alloc (abfd, amt);
2594   if (mdata->sections == NULL)
2595     return false;
2596
2597   /* Create Mach-O sections.
2598      Section type, attribute and align should have been set when the
2599      section was created - either read in or specified.  */
2600   target_index = 0;
2601   for (sec = abfd->sections; sec; sec = sec->next)
2602     {
2603       unsigned bfd_align = bfd_section_alignment (sec);
2604       bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
2605
2606       mdata->sections[target_index] = msect;
2607
2608       msect->addr = bfd_section_vma (sec);
2609       msect->size = bfd_section_size (sec);
2610
2611       /* Use the largest alignment set, in case it was bumped after the
2612          section was created.  */
2613       msect->align = msect->align > bfd_align ? msect->align : bfd_align;
2614
2615       msect->offset = 0;
2616       sec->target_index = ++target_index;
2617     }
2618
2619   return true;
2620 }
2621
2622 bool
2623 bfd_mach_o_write_contents (bfd *abfd)
2624 {
2625   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2626   bfd_mach_o_load_command *cmd;
2627   bfd_mach_o_symtab_command *symtab = NULL;
2628   bfd_mach_o_dysymtab_command *dysymtab = NULL;
2629   bfd_mach_o_segment_command *linkedit = NULL;
2630
2631   /* Make the commands, if not already present.  */
2632   if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
2633     return false;
2634   abfd->output_has_begun = true;
2635
2636   /* Write the header.  */
2637   if (!bfd_mach_o_write_header (abfd, &mdata->header))
2638     return false;
2639
2640   /* First pass: allocate the linkedit segment.  */
2641   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2642     switch (cmd->type)
2643       {
2644       case BFD_MACH_O_LC_SEGMENT_64:
2645       case BFD_MACH_O_LC_SEGMENT:
2646         if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
2647           linkedit = &cmd->command.segment;
2648         break;
2649       case BFD_MACH_O_LC_SYMTAB:
2650         symtab = &cmd->command.symtab;
2651         break;
2652       case BFD_MACH_O_LC_DYSYMTAB:
2653         dysymtab = &cmd->command.dysymtab;
2654         break;
2655       case BFD_MACH_O_LC_DYLD_INFO:
2656         {
2657           bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
2658
2659           if (di->rebase_size != 0)
2660             {
2661               di->rebase_off = mdata->filelen;
2662               mdata->filelen += di->rebase_size;
2663             }
2664           if (di->bind_size != 0)
2665             {
2666               di->bind_off = mdata->filelen;
2667               mdata->filelen += di->bind_size;
2668             }
2669           if (di->weak_bind_size != 0)
2670             {
2671               di->weak_bind_off = mdata->filelen;
2672               mdata->filelen += di->weak_bind_size;
2673             }
2674           if (di->lazy_bind_size != 0)
2675             {
2676               di->lazy_bind_off = mdata->filelen;
2677               mdata->filelen += di->lazy_bind_size;
2678             }
2679           if (di->export_size != 0)
2680             {
2681               di->export_off = mdata->filelen;
2682               mdata->filelen += di->export_size;
2683             }
2684         }
2685         break;
2686       case BFD_MACH_O_LC_LOAD_DYLIB:
2687       case BFD_MACH_O_LC_LOAD_DYLINKER:
2688       case BFD_MACH_O_LC_MAIN:
2689         /* Nothing to do.  */
2690         break;
2691       default:
2692         _bfd_error_handler
2693           (_("unable to allocate data for load command %#x"),
2694            cmd->type);
2695         break;
2696       }
2697
2698   /* Specially handle symtab and dysymtab.  */
2699
2700   /* Pre-allocate the symbol table (but not the string table).  The reason
2701      is that the dysymtab is after the symbol table but before the string
2702      table (required by the native strip tool).  */
2703   if (symtab != NULL)
2704     {
2705       unsigned int symlen;
2706       unsigned int wide = bfd_mach_o_wide_p (abfd);
2707
2708       symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2709
2710       /* Align for symbols.  */
2711       mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
2712       symtab->symoff = mdata->filelen;
2713
2714       symtab->nsyms = bfd_get_symcount (abfd);
2715       mdata->filelen += symtab->nsyms * symlen;
2716     }
2717
2718   /* Build the dysymtab.  */
2719   if (dysymtab != NULL)
2720     if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
2721       return false;
2722
2723   /* Write symtab and strtab.  */
2724   if (symtab != NULL)
2725     if (!bfd_mach_o_write_symtab_content (abfd, symtab))
2726       return false;
2727
2728   /* Adjust linkedit size.  */
2729   if (linkedit != NULL)
2730     {
2731       /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2732
2733       linkedit->vmsize = mdata->filelen - linkedit->fileoff;
2734       /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2735       linkedit->filesize = mdata->filelen - linkedit->fileoff;
2736
2737       linkedit->initprot = BFD_MACH_O_PROT_READ;
2738       linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2739         | BFD_MACH_O_PROT_EXECUTE;
2740     }
2741
2742   /* Second pass: write commands.  */
2743   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2744     {
2745       struct mach_o_load_command_external raw;
2746       unsigned long typeflag;
2747
2748       typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
2749
2750       bfd_h_put_32 (abfd, typeflag, raw.cmd);
2751       bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
2752
2753       if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
2754           || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
2755         return false;
2756
2757       switch (cmd->type)
2758         {
2759         case BFD_MACH_O_LC_SEGMENT:
2760           if (!bfd_mach_o_write_segment_32 (abfd, cmd))
2761             return false;
2762           break;
2763         case BFD_MACH_O_LC_SEGMENT_64:
2764           if (!bfd_mach_o_write_segment_64 (abfd, cmd))
2765             return false;
2766           break;
2767         case BFD_MACH_O_LC_SYMTAB:
2768           if (!bfd_mach_o_write_symtab (abfd, cmd))
2769             return false;
2770           break;
2771         case BFD_MACH_O_LC_DYSYMTAB:
2772           if (!bfd_mach_o_write_dysymtab (abfd, cmd))
2773             return false;
2774           break;
2775         case BFD_MACH_O_LC_THREAD:
2776         case BFD_MACH_O_LC_UNIXTHREAD:
2777           if (!bfd_mach_o_write_thread (abfd, cmd))
2778             return false;
2779           break;
2780         case BFD_MACH_O_LC_LOAD_DYLIB:
2781           if (!bfd_mach_o_write_dylib (abfd, cmd))
2782             return false;
2783           break;
2784         case BFD_MACH_O_LC_LOAD_DYLINKER:
2785           if (!bfd_mach_o_write_dylinker (abfd, cmd))
2786             return false;
2787           break;
2788         case BFD_MACH_O_LC_MAIN:
2789           if (!bfd_mach_o_write_main (abfd, cmd))
2790             return false;
2791           break;
2792         case BFD_MACH_O_LC_DYLD_INFO:
2793           if (!bfd_mach_o_write_dyld_info (abfd, cmd))
2794             return false;
2795           break;
2796         default:
2797           _bfd_error_handler
2798             (_("unable to write unknown load command %#x"),
2799              cmd->type);
2800           return false;
2801         }
2802     }
2803
2804   return true;
2805 }
2806
2807 static void
2808 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2809                                       bfd_mach_o_section *s)
2810 {
2811   if (seg->sect_head == NULL)
2812     seg->sect_head = s;
2813   else
2814     seg->sect_tail->next = s;
2815   seg->sect_tail = s;
2816 }
2817
2818 /* Create section Mach-O flags from BFD flags.  */
2819
2820 static void
2821 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2822                                        asection *sec)
2823 {
2824   flagword bfd_flags;
2825   bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2826
2827   /* Create default flags.  */
2828   bfd_flags = bfd_section_flags (sec);
2829   if ((bfd_flags & SEC_CODE) == SEC_CODE)
2830     s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2831       | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2832       | BFD_MACH_O_S_REGULAR;
2833   else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2834     s->flags = BFD_MACH_O_S_ZEROFILL;
2835   else if (bfd_flags & SEC_DEBUGGING)
2836     s->flags = BFD_MACH_O_S_REGULAR |  BFD_MACH_O_S_ATTR_DEBUG;
2837   else
2838     s->flags = BFD_MACH_O_S_REGULAR;
2839 }
2840
2841 static bool
2842 bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2843 {
2844   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2845   unsigned int i, j;
2846
2847   seg->vmaddr = 0;
2848   seg->fileoff = mdata->filelen;
2849   seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2850     | BFD_MACH_O_PROT_EXECUTE;
2851   seg->maxprot = seg->initprot;
2852
2853   /*  Append sections to the segment.
2854
2855       This is a little tedious, we have to honor the need to account zerofill
2856       sections after all the rest.  This forces us to do the calculation of
2857       total vmsize in three passes so that any alignment increments are
2858       properly accounted.  */
2859   for (i = 0; i < mdata->nsects; ++i)
2860     {
2861       bfd_mach_o_section *s = mdata->sections[i];
2862       asection *sec = s->bfdsection;
2863
2864       /* Although we account for zerofill section sizes in vm order, they are
2865          placed in the file in source sequence.  */
2866       bfd_mach_o_append_section_to_segment (seg, s);
2867       s->offset = 0;
2868
2869       /* Zerofill sections have zero file size & offset, the only content
2870          written to the file is the symbols.  */
2871       if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2872           || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2873               == BFD_MACH_O_S_GB_ZEROFILL))
2874         continue;
2875
2876       /* The Darwin system tools (in MH_OBJECT files, at least) always account
2877          sections, even those with zero size.  */
2878       if (s->size > 0)
2879         {
2880           seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2881           seg->vmsize += s->size;
2882
2883           /* MH_OBJECT files have unaligned content.  */
2884           if (1)
2885             {
2886               seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2887               mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2888             }
2889           seg->filesize += s->size;
2890
2891           /* The system tools write even zero-sized sections with an offset
2892              field set to the current file position.  */
2893           s->offset = mdata->filelen;
2894         }
2895
2896       sec->filepos = s->offset;
2897       mdata->filelen += s->size;
2898     }
2899
2900   /* Now pass through again, for zerofill, only now we just update the
2901      vmsize, and then for zerofill_GB.  */
2902   for (j = 0; j < 2; j++)
2903     {
2904       unsigned int stype;
2905
2906       if (j == 0)
2907         stype = BFD_MACH_O_S_ZEROFILL;
2908       else
2909         stype = BFD_MACH_O_S_GB_ZEROFILL;
2910
2911       for (i = 0; i < mdata->nsects; ++i)
2912         {
2913           bfd_mach_o_section *s = mdata->sections[i];
2914
2915           if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
2916             continue;
2917
2918           if (s->size > 0)
2919             {
2920               seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2921               seg->vmsize += s->size;
2922             }
2923         }
2924     }
2925
2926   /* Allocate space for the relocations.  */
2927   mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2928
2929   for (i = 0; i < mdata->nsects; ++i)
2930     {
2931       bfd_mach_o_section *ms = mdata->sections[i];
2932       asection *sec = ms->bfdsection;
2933
2934       ms->nreloc = sec->reloc_count;
2935       if (ms->nreloc == 0)
2936         {
2937           /* Clear nreloc and reloff if there is no relocs.  */
2938           ms->reloff = 0;
2939           continue;
2940         }
2941       sec->rel_filepos = mdata->filelen;
2942       ms->reloff = sec->rel_filepos;
2943       mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2944     }
2945
2946   return true;
2947 }
2948
2949 static bool
2950 bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2951 {
2952   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2953   unsigned int i;
2954   bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
2955   bfd_vma vma;
2956   bfd_mach_o_section *s;
2957
2958   seg->vmsize = 0;
2959
2960   seg->fileoff = mdata->filelen;
2961   seg->maxprot = 0;
2962   seg->initprot = 0;
2963   seg->flags = 0;
2964
2965   /*  Append sections to the segment.  We assume they are properly ordered
2966       by vma (but we check that).  */
2967   vma = 0;
2968   for (i = 0; i < mdata->nsects; ++i)
2969     {
2970       s = mdata->sections[i];
2971
2972       /* Consider only sections for this segment.  */
2973       if (strcmp (seg->segname, s->segname) != 0)
2974         continue;
2975
2976       bfd_mach_o_append_section_to_segment (seg, s);
2977
2978       if (s->addr < vma)
2979         {
2980           _bfd_error_handler
2981             /* xgettext:c-format */
2982             (_("section address (%#" PRIx64 ") "
2983                "below start of segment (%#" PRIx64 ")"),
2984                (uint64_t) s->addr, (uint64_t) vma);
2985           return false;
2986         }
2987
2988       vma = s->addr + s->size;
2989     }
2990
2991   /* Set segment file offset: make it page aligned.  */
2992   vma = seg->sect_head->addr;
2993   seg->vmaddr = vma & ~pagemask;
2994   if ((mdata->filelen & pagemask) > (vma & pagemask))
2995     mdata->filelen += pagemask + 1;
2996   seg->fileoff = mdata->filelen & ~pagemask;
2997   mdata->filelen = seg->fileoff + (vma & pagemask);
2998
2999   /* Set section file offset.  */
3000   for (s = seg->sect_head; s != NULL; s = s->next)
3001     {
3002       asection *sec = s->bfdsection;
3003       flagword flags = bfd_section_flags (sec);
3004
3005       /* Adjust segment size.  */
3006       seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
3007       seg->vmsize += s->size;
3008
3009       /* File offset and length.  */
3010       seg->filesize = FILE_ALIGN (seg->filesize, s->align);
3011
3012       if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
3013           && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3014               != BFD_MACH_O_S_GB_ZEROFILL))
3015         {
3016           mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
3017
3018           s->offset = mdata->filelen;
3019           s->bfdsection->filepos = s->offset;
3020
3021           seg->filesize += s->size;
3022           mdata->filelen += s->size;
3023         }
3024       else
3025         {
3026           s->offset = 0;
3027           s->bfdsection->filepos = 0;
3028         }
3029
3030       /* Set protection.  */
3031       if (flags & SEC_LOAD)
3032         {
3033           if (flags & SEC_CODE)
3034             seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
3035           if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
3036             seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
3037         }
3038
3039       /* Relocs shouldn't appear in non-object files.  */
3040       if (s->bfdsection->reloc_count != 0)
3041         return false;
3042     }
3043
3044   /* Set maxprot.  */
3045   if (seg->initprot != 0)
3046     seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
3047                  | BFD_MACH_O_PROT_EXECUTE;
3048   else
3049     seg->maxprot = 0;
3050
3051   /* Round segment size (and file size).  */
3052   seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
3053   seg->filesize = (seg->filesize + pagemask) & ~pagemask;
3054   mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
3055
3056   return true;
3057 }
3058
3059 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3060    fields in header.  */
3061
3062 static bool
3063 bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
3064 {
3065   unsigned wide = mach_o_wide_p (&mdata->header);
3066   unsigned int hdrlen;
3067   ufile_ptr offset;
3068   bfd_mach_o_load_command *cmd;
3069   unsigned int align;
3070   bool ret = true;
3071
3072   hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3073   align = wide ? 8 - 1 : 4 - 1;
3074   offset = hdrlen;
3075   mdata->header.ncmds = 0;
3076
3077   for (cmd = mdata->first_command; cmd; cmd = cmd->next)
3078     {
3079       mdata->header.ncmds++;
3080       cmd->offset = offset;
3081
3082       switch (cmd->type)
3083         {
3084         case BFD_MACH_O_LC_SEGMENT_64:
3085           cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
3086             + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
3087           break;
3088         case BFD_MACH_O_LC_SEGMENT:
3089           cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
3090             + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
3091           break;
3092         case BFD_MACH_O_LC_SYMTAB:
3093           cmd->len = sizeof (struct mach_o_symtab_command_external)
3094             + BFD_MACH_O_LC_SIZE;
3095           break;
3096         case BFD_MACH_O_LC_DYSYMTAB:
3097           cmd->len = sizeof (struct mach_o_dysymtab_command_external)
3098                  + BFD_MACH_O_LC_SIZE;
3099           break;
3100         case BFD_MACH_O_LC_LOAD_DYLIB:
3101           cmd->len = sizeof (struct mach_o_dylib_command_external)
3102                  + BFD_MACH_O_LC_SIZE;
3103           cmd->command.dylib.name_offset = cmd->len;
3104           cmd->len += strlen (cmd->command.dylib.name_str);
3105           cmd->len = (cmd->len + align) & ~align;
3106           break;
3107         case BFD_MACH_O_LC_LOAD_DYLINKER:
3108           cmd->len = sizeof (struct mach_o_str_command_external)
3109                  + BFD_MACH_O_LC_SIZE;
3110           cmd->command.dylinker.name_offset = cmd->len;
3111           cmd->len += strlen (cmd->command.dylinker.name_str);
3112           cmd->len = (cmd->len + align) & ~align;
3113           break;
3114         case BFD_MACH_O_LC_MAIN:
3115           cmd->len = sizeof (struct mach_o_entry_point_command_external)
3116                  + BFD_MACH_O_LC_SIZE;
3117           break;
3118         case BFD_MACH_O_LC_DYLD_INFO:
3119           cmd->len = sizeof (struct mach_o_dyld_info_command_external)
3120                  + BFD_MACH_O_LC_SIZE;
3121           break;
3122         default:
3123           _bfd_error_handler
3124             (_("unable to layout unknown load command %#x"),
3125              cmd->type);
3126           ret = false;
3127           break;
3128         }
3129
3130       BFD_ASSERT (cmd->len % (align + 1) == 0);
3131       offset += cmd->len;
3132     }
3133   mdata->header.sizeofcmds = offset - hdrlen;
3134   mdata->filelen = offset;
3135
3136   return ret;
3137 }
3138
3139 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3140    segment.  */
3141
3142 static void
3143 bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
3144                          bfd_mach_o_load_command *cmd,
3145                          const char *segname, unsigned int nbr_sect)
3146 {
3147   bfd_mach_o_segment_command *seg = &cmd->command.segment;
3148   unsigned wide = mach_o_wide_p (&mdata->header);
3149
3150   /* Init segment command.  */
3151   cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
3152   cmd->type_required = false;
3153
3154   strcpy (seg->segname, segname);
3155   seg->nsects = nbr_sect;
3156
3157   seg->vmaddr = 0;
3158   seg->vmsize = 0;
3159
3160   seg->fileoff = 0;
3161   seg->filesize = 0;
3162   seg->maxprot = 0;
3163   seg->initprot = 0;
3164   seg->flags = 0;
3165   seg->sect_head = NULL;
3166   seg->sect_tail = NULL;
3167 }
3168
3169 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3170    TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3171    and copy functionality.  */
3172
3173 bool
3174 bfd_mach_o_build_commands (bfd *abfd)
3175 {
3176   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3177   unsigned wide = mach_o_wide_p (&mdata->header);
3178   unsigned int nbr_segcmd = 0;
3179   bfd_mach_o_load_command *commands;
3180   unsigned int nbr_commands;
3181   int symtab_idx = -1;
3182   int dysymtab_idx = -1;
3183   int main_idx = -1;
3184   unsigned int i;
3185
3186   /* Return now if already built.  */
3187   if (mdata->header.ncmds != 0)
3188     return true;
3189
3190   /* Fill in the file type, if not already set.  */
3191   if (mdata->header.filetype == 0)
3192     {
3193       if (abfd->flags & EXEC_P)
3194         mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
3195       else if (abfd->flags & DYNAMIC)
3196         mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
3197       else
3198         mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
3199     }
3200
3201   /* If hasn't already been done, flatten sections list, and sort
3202      if/when required.  Must be done before the symbol table is adjusted,
3203      since that depends on properly numbered sections.  */
3204   if (mdata->nsects == 0 || mdata->sections == NULL)
3205     if (! bfd_mach_o_mangle_sections (abfd, mdata))
3206       return false;
3207
3208   /* Order the symbol table, fill-in/check mach-o specific fields and
3209      partition out any indirect symbols.  */
3210   if (!bfd_mach_o_mangle_symbols (abfd))
3211     return false;
3212
3213   /* Segment commands.  */
3214   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3215     {
3216       /* Only one segment for all the sections.  But the segment is
3217          optional if there is no sections.  */
3218       nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
3219     }
3220   else
3221     {
3222       bfd_mach_o_section *prev_sect = NULL;
3223
3224       /* One pagezero segment and one linkedit segment.  */
3225       nbr_segcmd = 2;
3226
3227       /* Create one segment for associated segment name in sections.
3228          Assume that sections with the same segment name are consecutive.  */
3229       for (i = 0; i < mdata->nsects; i++)
3230         {
3231           bfd_mach_o_section *this_sect = mdata->sections[i];
3232
3233           if (prev_sect == NULL
3234               || strcmp (prev_sect->segname, this_sect->segname) != 0)
3235             {
3236               nbr_segcmd++;
3237               prev_sect = this_sect;
3238             }
3239         }
3240     }
3241
3242   nbr_commands = nbr_segcmd;
3243
3244   /* One command for the symbol table (only if there are symbols.  */
3245   if (bfd_get_symcount (abfd) > 0)
3246     symtab_idx = nbr_commands++;
3247
3248   /* FIXME:
3249      This is a rather crude test for whether we should build a dysymtab.  */
3250   if (bfd_mach_o_should_emit_dysymtab ()
3251       && bfd_get_symcount (abfd))
3252     {
3253       /* If there should be a case where a dysymtab could be emitted without
3254          a symtab (seems improbable), this would need amending.  */
3255       dysymtab_idx = nbr_commands++;
3256     }
3257
3258   /* Add an entry point command.  */
3259   if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3260       && bfd_get_start_address (abfd) != 0)
3261     main_idx = nbr_commands++;
3262
3263   /* Well, we must have a header, at least.  */
3264   mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3265
3266   /* A bit unusual, but no content is valid;
3267      as -n empty.s -o empty.o  */
3268   if (nbr_commands == 0)
3269     {
3270       /* Layout commands (well none...) and set headers command fields.  */
3271       return bfd_mach_o_layout_commands (mdata);
3272     }
3273
3274   /* Create commands for segments (and symtabs), prepend them.  */
3275   commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3276   if (commands == NULL)
3277     return false;
3278   for (i = 0; i < nbr_commands - 1; i++)
3279     commands[i].next = &commands[i + 1];
3280   commands[nbr_commands - 1].next = mdata->first_command;
3281   if (mdata->first_command == NULL)
3282     mdata->last_command = &commands[nbr_commands - 1];
3283   mdata->first_command = &commands[0];
3284
3285   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3286     {
3287       /* For object file, there is only one segment.  */
3288       bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3289     }
3290   else if (nbr_segcmd != 0)
3291     {
3292       bfd_mach_o_load_command *cmd;
3293
3294       BFD_ASSERT (nbr_segcmd >= 2);
3295
3296       /* The pagezero.  */
3297       cmd = &commands[0];
3298       bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3299
3300       /* Segments from sections.  */
3301       cmd++;
3302       for (i = 0; i < mdata->nsects;)
3303         {
3304           const char *segname = mdata->sections[i]->segname;
3305           unsigned int nbr_sect = 1;
3306
3307           /* Count number of sections for this segment.  */
3308           for (i++; i < mdata->nsects; i++)
3309             if (strcmp (mdata->sections[i]->segname, segname) == 0)
3310               nbr_sect++;
3311             else
3312               break;
3313
3314           bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3315           cmd++;
3316         }
3317
3318       /* The linkedit.  */
3319       bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
3320     }
3321
3322   if (symtab_idx >= 0)
3323     {
3324       /* Init symtab command.  */
3325       bfd_mach_o_load_command *cmd = &commands[symtab_idx];
3326
3327       cmd->type = BFD_MACH_O_LC_SYMTAB;
3328       cmd->type_required = false;
3329     }
3330
3331   /* If required, setup symtab command, see comment above about the quality
3332      of this test.  */
3333   if (dysymtab_idx >= 0)
3334     {
3335       bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
3336
3337       cmd->type = BFD_MACH_O_LC_DYSYMTAB;
3338       cmd->type_required = false;
3339     }
3340
3341   /* Create the main command.  */
3342   if (main_idx >= 0)
3343     {
3344       bfd_mach_o_load_command *cmd = &commands[main_idx];
3345
3346       cmd->type = BFD_MACH_O_LC_MAIN;
3347       cmd->type_required = true;
3348
3349       cmd->command.main.entryoff = 0;
3350       cmd->command.main.stacksize = 0;
3351     }
3352
3353   /* Layout commands.  */
3354   if (! bfd_mach_o_layout_commands (mdata))
3355     return false;
3356
3357   /* So, now we have sized the commands and the filelen set to that.
3358      Now we can build the segment command and set the section file offsets.  */
3359   if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3360     {
3361       for (i = 0; i < nbr_segcmd; i++)
3362         if (!bfd_mach_o_build_obj_seg_command
3363             (abfd, &commands[i].command.segment))
3364           return false;
3365     }
3366   else
3367     {
3368       bfd_vma maxvma = 0;
3369
3370       /* Skip pagezero and linkedit segments.  */
3371       for (i = 1; i < nbr_segcmd - 1; i++)
3372         {
3373           bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3374
3375           if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3376             return false;
3377
3378           if (seg->vmaddr + seg->vmsize > maxvma)
3379             maxvma = seg->vmaddr + seg->vmsize;
3380         }
3381
3382       /* Set the size of __PAGEZERO.  */
3383       commands[0].command.segment.vmsize =
3384         commands[1].command.segment.vmaddr;
3385
3386       /* Set the vma and fileoff of __LINKEDIT.  */
3387       commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3388       commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3389
3390       /* Set entry point (once segments have been laid out).  */
3391       if (main_idx >= 0)
3392         commands[main_idx].command.main.entryoff =
3393           bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3394     }
3395
3396   return true;
3397 }
3398
3399 /* Set the contents of a section.  */
3400
3401 bool
3402 bfd_mach_o_set_section_contents (bfd *abfd,
3403                                  asection *section,
3404                                  const void * location,
3405                                  file_ptr offset,
3406                                  bfd_size_type count)
3407 {
3408   file_ptr pos;
3409
3410   /* Trying to write the first section contents will trigger the creation of
3411      the load commands if they are not already present.  */
3412   if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
3413     return false;
3414
3415   if (count == 0)
3416     return true;
3417
3418   pos = section->filepos + offset;
3419   if (bfd_seek (abfd, pos, SEEK_SET) != 0
3420       || bfd_bwrite (location, count, abfd) != count)
3421     return false;
3422
3423   return true;
3424 }
3425
3426 int
3427 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
3428                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
3429 {
3430   return 0;
3431 }
3432
3433 /* Make an empty symbol.  This is required only because
3434    bfd_make_section_anyway wants to create a symbol for the section.  */
3435
3436 asymbol *
3437 bfd_mach_o_make_empty_symbol (bfd *abfd)
3438 {
3439   asymbol *new_symbol;
3440
3441   new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3442   if (new_symbol == NULL)
3443     return new_symbol;
3444   new_symbol->the_bfd = abfd;
3445   new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
3446   return new_symbol;
3447 }
3448
3449 static bool
3450 bfd_mach_o_read_header (bfd *abfd, file_ptr hdr_off, bfd_mach_o_header *header)
3451 {
3452   struct mach_o_header_external raw;
3453   unsigned int size;
3454   bfd_vma (*get32) (const void *) = NULL;
3455
3456   /* Just read the magic number.  */
3457   if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
3458       || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
3459     return false;
3460
3461   if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3462     {
3463       header->byteorder = BFD_ENDIAN_BIG;
3464       header->magic = BFD_MACH_O_MH_MAGIC;
3465       header->version = 1;
3466       get32 = bfd_getb32;
3467     }
3468   else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3469     {
3470       header->byteorder = BFD_ENDIAN_LITTLE;
3471       header->magic = BFD_MACH_O_MH_MAGIC;
3472       header->version = 1;
3473       get32 = bfd_getl32;
3474     }
3475   else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3476     {
3477       header->byteorder = BFD_ENDIAN_BIG;
3478       header->magic = BFD_MACH_O_MH_MAGIC_64;
3479       header->version = 2;
3480       get32 = bfd_getb32;
3481     }
3482   else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3483     {
3484       header->byteorder = BFD_ENDIAN_LITTLE;
3485       header->magic = BFD_MACH_O_MH_MAGIC_64;
3486       header->version = 2;
3487       get32 = bfd_getl32;
3488     }
3489   else
3490     {
3491       header->byteorder = BFD_ENDIAN_UNKNOWN;
3492       return false;
3493     }
3494
3495   /* Once the size of the header is known, read the full header.  */
3496   size = mach_o_wide_p (header) ?
3497     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3498
3499   if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
3500       || bfd_bread (&raw, size, abfd) != size)
3501     return false;
3502
3503   header->cputype = (*get32) (raw.cputype);
3504   header->cpusubtype = (*get32) (raw.cpusubtype);
3505   header->filetype = (*get32) (raw.filetype);
3506   header->ncmds = (*get32) (raw.ncmds);
3507   header->sizeofcmds = (*get32) (raw.sizeofcmds);
3508   header->flags = (*get32) (raw.flags);
3509
3510   if (mach_o_wide_p (header))
3511     header->reserved = (*get32) (raw.reserved);
3512   else
3513     header->reserved = 0;
3514
3515   return true;
3516 }
3517
3518 bool
3519 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3520 {
3521   bfd_mach_o_section *s;
3522   unsigned bfdalign = bfd_section_alignment (sec);
3523
3524   s = bfd_mach_o_get_mach_o_section (sec);
3525   if (s == NULL)
3526     {
3527       flagword bfd_flags;
3528       static const mach_o_section_name_xlat * xlat;
3529
3530       s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3531       if (s == NULL)
3532         return false;
3533       sec->used_by_bfd = s;
3534       s->bfdsection = sec;
3535
3536       /* Create the Darwin seg/sect name pair from the bfd name.
3537          If this is a canonical name for which a specific paiting exists
3538          there will also be defined flags, type, attribute and alignment
3539          values.  */
3540       xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3541       if (xlat != NULL)
3542         {
3543           s->flags = xlat->macho_sectype | xlat->macho_secattr;
3544           s->align = xlat->sectalign > bfdalign ? xlat->sectalign
3545                                                 : bfdalign;
3546           bfd_set_section_alignment (sec, s->align);
3547           bfd_flags = bfd_section_flags (sec);
3548           if (bfd_flags == SEC_NO_FLAGS)
3549             bfd_set_section_flags (sec, xlat->bfd_flags);
3550         }
3551       else
3552         /* Create default flags.  */
3553         bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
3554     }
3555
3556   return _bfd_generic_new_section_hook (abfd, sec);
3557 }
3558
3559 static void
3560 bfd_mach_o_init_section_from_mach_o (asection *sec, unsigned long prot)
3561 {
3562   flagword flags;
3563   bfd_mach_o_section *section;
3564
3565   flags = bfd_section_flags (sec);
3566   section = bfd_mach_o_get_mach_o_section (sec);
3567
3568   /* TODO: see if we should use the xlat system for doing this by
3569      preference and fall back to this for unknown sections.  */
3570
3571   if (flags == SEC_NO_FLAGS)
3572     {
3573       /* Try to guess flags.  */
3574       if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
3575         flags = SEC_DEBUGGING;
3576       else
3577         {
3578           flags = SEC_ALLOC;
3579           if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3580               != BFD_MACH_O_S_ZEROFILL)
3581             {
3582               flags |= SEC_LOAD;
3583               if (prot & BFD_MACH_O_PROT_EXECUTE)
3584                 flags |= SEC_CODE;
3585               if (prot & BFD_MACH_O_PROT_WRITE)
3586                 flags |= SEC_DATA;
3587               else if (prot & BFD_MACH_O_PROT_READ)
3588                 flags |= SEC_READONLY;
3589             }
3590         }
3591     }
3592   else
3593     {
3594       if ((flags & SEC_DEBUGGING) == 0)
3595         flags |= SEC_ALLOC;
3596     }
3597
3598   if (section->offset != 0)
3599     flags |= SEC_HAS_CONTENTS;
3600   if (section->nreloc != 0)
3601     flags |= SEC_RELOC;
3602
3603   bfd_set_section_flags (sec, flags);
3604
3605   sec->vma = section->addr;
3606   sec->lma = section->addr;
3607   sec->size = section->size;
3608   sec->filepos = section->offset;
3609   sec->alignment_power = section->align;
3610   sec->segment_mark = 0;
3611   sec->reloc_count = section->nreloc;
3612   sec->rel_filepos = section->reloff;
3613 }
3614
3615 static asection *
3616 bfd_mach_o_make_bfd_section (bfd *abfd,
3617                              const unsigned char *segname,
3618                              const unsigned char *sectname)
3619 {
3620   const char *sname;
3621   flagword flags;
3622
3623   bfd_mach_o_convert_section_name_to_bfd
3624     (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3625   if (sname == NULL)
3626     return NULL;
3627
3628   return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3629 }
3630
3631 static asection *
3632 bfd_mach_o_read_section_32 (bfd *abfd, unsigned long prot)
3633 {
3634   struct mach_o_section_32_external raw;
3635   asection *sec;
3636   bfd_mach_o_section *section;
3637
3638   if (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3639       != BFD_MACH_O_SECTION_SIZE)
3640     return NULL;
3641
3642   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3643   if (sec == NULL)
3644     return NULL;
3645
3646   section = bfd_mach_o_get_mach_o_section (sec);
3647   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3648   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3649   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3650   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3651   section->addr = bfd_h_get_32 (abfd, raw.addr);
3652   section->size = bfd_h_get_32 (abfd, raw.size);
3653   section->offset = bfd_h_get_32 (abfd, raw.offset);
3654   section->align = bfd_h_get_32 (abfd, raw.align);
3655   /* PR 17512: file: 0017eb76.  */
3656   if (section->align > 64)
3657     {
3658       _bfd_error_handler
3659         (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx, "
3660            "using 32 instead"), section->align);
3661       section->align = 32;
3662     }
3663   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3664   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3665   section->flags = bfd_h_get_32 (abfd, raw.flags);
3666   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3667   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3668   section->reserved3 = 0;
3669
3670   bfd_mach_o_init_section_from_mach_o (sec, prot);
3671
3672   return sec;
3673 }
3674
3675 static asection *
3676 bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
3677 {
3678   struct mach_o_section_64_external raw;
3679   asection *sec;
3680   bfd_mach_o_section *section;
3681
3682   if (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3683       != BFD_MACH_O_SECTION_64_SIZE)
3684     return NULL;
3685
3686   sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3687   if (sec == NULL)
3688     return NULL;
3689
3690   section = bfd_mach_o_get_mach_o_section (sec);
3691   memcpy (section->segname, raw.segname, sizeof (raw.segname));
3692   section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3693   memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3694   section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3695   section->addr = bfd_h_get_64 (abfd, raw.addr);
3696   section->size = bfd_h_get_64 (abfd, raw.size);
3697   section->offset = bfd_h_get_32 (abfd, raw.offset);
3698   section->align = bfd_h_get_32 (abfd, raw.align);
3699   if (section->align > 64)
3700     {
3701       _bfd_error_handler
3702         (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx, "
3703            "using 32 instead"), section->align);
3704       section->align = 32;
3705     }
3706   section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3707   section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3708   section->flags = bfd_h_get_32 (abfd, raw.flags);
3709   section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3710   section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3711   section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3712
3713   bfd_mach_o_init_section_from_mach_o (sec, prot);
3714
3715   return sec;
3716 }
3717
3718 static asection *
3719 bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
3720 {
3721   if (wide)
3722     return bfd_mach_o_read_section_64 (abfd, prot);
3723   else
3724     return bfd_mach_o_read_section_32 (abfd, prot);
3725 }
3726
3727 static bool
3728 bfd_mach_o_read_symtab_symbol (bfd *abfd,
3729                                bfd_mach_o_symtab_command *sym,
3730                                bfd_mach_o_asymbol *s,
3731                                unsigned long i)
3732 {
3733   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3734   unsigned int wide = mach_o_wide_p (&mdata->header);
3735   unsigned int symwidth =
3736     wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3737   unsigned int symoff = sym->symoff + (i * symwidth);
3738   struct mach_o_nlist_64_external raw;
3739   unsigned char type = -1;
3740   unsigned char section = -1;
3741   short desc = -1;
3742   symvalue value = -1;
3743   unsigned long stroff = -1;
3744   unsigned int symtype = -1;
3745
3746   BFD_ASSERT (sym->strtab != NULL);
3747
3748   if (bfd_seek (abfd, symoff, SEEK_SET) != 0
3749       || bfd_bread (&raw, symwidth, abfd) != symwidth)
3750     {
3751       _bfd_error_handler
3752         /* xgettext:c-format */
3753         (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3754          symwidth, symoff);
3755       return false;
3756     }
3757
3758   stroff = bfd_h_get_32 (abfd, raw.n_strx);
3759   type = bfd_h_get_8 (abfd, raw.n_type);
3760   symtype = type & BFD_MACH_O_N_TYPE;
3761   section = bfd_h_get_8 (abfd, raw.n_sect);
3762   desc = bfd_h_get_16 (abfd, raw.n_desc);
3763   if (wide)
3764     value = bfd_h_get_64 (abfd, raw.n_value);
3765   else
3766     value = bfd_h_get_32 (abfd, raw.n_value);
3767
3768   if (stroff >= sym->strsize)
3769     {
3770       _bfd_error_handler
3771         /* xgettext:c-format */
3772         (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3773          stroff,
3774          sym->strsize);
3775       return false;
3776     }
3777
3778   s->symbol.the_bfd = abfd;
3779   s->symbol.name = sym->strtab + stroff;
3780   s->symbol.value = value;
3781   s->symbol.flags = 0x0;
3782   s->symbol.udata.i = i;
3783   s->n_type = type;
3784   s->n_sect = section;
3785   s->n_desc = desc;
3786
3787   if (type & BFD_MACH_O_N_STAB)
3788     {
3789       s->symbol.flags |= BSF_DEBUGGING;
3790       s->symbol.section = bfd_und_section_ptr;
3791       switch (type)
3792         {
3793         case N_FUN:
3794         case N_STSYM:
3795         case N_LCSYM:
3796         case N_BNSYM:
3797         case N_SLINE:
3798         case N_ENSYM:
3799         case N_ECOMM:
3800         case N_ECOML:
3801         case N_GSYM:
3802           if ((section > 0) && (section <= mdata->nsects))
3803             {
3804               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3805               s->symbol.value =
3806                 s->symbol.value - mdata->sections[section - 1]->addr;
3807             }
3808           break;
3809         }
3810     }
3811   else
3812     {
3813       if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
3814         s->symbol.flags |= BSF_GLOBAL;
3815       else
3816         s->symbol.flags |= BSF_LOCAL;
3817
3818       switch (symtype)
3819         {
3820         case BFD_MACH_O_N_UNDF:
3821           if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3822               && s->symbol.value != 0)
3823             {
3824               /* A common symbol.  */
3825               s->symbol.section = bfd_com_section_ptr;
3826               s->symbol.flags = BSF_NO_FLAGS;
3827             }
3828           else
3829             {
3830               s->symbol.section = bfd_und_section_ptr;
3831               if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3832                 s->symbol.flags |= BSF_WEAK;
3833             }
3834           break;
3835         case BFD_MACH_O_N_PBUD:
3836           s->symbol.section = bfd_und_section_ptr;
3837           break;
3838         case BFD_MACH_O_N_ABS:
3839           s->symbol.section = bfd_abs_section_ptr;
3840           break;
3841         case BFD_MACH_O_N_SECT:
3842           if ((section > 0) && (section <= mdata->nsects))
3843             {
3844               s->symbol.section = mdata->sections[section - 1]->bfdsection;
3845               s->symbol.value =
3846                 s->symbol.value - mdata->sections[section - 1]->addr;
3847             }
3848           else
3849             {
3850               /* Mach-O uses 0 to mean "no section"; not an error.  */
3851               if (section != 0)
3852                 {
3853                   _bfd_error_handler
3854                     /* xgettext:c-format */
3855                     (_("bfd_mach_o_read_symtab_symbol: "
3856                        "symbol \"%s\" specified invalid section %d (max %lu): "
3857                        "setting to undefined"),
3858                      s->symbol.name, section, mdata->nsects);
3859                 }
3860               s->symbol.section = bfd_und_section_ptr;
3861             }
3862           break;
3863         case BFD_MACH_O_N_INDR:
3864           /* FIXME: we don't follow the BFD convention as this indirect symbol
3865              won't be followed by the referenced one.  This looks harmless
3866              unless we start using the linker.  */
3867           s->symbol.flags |= BSF_INDIRECT;
3868           s->symbol.section = bfd_ind_section_ptr;
3869           s->symbol.value = 0;
3870           break;
3871         default:
3872           _bfd_error_handler
3873             /* xgettext:c-format */
3874             (_("bfd_mach_o_read_symtab_symbol: "
3875                "symbol \"%s\" specified invalid type field 0x%x: "
3876                "setting to undefined"), s->symbol.name, symtype);
3877           s->symbol.section = bfd_und_section_ptr;
3878           break;
3879         }
3880     }
3881
3882   return true;
3883 }
3884
3885 bool
3886 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3887 {
3888   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3889   bfd_mach_o_symtab_command *sym = mdata->symtab;
3890
3891   /* Fail if there is no symtab.  */
3892   if (sym == NULL)
3893     return false;
3894
3895   /* Success if already loaded.  */
3896   if (sym->strtab)
3897     return true;
3898
3899   if (abfd->flags & BFD_IN_MEMORY)
3900     {
3901       struct bfd_in_memory *b;
3902
3903       b = (struct bfd_in_memory *) abfd->iostream;
3904
3905       if ((sym->stroff + sym->strsize) > b->size)
3906         {
3907           bfd_set_error (bfd_error_file_truncated);
3908           return false;
3909         }
3910       sym->strtab = (char *) b->buffer + sym->stroff;
3911     }
3912   else
3913     {
3914       /* See PR 21840 for a reproducer.  */
3915       if ((sym->strsize + 1) == 0)
3916         return false;
3917       if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
3918         return false;
3919       sym->strtab = (char *) _bfd_alloc_and_read (abfd, sym->strsize + 1,
3920                                                   sym->strsize);
3921       if (sym->strtab == NULL)
3922         return false;
3923
3924       /* Zero terminate the string table.  */
3925       sym->strtab[sym->strsize] = 0;
3926     }
3927
3928   return true;
3929 }
3930
3931 bool
3932 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3933 {
3934   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3935   bfd_mach_o_symtab_command *sym = mdata->symtab;
3936   unsigned long i;
3937   size_t amt;
3938   ufile_ptr filesize;
3939
3940   if (sym == NULL || sym->nsyms == 0 || sym->symbols)
3941     /* Return now if there are no symbols or if already loaded.  */
3942     return true;
3943
3944   filesize = bfd_get_file_size (abfd);
3945   if (filesize != 0)
3946     {
3947       unsigned int wide = mach_o_wide_p (&mdata->header);
3948       unsigned int symwidth
3949         = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3950
3951       if (sym->symoff > filesize
3952           || sym->nsyms > (filesize - sym->symoff) / symwidth)
3953         {
3954           bfd_set_error (bfd_error_file_truncated);
3955           sym->nsyms = 0;
3956           return false;
3957         }
3958     }
3959   if (_bfd_mul_overflow (sym->nsyms, sizeof (bfd_mach_o_asymbol), &amt)
3960       || (sym->symbols = bfd_alloc (abfd, amt)) == NULL)
3961     {
3962       bfd_set_error (bfd_error_no_memory);
3963       sym->nsyms = 0;
3964       return false;
3965     }
3966
3967   if (!bfd_mach_o_read_symtab_strtab (abfd))
3968     goto fail;
3969
3970   for (i = 0; i < sym->nsyms; i++)
3971     if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3972       goto fail;
3973
3974   return true;
3975
3976  fail:
3977   bfd_release (abfd, sym->symbols);
3978   sym->symbols = NULL;
3979   sym->nsyms = 0;
3980   return false;
3981 }
3982
3983 static const char *
3984 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3985 {
3986   switch ((int) flavour)
3987     {
3988     case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
3989     case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
3990     case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3991     case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
3992     case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
3993     case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3994     case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
3995     case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
3996     case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
3997     case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
3998     case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
3999     case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
4000     case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
4001     default: return "UNKNOWN";
4002     }
4003 }
4004
4005 static const char *
4006 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
4007 {
4008   switch ((int) flavour)
4009     {
4010     case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
4011     case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
4012     case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
4013     case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
4014     case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
4015     case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
4016     default: return "UNKNOWN";
4017     }
4018 }
4019
4020 static unsigned char *
4021 bfd_mach_o_alloc_and_read (bfd *abfd, file_ptr filepos, size_t size)
4022 {
4023   if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
4024     return NULL;
4025   return _bfd_alloc_and_read (abfd, size, size);
4026 }
4027
4028 static bool
4029 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
4030 {
4031   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
4032   struct mach_o_str_command_external raw;
4033   unsigned int nameoff;
4034   unsigned int namelen;
4035
4036   if (command->len < sizeof (raw) + 8)
4037     return false;
4038   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4039     return false;
4040
4041   nameoff = bfd_h_get_32 (abfd, raw.str);
4042   if (nameoff > command->len)
4043     return false;
4044
4045   cmd->name_offset = nameoff;
4046   namelen = command->len - nameoff;
4047   nameoff += command->offset;
4048   cmd->name_str = (char *) bfd_mach_o_alloc_and_read (abfd, nameoff, namelen);
4049   return cmd->name_str != NULL;
4050 }
4051
4052 static bool
4053 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
4054 {
4055   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4056   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
4057   struct mach_o_dylib_command_external raw;
4058   unsigned int nameoff;
4059   unsigned int namelen;
4060   file_ptr pos;
4061
4062   if (command->len < sizeof (raw) + 8)
4063     return false;
4064   switch (command->type)
4065     {
4066     case BFD_MACH_O_LC_LOAD_DYLIB:
4067     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4068     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4069     case BFD_MACH_O_LC_ID_DYLIB:
4070     case BFD_MACH_O_LC_REEXPORT_DYLIB:
4071     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4072       break;
4073     default:
4074       BFD_FAIL ();
4075       return false;
4076     }
4077
4078   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4079     return false;
4080
4081   nameoff = bfd_h_get_32 (abfd, raw.name);
4082   if (nameoff > command->len)
4083     return false;
4084   cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
4085   cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
4086   cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
4087
4088   cmd->name_offset = command->offset + nameoff;
4089   namelen = command->len - nameoff;
4090   pos = mdata->hdr_offset + cmd->name_offset;
4091   cmd->name_str = (char *) bfd_mach_o_alloc_and_read (abfd, pos, namelen);
4092   return cmd->name_str != NULL;
4093 }
4094
4095 static bool
4096 bfd_mach_o_read_prebound_dylib (bfd *abfd,
4097                                 bfd_mach_o_load_command *command)
4098 {
4099   bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
4100   struct mach_o_prebound_dylib_command_external raw;
4101   unsigned int nameoff;
4102   unsigned int modoff;
4103   unsigned int str_len;
4104   unsigned char *str;
4105
4106   if (command->len < sizeof (raw) + 8)
4107     return false;
4108   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4109     return false;
4110
4111   nameoff = bfd_h_get_32 (abfd, raw.name);
4112   modoff = bfd_h_get_32 (abfd, raw.linked_modules);
4113   if (nameoff > command->len || modoff > command->len)
4114     return false;
4115
4116   str_len = command->len - sizeof (raw);
4117   str = _bfd_alloc_and_read (abfd, str_len, str_len);
4118   if (str == NULL)
4119     return false;
4120
4121   cmd->name_offset = command->offset + nameoff;
4122   cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
4123   cmd->linked_modules_offset = command->offset + modoff;
4124
4125   cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
4126   cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
4127   return true;
4128 }
4129
4130 static bool
4131 bfd_mach_o_read_prebind_cksum (bfd *abfd,
4132                                bfd_mach_o_load_command *command)
4133 {
4134   bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
4135   struct mach_o_prebind_cksum_command_external raw;
4136
4137   if (command->len < sizeof (raw) + 8)
4138     return false;
4139   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4140     return false;
4141
4142   cmd->cksum = bfd_get_32 (abfd, raw.cksum);
4143   return true;
4144 }
4145
4146 static bool
4147 bfd_mach_o_read_twolevel_hints (bfd *abfd,
4148                                 bfd_mach_o_load_command *command)
4149 {
4150   bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
4151   struct mach_o_twolevel_hints_command_external raw;
4152
4153   if (command->len < sizeof (raw) + 8)
4154     return false;
4155   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4156     return false;
4157
4158   cmd->offset = bfd_get_32 (abfd, raw.offset);
4159   cmd->nhints = bfd_get_32 (abfd, raw.nhints);
4160   return true;
4161 }
4162
4163 static bool
4164 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
4165 {
4166   bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
4167   struct mach_o_fvmlib_command_external raw;
4168   unsigned int nameoff;
4169   unsigned int namelen;
4170
4171   if (command->len < sizeof (raw) + 8)
4172     return false;
4173   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4174     return false;
4175
4176   nameoff = bfd_h_get_32 (abfd, raw.name);
4177   if (nameoff > command->len)
4178     return false;
4179   fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
4180   fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
4181
4182   fvm->name_offset = command->offset + nameoff;
4183   namelen = command->len - nameoff;
4184   fvm->name_str = (char *) bfd_mach_o_alloc_and_read (abfd, fvm->name_offset,
4185                                                       namelen);
4186   return fvm->name_str != NULL;
4187 }
4188
4189 static bool
4190 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
4191 {
4192   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4193   bfd_mach_o_thread_command *cmd = &command->command.thread;
4194   unsigned int offset;
4195   unsigned int nflavours;
4196   unsigned int i;
4197   struct mach_o_thread_command_external raw;
4198   size_t amt;
4199
4200   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
4201               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
4202
4203   /* Count the number of threads.  */
4204   offset = 8;
4205   nflavours = 0;
4206   while (offset + sizeof (raw) <= command->len)
4207     {
4208       unsigned int count;
4209
4210       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4211           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4212         return false;
4213
4214       count = bfd_h_get_32 (abfd, raw.count);
4215       if (count > (unsigned) -1 / 4
4216           || command->len - (offset + sizeof (raw)) < count * 4)
4217         return false;
4218       offset += sizeof (raw) + count * 4;
4219       nflavours++;
4220     }
4221   if (nflavours == 0 || offset != command->len)
4222     return false;
4223
4224   /* Allocate threads.  */
4225   if (_bfd_mul_overflow (nflavours, sizeof (bfd_mach_o_thread_flavour), &amt))
4226     {
4227       bfd_set_error (bfd_error_file_too_big);
4228       return false;
4229     }
4230   cmd->flavours = bfd_alloc (abfd, amt);
4231   if (cmd->flavours == NULL)
4232     return false;
4233   cmd->nflavours = nflavours;
4234
4235   offset = 8;
4236   nflavours = 0;
4237   while (offset != command->len)
4238     {
4239       if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4240           || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4241         return false;
4242
4243       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4244       cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4245       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4246       offset += cmd->flavours[nflavours].size + sizeof (raw);
4247       nflavours++;
4248     }
4249
4250   for (i = 0; i < nflavours; i++)
4251     {
4252       asection *bfdsec;
4253       unsigned int snamelen;
4254       char *sname;
4255       const char *flavourstr;
4256       const char *prefix = "LC_THREAD";
4257       unsigned int j = 0;
4258
4259       switch (mdata->header.cputype)
4260         {
4261         case BFD_MACH_O_CPU_TYPE_POWERPC:
4262         case BFD_MACH_O_CPU_TYPE_POWERPC_64:
4263           flavourstr =
4264             bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
4265           break;
4266         case BFD_MACH_O_CPU_TYPE_I386:
4267         case BFD_MACH_O_CPU_TYPE_X86_64:
4268           flavourstr =
4269             bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
4270           break;
4271         default:
4272           flavourstr = "UNKNOWN_ARCHITECTURE";
4273           break;
4274         }
4275
4276       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
4277       sname = bfd_alloc (abfd, snamelen);
4278       if (sname == NULL)
4279         return false;
4280
4281       for (;;)
4282         {
4283           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4284           if (bfd_get_section_by_name (abfd, sname) == NULL)
4285             break;
4286           j++;
4287         }
4288
4289       bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
4290
4291       bfdsec->vma = 0;
4292       bfdsec->lma = 0;
4293       bfdsec->size = cmd->flavours[i].size;
4294       bfdsec->filepos = cmd->flavours[i].offset;
4295       bfdsec->alignment_power = 0x0;
4296
4297       cmd->section = bfdsec;
4298     }
4299
4300   return true;
4301 }
4302
4303 static bool
4304 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command,
4305                           ufile_ptr filesize)
4306 {
4307   bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
4308   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4309
4310   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4311
4312   {
4313     struct mach_o_dysymtab_command_external raw;
4314
4315     if (command->len < sizeof (raw) + 8)
4316       return false;
4317     if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4318       return false;
4319
4320     cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4321     cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4322     cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4323     cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4324     cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4325     cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4326     cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4327     cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4328     cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4329     cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4330     cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4331     cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4332     cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4333     cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4334     cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4335     cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4336     cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4337     cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4338   }
4339
4340   if (cmd->nmodtab != 0)
4341     {
4342       unsigned int i;
4343       int wide = bfd_mach_o_wide_p (abfd);
4344       unsigned int module_len = wide ? 56 : 52;
4345       size_t amt;
4346
4347       if (cmd->modtaboff > filesize
4348           || cmd->nmodtab > (filesize - cmd->modtaboff) / module_len)
4349         {
4350           bfd_set_error (bfd_error_file_truncated);
4351           return false;
4352         }
4353       if (_bfd_mul_overflow (cmd->nmodtab,
4354                              sizeof (bfd_mach_o_dylib_module), &amt))
4355         {
4356           bfd_set_error (bfd_error_file_too_big);
4357           return false;
4358         }
4359       cmd->dylib_module = bfd_alloc (abfd, amt);
4360       if (cmd->dylib_module == NULL)
4361         return false;
4362
4363       if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
4364         return false;
4365
4366       for (i = 0; i < cmd->nmodtab; i++)
4367         {
4368           bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4369           unsigned long v;
4370           unsigned char buf[56];
4371
4372           if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4373             return false;
4374
4375           module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4376           module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4377           module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4378           module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4379           module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4380           module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4381           module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4382           module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4383           module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4384           v = bfd_h_get_32 (abfd, buf +36);
4385           module->iinit = v & 0xffff;
4386           module->iterm = (v >> 16) & 0xffff;
4387           v = bfd_h_get_32 (abfd, buf + 40);
4388           module->ninit = v & 0xffff;
4389           module->nterm = (v >> 16) & 0xffff;
4390           if (wide)
4391             {
4392               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4393               module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4394             }
4395           else
4396             {
4397               module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4398               module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4399             }
4400         }
4401     }
4402
4403   if (cmd->ntoc != 0)
4404     {
4405       unsigned long i;
4406       size_t amt;
4407       struct mach_o_dylib_table_of_contents_external raw;
4408
4409       if (cmd->tocoff > filesize
4410           || cmd->ntoc > (filesize - cmd->tocoff) / sizeof (raw))
4411         {
4412           bfd_set_error (bfd_error_file_truncated);
4413           return false;
4414         }
4415       if (_bfd_mul_overflow (cmd->ntoc,
4416                              sizeof (bfd_mach_o_dylib_table_of_content), &amt))
4417         {
4418           bfd_set_error (bfd_error_file_too_big);
4419           return false;
4420         }
4421       cmd->dylib_toc = bfd_alloc (abfd, amt);
4422       if (cmd->dylib_toc == NULL)
4423         return false;
4424
4425       if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
4426         return false;
4427
4428       for (i = 0; i < cmd->ntoc; i++)
4429         {
4430           bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
4431
4432           if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4433             return false;
4434
4435           toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4436           toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4437         }
4438     }
4439
4440   if (cmd->nindirectsyms != 0)
4441     {
4442       unsigned int i;
4443       size_t amt;
4444
4445       if (cmd->indirectsymoff > filesize
4446           || cmd->nindirectsyms > (filesize - cmd->indirectsymoff) / 4)
4447         {
4448           bfd_set_error (bfd_error_file_truncated);
4449           return false;
4450         }
4451       if (_bfd_mul_overflow (cmd->nindirectsyms, sizeof (unsigned int), &amt))
4452         {
4453           bfd_set_error (bfd_error_file_too_big);
4454           return false;
4455         }
4456       cmd->indirect_syms = bfd_alloc (abfd, amt);
4457       if (cmd->indirect_syms == NULL)
4458         return false;
4459
4460       if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
4461         return false;
4462
4463       for (i = 0; i < cmd->nindirectsyms; i++)
4464         {
4465           unsigned char raw[4];
4466           unsigned int *is = &cmd->indirect_syms[i];
4467
4468           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4469             return false;
4470
4471           *is = bfd_h_get_32 (abfd, raw);
4472         }
4473     }
4474
4475   if (cmd->nextrefsyms != 0)
4476     {
4477       unsigned long v;
4478       unsigned int i;
4479       size_t amt;
4480
4481       if (cmd->extrefsymoff > filesize
4482           || cmd->nextrefsyms > (filesize - cmd->extrefsymoff) / 4)
4483         {
4484           bfd_set_error (bfd_error_file_truncated);
4485           return false;
4486         }
4487       if (_bfd_mul_overflow (cmd->nextrefsyms,
4488                              sizeof (bfd_mach_o_dylib_reference), &amt))
4489         {
4490           bfd_set_error (bfd_error_file_too_big);
4491           return false;
4492         }
4493       cmd->ext_refs = bfd_alloc (abfd, amt);
4494       if (cmd->ext_refs == NULL)
4495         return false;
4496
4497       if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
4498         return false;
4499
4500       for (i = 0; i < cmd->nextrefsyms; i++)
4501         {
4502           unsigned char raw[4];
4503           bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4504
4505           if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4506             return false;
4507
4508           /* Fields isym and flags are written as bit-fields, thus we need
4509              a specific processing for endianness.  */
4510           v = bfd_h_get_32 (abfd, raw);
4511           if (bfd_big_endian (abfd))
4512             {
4513               ref->isym = (v >> 8) & 0xffffff;
4514               ref->flags = v & 0xff;
4515             }
4516           else
4517             {
4518               ref->isym = v & 0xffffff;
4519               ref->flags = (v >> 24) & 0xff;
4520             }
4521         }
4522     }
4523
4524   if (mdata->dysymtab)
4525     return false;
4526   mdata->dysymtab = cmd;
4527
4528   return true;
4529 }
4530
4531 static bool
4532 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command,
4533                         ufile_ptr filesize)
4534 {
4535   bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4536   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4537   struct mach_o_symtab_command_external raw;
4538
4539   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4540
4541   if (command->len < sizeof (raw) + 8)
4542     return false;
4543   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4544     return false;
4545
4546   symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4547   symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4548   symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4549   symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
4550   symtab->symbols = NULL;
4551   symtab->strtab = NULL;
4552
4553   if (symtab->symoff > filesize
4554       || symtab->nsyms > (filesize - symtab->symoff) / BFD_MACH_O_NLIST_SIZE
4555       || symtab->stroff > filesize
4556       || symtab->strsize > filesize - symtab->stroff)
4557     {
4558       bfd_set_error (bfd_error_file_truncated);
4559       return false;
4560     }
4561
4562   if (symtab->nsyms != 0)
4563     abfd->flags |= HAS_SYMS;
4564
4565   if (mdata->symtab)
4566     return false;
4567   mdata->symtab = symtab;
4568   return true;
4569 }
4570
4571 static bool
4572 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
4573 {
4574   bfd_mach_o_uuid_command *cmd = &command->command.uuid;
4575
4576   BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4577
4578   if (command->len < 16 + 8)
4579     return false;
4580   if (bfd_bread (cmd->uuid, 16, abfd) != 16)
4581     return false;
4582
4583   return true;
4584 }
4585
4586 static bool
4587 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
4588 {
4589   bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
4590   struct mach_o_linkedit_data_command_external raw;
4591
4592   if (command->len < sizeof (raw) + 8)
4593     return false;
4594   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4595     return false;
4596
4597   cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4598   cmd->datasize = bfd_get_32 (abfd, raw.datasize);
4599   return true;
4600 }
4601
4602 static bool
4603 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
4604 {
4605   bfd_mach_o_str_command *cmd = &command->command.str;
4606   struct mach_o_str_command_external raw;
4607   unsigned long off;
4608
4609   if (command->len < sizeof (raw) + 8)
4610     return false;
4611   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4612     return false;
4613
4614   off = bfd_get_32 (abfd, raw.str);
4615   if (off > command->len)
4616     return false;
4617
4618   cmd->stroff = command->offset + off;
4619   cmd->str_len = command->len - off;
4620   cmd->str = (char *) bfd_mach_o_alloc_and_read (abfd, cmd->stroff,
4621                                                  cmd->str_len);
4622   return cmd->str != NULL;
4623 }
4624
4625 static bool
4626 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4627 {
4628   /* Read rebase content.  */
4629   if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4630     {
4631       cmd->rebase_content
4632         = bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4633       if (cmd->rebase_content == NULL)
4634         return false;
4635     }
4636
4637   /* Read bind content.  */
4638   if (cmd->bind_content == NULL && cmd->bind_size != 0)
4639     {
4640       cmd->bind_content
4641         = bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4642       if (cmd->bind_content == NULL)
4643         return false;
4644     }
4645
4646   /* Read weak bind content.  */
4647   if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4648     {
4649       cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4650         (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4651       if (cmd->weak_bind_content == NULL)
4652         return false;
4653     }
4654
4655   /* Read lazy bind content.  */
4656   if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4657     {
4658       cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4659         (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4660       if (cmd->lazy_bind_content == NULL)
4661         return false;
4662     }
4663
4664   /* Read export content.  */
4665   if (cmd->export_content == NULL && cmd->export_size != 0)
4666     {
4667       cmd->export_content = bfd_mach_o_alloc_and_read
4668         (abfd, cmd->export_off, cmd->export_size);
4669       if (cmd->export_content == NULL)
4670         return false;
4671     }
4672
4673   return true;
4674 }
4675
4676 static bool
4677 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
4678 {
4679   bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
4680   struct mach_o_dyld_info_command_external raw;
4681
4682   if (command->len < sizeof (raw) + 8)
4683     return false;
4684   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4685     return false;
4686
4687   cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4688   cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
4689   cmd->rebase_content = NULL;
4690   cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4691   cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
4692   cmd->bind_content = NULL;
4693   cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4694   cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
4695   cmd->weak_bind_content = NULL;
4696   cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4697   cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
4698   cmd->lazy_bind_content = NULL;
4699   cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4700   cmd->export_size = bfd_get_32 (abfd, raw.export_size);
4701   cmd->export_content = NULL;
4702   return true;
4703 }
4704
4705 static bool
4706 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4707 {
4708   bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4709   struct mach_o_version_min_command_external raw;
4710
4711   if (command->len < sizeof (raw) + 8)
4712     return false;
4713   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4714     return false;
4715
4716   cmd->version = bfd_get_32 (abfd, raw.version);
4717   cmd->sdk = bfd_get_32 (abfd, raw.sdk);
4718   return true;
4719 }
4720
4721 static bool
4722 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4723 {
4724   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4725   struct mach_o_encryption_info_command_external raw;
4726
4727   if (command->len < sizeof (raw) + 8)
4728     return false;
4729   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4730     return false;
4731
4732   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4733   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4734   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4735   return true;
4736 }
4737
4738 static bool
4739 bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
4740 {
4741   bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4742   struct mach_o_encryption_info_64_command_external raw;
4743
4744   if (command->len < sizeof (raw) + 8)
4745     return false;
4746   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4747     return false;
4748
4749   cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4750   cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4751   cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4752   return true;
4753 }
4754
4755 static bool
4756 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4757 {
4758   bfd_mach_o_main_command *cmd = &command->command.main;
4759   struct mach_o_entry_point_command_external raw;
4760
4761   if (command->len < sizeof (raw) + 8)
4762     return false;
4763   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4764     return false;
4765
4766   cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4767   cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4768   return true;
4769 }
4770
4771 static bool
4772 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4773 {
4774   bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4775   struct mach_o_source_version_command_external raw;
4776   bfd_uint64_t ver;
4777
4778   if (command->len < sizeof (raw) + 8)
4779     return false;
4780   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4781     return false;
4782
4783   ver = bfd_get_64 (abfd, raw.version);
4784   /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4785      generates warnings) in case of the host doesn't support 64 bit
4786      integers.  */
4787   cmd->e = ver & 0x3ff;
4788   ver >>= 10;
4789   cmd->d = ver & 0x3ff;
4790   ver >>= 10;
4791   cmd->c = ver & 0x3ff;
4792   ver >>= 10;
4793   cmd->b = ver & 0x3ff;
4794   ver >>= 10;
4795   cmd->a = ver & 0xffffff;
4796   return true;
4797 }
4798
4799 static bool
4800 bfd_mach_o_read_note (bfd *abfd, bfd_mach_o_load_command *command)
4801 {
4802   bfd_mach_o_note_command *cmd = &command->command.note;
4803   struct mach_o_note_command_external raw;
4804
4805   if (command->len < sizeof (raw) + 8)
4806     return false;
4807   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4808     return false;
4809
4810   memcpy (cmd->data_owner, raw.data_owner, 16);
4811   cmd->offset = bfd_get_64 (abfd, raw.offset);
4812   cmd->size = bfd_get_64 (abfd, raw.size);
4813   return true;
4814 }
4815
4816 static bool
4817 bfd_mach_o_read_build_version (bfd *abfd, bfd_mach_o_load_command *command)
4818 {
4819   bfd_mach_o_build_version_command *cmd = &command->command.build_version;
4820   struct mach_o_build_version_command_external raw;
4821
4822   if (command->len < sizeof (raw) + 8)
4823     return false;
4824   if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4825     return false;
4826
4827   cmd->platform = bfd_get_32 (abfd, raw.platform);
4828   cmd->minos = bfd_get_32 (abfd, raw.minos);
4829   cmd->sdk = bfd_get_32 (abfd, raw.sdk);
4830   cmd->ntools = bfd_get_32 (abfd, raw.ntools);
4831   return true;
4832 }
4833
4834 static bool
4835 bfd_mach_o_read_segment (bfd *abfd,
4836                          bfd_mach_o_load_command *command,
4837                          unsigned int wide)
4838 {
4839   bfd_mach_o_segment_command *seg = &command->command.segment;
4840   unsigned long i;
4841
4842   if (wide)
4843     {
4844       struct mach_o_segment_command_64_external raw;
4845
4846       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
4847
4848       if (command->len < sizeof (raw) + 8)
4849         return false;
4850       if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4851         return false;
4852
4853       memcpy (seg->segname, raw.segname, 16);
4854       seg->segname[16] = '\0';
4855
4856       seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4857       seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4858       seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4859       seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4860       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4861       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4862       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4863       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4864     }
4865   else
4866     {
4867       struct mach_o_segment_command_32_external raw;
4868
4869       BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4870
4871       if (command->len < sizeof (raw) + 8)
4872         return false;
4873       if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4874         return false;
4875
4876       memcpy (seg->segname, raw.segname, 16);
4877       seg->segname[16] = '\0';
4878
4879       seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4880       seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4881       seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4882       seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4883       seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4884       seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4885       seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4886       seg->flags = bfd_h_get_32 (abfd, raw.flags);
4887     }
4888   seg->sect_head = NULL;
4889   seg->sect_tail = NULL;
4890
4891   for (i = 0; i < seg->nsects; i++)
4892     {
4893       asection *sec;
4894
4895       sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
4896       if (sec == NULL)
4897         return false;
4898
4899       bfd_mach_o_append_section_to_segment
4900         (seg, bfd_mach_o_get_mach_o_section (sec));
4901     }
4902
4903   return true;
4904 }
4905
4906 static bool
4907 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
4908 {
4909   return bfd_mach_o_read_segment (abfd, command, 0);
4910 }
4911
4912 static bool
4913 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
4914 {
4915   return bfd_mach_o_read_segment (abfd, command, 1);
4916 }
4917
4918 static bool
4919 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command,
4920                          ufile_ptr filesize)
4921 {
4922   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4923   struct mach_o_load_command_external raw;
4924   unsigned int cmd;
4925
4926   /* Read command type and length.  */
4927   if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
4928       || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
4929     return false;
4930
4931   cmd = bfd_h_get_32 (abfd, raw.cmd);
4932   command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4933   command->type_required = (cmd & BFD_MACH_O_LC_REQ_DYLD) != 0;
4934   command->len = bfd_h_get_32 (abfd, raw.cmdsize);
4935   if (command->len < 8 || command->len % 4 != 0)
4936     return false;
4937
4938   switch (command->type)
4939     {
4940     case BFD_MACH_O_LC_SEGMENT:
4941       if (!bfd_mach_o_read_segment_32 (abfd, command))
4942         return false;
4943       break;
4944     case BFD_MACH_O_LC_SEGMENT_64:
4945       if (!bfd_mach_o_read_segment_64 (abfd, command))
4946         return false;
4947       break;
4948     case BFD_MACH_O_LC_SYMTAB:
4949       if (!bfd_mach_o_read_symtab (abfd, command, filesize))
4950         return false;
4951       break;
4952     case BFD_MACH_O_LC_SYMSEG:
4953       break;
4954     case BFD_MACH_O_LC_THREAD:
4955     case BFD_MACH_O_LC_UNIXTHREAD:
4956       if (!bfd_mach_o_read_thread (abfd, command))
4957         return false;
4958       break;
4959     case BFD_MACH_O_LC_LOAD_DYLINKER:
4960     case BFD_MACH_O_LC_ID_DYLINKER:
4961     case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
4962       if (!bfd_mach_o_read_dylinker (abfd, command))
4963         return false;
4964       break;
4965     case BFD_MACH_O_LC_LOAD_DYLIB:
4966     case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4967     case BFD_MACH_O_LC_ID_DYLIB:
4968     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4969     case BFD_MACH_O_LC_REEXPORT_DYLIB:
4970     case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4971       if (!bfd_mach_o_read_dylib (abfd, command))
4972         return false;
4973       break;
4974     case BFD_MACH_O_LC_PREBOUND_DYLIB:
4975       if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4976         return false;
4977       break;
4978     case BFD_MACH_O_LC_LOADFVMLIB:
4979     case BFD_MACH_O_LC_IDFVMLIB:
4980       if (!bfd_mach_o_read_fvmlib (abfd, command))
4981         return false;
4982       break;
4983     case BFD_MACH_O_LC_IDENT:
4984     case BFD_MACH_O_LC_FVMFILE:
4985     case BFD_MACH_O_LC_PREPAGE:
4986     case BFD_MACH_O_LC_ROUTINES:
4987     case BFD_MACH_O_LC_ROUTINES_64:
4988       break;
4989     case BFD_MACH_O_LC_SUB_FRAMEWORK:
4990     case BFD_MACH_O_LC_SUB_UMBRELLA:
4991     case BFD_MACH_O_LC_SUB_LIBRARY:
4992     case BFD_MACH_O_LC_SUB_CLIENT:
4993     case BFD_MACH_O_LC_RPATH:
4994       if (!bfd_mach_o_read_str (abfd, command))
4995         return false;
4996       break;
4997     case BFD_MACH_O_LC_DYSYMTAB:
4998       if (!bfd_mach_o_read_dysymtab (abfd, command, filesize))
4999         return false;
5000       break;
5001     case BFD_MACH_O_LC_PREBIND_CKSUM:
5002       if (!bfd_mach_o_read_prebind_cksum (abfd, command))
5003         return false;
5004       break;
5005     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
5006       if (!bfd_mach_o_read_twolevel_hints (abfd, command))
5007         return false;
5008       break;
5009     case BFD_MACH_O_LC_UUID:
5010       if (!bfd_mach_o_read_uuid (abfd, command))
5011         return false;
5012       break;
5013     case BFD_MACH_O_LC_CODE_SIGNATURE:
5014     case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
5015     case BFD_MACH_O_LC_FUNCTION_STARTS:
5016     case BFD_MACH_O_LC_DATA_IN_CODE:
5017     case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
5018     case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
5019     case BFD_MACH_O_LC_DYLD_EXPORTS_TRIE:
5020     case BFD_MACH_O_LC_DYLD_CHAINED_FIXUPS:
5021       if (!bfd_mach_o_read_linkedit (abfd, command))
5022         return false;
5023       break;
5024     case BFD_MACH_O_LC_ENCRYPTION_INFO:
5025       if (!bfd_mach_o_read_encryption_info (abfd, command))
5026         return false;
5027       break;
5028     case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
5029       if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
5030         return false;
5031       break;
5032     case BFD_MACH_O_LC_DYLD_INFO:
5033       if (!bfd_mach_o_read_dyld_info (abfd, command))
5034         return false;
5035       break;
5036     case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
5037     case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
5038     case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
5039     case BFD_MACH_O_LC_VERSION_MIN_TVOS:
5040       if (!bfd_mach_o_read_version_min (abfd, command))
5041         return false;
5042       break;
5043     case BFD_MACH_O_LC_MAIN:
5044       if (!bfd_mach_o_read_main (abfd, command))
5045         return false;
5046       break;
5047     case BFD_MACH_O_LC_SOURCE_VERSION:
5048       if (!bfd_mach_o_read_source_version (abfd, command))
5049         return false;
5050       break;
5051     case BFD_MACH_O_LC_LINKER_OPTIONS:
5052       break;
5053     case BFD_MACH_O_LC_NOTE:
5054       if (!bfd_mach_o_read_note (abfd, command))
5055         return false;
5056       break;
5057     case BFD_MACH_O_LC_BUILD_VERSION:
5058       if (!bfd_mach_o_read_build_version (abfd, command))
5059         return false;
5060       break;
5061     default:
5062       command->len = 0;
5063       _bfd_error_handler (_("%pB: unknown load command %#x"),
5064                           abfd, command->type);
5065       return false;
5066     }
5067
5068   return true;
5069 }
5070
5071 static bool
5072 bfd_mach_o_flatten_sections (bfd *abfd)
5073 {
5074   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5075   bfd_mach_o_load_command *cmd;
5076   long csect = 0;
5077   size_t amt;
5078
5079   /* Count total number of sections.  */
5080   mdata->nsects = 0;
5081
5082   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5083     {
5084       if (cmd->type == BFD_MACH_O_LC_SEGMENT
5085           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
5086         {
5087           bfd_mach_o_segment_command *seg = &cmd->command.segment;
5088
5089           mdata->nsects += seg->nsects;
5090         }
5091     }
5092
5093   /* Allocate sections array.  */
5094   if (_bfd_mul_overflow (mdata->nsects, sizeof (bfd_mach_o_section *), &amt))
5095     {
5096       bfd_set_error (bfd_error_file_too_big);
5097       return false;
5098     }
5099   mdata->sections = bfd_alloc (abfd, amt);
5100   if (mdata->sections == NULL && mdata->nsects != 0)
5101     return false;
5102
5103   /* Fill the array.  */
5104   csect = 0;
5105
5106   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5107     {
5108       if (cmd->type == BFD_MACH_O_LC_SEGMENT
5109           || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
5110         {
5111           bfd_mach_o_segment_command *seg = &cmd->command.segment;
5112           bfd_mach_o_section *sec;
5113
5114           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
5115
5116           for (sec = seg->sect_head; sec != NULL; sec = sec->next)
5117             mdata->sections[csect++] = sec;
5118         }
5119     }
5120   return true;
5121 }
5122
5123 static bool
5124 bfd_mach_o_scan_start_address (bfd *abfd)
5125 {
5126   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5127   bfd_mach_o_thread_command *thr = NULL;
5128   bfd_mach_o_load_command *cmd;
5129   unsigned long i;
5130
5131   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5132     if (cmd->type == BFD_MACH_O_LC_THREAD
5133         || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
5134       {
5135         thr = &cmd->command.thread;
5136         break;
5137       }
5138     else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
5139       {
5140         bfd_mach_o_main_command *main_cmd = &cmd->command.main;
5141         bfd_mach_o_section *text_sect = mdata->sections[0];
5142
5143         if (text_sect)
5144           {
5145             abfd->start_address = main_cmd->entryoff
5146               + (text_sect->addr - text_sect->offset);
5147             return true;
5148           }
5149       }
5150
5151   /* An object file has no start address, so do not fail if not found.  */
5152   if (thr == NULL)
5153     return true;
5154
5155   /* FIXME: create a subtarget hook ?  */
5156   for (i = 0; i < thr->nflavours; i++)
5157     {
5158       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
5159           && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
5160         {
5161           unsigned char buf[4];
5162
5163           if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
5164               || bfd_bread (buf, 4, abfd) != 4)
5165             return false;
5166
5167           abfd->start_address = bfd_h_get_32 (abfd, buf);
5168         }
5169       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
5170                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
5171         {
5172           unsigned char buf[4];
5173
5174           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
5175               || bfd_bread (buf, 4, abfd) != 4)
5176             return false;
5177
5178           abfd->start_address = bfd_h_get_32 (abfd, buf);
5179         }
5180       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
5181                && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
5182         {
5183           unsigned char buf[8];
5184
5185           if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
5186               || bfd_bread (buf, 8, abfd) != 8)
5187             return false;
5188
5189           abfd->start_address = bfd_h_get_64 (abfd, buf);
5190         }
5191       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
5192                && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
5193         {
5194           unsigned char buf[8];
5195
5196           if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
5197               || bfd_bread (buf, 8, abfd) != 8)
5198             return false;
5199
5200           abfd->start_address = bfd_h_get_64 (abfd, buf);
5201         }
5202     }
5203
5204   return true;
5205 }
5206
5207 bool
5208 bfd_mach_o_set_arch_mach (bfd *abfd,
5209                           enum bfd_architecture arch,
5210                           unsigned long machine)
5211 {
5212   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5213
5214   /* If this isn't the right architecture for this backend, and this
5215      isn't the generic backend, fail.  */
5216   if (arch != bed->arch
5217       && arch != bfd_arch_unknown
5218       && bed->arch != bfd_arch_unknown)
5219     return false;
5220
5221   return bfd_default_set_arch_mach (abfd, arch, machine);
5222 }
5223
5224 static bool
5225 bfd_mach_o_scan (bfd *abfd,
5226                  bfd_mach_o_header *header,
5227                  bfd_mach_o_data_struct *mdata)
5228 {
5229   unsigned int i;
5230   enum bfd_architecture cpu_type;
5231   unsigned long cpu_subtype;
5232   unsigned int hdrsize;
5233
5234   hdrsize = mach_o_wide_p (header) ?
5235     BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
5236
5237   mdata->header = *header;
5238
5239   abfd->flags = abfd->flags & BFD_IN_MEMORY;
5240   switch (header->filetype)
5241     {
5242     case BFD_MACH_O_MH_OBJECT:
5243       abfd->flags |= HAS_RELOC;
5244       break;
5245     case BFD_MACH_O_MH_EXECUTE:
5246       abfd->flags |= EXEC_P;
5247       break;
5248     case BFD_MACH_O_MH_DYLIB:
5249     case BFD_MACH_O_MH_BUNDLE:
5250       abfd->flags |= DYNAMIC;
5251       break;
5252     }
5253
5254   abfd->tdata.mach_o_data = mdata;
5255
5256   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
5257                                    &cpu_type, &cpu_subtype);
5258   if (cpu_type == bfd_arch_unknown)
5259     {
5260       _bfd_error_handler
5261         /* xgettext:c-format */
5262         (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5263          header->cputype, header->cpusubtype);
5264       return false;
5265     }
5266
5267   bfd_set_arch_mach (abfd, cpu_type, cpu_subtype);
5268
5269   if (header->ncmds != 0)
5270     {
5271       bfd_mach_o_load_command *cmd;
5272       size_t amt;
5273       ufile_ptr filesize = bfd_get_file_size (abfd);
5274
5275       if (filesize == 0)
5276         filesize = (ufile_ptr) -1;
5277
5278       mdata->first_command = NULL;
5279       mdata->last_command = NULL;
5280
5281       if (header->ncmds > (filesize - hdrsize) / BFD_MACH_O_LC_SIZE)
5282         {
5283           bfd_set_error (bfd_error_file_truncated);
5284           return false;
5285         }
5286       if (_bfd_mul_overflow (header->ncmds,
5287                              sizeof (bfd_mach_o_load_command), &amt))
5288         {
5289           bfd_set_error (bfd_error_file_too_big);
5290           return false;
5291         }
5292       cmd = bfd_alloc (abfd, amt);
5293       if (cmd == NULL)
5294         return false;
5295
5296       for (i = 0; i < header->ncmds; i++)
5297         {
5298           bfd_mach_o_load_command *cur = &cmd[i];
5299
5300           bfd_mach_o_append_command (abfd, cur);
5301
5302           if (i == 0)
5303             cur->offset = hdrsize;
5304           else
5305             {
5306               bfd_mach_o_load_command *prev = &cmd[i - 1];
5307               cur->offset = prev->offset + prev->len;
5308             }
5309
5310           if (!bfd_mach_o_read_command (abfd, cur, filesize))
5311             return false;
5312         }
5313     }
5314
5315   /* Sections should be flatten before scanning start address.  */
5316   if (!bfd_mach_o_flatten_sections (abfd))
5317     return false;
5318   if (!bfd_mach_o_scan_start_address (abfd))
5319     return false;
5320
5321   return true;
5322 }
5323
5324 bool
5325 bfd_mach_o_mkobject_init (bfd *abfd)
5326 {
5327   bfd_mach_o_data_struct *mdata = NULL;
5328
5329   mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
5330   if (mdata == NULL)
5331     return false;
5332   abfd->tdata.mach_o_data = mdata;
5333
5334   mdata->header.magic = 0;
5335   mdata->header.cputype = 0;
5336   mdata->header.cpusubtype = 0;
5337   mdata->header.filetype = 0;
5338   mdata->header.ncmds = 0;
5339   mdata->header.sizeofcmds = 0;
5340   mdata->header.flags = 0;
5341   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
5342   mdata->first_command = NULL;
5343   mdata->last_command = NULL;
5344   mdata->nsects = 0;
5345   mdata->sections = NULL;
5346   mdata->dyn_reloc_cache = NULL;
5347
5348   return true;
5349 }
5350
5351 static bool
5352 bfd_mach_o_gen_mkobject (bfd *abfd)
5353 {
5354   bfd_mach_o_data_struct *mdata;
5355
5356   if (!bfd_mach_o_mkobject_init (abfd))
5357     return false;
5358
5359   mdata = bfd_mach_o_get_data (abfd);
5360   mdata->header.magic = BFD_MACH_O_MH_MAGIC;
5361   mdata->header.cputype = 0;
5362   mdata->header.cpusubtype = 0;
5363   mdata->header.byteorder = abfd->xvec->byteorder;
5364   mdata->header.version = 1;
5365
5366   return true;
5367 }
5368
5369 bfd_cleanup
5370 bfd_mach_o_header_p (bfd *abfd,
5371                      file_ptr hdr_off,
5372                      bfd_mach_o_filetype file_type,
5373                      bfd_mach_o_cpu_type cpu_type)
5374 {
5375   bfd_mach_o_header header;
5376   bfd_mach_o_data_struct *mdata;
5377
5378   if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
5379     goto wrong;
5380
5381   if (! (header.byteorder == BFD_ENDIAN_BIG
5382          || header.byteorder == BFD_ENDIAN_LITTLE))
5383     {
5384       _bfd_error_handler (_("unknown header byte-order value %#x"),
5385                           header.byteorder);
5386       goto wrong;
5387     }
5388
5389   if (! ((header.byteorder == BFD_ENDIAN_BIG
5390           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5391           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5392          || (header.byteorder == BFD_ENDIAN_LITTLE
5393              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5394              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5395     goto wrong;
5396
5397   /* Check cputype and filetype.
5398      In case of wildcard, do not accept magics that are handled by existing
5399      targets.  */
5400   if (cpu_type)
5401     {
5402       if (header.cputype != cpu_type)
5403         goto wrong;
5404     }
5405   else
5406     {
5407 #ifndef BFD64
5408       /* Do not recognize 64 architectures if not configured for 64bit targets.
5409          This could happen only for generic targets.  */
5410       if (mach_o_wide_p (&header))
5411          goto wrong;
5412 #endif
5413     }
5414
5415   if (file_type)
5416     {
5417       if (header.filetype != file_type)
5418         goto wrong;
5419     }
5420   else
5421     {
5422       switch (header.filetype)
5423         {
5424         case BFD_MACH_O_MH_CORE:
5425           /* Handled by core_p */
5426           goto wrong;
5427         default:
5428           break;
5429         }
5430     }
5431
5432   mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5433   if (mdata == NULL)
5434     goto fail;
5435   mdata->hdr_offset = hdr_off;
5436
5437   if (!bfd_mach_o_scan (abfd, &header, mdata))
5438     goto wrong;
5439
5440   return _bfd_no_cleanup;
5441
5442  wrong:
5443   bfd_set_error (bfd_error_wrong_format);
5444
5445  fail:
5446   return NULL;
5447 }
5448
5449 static bfd_cleanup
5450 bfd_mach_o_gen_object_p (bfd *abfd)
5451 {
5452   return bfd_mach_o_header_p (abfd, 0, 0, 0);
5453 }
5454
5455 static bfd_cleanup
5456 bfd_mach_o_gen_core_p (bfd *abfd)
5457 {
5458   return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
5459 }
5460
5461 /* Return the base address of ABFD, ie the address at which the image is
5462    mapped.  The possible initial pagezero is ignored.  */
5463
5464 bfd_vma
5465 bfd_mach_o_get_base_address (bfd *abfd)
5466 {
5467   bfd_mach_o_data_struct *mdata;
5468   bfd_mach_o_load_command *cmd;
5469
5470   /* Check for Mach-O.  */
5471   if (!bfd_mach_o_valid (abfd))
5472     return 0;
5473   mdata = bfd_mach_o_get_data (abfd);
5474
5475   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5476     {
5477       if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5478            || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5479         {
5480           struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5481
5482           if (segcmd->initprot != 0)
5483             return segcmd->vmaddr;
5484         }
5485     }
5486   return 0;
5487 }
5488
5489 typedef struct mach_o_fat_archentry
5490 {
5491   unsigned long cputype;
5492   unsigned long cpusubtype;
5493   unsigned long offset;
5494   unsigned long size;
5495   unsigned long align;
5496 } mach_o_fat_archentry;
5497
5498 typedef struct mach_o_fat_data_struct
5499 {
5500   unsigned long magic;
5501   unsigned long nfat_arch;
5502   mach_o_fat_archentry *archentries;
5503 } mach_o_fat_data_struct;
5504
5505 bfd_cleanup
5506 bfd_mach_o_fat_archive_p (bfd *abfd)
5507 {
5508   mach_o_fat_data_struct *adata = NULL;
5509   struct mach_o_fat_header_external hdr;
5510   unsigned long i;
5511   size_t amt;
5512
5513   if (bfd_seek (abfd, 0, SEEK_SET) != 0
5514       || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
5515     goto error;
5516
5517   adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
5518   if (adata == NULL)
5519     goto error;
5520
5521   adata->magic = bfd_getb32 (hdr.magic);
5522   adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
5523   if (adata->magic != 0xcafebabe)
5524     goto error;
5525   /* Avoid matching Java bytecode files, which have the same magic number.
5526      In the Java bytecode file format this field contains the JVM version,
5527      which starts at 43.0.  */
5528   if (adata->nfat_arch > 30)
5529     goto error;
5530
5531   if (_bfd_mul_overflow (adata->nfat_arch,
5532                          sizeof (mach_o_fat_archentry), &amt))
5533     {
5534       bfd_set_error (bfd_error_file_too_big);
5535       goto error;
5536     }
5537   adata->archentries = bfd_alloc (abfd, amt);
5538   if (adata->archentries == NULL)
5539     goto error;
5540
5541   for (i = 0; i < adata->nfat_arch; i++)
5542     {
5543       struct mach_o_fat_arch_external arch;
5544       if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
5545         goto error;
5546       adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5547       adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5548       adata->archentries[i].offset = bfd_getb32 (arch.offset);
5549       adata->archentries[i].size = bfd_getb32 (arch.size);
5550       adata->archentries[i].align = bfd_getb32 (arch.align);
5551     }
5552
5553   abfd->tdata.mach_o_fat_data = adata;
5554
5555   return _bfd_no_cleanup;
5556
5557  error:
5558   if (adata != NULL)
5559     bfd_release (abfd, adata);
5560   bfd_set_error (bfd_error_wrong_format);
5561   return NULL;
5562 }
5563
5564 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5565    ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5566    Set arelt_data and origin fields too.  */
5567
5568 static bool
5569 bfd_mach_o_fat_member_init (bfd *abfd,
5570                             enum bfd_architecture arch_type,
5571                             unsigned long arch_subtype,
5572                             mach_o_fat_archentry *entry)
5573 {
5574   struct areltdata *areltdata;
5575   /* Create the member filename. Use ARCH_NAME.  */
5576   const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5577   const char *filename;
5578
5579   if (ap)
5580     {
5581       /* Use the architecture name if known.  */
5582       filename = bfd_set_filename (abfd, ap->printable_name);
5583     }
5584   else
5585     {
5586       /* Forge a uniq id.  */
5587       char buf[2 + 8 + 1 + 2 + 8 + 1];
5588       snprintf (buf, sizeof (buf), "0x%lx-0x%lx",
5589                 entry->cputype, entry->cpusubtype);
5590       filename = bfd_set_filename (abfd, buf);
5591     }
5592   if (!filename)
5593     return false;
5594
5595   areltdata = bfd_zmalloc (sizeof (struct areltdata));
5596   if (areltdata == NULL)
5597     return false;
5598   areltdata->parsed_size = entry->size;
5599   abfd->arelt_data = areltdata;
5600   abfd->iostream = NULL;
5601   abfd->origin = entry->offset;
5602   return true;
5603 }
5604
5605 bfd *
5606 bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
5607 {
5608   mach_o_fat_data_struct *adata;
5609   mach_o_fat_archentry *entry = NULL;
5610   unsigned long i;
5611   bfd *nbfd;
5612   enum bfd_architecture arch_type;
5613   unsigned long arch_subtype;
5614
5615   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
5616   BFD_ASSERT (adata != NULL);
5617
5618   /* Find index of previous entry.  */
5619   if (prev == NULL)
5620     {
5621       /* Start at first one.  */
5622       i = 0;
5623     }
5624   else
5625     {
5626       /* Find index of PREV.  */
5627       for (i = 0; i < adata->nfat_arch; i++)
5628         {
5629           if (adata->archentries[i].offset == prev->origin)
5630             break;
5631         }
5632
5633       if (i == adata->nfat_arch)
5634         {
5635           /* Not found.  */
5636           bfd_set_error (bfd_error_bad_value);
5637           return NULL;
5638         }
5639
5640       /* Get next entry.  */
5641       i++;
5642     }
5643
5644   if (i >= adata->nfat_arch)
5645     {
5646       bfd_set_error (bfd_error_no_more_archived_files);
5647       return NULL;
5648     }
5649
5650   entry = &adata->archentries[i];
5651   nbfd = _bfd_new_bfd_contained_in (archive);
5652   if (nbfd == NULL)
5653     return NULL;
5654
5655   bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5656                                    &arch_type, &arch_subtype);
5657
5658   if (!bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry))
5659     {
5660       bfd_close (nbfd);
5661       return NULL;
5662     }
5663
5664   bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
5665
5666   return nbfd;
5667 }
5668
5669 /* Analogous to stat call.  */
5670
5671 static int
5672 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5673 {
5674   if (abfd->arelt_data == NULL)
5675     {
5676       bfd_set_error (bfd_error_invalid_operation);
5677       return -1;
5678     }
5679
5680   buf->st_mtime = 0;
5681   buf->st_uid = 0;
5682   buf->st_gid = 0;
5683   buf->st_mode = 0644;
5684   buf->st_size = arelt_size (abfd);
5685
5686   return 0;
5687 }
5688
5689 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5690    If ABFD is a fat image containing a member that corresponds to FORMAT
5691    and ARCH, returns it.
5692    In other case, returns NULL.
5693    This function allows transparent uses of fat images.  */
5694
5695 bfd *
5696 bfd_mach_o_fat_extract (bfd *abfd,
5697                         bfd_format format,
5698                         const bfd_arch_info_type *arch)
5699 {
5700   bfd *res;
5701   mach_o_fat_data_struct *adata;
5702   unsigned int i;
5703
5704   if (bfd_check_format (abfd, format))
5705     {
5706       if (bfd_get_arch_info (abfd) == arch)
5707         return abfd;
5708       return NULL;
5709     }
5710   if (!bfd_check_format (abfd, bfd_archive)
5711       || abfd->xvec != &mach_o_fat_vec)
5712     return NULL;
5713
5714   /* This is a Mach-O fat image.  */
5715   adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5716   BFD_ASSERT (adata != NULL);
5717
5718   for (i = 0; i < adata->nfat_arch; i++)
5719     {
5720       struct mach_o_fat_archentry *e = &adata->archentries[i];
5721       enum bfd_architecture cpu_type;
5722       unsigned long cpu_subtype;
5723
5724       bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5725                                        &cpu_type, &cpu_subtype);
5726       if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5727         continue;
5728
5729       /* The architecture is found.  */
5730       res = _bfd_new_bfd_contained_in (abfd);
5731       if (res == NULL)
5732         return NULL;
5733
5734       if (bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e)
5735           && bfd_check_format (res, format))
5736         {
5737           BFD_ASSERT (bfd_get_arch_info (res) == arch);
5738           return res;
5739         }
5740       bfd_close (res);
5741       return NULL;
5742     }
5743
5744   return NULL;
5745 }
5746
5747 static bool
5748 bfd_mach_o_fat_close_and_cleanup (bfd *abfd)
5749 {
5750   _bfd_unlink_from_archive_parent (abfd);
5751   return true;
5752 }
5753
5754 int
5755 bfd_mach_o_lookup_command (bfd *abfd,
5756                            bfd_mach_o_load_command_type type,
5757                            bfd_mach_o_load_command **mcommand)
5758 {
5759   struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5760   struct bfd_mach_o_load_command *cmd;
5761   unsigned int num;
5762
5763   BFD_ASSERT (mdata != NULL);
5764   BFD_ASSERT (mcommand != NULL);
5765
5766   num = 0;
5767   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5768     {
5769       if (cmd->type != type)
5770         continue;
5771
5772       if (num == 0)
5773         *mcommand = cmd;
5774       num++;
5775     }
5776
5777   return num;
5778 }
5779
5780 unsigned long
5781 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
5782 {
5783   switch (type)
5784     {
5785     case BFD_MACH_O_CPU_TYPE_MC680x0:
5786       return 0x04000000;
5787     case BFD_MACH_O_CPU_TYPE_POWERPC:
5788       return 0xc0000000;
5789     case BFD_MACH_O_CPU_TYPE_I386:
5790       return 0xc0000000;
5791     case BFD_MACH_O_CPU_TYPE_SPARC:
5792       return 0xf0000000;
5793     case BFD_MACH_O_CPU_TYPE_HPPA:
5794       return 0xc0000000 - 0x04000000;
5795     default:
5796       return 0;
5797     }
5798 }
5799
5800 /* The following two tables should be kept, as far as possible, in order of
5801    most frequently used entries to optimize their use from gas.  */
5802
5803 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
5804 {
5805   { "regular", BFD_MACH_O_S_REGULAR},
5806   { "coalesced", BFD_MACH_O_S_COALESCED},
5807   { "zerofill", BFD_MACH_O_S_ZEROFILL},
5808   { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5809   { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5810   { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
5811   { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
5812   { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
5813   { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5814   { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
5815   { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5816   { "interposing", BFD_MACH_O_S_INTERPOSING},
5817   { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
5818   { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5819   { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
5820   { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
5821   { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5822   { NULL, 0}
5823 };
5824
5825 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
5826 {
5827   { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5828   { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
5829   { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5830   { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
5831   { "debug", BFD_MACH_O_S_ATTR_DEBUG },
5832   { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5833   { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5834   { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5835   { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
5836   { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5837   { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5838   { NULL, 0}
5839 };
5840
5841 /* Get the section type from NAME.  Return 256 if NAME is unknown.  */
5842
5843 unsigned int
5844 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
5845 {
5846   const bfd_mach_o_xlat_name *x;
5847   bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5848
5849   for (x = bfd_mach_o_section_type_name; x->name; x++)
5850     if (strcmp (x->name, name) == 0)
5851       {
5852         /* We found it... does the target support it?  */
5853         if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5854             || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5855           return x->val; /* OK.  */
5856         else
5857           break; /* Not supported.  */
5858       }
5859   /* Maximum section ID = 0xff.  */
5860   return 256;
5861 }
5862
5863 /* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
5864
5865 unsigned int
5866 bfd_mach_o_get_section_attribute_from_name (const char *name)
5867 {
5868   const bfd_mach_o_xlat_name *x;
5869
5870   for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5871     if (strcmp (x->name, name) == 0)
5872       return x->val;
5873   return (unsigned int)-1;
5874 }
5875
5876 int
5877 bfd_mach_o_core_fetch_environment (bfd *abfd,
5878                                    unsigned char **rbuf,
5879                                    unsigned int *rlen)
5880 {
5881   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5882   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
5883   bfd_mach_o_load_command *cmd;
5884
5885   for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5886     {
5887       bfd_mach_o_segment_command *seg;
5888
5889       if (cmd->type != BFD_MACH_O_LC_SEGMENT)
5890         continue;
5891
5892       seg = &cmd->command.segment;
5893
5894       if ((seg->vmaddr + seg->vmsize) == stackaddr)
5895         {
5896           unsigned long start = seg->fileoff;
5897           unsigned long end = seg->fileoff + seg->filesize;
5898           unsigned char *buf = bfd_malloc (1024);
5899           unsigned long size = 1024;
5900
5901           if (buf == NULL)
5902             return -1;
5903           for (;;)
5904             {
5905               bfd_size_type nread = 0;
5906               unsigned long offset;
5907               int found_nonnull = 0;
5908
5909               if (size > (end - start))
5910                 size = (end - start);
5911
5912               buf = bfd_realloc_or_free (buf, size);
5913               if (buf == NULL)
5914                 return -1;
5915
5916               if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
5917                 {
5918                   free (buf);
5919                   return -1;
5920                 }
5921
5922               nread = bfd_bread (buf, size, abfd);
5923
5924               if (nread != size)
5925                 {
5926                   free (buf);
5927                   return -1;
5928                 }
5929
5930               for (offset = 4; offset <= size; offset += 4)
5931                 {
5932                   unsigned long val;
5933
5934                   val = *((unsigned long *) (buf + size - offset));
5935                   if (! found_nonnull)
5936                     {
5937                       if (val != 0)
5938                         found_nonnull = 1;
5939                     }
5940                   else if (val == 0x0)
5941                     {
5942                       unsigned long bottom;
5943                       unsigned long top;
5944
5945                       bottom = seg->fileoff + seg->filesize - offset;
5946                       top = seg->fileoff + seg->filesize - 4;
5947                       *rbuf = bfd_malloc (top - bottom);
5948                       if (*rbuf == NULL)
5949                         return -1;
5950                       *rlen = top - bottom;
5951
5952                       memcpy (*rbuf, buf + size - *rlen, *rlen);
5953                       free (buf);
5954                       return 0;
5955                     }
5956                 }
5957
5958               if (size == (end - start))
5959                 break;
5960
5961               size *= 2;
5962             }
5963
5964           free (buf);
5965         }
5966     }
5967
5968   return -1;
5969 }
5970
5971 char *
5972 bfd_mach_o_core_file_failing_command (bfd *abfd)
5973 {
5974   unsigned char *buf = NULL;
5975   unsigned int len = 0;
5976   int ret;
5977
5978   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5979   if (ret < 0)
5980     return NULL;
5981
5982   return (char *) buf;
5983 }
5984
5985 int
5986 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
5987 {
5988   return 0;
5989 }
5990
5991 static bfd_mach_o_uuid_command *
5992 bfd_mach_o_lookup_uuid_command (bfd *abfd)
5993 {
5994   bfd_mach_o_load_command *uuid_cmd = NULL;
5995   int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
5996   if (ncmd != 1 || uuid_cmd == NULL)
5997     return false;
5998   return &uuid_cmd->command.uuid;
5999 }
6000
6001 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
6002
6003 static bool
6004 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
6005 {
6006   bfd_mach_o_uuid_command *dsym_uuid_cmd;
6007
6008   BFD_ASSERT (abfd);
6009   BFD_ASSERT (uuid_cmd);
6010
6011   if (!bfd_check_format (abfd, bfd_object))
6012     return false;
6013
6014   if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
6015       || bfd_mach_o_get_data (abfd) == NULL
6016       || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
6017     return false;
6018
6019   dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
6020   if (dsym_uuid_cmd == NULL)
6021     return false;
6022
6023   if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
6024               sizeof (uuid_cmd->uuid)) != 0)
6025     return false;
6026
6027   return true;
6028 }
6029
6030 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
6031    The caller is responsible for closing the returned BFD object and
6032    its my_archive if the returned BFD is in a fat dSYM. */
6033
6034 static bfd *
6035 bfd_mach_o_find_dsym (const char *dsym_filename,
6036                       const bfd_mach_o_uuid_command *uuid_cmd,
6037                       const bfd_arch_info_type *arch)
6038 {
6039   bfd *base_dsym_bfd, *dsym_bfd;
6040
6041   BFD_ASSERT (uuid_cmd);
6042
6043   base_dsym_bfd = bfd_openr (dsym_filename, NULL);
6044   if (base_dsym_bfd == NULL)
6045     return NULL;
6046
6047   dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
6048   if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
6049     return dsym_bfd;
6050
6051   bfd_close (dsym_bfd);
6052   if (base_dsym_bfd != dsym_bfd)
6053     bfd_close (base_dsym_bfd);
6054
6055   return NULL;
6056 }
6057
6058 /* Return a BFD created from a dSYM file for ABFD.
6059    The caller is responsible for closing the returned BFD object, its
6060    filename, and its my_archive if the returned BFD is in a fat dSYM. */
6061
6062 static bfd *
6063 bfd_mach_o_follow_dsym (bfd *abfd)
6064 {
6065   char *dsym_filename;
6066   bfd_mach_o_uuid_command *uuid_cmd;
6067   bfd *dsym_bfd, *base_bfd = abfd;
6068   const char *base_basename;
6069
6070   if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
6071     return NULL;
6072
6073   if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
6074     base_bfd = abfd->my_archive;
6075   /* BFD may have been opened from a stream. */
6076   if (bfd_get_filename (base_bfd) == NULL)
6077     {
6078       bfd_set_error (bfd_error_invalid_operation);
6079       return NULL;
6080     }
6081   base_basename = lbasename (bfd_get_filename (base_bfd));
6082
6083   uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
6084   if (uuid_cmd == NULL)
6085     return NULL;
6086
6087   /* TODO: We assume the DWARF file has the same as the binary's.
6088      It seems apple's GDB checks all files in the dSYM bundle directory.
6089      http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
6090   */
6091   dsym_filename = (char *)bfd_malloc (strlen (bfd_get_filename (base_bfd))
6092                                        + strlen (dsym_subdir) + 1
6093                                        + strlen (base_basename) + 1);
6094   if (dsym_filename == NULL)
6095     return NULL;
6096
6097   sprintf (dsym_filename, "%s%s/%s",
6098            bfd_get_filename (base_bfd), dsym_subdir, base_basename);
6099
6100   dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
6101                                    bfd_get_arch_info (abfd));
6102   if (dsym_bfd == NULL)
6103     free (dsym_filename);
6104
6105   return dsym_bfd;
6106 }
6107
6108 bool
6109 bfd_mach_o_find_nearest_line (bfd *abfd,
6110                               asymbol **symbols,
6111                               asection *section,
6112                               bfd_vma offset,
6113                               const char **filename_ptr,
6114                               const char **functionname_ptr,
6115                               unsigned int *line_ptr,
6116                               unsigned int *discriminator_ptr)
6117 {
6118   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6119   if (mdata == NULL)
6120     return false;
6121   switch (mdata->header.filetype)
6122     {
6123     case BFD_MACH_O_MH_OBJECT:
6124       break;
6125     case BFD_MACH_O_MH_EXECUTE:
6126     case BFD_MACH_O_MH_DYLIB:
6127     case BFD_MACH_O_MH_BUNDLE:
6128     case BFD_MACH_O_MH_KEXT_BUNDLE:
6129       if (mdata->dwarf2_find_line_info == NULL)
6130         {
6131           mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
6132           /* When we couldn't find dSYM for this binary, we look for
6133              the debug information in the binary itself. In this way,
6134              we won't try finding separated dSYM again because
6135              mdata->dwarf2_find_line_info will be filled. */
6136           if (! mdata->dsym_bfd)
6137             break;
6138           if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
6139                                               dwarf_debug_sections, symbols,
6140                                               &mdata->dwarf2_find_line_info,
6141                                               false))
6142             return false;
6143         }
6144       break;
6145     default:
6146       return false;
6147     }
6148   return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
6149                                         filename_ptr, functionname_ptr,
6150                                         line_ptr, discriminator_ptr,
6151                                         dwarf_debug_sections,
6152                                         &mdata->dwarf2_find_line_info);
6153 }
6154
6155 bool
6156 bfd_mach_o_close_and_cleanup (bfd *abfd)
6157 {
6158   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6159   if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
6160     {
6161       _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
6162       bfd_mach_o_free_cached_info (abfd);
6163       if (mdata->dsym_bfd != NULL)
6164         {
6165           bfd *fat_bfd = mdata->dsym_bfd->my_archive;
6166 #if 0
6167           /* FIXME: PR 19435: This calculation to find the memory allocated by
6168              bfd_mach_o_follow_dsym for the filename does not always end up
6169              selecting the correct pointer.  Unfortunately this problem is
6170              very hard to reproduce on a non Mach-O native system, so until it
6171              can be traced and fixed on such a system, this code will remain
6172              commented out.  This does mean that there will be a memory leak,
6173              but it is small, and happens when we are closing down, so it
6174              should not matter too much.  */
6175           char *dsym_filename = (char *)(fat_bfd
6176                                          ? bfd_get_filename (fat_bfd)
6177                                          : bfd_get_filename (mdata->dsym_bfd));
6178 #endif
6179           bfd_close (mdata->dsym_bfd);
6180           mdata->dsym_bfd = NULL;
6181           if (fat_bfd)
6182             bfd_close (fat_bfd);
6183 #if 0
6184           free (dsym_filename);
6185 #endif
6186         }
6187     }
6188
6189   return _bfd_generic_close_and_cleanup (abfd);
6190 }
6191
6192 bool
6193 bfd_mach_o_free_cached_info (bfd *abfd)
6194 {
6195   bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6196   asection *asect;
6197   free (mdata->dyn_reloc_cache);
6198   mdata->dyn_reloc_cache = NULL;
6199   for (asect = abfd->sections; asect != NULL; asect = asect->next)
6200     {
6201       free (asect->relocation);
6202       asect->relocation = NULL;
6203     }
6204
6205   return true;
6206 }
6207
6208 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
6209 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6210
6211 #define bfd_mach_o_canonicalize_one_reloc NULL
6212 #define bfd_mach_o_swap_reloc_out NULL
6213 #define bfd_mach_o_print_thread NULL
6214 #define bfd_mach_o_tgt_seg_table NULL
6215 #define bfd_mach_o_section_type_valid_for_tgt NULL
6216
6217 #define TARGET_NAME             mach_o_be_vec
6218 #define TARGET_STRING           "mach-o-be"
6219 #define TARGET_ARCHITECTURE     bfd_arch_unknown
6220 #define TARGET_PAGESIZE         1
6221 #define TARGET_BIG_ENDIAN       1
6222 #define TARGET_ARCHIVE          0
6223 #define TARGET_PRIORITY         1
6224 #include "mach-o-target.c"
6225
6226 #undef TARGET_NAME
6227 #undef TARGET_STRING
6228 #undef TARGET_ARCHITECTURE
6229 #undef TARGET_PAGESIZE
6230 #undef TARGET_BIG_ENDIAN
6231 #undef TARGET_ARCHIVE
6232 #undef TARGET_PRIORITY
6233
6234 #define TARGET_NAME             mach_o_le_vec
6235 #define TARGET_STRING           "mach-o-le"
6236 #define TARGET_ARCHITECTURE     bfd_arch_unknown
6237 #define TARGET_PAGESIZE         1
6238 #define TARGET_BIG_ENDIAN       0
6239 #define TARGET_ARCHIVE          0
6240 #define TARGET_PRIORITY         1
6241
6242 #include "mach-o-target.c"
6243
6244 #undef TARGET_NAME
6245 #undef TARGET_STRING
6246 #undef TARGET_ARCHITECTURE
6247 #undef TARGET_PAGESIZE
6248 #undef TARGET_BIG_ENDIAN
6249 #undef TARGET_ARCHIVE
6250 #undef TARGET_PRIORITY
6251
6252 /* Not yet handled: creating an archive.  */
6253 #define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
6254
6255 #define bfd_mach_o_close_and_cleanup              bfd_mach_o_fat_close_and_cleanup
6256
6257 /* Not used.  */
6258 #define bfd_mach_o_generic_stat_arch_elt          bfd_mach_o_fat_stat_arch_elt
6259 #define bfd_mach_o_openr_next_archived_file       bfd_mach_o_fat_openr_next_archived_file
6260 #define bfd_mach_o_archive_p    bfd_mach_o_fat_archive_p
6261
6262 #define TARGET_NAME             mach_o_fat_vec
6263 #define TARGET_STRING           "mach-o-fat"
6264 #define TARGET_ARCHITECTURE     bfd_arch_unknown
6265 #define TARGET_PAGESIZE         1
6266 #define TARGET_BIG_ENDIAN       1
6267 #define TARGET_ARCHIVE          1
6268 #define TARGET_PRIORITY         0
6269
6270 #include "mach-o-target.c"
6271
6272 #undef TARGET_NAME
6273 #undef TARGET_STRING
6274 #undef TARGET_ARCHITECTURE
6275 #undef TARGET_PAGESIZE
6276 #undef TARGET_BIG_ENDIAN
6277 #undef TARGET_ARCHIVE
6278 #undef TARGET_PRIORITY