1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
28 #include "aout/stab_gnu.h"
29 #include "mach-o/reloc.h"
30 #include "mach-o/external.h"
35 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
36 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
37 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
39 #define FILE_ALIGN(off, algn) \
40 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
43 bfd_mach_o_version (bfd *abfd)
45 bfd_mach_o_data_struct *mdata = NULL;
47 BFD_ASSERT (bfd_mach_o_valid (abfd));
48 mdata = bfd_mach_o_get_data (abfd);
50 return mdata->header.version;
54 bfd_mach_o_valid (bfd *abfd)
56 if (abfd == NULL || abfd->xvec == NULL)
59 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
62 if (bfd_mach_o_get_data (abfd) == NULL)
67 static INLINE bfd_boolean
68 mach_o_wide_p (bfd_mach_o_header *header)
70 switch (header->version)
82 static INLINE bfd_boolean
83 bfd_mach_o_wide_p (bfd *abfd)
85 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
88 /* Tables to translate well known Mach-O segment/section names to bfd
89 names. Use of canonical names (such as .text or .debug_frame) is required
93 static const mach_o_section_name_xlat text_section_names_xlat[] =
96 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
97 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS, 0},
98 { ".const", "__const",
99 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
100 BFD_MACH_O_S_ATTR_NONE, 0},
101 { ".static_const", "__static_const",
102 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
103 BFD_MACH_O_S_ATTR_NONE, 0},
104 { ".cstring", "__cstring",
105 SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
106 BFD_MACH_O_S_CSTRING_LITERALS,
107 BFD_MACH_O_S_ATTR_NONE, 0},
108 { ".literal4", "__literal4",
109 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_4BYTE_LITERALS,
110 BFD_MACH_O_S_ATTR_NONE, 2},
111 { ".literal8", "__literal8",
112 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_8BYTE_LITERALS,
113 BFD_MACH_O_S_ATTR_NONE, 3},
114 { ".literal16", "__literal16",
115 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_16BYTE_LITERALS,
116 BFD_MACH_O_S_ATTR_NONE, 4},
117 { ".constructor", "__constructor",
118 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
119 BFD_MACH_O_S_ATTR_NONE, 0},
120 { ".destructor", "__destructor",
121 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
122 BFD_MACH_O_S_ATTR_NONE, 0},
123 { ".eh_frame", "__eh_frame",
124 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_COALESCED,
125 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
126 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
127 | BFD_MACH_O_S_ATTR_NO_TOC, 2},
128 { NULL, NULL, 0, 0, 0, 0}
131 /* __DATA Segment. */
132 static const mach_o_section_name_xlat data_section_names_xlat[] =
135 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
136 BFD_MACH_O_S_ATTR_NONE, 0},
138 SEC_NO_FLAGS, BFD_MACH_O_S_ZEROFILL,
139 BFD_MACH_O_S_ATTR_NONE, 0},
140 { ".const_data", "__const",
141 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
142 BFD_MACH_O_S_ATTR_NONE, 0},
143 { ".static_data", "__static_data",
144 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
145 BFD_MACH_O_S_ATTR_NONE, 0},
146 { ".mod_init_func", "__mod_init_func",
147 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
148 BFD_MACH_O_S_ATTR_NONE, 2},
149 { ".mod_term_func", "__mod_term_func",
150 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
151 BFD_MACH_O_S_ATTR_NONE, 2},
153 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
154 BFD_MACH_O_S_ATTR_NONE, 0},
155 { ".cfstring", "__cfstring",
156 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
157 BFD_MACH_O_S_ATTR_NONE, 2},
158 { NULL, NULL, 0, 0, 0, 0}
161 /* __DWARF Segment. */
162 static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
164 { ".debug_frame", "__debug_frame",
165 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
166 BFD_MACH_O_S_ATTR_DEBUG, 0},
167 { ".debug_info", "__debug_info",
168 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
169 BFD_MACH_O_S_ATTR_DEBUG, 0},
170 { ".debug_abbrev", "__debug_abbrev",
171 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
172 BFD_MACH_O_S_ATTR_DEBUG, 0},
173 { ".debug_aranges", "__debug_aranges",
174 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
175 BFD_MACH_O_S_ATTR_DEBUG, 0},
176 { ".debug_macinfo", "__debug_macinfo",
177 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
178 BFD_MACH_O_S_ATTR_DEBUG, 0},
179 { ".debug_line", "__debug_line",
180 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
181 BFD_MACH_O_S_ATTR_DEBUG, 0},
182 { ".debug_loc", "__debug_loc",
183 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
184 BFD_MACH_O_S_ATTR_DEBUG, 0},
185 { ".debug_pubnames", "__debug_pubnames",
186 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
187 BFD_MACH_O_S_ATTR_DEBUG, 0},
188 { ".debug_pubtypes", "__debug_pubtypes",
189 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
190 BFD_MACH_O_S_ATTR_DEBUG, 0},
191 { ".debug_str", "__debug_str",
192 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
193 BFD_MACH_O_S_ATTR_DEBUG, 0},
194 { ".debug_ranges", "__debug_ranges",
195 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
196 BFD_MACH_O_S_ATTR_DEBUG, 0},
197 { ".debug_macro", "__debug_macro",
198 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
199 BFD_MACH_O_S_ATTR_DEBUG, 0},
200 { NULL, NULL, 0, 0, 0, 0}
203 /* __OBJC Segment. */
204 static const mach_o_section_name_xlat objc_section_names_xlat[] =
206 { ".objc_class", "__class",
207 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
208 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
209 { ".objc_meta_class", "__meta_class",
210 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
211 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
212 { ".objc_cat_cls_meth", "__cat_cls_meth",
213 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
214 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
215 { ".objc_cat_inst_meth", "__cat_inst_meth",
216 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
217 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
218 { ".objc_protocol", "__protocol",
219 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
220 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
221 { ".objc_string_object", "__string_object",
222 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
223 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
224 { ".objc_cls_meth", "__cls_meth",
225 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
226 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
227 { ".objc_inst_meth", "__inst_meth",
228 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
229 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
230 { ".objc_cls_refs", "__cls_refs",
231 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
232 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
233 { ".objc_message_refs", "__message_refs",
234 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
235 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
236 { ".objc_symbols", "__symbols",
237 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
238 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
239 { ".objc_category", "__category",
240 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
241 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
242 { ".objc_class_vars", "__class_vars",
243 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
244 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
245 { ".objc_instance_vars", "__instance_vars",
246 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
247 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
248 { ".objc_module_info", "__module_info",
249 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
250 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
251 { ".objc_selector_strs", "__selector_strs",
252 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_CSTRING_LITERALS,
253 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
254 { ".objc_image_info", "__image_info",
255 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
256 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
257 { ".objc_selector_fixup", "__sel_fixup",
258 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
259 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
261 { ".objc1_class_ext", "__class_ext",
262 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
263 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
264 { ".objc1_property_list", "__property",
265 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
266 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
267 { ".objc1_protocol_ext", "__protocol_ext",
268 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
269 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
270 { NULL, NULL, 0, 0, 0, 0}
273 static const mach_o_segment_name_xlat segsec_names_xlat[] =
275 { "__TEXT", text_section_names_xlat },
276 { "__DATA", data_section_names_xlat },
277 { "__DWARF", dwarf_section_names_xlat },
278 { "__OBJC", objc_section_names_xlat },
282 static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
284 /* For both cases bfd-name => mach-o name and vice versa, the specific target
285 is checked before the generic. This allows a target (e.g. ppc for cstring)
286 to override the generic definition with a more specific one. */
288 /* Fetch the translation from a Mach-O section designation (segment, section)
289 as a bfd short name, if one exists. Otherwise return NULL.
291 Allow the segment and section names to be unterminated 16 byte arrays. */
293 const mach_o_section_name_xlat *
294 bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
295 const char *sectname)
297 const struct mach_o_segment_name_xlat *seg;
298 const mach_o_section_name_xlat *sec;
299 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
301 /* First try any target-specific translations defined... */
302 if (bed->segsec_names_xlat)
303 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
304 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
305 for (sec = seg->sections; sec->mach_o_name; sec++)
306 if (strncmp (sec->mach_o_name, sectname,
307 BFD_MACH_O_SECTNAME_SIZE) == 0)
310 /* ... and then the Mach-O generic ones. */
311 for (seg = segsec_names_xlat; seg->segname; seg++)
312 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
313 for (sec = seg->sections; sec->mach_o_name; sec++)
314 if (strncmp (sec->mach_o_name, sectname,
315 BFD_MACH_O_SECTNAME_SIZE) == 0)
321 /* If the bfd_name for this section is a 'canonical' form for which we
322 know the Mach-O data, return the segment name and the data for the
323 Mach-O equivalent. Otherwise return NULL. */
325 const mach_o_section_name_xlat *
326 bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
327 const char **segname)
329 const struct mach_o_segment_name_xlat *seg;
330 const mach_o_section_name_xlat *sec;
331 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
334 if (bfd_name[0] != '.')
337 /* First try any target-specific translations defined... */
338 if (bed->segsec_names_xlat)
339 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
340 for (sec = seg->sections; sec->bfd_name; sec++)
341 if (strcmp (bfd_name, sec->bfd_name) == 0)
343 *segname = seg->segname;
347 /* ... and then the Mach-O generic ones. */
348 for (seg = segsec_names_xlat; seg->segname; seg++)
349 for (sec = seg->sections; sec->bfd_name; sec++)
350 if (strcmp (bfd_name, sec->bfd_name) == 0)
352 *segname = seg->segname;
359 /* Convert Mach-O section name to BFD.
361 Try to use standard/canonical names, for which we have tables including
362 default flag settings - which are returned. Otherwise forge a new name
363 in the form "<segmentname>.<sectionname>" this will be prefixed with
364 LC_SEGMENT. if the segment name does not begin with an underscore.
366 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
367 terminated if the name length is exactly 16 bytes - but must be if the name
368 length is less than 16 characters). */
371 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
372 const char *secname, const char **name,
375 const mach_o_section_name_xlat *xlat;
378 const char *pfx = "";
381 *flags = SEC_NO_FLAGS;
383 /* First search for a canonical name...
384 xlat will be non-null if there is an entry for segname, secname. */
385 xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
388 len = strlen (xlat->bfd_name);
389 res = bfd_alloc (abfd, len+1);
392 memcpy (res, xlat->bfd_name, len+1);
394 *flags = xlat->bfd_flags;
398 /* ... else we make up a bfd name from the segment concatenated with the
401 len = 16 + 1 + 16 + 1;
403 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
404 with an underscore. */
405 if (segname[0] != '_')
407 static const char seg_pfx[] = "LC_SEGMENT.";
410 len += sizeof (seg_pfx) - 1;
413 res = bfd_alloc (abfd, len);
416 snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
420 /* Convert a bfd section name to a Mach-O segment + section name.
422 If the name is a canonical one for which we have a Darwin match
423 return the translation table - which contains defaults for flags,
424 type, attribute and default alignment data.
426 Otherwise, expand the bfd_name (assumed to be in the form
427 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
429 static const mach_o_section_name_xlat *
430 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
432 bfd_mach_o_section *section)
434 const mach_o_section_name_xlat *xlat;
435 const char *name = bfd_get_section_name (abfd, sect);
442 memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
443 memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
445 /* See if is a canonical name ... */
446 xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
449 strcpy (section->segname, segname);
450 strcpy (section->sectname, xlat->mach_o_name);
454 /* .. else we convert our constructed one back to Mach-O.
455 Strip LC_SEGMENT. prefix, if present. */
456 if (strncmp (name, "LC_SEGMENT.", 11) == 0)
460 dot = strchr (name, '.');
463 /* Try to split name into segment and section names. */
464 if (dot && dot != name)
467 seclen = len - (dot + 1 - name);
469 if (seglen < 16 && seclen < 16)
471 memcpy (section->segname, name, seglen);
472 section->segname[seglen] = 0;
473 memcpy (section->sectname, dot + 1, seclen);
474 section->sectname[seclen] = 0;
479 /* The segment and section names are both missing - don't make them
481 if (dot && dot == name)
484 /* Just duplicate the name into both segment and section. */
487 memcpy (section->segname, name, len);
488 section->segname[len] = 0;
489 memcpy (section->sectname, name, len);
490 section->sectname[len] = 0;
494 /* Return the size of an entry for section SEC.
495 Must be called only for symbol pointer section and symbol stubs
499 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
501 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
503 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
504 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
505 return bfd_mach_o_wide_p (abfd) ? 8 : 4;
506 case BFD_MACH_O_S_SYMBOL_STUBS:
507 return sec->reserved2;
514 /* Return the number of indirect symbols for a section.
515 Must be called only for symbol pointer section and symbol stubs
519 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
523 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
527 return sec->size / elsz;
531 /* Copy any private info we understand from the input symbol
532 to the output symbol. */
535 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
537 bfd *obfd ATTRIBUTE_UNUSED,
540 bfd_mach_o_asymbol *os, *is;
541 os = (bfd_mach_o_asymbol *)osymbol;
542 is = (bfd_mach_o_asymbol *)isymbol;
543 os->n_type = is->n_type;
544 os->n_sect = is->n_sect;
545 os->n_desc = is->n_desc;
546 os->symbol.udata.i = is->symbol.udata.i;
550 /* Copy any private info we understand from the input section
551 to the output section. */
554 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
556 bfd *obfd ATTRIBUTE_UNUSED,
559 if (osection->used_by_bfd == NULL)
560 osection->used_by_bfd = isection->used_by_bfd;
562 if (isection->used_by_bfd != NULL)
563 memcpy (osection->used_by_bfd, isection->used_by_bfd,
564 sizeof (bfd_mach_o_section));
566 if (osection->used_by_bfd != NULL)
567 ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
572 /* Copy any private info we understand from the input bfd
573 to the output bfd. */
576 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
578 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
579 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
582 BFD_ASSERT (bfd_mach_o_valid (ibfd));
583 BFD_ASSERT (bfd_mach_o_valid (obfd));
585 /* FIXME: copy commands. */
590 /* This allows us to set up to 32 bits of flags (unless we invent some
591 fiendish scheme to subdivide). For now, we'll just set the file flags
592 without error checking - just overwrite. */
595 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
597 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
602 mdata->header.flags = flags;
606 /* Count the total number of symbols. */
609 bfd_mach_o_count_symbols (bfd *abfd)
611 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
613 if (mdata->symtab == NULL)
615 return mdata->symtab->nsyms;
619 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
621 long nsyms = bfd_mach_o_count_symbols (abfd);
623 return ((nsyms + 1) * sizeof (asymbol *));
627 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
629 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
630 long nsyms = bfd_mach_o_count_symbols (abfd);
631 bfd_mach_o_symtab_command *sym = mdata->symtab;
639 /* Do not try to read symbols if there are none. */
644 if (!bfd_mach_o_read_symtab_symbols (abfd))
646 (*_bfd_error_handler)
647 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
651 BFD_ASSERT (sym->symbols != NULL);
653 for (j = 0; j < sym->nsyms; j++)
654 alocation[j] = &sym->symbols[j].symbol;
661 /* Create synthetic symbols for indirect symbols. */
664 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
665 long symcount ATTRIBUTE_UNUSED,
666 asymbol **syms ATTRIBUTE_UNUSED,
667 long dynsymcount ATTRIBUTE_UNUSED,
668 asymbol **dynsyms ATTRIBUTE_UNUSED,
671 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
672 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
673 bfd_mach_o_symtab_command *symtab = mdata->symtab;
675 unsigned long count, i, j, n;
682 /* Stop now if no symbols or no indirect symbols. */
683 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
686 if (dysymtab->nindirectsyms == 0)
689 /* We need to allocate a bfd symbol for every indirect symbol and to
690 allocate the memory for its name. */
691 count = dysymtab->nindirectsyms;
692 size = count * sizeof (asymbol) + 1;
694 for (j = 0; j < count; j++)
696 unsigned int isym = dysymtab->indirect_syms[j];
698 /* Some indirect symbols are anonymous. */
699 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
700 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
703 s = *ret = (asymbol *) bfd_malloc (size);
706 names = (char *) (s + count);
711 for (i = 0; i < mdata->nsects; i++)
713 bfd_mach_o_section *sec = mdata->sections[i];
714 unsigned int first, last;
718 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
720 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
721 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
722 case BFD_MACH_O_S_SYMBOL_STUBS:
723 /* Only these sections have indirect symbols. */
724 first = sec->reserved1;
725 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
727 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
728 for (j = first; j < last; j++)
730 unsigned int isym = dysymtab->indirect_syms[j];
732 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
733 s->section = sec->bfdsection;
734 s->value = addr - sec->addr;
737 if (isym < symtab->nsyms
738 && symtab->symbols[isym].symbol.name)
740 const char *sym = symtab->symbols[isym].symbol.name;
745 memcpy (names, sym, len);
747 memcpy (names, "$stub", sizeof ("$stub"));
748 names += sizeof ("$stub");
767 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
771 bfd_symbol_info (symbol, ret);
775 bfd_mach_o_print_symbol (bfd *abfd,
778 bfd_print_symbol_type how)
780 FILE *file = (FILE *) afile;
782 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
786 case bfd_print_symbol_name:
787 fprintf (file, "%s", symbol->name);
790 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
791 if (asym->n_type & BFD_MACH_O_N_STAB)
792 name = bfd_get_stab_name (asym->n_type);
794 switch (asym->n_type & BFD_MACH_O_N_TYPE)
796 case BFD_MACH_O_N_UNDF:
797 if (symbol->value == 0)
802 case BFD_MACH_O_N_ABS:
805 case BFD_MACH_O_N_INDR:
808 case BFD_MACH_O_N_PBUD:
811 case BFD_MACH_O_N_SECT:
820 fprintf (file, " %02x %-6s %02x %04x",
821 asym->n_type, name, asym->n_sect, asym->n_desc);
822 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
823 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
824 fprintf (file, " [%s]", symbol->section->name);
825 fprintf (file, " %s", symbol->name);
830 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
831 bfd_mach_o_cpu_subtype msubtype,
832 enum bfd_architecture *type,
833 unsigned long *subtype)
835 *subtype = bfd_arch_unknown;
839 case BFD_MACH_O_CPU_TYPE_VAX:
840 *type = bfd_arch_vax;
842 case BFD_MACH_O_CPU_TYPE_MC680x0:
843 *type = bfd_arch_m68k;
845 case BFD_MACH_O_CPU_TYPE_I386:
846 *type = bfd_arch_i386;
847 *subtype = bfd_mach_i386_i386;
849 case BFD_MACH_O_CPU_TYPE_X86_64:
850 *type = bfd_arch_i386;
851 *subtype = bfd_mach_x86_64;
853 case BFD_MACH_O_CPU_TYPE_MIPS:
854 *type = bfd_arch_mips;
856 case BFD_MACH_O_CPU_TYPE_MC98000:
857 *type = bfd_arch_m98k;
859 case BFD_MACH_O_CPU_TYPE_HPPA:
860 *type = bfd_arch_hppa;
862 case BFD_MACH_O_CPU_TYPE_ARM:
863 *type = bfd_arch_arm;
866 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
867 *subtype = bfd_mach_arm_4T;
869 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
870 *subtype = bfd_mach_arm_4T; /* Best fit ? */
872 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
873 *subtype = bfd_mach_arm_5TE;
875 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
876 *subtype = bfd_mach_arm_XScale;
878 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
879 *subtype = bfd_mach_arm_5TE; /* Best fit ? */
881 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
886 case BFD_MACH_O_CPU_TYPE_MC88000:
887 *type = bfd_arch_m88k;
889 case BFD_MACH_O_CPU_TYPE_SPARC:
890 *type = bfd_arch_sparc;
891 *subtype = bfd_mach_sparc;
893 case BFD_MACH_O_CPU_TYPE_I860:
894 *type = bfd_arch_i860;
896 case BFD_MACH_O_CPU_TYPE_ALPHA:
897 *type = bfd_arch_alpha;
899 case BFD_MACH_O_CPU_TYPE_POWERPC:
900 *type = bfd_arch_powerpc;
901 *subtype = bfd_mach_ppc;
903 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
904 *type = bfd_arch_powerpc;
905 *subtype = bfd_mach_ppc64;
908 *type = bfd_arch_unknown;
914 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
916 struct mach_o_header_external raw;
919 size = mach_o_wide_p (header) ?
920 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
922 bfd_h_put_32 (abfd, header->magic, raw.magic);
923 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
924 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
925 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
926 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
927 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
928 bfd_h_put_32 (abfd, header->flags, raw.flags);
930 if (mach_o_wide_p (header))
931 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
933 if (bfd_seek (abfd, 0, SEEK_SET) != 0
934 || bfd_bwrite (&raw, size, abfd) != size)
941 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
943 bfd_mach_o_thread_command *cmd = &command->command.thread;
945 struct mach_o_thread_command_external raw;
948 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
949 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
952 for (i = 0; i < cmd->nflavours; i++)
954 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
955 BFD_ASSERT (cmd->flavours[i].offset ==
956 (command->offset + offset + BFD_MACH_O_LC_SIZE));
958 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
959 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
961 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
962 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
965 offset += cmd->flavours[i].size + sizeof (raw);
972 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
975 return (asect->reloc_count + 1) * sizeof (arelent *);
978 /* In addition to the need to byte-swap the symbol number, the bit positions
979 of the fields in the relocation information vary per target endian-ness. */
982 bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
983 unsigned char *fields)
985 unsigned char info = fields[3];
987 if (bfd_big_endian (abfd))
989 rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
990 rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
991 rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
992 rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
993 & BFD_MACH_O_LENGTH_MASK;
994 rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
998 rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
999 rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1000 rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1001 rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1002 & BFD_MACH_O_LENGTH_MASK;
1003 rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1008 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
1009 struct mach_o_reloc_info_external *raw,
1010 arelent *res, asymbol **syms)
1012 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1013 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1014 bfd_mach_o_reloc_info reloc;
1018 addr = bfd_get_32 (abfd, raw->r_address);
1019 res->sym_ptr_ptr = NULL;
1022 if (addr & BFD_MACH_O_SR_SCATTERED)
1025 bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1027 /* Scattered relocation, can't be extern. */
1028 reloc.r_scattered = 1;
1031 /* Extract section and offset from r_value (symnum). */
1032 reloc.r_value = symnum;
1033 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1034 end of the data for the section (e.g. in a calculation of section
1035 data length). At present, the symbol will end up associated with
1036 the following section or, if it falls within alignment padding, as
1037 null - which will assert later. */
1038 for (j = 0; j < mdata->nsects; j++)
1040 bfd_mach_o_section *sect = mdata->sections[j];
1041 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1043 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1044 res->addend = symnum - sect->addr;
1049 /* Extract the info and address fields from r_address. */
1050 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1051 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1052 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1053 reloc.r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1054 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1060 /* Non-scattered relocation. */
1061 reloc.r_scattered = 0;
1063 /* The value and info fields have to be extracted dependent on target
1065 bfd_mach_o_swap_in_non_scattered_reloc (abfd, &reloc, raw->r_symbolnum);
1066 num = reloc.r_value;
1070 /* An external symbol number. */
1073 else if (num == 0x00ffffff)
1075 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1076 is generic code, we don't know wether this is really a PAIR.
1077 This value is almost certainly not a valid section number, hence
1078 this specific case to avoid an assertion failure.
1079 Target specific swap_reloc_in routine should adjust that. */
1080 sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1084 /* A section number. */
1085 BFD_ASSERT (num != 0);
1086 BFD_ASSERT (num <= mdata->nsects);
1088 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1089 /* For a symbol defined in section S, the addend (stored in the
1090 binary) contains the address of the section. To comply with
1091 bfd convention, subtract the section address.
1092 Use the address from the header, so that the user can modify
1093 the vma of the section. */
1094 res->addend = -mdata->sections[num - 1]->addr;
1096 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1097 in the lower 16bits of the address value. So we have to find the
1098 'symbol' from the preceding reloc. We do this even though the
1099 section symbol is probably not needed here, because NULL symbol
1100 values cause an assert in generic BFD code. This must be done in
1101 the PPC swap_reloc_in routine. */
1102 res->sym_ptr_ptr = sym;
1104 /* The 'address' is just r_address.
1105 ??? maybe this should be masked with 0xffffff for safety. */
1106 res->address = addr;
1107 reloc.r_address = addr;
1110 /* We have set up a reloc with all the information present, so the swapper
1111 can modify address, value and addend fields, if necessary, to convey
1112 information in the generic BFD reloc that is mach-o specific. */
1114 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1120 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1121 unsigned long count,
1122 arelent *res, asymbol **syms)
1125 struct mach_o_reloc_info_external *native_relocs;
1126 bfd_size_type native_size;
1128 /* Allocate and read relocs. */
1129 native_size = count * BFD_MACH_O_RELENT_SIZE;
1131 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1132 if (native_relocs == NULL)
1135 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1136 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1139 for (i = 0; i < count; i++)
1141 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1145 free (native_relocs);
1148 free (native_relocs);
1153 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1154 arelent **rels, asymbol **syms)
1156 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1160 if (asect->reloc_count == 0)
1163 /* No need to go further if we don't know how to read relocs. */
1164 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1167 if (asect->relocation == NULL)
1169 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1173 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1174 asect->reloc_count, res, syms) < 0)
1179 asect->relocation = res;
1182 res = asect->relocation;
1183 for (i = 0; i < asect->reloc_count; i++)
1191 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1193 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1195 if (mdata->dysymtab == NULL)
1197 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1198 * sizeof (arelent *);
1202 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1203 struct bfd_symbol **syms)
1205 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1206 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1207 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1211 if (dysymtab == NULL)
1213 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1216 /* No need to go further if we don't know how to read relocs. */
1217 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1220 if (mdata->dyn_reloc_cache == NULL)
1222 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1223 * sizeof (arelent));
1227 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1228 dysymtab->nextrel, res, syms) < 0)
1234 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1236 res + dysymtab->nextrel, syms) < 0)
1242 mdata->dyn_reloc_cache = res;
1245 res = mdata->dyn_reloc_cache;
1246 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1252 /* In addition to the need to byte-swap the symbol number, the bit positions
1253 of the fields in the relocation information vary per target endian-ness. */
1256 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1257 bfd_mach_o_reloc_info *rel)
1259 unsigned char info = 0;
1261 BFD_ASSERT (rel->r_type <= 15);
1262 BFD_ASSERT (rel->r_length <= 3);
1264 if (bfd_big_endian (abfd))
1266 fields[0] = (rel->r_value >> 16) & 0xff;
1267 fields[1] = (rel->r_value >> 8) & 0xff;
1268 fields[2] = rel->r_value & 0xff;
1269 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1270 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1271 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1272 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1276 fields[2] = (rel->r_value >> 16) & 0xff;
1277 fields[1] = (rel->r_value >> 8) & 0xff;
1278 fields[0] = rel->r_value & 0xff;
1279 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1280 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1281 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1282 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1288 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1293 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1295 sec = section->bfdsection;
1296 if (sec->reloc_count == 0)
1299 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1302 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1305 /* Convert and write. */
1306 entries = section->bfdsection->orelocation;
1307 for (i = 0; i < section->nreloc; i++)
1309 arelent *rel = entries[i];
1310 struct mach_o_reloc_info_external raw;
1311 bfd_mach_o_reloc_info info, *pinfo = &info;
1313 /* Convert relocation to an intermediate representation. */
1314 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1317 /* Lower the relocation info. */
1318 if (pinfo->r_scattered)
1322 v = BFD_MACH_O_SR_SCATTERED
1323 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1324 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1325 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1326 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
1327 /* Note: scattered relocs have field in reverse order... */
1328 bfd_put_32 (abfd, v, raw.r_address);
1329 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1333 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1334 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1338 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1339 != BFD_MACH_O_RELENT_SIZE)
1346 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1348 struct mach_o_section_32_external raw;
1350 memcpy (raw.sectname, section->sectname, 16);
1351 memcpy (raw.segname, section->segname, 16);
1352 bfd_h_put_32 (abfd, section->addr, raw.addr);
1353 bfd_h_put_32 (abfd, section->size, raw.size);
1354 bfd_h_put_32 (abfd, section->offset, raw.offset);
1355 bfd_h_put_32 (abfd, section->align, raw.align);
1356 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1357 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1358 bfd_h_put_32 (abfd, section->flags, raw.flags);
1359 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1360 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1362 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1363 != BFD_MACH_O_SECTION_SIZE)
1370 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1372 struct mach_o_section_64_external raw;
1374 memcpy (raw.sectname, section->sectname, 16);
1375 memcpy (raw.segname, section->segname, 16);
1376 bfd_h_put_64 (abfd, section->addr, raw.addr);
1377 bfd_h_put_64 (abfd, section->size, raw.size);
1378 bfd_h_put_32 (abfd, section->offset, raw.offset);
1379 bfd_h_put_32 (abfd, section->align, raw.align);
1380 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1381 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1382 bfd_h_put_32 (abfd, section->flags, raw.flags);
1383 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1384 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1385 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1387 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1388 != BFD_MACH_O_SECTION_64_SIZE)
1395 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1397 struct mach_o_segment_command_32_external raw;
1398 bfd_mach_o_segment_command *seg = &command->command.segment;
1399 bfd_mach_o_section *sec;
1401 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1403 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1404 if (!bfd_mach_o_write_relocs (abfd, sec))
1407 memcpy (raw.segname, seg->segname, 16);
1408 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1409 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1410 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1411 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1412 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1413 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1414 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1415 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1417 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1418 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1421 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1422 if (bfd_mach_o_write_section_32 (abfd, sec))
1429 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1431 struct mach_o_segment_command_64_external raw;
1432 bfd_mach_o_segment_command *seg = &command->command.segment;
1433 bfd_mach_o_section *sec;
1435 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1437 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1438 if (!bfd_mach_o_write_relocs (abfd, sec))
1441 memcpy (raw.segname, seg->segname, 16);
1442 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1443 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1444 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1445 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1446 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1447 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1448 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1449 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1451 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1452 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1455 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1456 if (bfd_mach_o_write_section_64 (abfd, sec))
1463 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1465 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1466 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1468 unsigned int wide = bfd_mach_o_wide_p (abfd);
1469 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1470 struct bfd_strtab_hash *strtab;
1471 asymbol **symbols = bfd_get_outsymbols (abfd);
1473 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1475 /* Write the symbols first. */
1476 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1477 sym->symoff = mdata->filelen;
1478 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1481 sym->nsyms = bfd_get_symcount (abfd);
1482 mdata->filelen += sym->nsyms * symlen;
1484 strtab = _bfd_stringtab_init ();
1489 /* Although we don't strictly need to do this, for compatibility with
1490 Darwin system tools, actually output an empty string for the index
1492 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1494 for (i = 0; i < sym->nsyms; i++)
1496 bfd_size_type str_index;
1497 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1499 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1500 /* An index of 0 always means the empty string. */
1504 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1506 if (str_index == (bfd_size_type) -1)
1512 struct mach_o_nlist_64_external raw;
1514 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1515 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1516 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1517 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1518 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1521 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1526 struct mach_o_nlist_external raw;
1528 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1529 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1530 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1531 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1532 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1535 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1539 sym->strsize = _bfd_stringtab_size (strtab);
1540 sym->stroff = mdata->filelen;
1541 mdata->filelen += sym->strsize;
1543 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1545 _bfd_stringtab_free (strtab);
1549 struct mach_o_symtab_command_external raw;
1551 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1552 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1553 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1554 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1556 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1557 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1564 _bfd_stringtab_free (strtab);
1568 /* Write a dysymtab command.
1569 TODO: Possibly coalesce writes of smaller objects. */
1572 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1574 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1576 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1578 if (cmd->nmodtab != 0)
1582 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1585 for (i = 0; i < cmd->nmodtab; i++)
1587 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1591 iinit = module->iinit & 0xffff;
1592 iinit |= ((module->iterm & 0xffff) << 16);
1594 ninit = module->ninit & 0xffff;
1595 ninit |= ((module->nterm & 0xffff) << 16);
1597 if (bfd_mach_o_wide_p (abfd))
1599 struct mach_o_dylib_module_64_external w;
1601 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1602 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1603 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1604 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1605 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1606 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1607 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1608 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1609 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1610 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1611 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1612 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1613 &w.objc_module_info_addr);
1614 bfd_h_put_32 (abfd, module->objc_module_info_size,
1615 &w.objc_module_info_size);
1617 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1622 struct mach_o_dylib_module_external n;
1624 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1625 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1626 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1627 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1628 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1629 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1630 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1631 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1632 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1633 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1634 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1635 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1636 &n.objc_module_info_addr);
1637 bfd_h_put_32 (abfd, module->objc_module_info_size,
1638 &n.objc_module_info_size);
1640 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1650 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1653 for (i = 0; i < cmd->ntoc; i++)
1655 struct mach_o_dylib_table_of_contents_external raw;
1656 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1658 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1659 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1661 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1666 if (cmd->nindirectsyms > 0)
1670 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1673 for (i = 0; i < cmd->nindirectsyms; ++i)
1675 unsigned char raw[4];
1677 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1678 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1683 if (cmd->nextrefsyms != 0)
1687 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1690 for (i = 0; i < cmd->nextrefsyms; i++)
1693 unsigned char raw[4];
1694 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1696 /* Fields isym and flags are written as bit-fields, thus we need
1697 a specific processing for endianness. */
1699 if (bfd_big_endian (abfd))
1701 v = ((ref->isym & 0xffffff) << 8);
1702 v |= ref->flags & 0xff;
1706 v = ref->isym & 0xffffff;
1707 v |= ((ref->flags & 0xff) << 24);
1710 bfd_h_put_32 (abfd, v, raw);
1711 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1717 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1721 struct mach_o_dysymtab_command_external raw;
1723 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1724 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1725 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1726 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1727 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1728 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1729 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1730 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1731 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1732 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1733 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1734 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1735 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1736 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1737 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1738 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1739 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1740 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1742 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1750 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
1752 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
1754 /* Just leave debug symbols where they are (pretend they are local, and
1755 then they will just be sorted on position). */
1756 if (s->n_type & BFD_MACH_O_N_STAB)
1759 /* Local (we should never see an undefined local AFAICT). */
1760 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1763 /* Common symbols look like undefined externs. */
1764 if (mtyp == BFD_MACH_O_N_UNDF)
1767 /* A defined non-local, non-debug symbol. */
1772 bfd_mach_o_cf_symbols (const void *a, const void *b)
1774 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1775 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1776 unsigned int soa, sob;
1778 soa = bfd_mach_o_primary_symbol_sort_key (sa);
1779 sob = bfd_mach_o_primary_symbol_sort_key (sb);
1786 /* If it's local or stab, just preserve the input order. */
1789 if (sa->symbol.udata.i < sb->symbol.udata.i)
1791 if (sa->symbol.udata.i > sb->symbol.udata.i)
1794 /* This is probably an error. */
1798 /* The second sort key is name. */
1799 return strcmp (sa->symbol.name, sb->symbol.name);
1802 /* Process the symbols.
1804 This should be OK for single-module files - but it is not likely to work
1805 for multi-module shared libraries.
1807 (a) If the application has not filled in the relevant mach-o fields, make
1810 (b) Order them, like this:
1813 ( ii) external defined
1815 (iii) external undefined/common
1822 bfd_mach_o_mangle_symbols (bfd *abfd)
1825 asymbol **symbols = bfd_get_outsymbols (abfd);
1827 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1830 for (i = 0; i < bfd_get_symcount (abfd); i++)
1832 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1834 /* We use this value, which is out-of-range as a symbol index, to signal
1835 that the mach-o-specific data are not filled in and need to be created
1836 from the bfd values. It is much preferable for the application to do
1837 this, since more meaningful diagnostics can be made that way. */
1839 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1841 /* No symbol information has been set - therefore determine
1842 it from the bfd symbol flags/info. */
1843 if (s->symbol.section == bfd_abs_section_ptr)
1844 s->n_type = BFD_MACH_O_N_ABS;
1845 else if (s->symbol.section == bfd_und_section_ptr)
1847 s->n_type = BFD_MACH_O_N_UNDF;
1848 if (s->symbol.flags & BSF_WEAK)
1849 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1850 /* mach-o automatically makes undefined symbols extern. */
1851 s->n_type |= BFD_MACH_O_N_EXT;
1852 s->symbol.flags |= BSF_GLOBAL;
1854 else if (s->symbol.section == bfd_com_section_ptr)
1856 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1857 s->symbol.flags |= BSF_GLOBAL;
1860 s->n_type = BFD_MACH_O_N_SECT;
1862 if (s->symbol.flags & BSF_GLOBAL)
1863 s->n_type |= BFD_MACH_O_N_EXT;
1866 /* Put the section index in, where required. */
1867 if ((s->symbol.section != bfd_abs_section_ptr
1868 && s->symbol.section != bfd_und_section_ptr
1869 && s->symbol.section != bfd_com_section_ptr)
1870 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1871 && s->symbol.name == NULL))
1872 s->n_sect = s->symbol.section->target_index;
1874 /* Number to preserve order for local and debug syms. */
1875 s->symbol.udata.i = i;
1878 /* Sort the symbols. */
1879 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
1880 sizeof (asymbol *), bfd_mach_o_cf_symbols);
1882 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1884 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1885 s->symbol.udata.i = i; /* renumber. */
1891 /* We build a flat table of sections, which can be re-ordered if necessary.
1892 Fill in the section number and other mach-o-specific data. */
1895 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1898 unsigned target_index;
1901 nsect = bfd_count_sections (abfd);
1903 /* Don't do it if it's already set - assume the application knows what it's
1905 if (mdata->nsects == nsect
1906 && (mdata->nsects == 0 || mdata->sections != NULL))
1909 mdata->nsects = nsect;
1910 mdata->sections = bfd_alloc (abfd,
1911 mdata->nsects * sizeof (bfd_mach_o_section *));
1912 if (mdata->sections == NULL)
1915 /* We need to check that this can be done... */
1917 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1918 " maximum is 255,\n"), nsect);
1920 /* Create Mach-O sections.
1921 Section type, attribute and align should have been set when the
1922 section was created - either read in or specified. */
1924 for (sec = abfd->sections; sec; sec = sec->next)
1926 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1927 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1929 mdata->sections[target_index] = msect;
1931 msect->addr = bfd_get_section_vma (abfd, sec);
1932 msect->size = bfd_get_section_size (sec);
1934 /* Use the largest alignment set, in case it was bumped after the
1935 section was created. */
1936 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1939 sec->target_index = ++target_index;
1946 bfd_mach_o_write_contents (bfd *abfd)
1949 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1951 /* Make the commands, if not already present. */
1952 if (mdata->header.ncmds == 0)
1953 if (!bfd_mach_o_build_commands (abfd))
1956 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1959 for (i = 0; i < mdata->header.ncmds; i++)
1961 struct mach_o_load_command_external raw;
1962 bfd_mach_o_load_command *cur = &mdata->commands[i];
1963 unsigned long typeflag;
1965 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1967 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1968 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1970 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1971 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1976 case BFD_MACH_O_LC_SEGMENT:
1977 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1980 case BFD_MACH_O_LC_SEGMENT_64:
1981 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1984 case BFD_MACH_O_LC_SYMTAB:
1985 if (!bfd_mach_o_write_symtab (abfd, cur))
1988 case BFD_MACH_O_LC_DYSYMTAB:
1989 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1992 case BFD_MACH_O_LC_SYMSEG:
1994 case BFD_MACH_O_LC_THREAD:
1995 case BFD_MACH_O_LC_UNIXTHREAD:
1996 if (bfd_mach_o_write_thread (abfd, cur) != 0)
1999 case BFD_MACH_O_LC_LOADFVMLIB:
2000 case BFD_MACH_O_LC_IDFVMLIB:
2001 case BFD_MACH_O_LC_IDENT:
2002 case BFD_MACH_O_LC_FVMFILE:
2003 case BFD_MACH_O_LC_PREPAGE:
2004 case BFD_MACH_O_LC_LOAD_DYLIB:
2005 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2006 case BFD_MACH_O_LC_ID_DYLIB:
2007 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2008 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
2009 case BFD_MACH_O_LC_LOAD_DYLINKER:
2010 case BFD_MACH_O_LC_ID_DYLINKER:
2011 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2012 case BFD_MACH_O_LC_ROUTINES:
2013 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2016 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
2017 (unsigned long) cur->type);
2026 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2029 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
2030 if (seg->sect_head == NULL)
2033 seg->sect_tail->next = s;
2037 /* Create section Mach-O flags from BFD flags. */
2040 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2043 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2045 /* Create default flags. */
2046 bfd_flags = bfd_get_section_flags (abfd, sec);
2047 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2048 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2049 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2050 | BFD_MACH_O_S_REGULAR;
2051 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2052 s->flags = BFD_MACH_O_S_ZEROFILL;
2053 else if (bfd_flags & SEC_DEBUGGING)
2054 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2056 s->flags = BFD_MACH_O_S_REGULAR;
2059 /* Count the number of sections in the list for the segment named.
2061 The special case of NULL or "" for the segment name is valid for
2062 an MH_OBJECT file and means 'all sections available'.
2064 Requires that the sections table in mdata be filled in.
2066 Returns the number of sections (0 is valid).
2067 Any number > 255 signals an invalid section count, although we will,
2068 perhaps, allow the file to be written (in line with Darwin tools up
2071 A section count of (unsigned long) -1 signals a definite error. */
2073 static unsigned long
2074 bfd_mach_o_count_sections_for_seg (const char *segment,
2075 bfd_mach_o_data_struct *mdata)
2078 if (mdata == NULL || mdata->sections == NULL)
2079 return (unsigned long) -1;
2081 /* The MH_OBJECT case, all sections are considered; Although nsects is
2082 is an unsigned long, the maximum valid section count is 255 and this
2083 will have been checked already by mangle_sections. */
2084 if (segment == NULL || segment[0] == '\0')
2085 return mdata->nsects;
2087 /* Count the number of sections we see in this segment. */
2089 for (i = 0; i < mdata->nsects; ++i)
2091 bfd_mach_o_section *s = mdata->sections[i];
2092 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2099 bfd_mach_o_build_seg_command (const char *segment,
2100 bfd_mach_o_data_struct *mdata,
2101 bfd_mach_o_segment_command *seg)
2104 int is_mho = (segment == NULL || segment[0] == '\0');
2106 /* Fill segment command. */
2108 memset (seg->segname, 0, sizeof (seg->segname));
2110 strncpy (seg->segname, segment, sizeof (seg->segname));
2112 /* TODO: fix this up for non-MH_OBJECT cases. */
2116 seg->fileoff = mdata->filelen;
2118 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2119 | BFD_MACH_O_PROT_EXECUTE;
2120 seg->initprot = seg->maxprot;
2122 seg->sect_head = NULL;
2123 seg->sect_tail = NULL;
2125 /* Append sections to the segment.
2127 This is a little tedious, we have to honor the need to account zerofill
2128 sections after all the rest. This forces us to do the calculation of
2129 total vmsize in three passes so that any alignment increments are
2130 properly accounted. */
2132 for (i = 0; i < mdata->nsects; ++i)
2134 bfd_mach_o_section *s = mdata->sections[i];
2135 asection *sec = s->bfdsection;
2137 /* If we're not making an MH_OBJECT, check whether this section is from
2138 our segment, and skip if not. Otherwise, just add all sections. */
2140 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2143 /* Although we account for zerofill section sizes in vm order, they are
2144 placed in the file in source sequence. */
2145 bfd_mach_o_append_section_to_segment (seg, sec);
2148 /* Zerofill sections have zero file size & offset,
2149 and are not written. */
2150 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2151 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2152 == BFD_MACH_O_S_GB_ZEROFILL)
2157 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2158 seg->vmsize += s->size;
2160 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2161 seg->filesize += s->size;
2163 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2164 s->offset = mdata->filelen;
2167 sec->filepos = s->offset;
2168 mdata->filelen += s->size;
2171 /* Now pass through again, for zerofill, only now we just update the vmsize. */
2172 for (i = 0; i < mdata->nsects; ++i)
2174 bfd_mach_o_section *s = mdata->sections[i];
2176 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2180 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2185 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2186 seg->vmsize += s->size;
2190 /* Now pass through again, for zerofill_GB. */
2191 for (i = 0; i < mdata->nsects; ++i)
2193 bfd_mach_o_section *s = mdata->sections[i];
2195 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2199 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2204 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2205 seg->vmsize += s->size;
2209 /* Allocate space for the relocations. */
2210 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
2212 for (i = 0; i < mdata->nsects; ++i)
2214 bfd_mach_o_section *ms = mdata->sections[i];
2215 asection *sec = ms->bfdsection;
2217 if ((ms->nreloc = sec->reloc_count) == 0)
2222 sec->rel_filepos = mdata->filelen;
2223 ms->reloff = sec->rel_filepos;
2224 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2230 /* Count the number of indirect symbols in the image.
2231 Requires that the sections are in their final order. */
2234 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2237 unsigned int nisyms = 0;
2239 for (i = 0; i < mdata->nsects; ++i)
2241 bfd_mach_o_section *sec = mdata->sections[i];
2243 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2245 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2246 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2247 case BFD_MACH_O_S_SYMBOL_STUBS:
2248 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2258 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2259 bfd_mach_o_data_struct *mdata,
2260 bfd_mach_o_load_command *cmd)
2262 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2265 We are not going to try and fill these in yet and, moreover, we are
2266 going to bail if they are already set. */
2267 if (dsym->nmodtab != 0
2269 || dsym->nextrefsyms != 0)
2271 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2272 " implemented for dysymtab commands."));
2276 dsym->ilocalsym = 0;
2278 if (bfd_get_symcount (abfd) > 0)
2280 asymbol **symbols = bfd_get_outsymbols (abfd);
2283 /* Count the number of each kind of symbol. */
2284 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2286 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2287 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2290 dsym->nlocalsym = i;
2291 dsym->iextdefsym = i;
2292 for (; i < bfd_get_symcount (abfd); ++i)
2294 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2295 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2298 dsym->nextdefsym = i - dsym->nlocalsym;
2299 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2300 dsym->nundefsym = bfd_get_symcount (abfd)
2306 dsym->nlocalsym = 0;
2307 dsym->iextdefsym = 0;
2308 dsym->nextdefsym = 0;
2309 dsym->iundefsym = 0;
2310 dsym->nundefsym = 0;
2313 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2314 if (dsym->nindirectsyms > 0)
2319 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2320 dsym->indirectsymoff = mdata->filelen;
2321 mdata->filelen += dsym->nindirectsyms * 4;
2323 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2324 if (dsym->indirect_syms == NULL)
2328 for (i = 0; i < mdata->nsects; ++i)
2330 bfd_mach_o_section *sec = mdata->sections[i];
2332 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2334 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2335 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2336 case BFD_MACH_O_S_SYMBOL_STUBS:
2339 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2341 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2342 if (isyms == NULL || num == 0)
2344 /* Record the starting index in the reserved1 field. */
2346 for (j = 0; j < num; j++, n++)
2348 if (isyms[j] == NULL)
2349 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2350 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2351 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2352 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2353 | BFD_MACH_O_INDIRECT_SYM_ABS;
2355 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2368 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2369 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2370 and copy functionality. */
2373 bfd_mach_o_build_commands (bfd *abfd)
2375 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2376 unsigned wide = mach_o_wide_p (&mdata->header);
2377 int segcmd_idx = -1;
2378 int symtab_idx = -1;
2379 int dysymtab_idx = -1;
2380 unsigned long base_offset = 0;
2382 /* Return now if commands are already present. */
2383 if (mdata->header.ncmds)
2386 /* Fill in the file type, if not already set. */
2388 if (mdata->header.filetype == 0)
2390 if (abfd->flags & EXEC_P)
2391 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2392 else if (abfd->flags & DYNAMIC)
2393 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2395 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2398 /* If hasn't already been done, flatten sections list, and sort
2399 if/when required. Must be done before the symbol table is adjusted,
2400 since that depends on properly numbered sections. */
2401 if (mdata->nsects == 0 || mdata->sections == NULL)
2402 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2405 /* Order the symbol table, fill-in/check mach-o specific fields and
2406 partition out any indirect symbols. */
2407 if (!bfd_mach_o_mangle_symbols (abfd))
2410 /* Very simple command set (only really applicable to MH_OBJECTs):
2411 All the commands are optional - present only when there is suitable data.
2412 (i.e. it is valid to have an empty file)
2414 a command (segment) to contain all the sections,
2415 command for the symbol table,
2416 a command for the dysymtab.
2418 ??? maybe we should assert that this is an MH_OBJECT? */
2420 if (mdata->nsects > 0)
2423 mdata->header.ncmds = 1;
2426 if (bfd_get_symcount (abfd) > 0)
2428 mdata->header.ncmds++;
2429 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2433 This is a rather crude test for whether we should build a dysymtab. */
2434 if (bfd_mach_o_should_emit_dysymtab ()
2435 && bfd_get_symcount (abfd))
2437 mdata->header.ncmds++;
2438 /* If there should be a case where a dysymtab could be emitted without
2439 a symtab (seems improbable), this would need amending. */
2440 dysymtab_idx = symtab_idx + 1;
2444 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2446 base_offset = BFD_MACH_O_HEADER_SIZE;
2448 /* Well, we must have a header, at least. */
2449 mdata->filelen = base_offset;
2451 /* A bit unusual, but no content is valid;
2452 as -n empty.s -o empty.o */
2453 if (mdata->header.ncmds == 0)
2456 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2457 * sizeof (bfd_mach_o_load_command));
2458 if (mdata->commands == NULL)
2461 if (segcmd_idx >= 0)
2463 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2464 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2466 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2467 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2468 if (seg->nsects == (unsigned long) -1)
2471 /* Init segment command. */
2472 cmd->offset = base_offset;
2475 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2476 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2477 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2481 cmd->type = BFD_MACH_O_LC_SEGMENT;
2482 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2483 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2486 cmd->type_required = FALSE;
2487 mdata->header.sizeofcmds = cmd->len;
2488 mdata->filelen += cmd->len;
2491 if (symtab_idx >= 0)
2493 /* Init symtab command. */
2494 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2496 cmd->type = BFD_MACH_O_LC_SYMTAB;
2497 cmd->offset = base_offset;
2498 if (segcmd_idx >= 0)
2499 cmd->offset += mdata->commands[segcmd_idx].len;
2501 cmd->len = sizeof (struct mach_o_symtab_command_external)
2502 + BFD_MACH_O_LC_SIZE;
2503 cmd->type_required = FALSE;
2504 mdata->header.sizeofcmds += cmd->len;
2505 mdata->filelen += cmd->len;
2508 /* If required, setup symtab command, see comment above about the quality
2510 if (dysymtab_idx >= 0)
2512 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2514 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2515 if (symtab_idx >= 0)
2516 cmd->offset = mdata->commands[symtab_idx].offset
2517 + mdata->commands[symtab_idx].len;
2518 else if (segcmd_idx >= 0)
2519 cmd->offset = mdata->commands[segcmd_idx].offset
2520 + mdata->commands[segcmd_idx].len;
2522 cmd->offset = base_offset;
2524 cmd->type_required = FALSE;
2525 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2526 + BFD_MACH_O_LC_SIZE;
2528 mdata->header.sizeofcmds += cmd->len;
2529 mdata->filelen += cmd->len;
2532 /* So, now we have sized the commands and the filelen set to that.
2533 Now we can build the segment command and set the section file offsets. */
2535 && ! bfd_mach_o_build_seg_command
2536 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2539 /* If we're doing a dysymtab, cmd points to its load command. */
2540 if (dysymtab_idx >= 0
2541 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2542 &mdata->commands[dysymtab_idx]))
2545 /* The symtab command is filled in when the symtab is written. */
2549 /* Set the contents of a section. */
2552 bfd_mach_o_set_section_contents (bfd *abfd,
2554 const void * location,
2556 bfd_size_type count)
2560 /* Trying to write the first section contents will trigger the creation of
2561 the load commands if they are not already present. */
2562 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2568 pos = section->filepos + offset;
2569 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2570 || bfd_bwrite (location, count, abfd) != count)
2577 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2578 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2583 /* Make an empty symbol. This is required only because
2584 bfd_make_section_anyway wants to create a symbol for the section. */
2587 bfd_mach_o_make_empty_symbol (bfd *abfd)
2589 asymbol *new_symbol;
2591 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2592 if (new_symbol == NULL)
2594 new_symbol->the_bfd = abfd;
2595 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2600 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2602 struct mach_o_header_external raw;
2604 bfd_vma (*get32) (const void *) = NULL;
2606 /* Just read the magic number. */
2607 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2608 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2611 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2613 header->byteorder = BFD_ENDIAN_BIG;
2614 header->magic = BFD_MACH_O_MH_MAGIC;
2615 header->version = 1;
2618 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2620 header->byteorder = BFD_ENDIAN_LITTLE;
2621 header->magic = BFD_MACH_O_MH_MAGIC;
2622 header->version = 1;
2625 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2627 header->byteorder = BFD_ENDIAN_BIG;
2628 header->magic = BFD_MACH_O_MH_MAGIC_64;
2629 header->version = 2;
2632 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2634 header->byteorder = BFD_ENDIAN_LITTLE;
2635 header->magic = BFD_MACH_O_MH_MAGIC_64;
2636 header->version = 2;
2641 header->byteorder = BFD_ENDIAN_UNKNOWN;
2645 /* Once the size of the header is known, read the full header. */
2646 size = mach_o_wide_p (header) ?
2647 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2649 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2650 || bfd_bread (&raw, size, abfd) != size)
2653 header->cputype = (*get32) (raw.cputype);
2654 header->cpusubtype = (*get32) (raw.cpusubtype);
2655 header->filetype = (*get32) (raw.filetype);
2656 header->ncmds = (*get32) (raw.ncmds);
2657 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2658 header->flags = (*get32) (raw.flags);
2660 if (mach_o_wide_p (header))
2661 header->reserved = (*get32) (raw.reserved);
2663 header->reserved = 0;
2669 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2671 bfd_mach_o_section *s;
2672 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2674 s = bfd_mach_o_get_mach_o_section (sec);
2678 static const mach_o_section_name_xlat * xlat;
2680 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2683 sec->used_by_bfd = s;
2684 s->bfdsection = sec;
2686 /* Create the Darwin seg/sect name pair from the bfd name.
2687 If this is a canonical name for which a specific paiting exists
2688 there will also be defined flags, type, attribute and alignment
2690 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2693 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2694 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2696 bfd_set_section_alignment (abfd, sec, s->align);
2697 bfd_flags = bfd_get_section_flags (abfd, sec);
2698 if (bfd_flags == SEC_NO_FLAGS)
2699 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2702 /* Create default flags. */
2703 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2706 return _bfd_generic_new_section_hook (abfd, sec);
2710 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2714 bfd_mach_o_section *section;
2716 flags = bfd_get_section_flags (abfd, sec);
2717 section = bfd_mach_o_get_mach_o_section (sec);
2719 /* TODO: see if we should use the xlat system for doing this by
2720 preference and fall back to this for unknown sections. */
2722 if (flags == SEC_NO_FLAGS)
2724 /* Try to guess flags. */
2725 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2726 flags = SEC_DEBUGGING;
2730 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2731 != BFD_MACH_O_S_ZEROFILL)
2734 if (prot & BFD_MACH_O_PROT_EXECUTE)
2736 if (prot & BFD_MACH_O_PROT_WRITE)
2738 else if (prot & BFD_MACH_O_PROT_READ)
2739 flags |= SEC_READONLY;
2745 if ((flags & SEC_DEBUGGING) == 0)
2749 if (section->offset != 0)
2750 flags |= SEC_HAS_CONTENTS;
2751 if (section->nreloc != 0)
2754 bfd_set_section_flags (abfd, sec, flags);
2756 sec->vma = section->addr;
2757 sec->lma = section->addr;
2758 sec->size = section->size;
2759 sec->filepos = section->offset;
2760 sec->alignment_power = section->align;
2761 sec->segment_mark = 0;
2762 sec->reloc_count = section->nreloc;
2763 sec->rel_filepos = section->reloff;
2767 bfd_mach_o_make_bfd_section (bfd *abfd,
2768 const unsigned char *segname,
2769 const unsigned char *sectname)
2774 bfd_mach_o_convert_section_name_to_bfd
2775 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2779 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2783 bfd_mach_o_read_section_32 (bfd *abfd,
2784 unsigned int offset,
2787 struct mach_o_section_32_external raw;
2789 bfd_mach_o_section *section;
2791 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2792 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2793 != BFD_MACH_O_SECTION_SIZE))
2796 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2800 section = bfd_mach_o_get_mach_o_section (sec);
2801 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2802 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2803 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2804 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2805 section->addr = bfd_h_get_32 (abfd, raw.addr);
2806 section->size = bfd_h_get_32 (abfd, raw.size);
2807 section->offset = bfd_h_get_32 (abfd, raw.offset);
2808 section->align = bfd_h_get_32 (abfd, raw.align);
2809 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2810 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2811 section->flags = bfd_h_get_32 (abfd, raw.flags);
2812 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2813 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2814 section->reserved3 = 0;
2816 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2822 bfd_mach_o_read_section_64 (bfd *abfd,
2823 unsigned int offset,
2826 struct mach_o_section_64_external raw;
2828 bfd_mach_o_section *section;
2830 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2831 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2832 != BFD_MACH_O_SECTION_64_SIZE))
2835 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2839 section = bfd_mach_o_get_mach_o_section (sec);
2840 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2841 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2842 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2843 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2844 section->addr = bfd_h_get_64 (abfd, raw.addr);
2845 section->size = bfd_h_get_64 (abfd, raw.size);
2846 section->offset = bfd_h_get_32 (abfd, raw.offset);
2847 section->align = bfd_h_get_32 (abfd, raw.align);
2848 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2849 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2850 section->flags = bfd_h_get_32 (abfd, raw.flags);
2851 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2852 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2853 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2855 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2861 bfd_mach_o_read_section (bfd *abfd,
2862 unsigned int offset,
2867 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2869 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2873 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2874 bfd_mach_o_symtab_command *sym,
2875 bfd_mach_o_asymbol *s,
2878 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2879 unsigned int wide = mach_o_wide_p (&mdata->header);
2880 unsigned int symwidth =
2881 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2882 unsigned int symoff = sym->symoff + (i * symwidth);
2883 struct mach_o_nlist_64_external raw;
2884 unsigned char type = -1;
2885 unsigned char section = -1;
2887 symvalue value = -1;
2888 unsigned long stroff = -1;
2889 unsigned int symtype = -1;
2891 BFD_ASSERT (sym->strtab != NULL);
2893 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2894 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2896 (*_bfd_error_handler)
2897 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2898 symwidth, (unsigned long) symoff);
2902 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2903 type = bfd_h_get_8 (abfd, raw.n_type);
2904 symtype = type & BFD_MACH_O_N_TYPE;
2905 section = bfd_h_get_8 (abfd, raw.n_sect);
2906 desc = bfd_h_get_16 (abfd, raw.n_desc);
2908 value = bfd_h_get_64 (abfd, raw.n_value);
2910 value = bfd_h_get_32 (abfd, raw.n_value);
2912 if (stroff >= sym->strsize)
2914 (*_bfd_error_handler)
2915 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2916 (unsigned long) stroff,
2917 (unsigned long) sym->strsize);
2921 s->symbol.the_bfd = abfd;
2922 s->symbol.name = sym->strtab + stroff;
2923 s->symbol.value = value;
2924 s->symbol.flags = 0x0;
2925 s->symbol.udata.i = i;
2927 s->n_sect = section;
2930 if (type & BFD_MACH_O_N_STAB)
2932 s->symbol.flags |= BSF_DEBUGGING;
2933 s->symbol.section = bfd_und_section_ptr;
2945 if ((section > 0) && (section <= mdata->nsects))
2947 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2949 s->symbol.value - mdata->sections[section - 1]->addr;
2956 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2957 s->symbol.flags |= BSF_GLOBAL;
2959 s->symbol.flags |= BSF_LOCAL;
2963 case BFD_MACH_O_N_UNDF:
2964 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2965 && s->symbol.value != 0)
2967 /* A common symbol. */
2968 s->symbol.section = bfd_com_section_ptr;
2969 s->symbol.flags = BSF_NO_FLAGS;
2973 s->symbol.section = bfd_und_section_ptr;
2974 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2975 s->symbol.flags |= BSF_WEAK;
2978 case BFD_MACH_O_N_PBUD:
2979 s->symbol.section = bfd_und_section_ptr;
2981 case BFD_MACH_O_N_ABS:
2982 s->symbol.section = bfd_abs_section_ptr;
2984 case BFD_MACH_O_N_SECT:
2985 if ((section > 0) && (section <= mdata->nsects))
2987 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2989 s->symbol.value - mdata->sections[section - 1]->addr;
2993 /* Mach-O uses 0 to mean "no section"; not an error. */
2996 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2997 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2998 s->symbol.name, section, mdata->nsects);
3000 s->symbol.section = bfd_und_section_ptr;
3003 case BFD_MACH_O_N_INDR:
3004 /* FIXME: we don't follow the BFD convention as this indirect symbol
3005 won't be followed by the referenced one. This looks harmless
3006 unless we start using the linker. */
3007 s->symbol.flags |= BSF_INDIRECT;
3008 s->symbol.section = bfd_ind_section_ptr;
3009 s->symbol.value = 0;
3012 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3013 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3014 s->symbol.name, symtype);
3015 s->symbol.section = bfd_und_section_ptr;
3024 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3026 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3027 bfd_mach_o_symtab_command *sym = mdata->symtab;
3029 /* Fail if there is no symtab. */
3033 /* Success if already loaded. */
3037 if (abfd->flags & BFD_IN_MEMORY)
3039 struct bfd_in_memory *b;
3041 b = (struct bfd_in_memory *) abfd->iostream;
3043 if ((sym->stroff + sym->strsize) > b->size)
3045 bfd_set_error (bfd_error_file_truncated);
3048 sym->strtab = (char *) b->buffer + sym->stroff;
3052 sym->strtab = bfd_alloc (abfd, sym->strsize);
3053 if (sym->strtab == NULL)
3056 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3057 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3059 bfd_set_error (bfd_error_file_truncated);
3068 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3070 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3071 bfd_mach_o_symtab_command *sym = mdata->symtab;
3074 if (sym == NULL || sym->symbols)
3076 /* Return now if there are no symbols or if already loaded. */
3080 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3082 if (sym->symbols == NULL)
3084 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3088 if (!bfd_mach_o_read_symtab_strtab (abfd))
3091 for (i = 0; i < sym->nsyms; i++)
3093 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3101 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3103 switch ((int) flavour)
3105 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3106 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3107 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3108 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3109 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3110 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3111 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3112 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3113 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3114 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3115 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3116 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3117 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3118 default: return "UNKNOWN";
3123 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3125 switch ((int) flavour)
3127 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3128 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3129 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3130 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3131 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3132 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3133 default: return "UNKNOWN";
3138 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3140 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3141 struct mach_o_str_command_external raw;
3142 unsigned int nameoff;
3144 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
3145 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
3147 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3148 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3151 nameoff = bfd_h_get_32 (abfd, raw.str);
3153 cmd->name_offset = command->offset + nameoff;
3154 cmd->name_len = command->len - nameoff;
3155 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3156 if (cmd->name_str == NULL)
3158 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3159 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3165 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3167 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3168 struct mach_o_dylib_command_external raw;
3169 unsigned int nameoff;
3171 switch (command->type)
3173 case BFD_MACH_O_LC_LOAD_DYLIB:
3174 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3175 case BFD_MACH_O_LC_ID_DYLIB:
3176 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3177 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3184 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3185 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3188 nameoff = bfd_h_get_32 (abfd, raw.name);
3189 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3190 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3191 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3193 cmd->name_offset = command->offset + nameoff;
3194 cmd->name_len = command->len - nameoff;
3195 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3196 if (cmd->name_str == NULL)
3198 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3199 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3205 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
3206 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3208 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3210 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3215 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3217 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3218 struct mach_o_fvmlib_command_external raw;
3219 unsigned int nameoff;
3221 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3222 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3225 nameoff = bfd_h_get_32 (abfd, raw.name);
3226 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3227 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3229 fvm->name_offset = command->offset + nameoff;
3230 fvm->name_len = command->len - nameoff;
3231 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3232 if (fvm->name_str == NULL)
3234 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3235 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3241 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3243 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3244 bfd_mach_o_thread_command *cmd = &command->command.thread;
3245 unsigned int offset;
3246 unsigned int nflavours;
3249 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3250 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3252 /* Count the number of threads. */
3255 while (offset != command->len)
3257 struct mach_o_thread_command_external raw;
3259 if (offset >= command->len)
3262 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3263 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3266 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3270 /* Allocate threads. */
3271 cmd->flavours = bfd_alloc
3272 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3273 if (cmd->flavours == NULL)
3275 cmd->nflavours = nflavours;
3279 while (offset != command->len)
3281 struct mach_o_thread_command_external raw;
3283 if (offset >= command->len)
3286 if (nflavours >= cmd->nflavours)
3289 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3290 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3293 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3294 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3295 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3296 offset += cmd->flavours[nflavours].size + sizeof (raw);
3300 for (i = 0; i < nflavours; i++)
3303 unsigned int snamelen;
3305 const char *flavourstr;
3306 const char *prefix = "LC_THREAD";
3309 switch (mdata->header.cputype)
3311 case BFD_MACH_O_CPU_TYPE_POWERPC:
3312 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3313 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3315 case BFD_MACH_O_CPU_TYPE_I386:
3316 case BFD_MACH_O_CPU_TYPE_X86_64:
3317 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3320 flavourstr = "UNKNOWN_ARCHITECTURE";
3324 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3325 sname = bfd_alloc (abfd, snamelen);
3331 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3332 if (bfd_get_section_by_name (abfd, sname) == NULL)
3337 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3341 bfdsec->size = cmd->flavours[i].size;
3342 bfdsec->filepos = cmd->flavours[i].offset;
3343 bfdsec->alignment_power = 0x0;
3345 cmd->section = bfdsec;
3352 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3354 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3355 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3357 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3360 struct mach_o_dysymtab_command_external raw;
3362 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3363 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3366 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3367 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3368 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3369 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3370 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3371 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3372 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3373 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3374 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3375 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3376 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3377 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3378 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3379 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3380 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3381 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3382 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3383 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3386 if (cmd->nmodtab != 0)
3389 int wide = bfd_mach_o_wide_p (abfd);
3390 unsigned int module_len = wide ? 56 : 52;
3393 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3394 if (cmd->dylib_module == NULL)
3397 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3400 for (i = 0; i < cmd->nmodtab; i++)
3402 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3404 unsigned char buf[56];
3406 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3409 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3410 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3411 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3412 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3413 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3414 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3415 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3416 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3417 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3418 v = bfd_h_get_32 (abfd, buf +36);
3419 module->iinit = v & 0xffff;
3420 module->iterm = (v >> 16) & 0xffff;
3421 v = bfd_h_get_32 (abfd, buf + 40);
3422 module->ninit = v & 0xffff;
3423 module->nterm = (v >> 16) & 0xffff;
3426 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3427 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3431 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3432 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3441 cmd->dylib_toc = bfd_alloc
3442 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3443 if (cmd->dylib_toc == NULL)
3446 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3449 for (i = 0; i < cmd->ntoc; i++)
3451 struct mach_o_dylib_table_of_contents_external raw;
3452 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3454 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3457 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3458 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3462 if (cmd->nindirectsyms != 0)
3466 cmd->indirect_syms = bfd_alloc
3467 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3468 if (cmd->indirect_syms == NULL)
3471 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3474 for (i = 0; i < cmd->nindirectsyms; i++)
3476 unsigned char raw[4];
3477 unsigned int *is = &cmd->indirect_syms[i];
3479 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3482 *is = bfd_h_get_32 (abfd, raw);
3486 if (cmd->nextrefsyms != 0)
3491 cmd->ext_refs = bfd_alloc
3492 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3493 if (cmd->ext_refs == NULL)
3496 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3499 for (i = 0; i < cmd->nextrefsyms; i++)
3501 unsigned char raw[4];
3502 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3504 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3507 /* Fields isym and flags are written as bit-fields, thus we need
3508 a specific processing for endianness. */
3509 v = bfd_h_get_32 (abfd, raw);
3510 if (bfd_big_endian (abfd))
3512 ref->isym = (v >> 8) & 0xffffff;
3513 ref->flags = v & 0xff;
3517 ref->isym = v & 0xffffff;
3518 ref->flags = (v >> 24) & 0xff;
3523 if (mdata->dysymtab)
3525 mdata->dysymtab = cmd;
3531 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3533 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3534 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3535 struct mach_o_symtab_command_external raw;
3537 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3539 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3540 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3543 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3544 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3545 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3546 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3547 symtab->symbols = NULL;
3548 symtab->strtab = NULL;
3550 if (symtab->nsyms != 0)
3551 abfd->flags |= HAS_SYMS;
3555 mdata->symtab = symtab;
3560 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3562 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3564 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3566 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3567 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3574 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3576 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3577 struct mach_o_linkedit_data_command_external raw;
3579 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3580 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3583 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3584 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3589 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3591 bfd_mach_o_str_command *cmd = &command->command.str;
3592 struct mach_o_str_command_external raw;
3595 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3596 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3599 off = bfd_get_32 (abfd, raw.str);
3600 cmd->stroff = command->offset + off;
3601 cmd->str_len = command->len - off;
3602 cmd->str = bfd_alloc (abfd, cmd->str_len);
3603 if (cmd->str == NULL)
3605 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3606 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3612 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3614 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3615 struct mach_o_dyld_info_command_external raw;
3617 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3618 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3621 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3622 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3623 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3624 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3625 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3626 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3627 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3628 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3629 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3630 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3635 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3637 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3638 struct mach_o_version_min_command_external raw;
3641 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3642 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3645 ver = bfd_get_32 (abfd, raw.version);
3646 cmd->rel = ver >> 16;
3647 cmd->maj = ver >> 8;
3649 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3654 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3656 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3657 struct mach_o_encryption_info_command_external raw;
3659 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3660 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3663 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3664 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3665 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3670 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3672 bfd_mach_o_main_command *cmd = &command->command.main;
3673 struct mach_o_entry_point_command_external raw;
3675 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3676 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3679 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3680 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3685 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3687 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3688 struct mach_o_source_version_command_external raw;
3691 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3692 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3695 ver = bfd_get_64 (abfd, raw.version);
3696 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3697 generates warnings) in case of the host doesn't support 64 bit
3699 cmd->e = ver & 0x3ff;
3701 cmd->d = ver & 0x3ff;
3703 cmd->c = ver & 0x3ff;
3705 cmd->b = ver & 0x3ff;
3707 cmd->a = ver & 0xffffff;
3712 bfd_mach_o_read_segment (bfd *abfd,
3713 bfd_mach_o_load_command *command,
3716 bfd_mach_o_segment_command *seg = &command->command.segment;
3721 struct mach_o_segment_command_64_external raw;
3723 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3725 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3726 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3729 memcpy (seg->segname, raw.segname, 16);
3730 seg->segname[16] = '\0';
3732 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3733 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3734 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3735 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3736 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3737 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3738 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3739 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3743 struct mach_o_segment_command_32_external raw;
3745 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3747 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3748 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3751 memcpy (seg->segname, raw.segname, 16);
3752 seg->segname[16] = '\0';
3754 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3755 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3756 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3757 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3758 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3759 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3760 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3761 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3763 seg->sect_head = NULL;
3764 seg->sect_tail = NULL;
3766 for (i = 0; i < seg->nsects; i++)
3772 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3773 + (i * BFD_MACH_O_SECTION_64_SIZE);
3775 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3776 + (i * BFD_MACH_O_SECTION_SIZE);
3778 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3782 bfd_mach_o_append_section_to_segment (seg, sec);
3789 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3791 return bfd_mach_o_read_segment (abfd, command, 0);
3795 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3797 return bfd_mach_o_read_segment (abfd, command, 1);
3801 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3803 struct mach_o_load_command_external raw;
3806 /* Read command type and length. */
3807 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3808 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3811 cmd = bfd_h_get_32 (abfd, raw.cmd);
3812 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3813 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3814 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3816 switch (command->type)
3818 case BFD_MACH_O_LC_SEGMENT:
3819 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3822 case BFD_MACH_O_LC_SEGMENT_64:
3823 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3826 case BFD_MACH_O_LC_SYMTAB:
3827 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3830 case BFD_MACH_O_LC_SYMSEG:
3832 case BFD_MACH_O_LC_THREAD:
3833 case BFD_MACH_O_LC_UNIXTHREAD:
3834 if (bfd_mach_o_read_thread (abfd, command) != 0)
3837 case BFD_MACH_O_LC_LOAD_DYLINKER:
3838 case BFD_MACH_O_LC_ID_DYLINKER:
3839 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3842 case BFD_MACH_O_LC_LOAD_DYLIB:
3843 case BFD_MACH_O_LC_ID_DYLIB:
3844 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3845 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3846 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3847 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3850 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3851 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3854 case BFD_MACH_O_LC_LOADFVMLIB:
3855 case BFD_MACH_O_LC_IDFVMLIB:
3856 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3859 case BFD_MACH_O_LC_IDENT:
3860 case BFD_MACH_O_LC_FVMFILE:
3861 case BFD_MACH_O_LC_PREPAGE:
3862 case BFD_MACH_O_LC_ROUTINES:
3863 case BFD_MACH_O_LC_ROUTINES_64:
3865 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3866 case BFD_MACH_O_LC_SUB_UMBRELLA:
3867 case BFD_MACH_O_LC_SUB_LIBRARY:
3868 case BFD_MACH_O_LC_SUB_CLIENT:
3869 case BFD_MACH_O_LC_RPATH:
3870 if (bfd_mach_o_read_str (abfd, command) != 0)
3873 case BFD_MACH_O_LC_DYSYMTAB:
3874 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3877 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3878 case BFD_MACH_O_LC_PREBIND_CKSUM:
3880 case BFD_MACH_O_LC_UUID:
3881 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3884 case BFD_MACH_O_LC_CODE_SIGNATURE:
3885 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3886 case BFD_MACH_O_LC_FUNCTION_STARTS:
3887 case BFD_MACH_O_LC_DATA_IN_CODE:
3888 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3889 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3892 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3893 if (!bfd_mach_o_read_encryption_info (abfd, command))
3896 case BFD_MACH_O_LC_DYLD_INFO:
3897 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3900 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3901 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3902 if (!bfd_mach_o_read_version_min (abfd, command))
3905 case BFD_MACH_O_LC_MAIN:
3906 if (!bfd_mach_o_read_main (abfd, command))
3909 case BFD_MACH_O_LC_SOURCE_VERSION:
3910 if (!bfd_mach_o_read_source_version (abfd, command))
3914 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3915 abfd, (unsigned long) command->type);
3923 bfd_mach_o_flatten_sections (bfd *abfd)
3925 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3929 /* Count total number of sections. */
3932 for (i = 0; i < mdata->header.ncmds; i++)
3934 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3935 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3937 bfd_mach_o_segment_command *seg;
3939 seg = &mdata->commands[i].command.segment;
3940 mdata->nsects += seg->nsects;
3944 /* Allocate sections array. */
3945 mdata->sections = bfd_alloc (abfd,
3946 mdata->nsects * sizeof (bfd_mach_o_section *));
3948 /* Fill the array. */
3951 for (i = 0; i < mdata->header.ncmds; i++)
3953 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3954 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3956 bfd_mach_o_segment_command *seg;
3957 bfd_mach_o_section *sec;
3959 seg = &mdata->commands[i].command.segment;
3960 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3962 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3963 mdata->sections[csect++] = sec;
3969 bfd_mach_o_scan_start_address (bfd *abfd)
3971 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3972 bfd_mach_o_thread_command *cmd = NULL;
3975 for (i = 0; i < mdata->header.ncmds; i++)
3976 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3977 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3979 cmd = &mdata->commands[i].command.thread;
3986 /* FIXME: create a subtarget hook ? */
3987 for (i = 0; i < cmd->nflavours; i++)
3989 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
3990 && (cmd->flavours[i].flavour
3991 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
3993 unsigned char buf[4];
3995 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
3996 || bfd_bread (buf, 4, abfd) != 4)
3999 abfd->start_address = bfd_h_get_32 (abfd, buf);
4001 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4002 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4004 unsigned char buf[4];
4006 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4007 || bfd_bread (buf, 4, abfd) != 4)
4010 abfd->start_address = bfd_h_get_32 (abfd, buf);
4012 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4013 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4015 unsigned char buf[8];
4017 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4018 || bfd_bread (buf, 8, abfd) != 8)
4021 abfd->start_address = bfd_h_get_64 (abfd, buf);
4023 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4024 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4026 unsigned char buf[8];
4028 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4029 || bfd_bread (buf, 8, abfd) != 8)
4032 abfd->start_address = bfd_h_get_64 (abfd, buf);
4040 bfd_mach_o_set_arch_mach (bfd *abfd,
4041 enum bfd_architecture arch,
4042 unsigned long machine)
4044 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4046 /* If this isn't the right architecture for this backend, and this
4047 isn't the generic backend, fail. */
4048 if (arch != bed->arch
4049 && arch != bfd_arch_unknown
4050 && bed->arch != bfd_arch_unknown)
4053 return bfd_default_set_arch_mach (abfd, arch, machine);
4057 bfd_mach_o_scan (bfd *abfd,
4058 bfd_mach_o_header *header,
4059 bfd_mach_o_data_struct *mdata)
4062 enum bfd_architecture cputype;
4063 unsigned long cpusubtype;
4064 unsigned int hdrsize;
4066 hdrsize = mach_o_wide_p (header) ?
4067 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4069 mdata->header = *header;
4071 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4072 switch (header->filetype)
4074 case BFD_MACH_O_MH_OBJECT:
4075 abfd->flags |= HAS_RELOC;
4077 case BFD_MACH_O_MH_EXECUTE:
4078 abfd->flags |= EXEC_P;
4080 case BFD_MACH_O_MH_DYLIB:
4081 case BFD_MACH_O_MH_BUNDLE:
4082 abfd->flags |= DYNAMIC;
4086 abfd->tdata.mach_o_data = mdata;
4088 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4089 &cputype, &cpusubtype);
4090 if (cputype == bfd_arch_unknown)
4092 (*_bfd_error_handler)
4093 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4094 header->cputype, header->cpusubtype);
4098 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4100 if (header->ncmds != 0)
4102 mdata->commands = bfd_alloc
4103 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4104 if (mdata->commands == NULL)
4107 for (i = 0; i < header->ncmds; i++)
4109 bfd_mach_o_load_command *cur = &mdata->commands[i];
4112 cur->offset = hdrsize;
4115 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4116 cur->offset = prev->offset + prev->len;
4119 if (bfd_mach_o_read_command (abfd, cur) < 0)
4124 if (bfd_mach_o_scan_start_address (abfd) < 0)
4127 bfd_mach_o_flatten_sections (abfd);
4132 bfd_mach_o_mkobject_init (bfd *abfd)
4134 bfd_mach_o_data_struct *mdata = NULL;
4136 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
4139 abfd->tdata.mach_o_data = mdata;
4141 mdata->header.magic = 0;
4142 mdata->header.cputype = 0;
4143 mdata->header.cpusubtype = 0;
4144 mdata->header.filetype = 0;
4145 mdata->header.ncmds = 0;
4146 mdata->header.sizeofcmds = 0;
4147 mdata->header.flags = 0;
4148 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4149 mdata->commands = NULL;
4151 mdata->sections = NULL;
4152 mdata->dyn_reloc_cache = NULL;
4158 bfd_mach_o_gen_mkobject (bfd *abfd)
4160 bfd_mach_o_data_struct *mdata;
4162 if (!bfd_mach_o_mkobject_init (abfd))
4165 mdata = bfd_mach_o_get_data (abfd);
4166 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4167 mdata->header.cputype = 0;
4168 mdata->header.cpusubtype = 0;
4169 mdata->header.byteorder = abfd->xvec->byteorder;
4170 mdata->header.version = 1;
4176 bfd_mach_o_header_p (bfd *abfd,
4177 bfd_mach_o_filetype filetype,
4178 bfd_mach_o_cpu_type cputype)
4180 bfd_mach_o_header header;
4181 bfd_mach_o_data_struct *mdata;
4183 if (!bfd_mach_o_read_header (abfd, &header))
4186 if (! (header.byteorder == BFD_ENDIAN_BIG
4187 || header.byteorder == BFD_ENDIAN_LITTLE))
4189 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4190 (unsigned long) header.byteorder);
4194 if (! ((header.byteorder == BFD_ENDIAN_BIG
4195 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4196 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4197 || (header.byteorder == BFD_ENDIAN_LITTLE
4198 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4199 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4202 /* Check cputype and filetype.
4203 In case of wildcard, do not accept magics that are handled by existing
4207 if (header.cputype != cputype)
4213 if (header.filetype != filetype)
4218 switch (header.filetype)
4220 case BFD_MACH_O_MH_CORE:
4221 /* Handled by core_p */
4228 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4232 if (!bfd_mach_o_scan (abfd, &header, mdata))
4238 bfd_set_error (bfd_error_wrong_format);
4244 static const bfd_target *
4245 bfd_mach_o_gen_object_p (bfd *abfd)
4247 return bfd_mach_o_header_p (abfd, 0, 0);
4250 static const bfd_target *
4251 bfd_mach_o_gen_core_p (bfd *abfd)
4253 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4256 typedef struct mach_o_fat_archentry
4258 unsigned long cputype;
4259 unsigned long cpusubtype;
4260 unsigned long offset;
4262 unsigned long align;
4263 } mach_o_fat_archentry;
4265 typedef struct mach_o_fat_data_struct
4267 unsigned long magic;
4268 unsigned long nfat_arch;
4269 mach_o_fat_archentry *archentries;
4270 } mach_o_fat_data_struct;
4273 bfd_mach_o_archive_p (bfd *abfd)
4275 mach_o_fat_data_struct *adata = NULL;
4276 struct mach_o_fat_header_external hdr;
4279 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4280 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4283 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4287 adata->magic = bfd_getb32 (hdr.magic);
4288 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4289 if (adata->magic != 0xcafebabe)
4291 /* Avoid matching Java bytecode files, which have the same magic number.
4292 In the Java bytecode file format this field contains the JVM version,
4293 which starts at 43.0. */
4294 if (adata->nfat_arch > 30)
4297 adata->archentries =
4298 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4299 if (adata->archentries == NULL)
4302 for (i = 0; i < adata->nfat_arch; i++)
4304 struct mach_o_fat_arch_external arch;
4305 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4307 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4308 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4309 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4310 adata->archentries[i].size = bfd_getb32 (arch.size);
4311 adata->archentries[i].align = bfd_getb32 (arch.align);
4314 abfd->tdata.mach_o_fat_data = adata;
4319 bfd_release (abfd, adata);
4320 bfd_set_error (bfd_error_wrong_format);
4324 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4325 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4326 Set arelt_data and origin fields too. */
4329 bfd_mach_o_fat_member_init (bfd *abfd,
4330 enum bfd_architecture arch_type,
4331 unsigned long arch_subtype,
4332 mach_o_fat_archentry *entry)
4334 struct areltdata *areltdata;
4335 /* Create the member filename. Use ARCH_NAME. */
4336 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4340 /* Use the architecture name if known. */
4341 abfd->filename = ap->printable_name;
4345 /* Forge a uniq id. */
4346 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4347 char *name = bfd_alloc (abfd, namelen);
4348 snprintf (name, namelen, "0x%lx-0x%lx",
4349 entry->cputype, entry->cpusubtype);
4350 abfd->filename = name;
4353 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4354 areltdata->parsed_size = entry->size;
4355 abfd->arelt_data = areltdata;
4356 abfd->iostream = NULL;
4357 abfd->origin = entry->offset;
4361 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4363 mach_o_fat_data_struct *adata;
4364 mach_o_fat_archentry *entry = NULL;
4367 enum bfd_architecture arch_type;
4368 unsigned long arch_subtype;
4370 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4371 BFD_ASSERT (adata != NULL);
4373 /* Find index of previous entry. */
4376 /* Start at first one. */
4381 /* Find index of PREV. */
4382 for (i = 0; i < adata->nfat_arch; i++)
4384 if (adata->archentries[i].offset == prev->origin)
4388 if (i == adata->nfat_arch)
4391 bfd_set_error (bfd_error_bad_value);
4395 /* Get next entry. */
4399 if (i >= adata->nfat_arch)
4401 bfd_set_error (bfd_error_no_more_archived_files);
4405 entry = &adata->archentries[i];
4406 nbfd = _bfd_new_bfd_contained_in (archive);
4410 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4411 &arch_type, &arch_subtype);
4413 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4415 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4420 /* Analogous to stat call. */
4423 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4425 if (abfd->arelt_data == NULL)
4427 bfd_set_error (bfd_error_invalid_operation);
4434 buf->st_mode = 0644;
4435 buf->st_size = arelt_size (abfd);
4440 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4441 If ABFD is a fat image containing a member that corresponds to FORMAT
4442 and ARCH, returns it.
4443 In other case, returns NULL.
4444 This function allows transparent uses of fat images. */
4447 bfd_mach_o_fat_extract (bfd *abfd,
4449 const bfd_arch_info_type *arch)
4452 mach_o_fat_data_struct *adata;
4455 if (bfd_check_format (abfd, format))
4457 if (bfd_get_arch_info (abfd) == arch)
4461 if (!bfd_check_format (abfd, bfd_archive)
4462 || abfd->xvec != &mach_o_fat_vec)
4465 /* This is a Mach-O fat image. */
4466 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4467 BFD_ASSERT (adata != NULL);
4469 for (i = 0; i < adata->nfat_arch; i++)
4471 struct mach_o_fat_archentry *e = &adata->archentries[i];
4472 enum bfd_architecture cpu_type;
4473 unsigned long cpu_subtype;
4475 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4476 &cpu_type, &cpu_subtype);
4477 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4480 /* The architecture is found. */
4481 res = _bfd_new_bfd_contained_in (abfd);
4485 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4487 if (bfd_check_format (res, format))
4489 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4500 bfd_mach_o_lookup_command (bfd *abfd,
4501 bfd_mach_o_load_command_type type,
4502 bfd_mach_o_load_command **mcommand)
4504 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4505 bfd_mach_o_load_command *ncmd = NULL;
4506 unsigned int i, num;
4508 BFD_ASSERT (md != NULL);
4509 BFD_ASSERT (mcommand != NULL);
4512 for (i = 0; i < md->header.ncmds; i++)
4514 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4516 if (cmd->type != type)
4529 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4533 case BFD_MACH_O_CPU_TYPE_MC680x0:
4535 case BFD_MACH_O_CPU_TYPE_MC88000:
4537 case BFD_MACH_O_CPU_TYPE_POWERPC:
4539 case BFD_MACH_O_CPU_TYPE_I386:
4541 case BFD_MACH_O_CPU_TYPE_SPARC:
4543 case BFD_MACH_O_CPU_TYPE_I860:
4545 case BFD_MACH_O_CPU_TYPE_HPPA:
4546 return 0xc0000000 - 0x04000000;
4552 /* The following two tables should be kept, as far as possible, in order of
4553 most frequently used entries to optimize their use from gas. */
4555 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4557 { "regular", BFD_MACH_O_S_REGULAR},
4558 { "coalesced", BFD_MACH_O_S_COALESCED},
4559 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4560 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4561 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4562 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4563 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4564 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4565 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4566 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4567 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4568 { "interposing", BFD_MACH_O_S_INTERPOSING},
4569 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4570 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4571 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4572 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4573 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4577 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4579 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4580 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4581 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4582 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4583 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4584 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4585 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4586 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4587 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4588 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4589 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4593 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4596 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4598 const bfd_mach_o_xlat_name *x;
4599 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4601 for (x = bfd_mach_o_section_type_name; x->name; x++)
4602 if (strcmp (x->name, name) == 0)
4604 /* We found it... does the target support it? */
4605 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4606 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4607 return x->val; /* OK. */
4609 break; /* Not supported. */
4611 /* Maximum section ID = 0xff. */
4615 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4618 bfd_mach_o_get_section_attribute_from_name (const char *name)
4620 const bfd_mach_o_xlat_name *x;
4622 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4623 if (strcmp (x->name, name) == 0)
4625 return (unsigned int)-1;
4629 bfd_mach_o_core_fetch_environment (bfd *abfd,
4630 unsigned char **rbuf,
4633 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4634 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4637 for (i = 0; i < mdata->header.ncmds; i++)
4639 bfd_mach_o_load_command *cur = &mdata->commands[i];
4640 bfd_mach_o_segment_command *seg = NULL;
4642 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4645 seg = &cur->command.segment;
4647 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4649 unsigned long start = seg->fileoff;
4650 unsigned long end = seg->fileoff + seg->filesize;
4651 unsigned char *buf = bfd_malloc (1024);
4652 unsigned long size = 1024;
4656 bfd_size_type nread = 0;
4657 unsigned long offset;
4658 int found_nonnull = 0;
4660 if (size > (end - start))
4661 size = (end - start);
4663 buf = bfd_realloc_or_free (buf, size);
4667 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4673 nread = bfd_bread (buf, size, abfd);
4681 for (offset = 4; offset <= size; offset += 4)
4685 val = *((unsigned long *) (buf + size - offset));
4686 if (! found_nonnull)
4691 else if (val == 0x0)
4693 unsigned long bottom;
4696 bottom = seg->fileoff + seg->filesize - offset;
4697 top = seg->fileoff + seg->filesize - 4;
4698 *rbuf = bfd_malloc (top - bottom);
4699 *rlen = top - bottom;
4701 memcpy (*rbuf, buf + size - *rlen, *rlen);
4707 if (size == (end - start))
4721 bfd_mach_o_core_file_failing_command (bfd *abfd)
4723 unsigned char *buf = NULL;
4724 unsigned int len = 0;
4727 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4731 return (char *) buf;
4735 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4740 static bfd_mach_o_uuid_command *
4741 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4743 bfd_mach_o_load_command *uuid_cmd;
4744 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4747 return &uuid_cmd->command.uuid;
4750 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4753 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4755 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4758 BFD_ASSERT (uuid_cmd);
4760 if (!bfd_check_format (abfd, bfd_object))
4763 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4764 || bfd_mach_o_get_data (abfd) == NULL
4765 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4768 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4769 if (dsym_uuid_cmd == NULL)
4772 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4773 sizeof (uuid_cmd->uuid)) != 0)
4779 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4780 The caller is responsible for closing the returned BFD object and
4781 its my_archive if the returned BFD is in a fat dSYM. */
4784 bfd_mach_o_find_dsym (const char *dsym_filename,
4785 const bfd_mach_o_uuid_command *uuid_cmd,
4786 const bfd_arch_info_type *arch)
4788 bfd *base_dsym_bfd, *dsym_bfd;
4790 BFD_ASSERT (uuid_cmd);
4792 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4793 if (base_dsym_bfd == NULL)
4796 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4797 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4800 bfd_close (dsym_bfd);
4801 if (base_dsym_bfd != dsym_bfd)
4802 bfd_close (base_dsym_bfd);
4807 /* Return a BFD created from a dSYM file for ABFD.
4808 The caller is responsible for closing the returned BFD object, its
4809 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4812 bfd_mach_o_follow_dsym (bfd *abfd)
4814 char *dsym_filename;
4815 bfd_mach_o_uuid_command *uuid_cmd;
4816 bfd *dsym_bfd, *base_bfd = abfd;
4817 const char *base_basename;
4819 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4822 if (abfd->my_archive)
4823 base_bfd = abfd->my_archive;
4824 /* BFD may have been opened from a stream. */
4825 if (base_bfd->filename == NULL)
4827 bfd_set_error (bfd_error_invalid_operation);
4830 base_basename = lbasename (base_bfd->filename);
4832 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4833 if (uuid_cmd == NULL)
4836 /* TODO: We assume the DWARF file has the same as the binary's.
4837 It seems apple's GDB checks all files in the dSYM bundle directory.
4838 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4840 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4841 + strlen (dsym_subdir) + 1
4842 + strlen (base_basename) + 1);
4843 sprintf (dsym_filename, "%s%s/%s",
4844 base_bfd->filename, dsym_subdir, base_basename);
4846 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4847 bfd_get_arch_info (abfd));
4848 if (dsym_bfd == NULL)
4849 free (dsym_filename);
4855 bfd_mach_o_find_nearest_line (bfd *abfd,
4859 const char **filename_ptr,
4860 const char **functionname_ptr,
4861 unsigned int *line_ptr)
4863 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4866 switch (mdata->header.filetype)
4868 case BFD_MACH_O_MH_OBJECT:
4870 case BFD_MACH_O_MH_EXECUTE:
4871 case BFD_MACH_O_MH_DYLIB:
4872 case BFD_MACH_O_MH_BUNDLE:
4873 case BFD_MACH_O_MH_KEXT_BUNDLE:
4874 if (mdata->dwarf2_find_line_info == NULL)
4876 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4877 /* When we couldn't find dSYM for this binary, we look for
4878 the debug information in the binary itself. In this way,
4879 we won't try finding separated dSYM again because
4880 mdata->dwarf2_find_line_info will be filled. */
4881 if (! mdata->dsym_bfd)
4883 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4884 dwarf_debug_sections, symbols,
4885 &mdata->dwarf2_find_line_info))
4892 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4893 section, symbols, offset,
4894 filename_ptr, functionname_ptr,
4896 &mdata->dwarf2_find_line_info))
4902 bfd_mach_o_close_and_cleanup (bfd *abfd)
4904 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4905 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4907 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4908 bfd_mach_o_free_cached_info (abfd);
4909 if (mdata->dsym_bfd != NULL)
4911 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4912 char *dsym_filename = (char *)(fat_bfd
4914 : mdata->dsym_bfd->filename);
4915 bfd_close (mdata->dsym_bfd);
4916 mdata->dsym_bfd = NULL;
4918 bfd_close (fat_bfd);
4919 free (dsym_filename);
4923 if (bfd_get_format (abfd) == bfd_archive
4924 && abfd->xvec == &mach_o_fat_vec)
4926 return _bfd_generic_close_and_cleanup (abfd);
4929 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4931 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4933 free (mdata->dyn_reloc_cache);
4934 mdata->dyn_reloc_cache = NULL;
4935 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4937 free (asect->relocation);
4938 asect->relocation = NULL;
4944 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4945 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4947 #define bfd_mach_o_swap_reloc_in NULL
4948 #define bfd_mach_o_swap_reloc_out NULL
4949 #define bfd_mach_o_print_thread NULL
4950 #define bfd_mach_o_tgt_seg_table NULL
4951 #define bfd_mach_o_section_type_valid_for_tgt NULL
4953 #define TARGET_NAME mach_o_be_vec
4954 #define TARGET_STRING "mach-o-be"
4955 #define TARGET_ARCHITECTURE bfd_arch_unknown
4956 #define TARGET_BIG_ENDIAN 1
4957 #define TARGET_ARCHIVE 0
4958 #define TARGET_PRIORITY 1
4959 #include "mach-o-target.c"
4962 #undef TARGET_STRING
4963 #undef TARGET_ARCHITECTURE
4964 #undef TARGET_BIG_ENDIAN
4965 #undef TARGET_ARCHIVE
4966 #undef TARGET_PRIORITY
4968 #define TARGET_NAME mach_o_le_vec
4969 #define TARGET_STRING "mach-o-le"
4970 #define TARGET_ARCHITECTURE bfd_arch_unknown
4971 #define TARGET_BIG_ENDIAN 0
4972 #define TARGET_ARCHIVE 0
4973 #define TARGET_PRIORITY 1
4975 #include "mach-o-target.c"
4978 #undef TARGET_STRING
4979 #undef TARGET_ARCHITECTURE
4980 #undef TARGET_BIG_ENDIAN
4981 #undef TARGET_ARCHIVE
4982 #undef TARGET_PRIORITY
4984 /* Not yet handled: creating an archive. */
4985 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4988 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4989 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4990 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4991 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4992 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4993 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4994 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4995 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4996 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
4997 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4999 #define TARGET_NAME mach_o_fat_vec
5000 #define TARGET_STRING "mach-o-fat"
5001 #define TARGET_ARCHITECTURE bfd_arch_unknown
5002 #define TARGET_BIG_ENDIAN 1
5003 #define TARGET_ARCHIVE 1
5004 #define TARGET_PRIORITY 0
5006 #include "mach-o-target.c"
5009 #undef TARGET_STRING
5010 #undef TARGET_ARCHITECTURE
5011 #undef TARGET_BIG_ENDIAN
5012 #undef TARGET_ARCHIVE
5013 #undef TARGET_PRIORITY