1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "aout/stab_gnu.h"
27 #include "mach-o/reloc.h"
28 #include "mach-o/external.h"
33 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
34 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
35 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
37 #define FILE_ALIGN(off, algn) \
38 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
41 bfd_mach_o_version (bfd *abfd)
43 bfd_mach_o_data_struct *mdata = NULL;
45 BFD_ASSERT (bfd_mach_o_valid (abfd));
46 mdata = bfd_mach_o_get_data (abfd);
48 return mdata->header.version;
52 bfd_mach_o_valid (bfd *abfd)
54 if (abfd == NULL || abfd->xvec == NULL)
57 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
60 if (bfd_mach_o_get_data (abfd) == NULL)
65 static INLINE bfd_boolean
66 mach_o_wide_p (bfd_mach_o_header *header)
68 switch (header->version)
80 static INLINE bfd_boolean
81 bfd_mach_o_wide_p (bfd *abfd)
83 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
86 /* Tables to translate well known Mach-O segment/section names to bfd
87 names. Use of canonical names (such as .text or .debug_frame) is required
91 static const mach_o_section_name_xlat text_section_names_xlat[] =
94 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
95 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS, 0},
96 { ".const", "__const",
97 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
98 BFD_MACH_O_S_ATTR_NONE, 0},
99 { ".static_const", "__static_const",
100 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
101 BFD_MACH_O_S_ATTR_NONE, 0},
102 { ".cstring", "__cstring",
103 SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
104 BFD_MACH_O_S_CSTRING_LITERALS,
105 BFD_MACH_O_S_ATTR_NONE, 0},
106 { ".literal4", "__literal4",
107 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_4BYTE_LITERALS,
108 BFD_MACH_O_S_ATTR_NONE, 2},
109 { ".literal8", "__literal8",
110 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_8BYTE_LITERALS,
111 BFD_MACH_O_S_ATTR_NONE, 3},
112 { ".literal16", "__literal16",
113 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_16BYTE_LITERALS,
114 BFD_MACH_O_S_ATTR_NONE, 4},
115 { ".constructor", "__constructor",
116 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
117 BFD_MACH_O_S_ATTR_NONE, 0},
118 { ".destructor", "__destructor",
119 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
120 BFD_MACH_O_S_ATTR_NONE, 0},
121 { ".eh_frame", "__eh_frame",
122 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_COALESCED,
123 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
124 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
125 | BFD_MACH_O_S_ATTR_NO_TOC, 2},
126 { NULL, NULL, 0, 0, 0, 0}
129 /* __DATA Segment. */
130 static const mach_o_section_name_xlat data_section_names_xlat[] =
133 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
134 BFD_MACH_O_S_ATTR_NONE, 0},
136 SEC_NO_FLAGS, BFD_MACH_O_S_ZEROFILL,
137 BFD_MACH_O_S_ATTR_NONE, 0},
138 { ".const_data", "__const",
139 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
140 BFD_MACH_O_S_ATTR_NONE, 0},
141 { ".static_data", "__static_data",
142 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
143 BFD_MACH_O_S_ATTR_NONE, 0},
144 { ".mod_init_func", "__mod_init_func",
145 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
146 BFD_MACH_O_S_ATTR_NONE, 2},
147 { ".mod_term_func", "__mod_term_func",
148 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
149 BFD_MACH_O_S_ATTR_NONE, 2},
151 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
152 BFD_MACH_O_S_ATTR_NONE, 0},
153 { ".cfstring", "__cfstring",
154 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
155 BFD_MACH_O_S_ATTR_NONE, 2},
156 { NULL, NULL, 0, 0, 0, 0}
159 /* __DWARF Segment. */
160 static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
162 { ".debug_frame", "__debug_frame",
163 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
164 BFD_MACH_O_S_ATTR_DEBUG, 0},
165 { ".debug_info", "__debug_info",
166 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
167 BFD_MACH_O_S_ATTR_DEBUG, 0},
168 { ".debug_abbrev", "__debug_abbrev",
169 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
170 BFD_MACH_O_S_ATTR_DEBUG, 0},
171 { ".debug_aranges", "__debug_aranges",
172 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
173 BFD_MACH_O_S_ATTR_DEBUG, 0},
174 { ".debug_macinfo", "__debug_macinfo",
175 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
176 BFD_MACH_O_S_ATTR_DEBUG, 0},
177 { ".debug_line", "__debug_line",
178 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
179 BFD_MACH_O_S_ATTR_DEBUG, 0},
180 { ".debug_loc", "__debug_loc",
181 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
182 BFD_MACH_O_S_ATTR_DEBUG, 0},
183 { ".debug_pubnames", "__debug_pubnames",
184 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
185 BFD_MACH_O_S_ATTR_DEBUG, 0},
186 { ".debug_pubtypes", "__debug_pubtypes",
187 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
188 BFD_MACH_O_S_ATTR_DEBUG, 0},
189 { ".debug_str", "__debug_str",
190 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
191 BFD_MACH_O_S_ATTR_DEBUG, 0},
192 { ".debug_ranges", "__debug_ranges",
193 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
194 BFD_MACH_O_S_ATTR_DEBUG, 0},
195 { ".debug_macro", "__debug_macro",
196 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
197 BFD_MACH_O_S_ATTR_DEBUG, 0},
198 { ".debug_gdb_scripts", "__debug_gdb_scri",
199 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
200 BFD_MACH_O_S_ATTR_DEBUG, 0},
201 { NULL, NULL, 0, 0, 0, 0}
204 /* __OBJC Segment. */
205 static const mach_o_section_name_xlat objc_section_names_xlat[] =
207 { ".objc_class", "__class",
208 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
209 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
210 { ".objc_meta_class", "__meta_class",
211 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
212 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
213 { ".objc_cat_cls_meth", "__cat_cls_meth",
214 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
215 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
216 { ".objc_cat_inst_meth", "__cat_inst_meth",
217 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
218 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
219 { ".objc_protocol", "__protocol",
220 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
221 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
222 { ".objc_string_object", "__string_object",
223 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
224 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
225 { ".objc_cls_meth", "__cls_meth",
226 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
227 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
228 { ".objc_inst_meth", "__inst_meth",
229 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
230 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
231 { ".objc_cls_refs", "__cls_refs",
232 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
233 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
234 { ".objc_message_refs", "__message_refs",
235 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
236 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
237 { ".objc_symbols", "__symbols",
238 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
239 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
240 { ".objc_category", "__category",
241 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
242 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
243 { ".objc_class_vars", "__class_vars",
244 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
245 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
246 { ".objc_instance_vars", "__instance_vars",
247 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
248 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
249 { ".objc_module_info", "__module_info",
250 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
251 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
252 { ".objc_selector_strs", "__selector_strs",
253 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_CSTRING_LITERALS,
254 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
255 { ".objc_image_info", "__image_info",
256 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
257 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
258 { ".objc_selector_fixup", "__sel_fixup",
259 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
260 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
262 { ".objc1_class_ext", "__class_ext",
263 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
264 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
265 { ".objc1_property_list", "__property",
266 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
267 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
268 { ".objc1_protocol_ext", "__protocol_ext",
269 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
270 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
271 { NULL, NULL, 0, 0, 0, 0}
274 static const mach_o_segment_name_xlat segsec_names_xlat[] =
276 { "__TEXT", text_section_names_xlat },
277 { "__DATA", data_section_names_xlat },
278 { "__DWARF", dwarf_section_names_xlat },
279 { "__OBJC", objc_section_names_xlat },
283 static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
285 /* For both cases bfd-name => mach-o name and vice versa, the specific target
286 is checked before the generic. This allows a target (e.g. ppc for cstring)
287 to override the generic definition with a more specific one. */
289 /* Fetch the translation from a Mach-O section designation (segment, section)
290 as a bfd short name, if one exists. Otherwise return NULL.
292 Allow the segment and section names to be unterminated 16 byte arrays. */
294 const mach_o_section_name_xlat *
295 bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
296 const char *sectname)
298 const struct mach_o_segment_name_xlat *seg;
299 const mach_o_section_name_xlat *sec;
300 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
302 /* First try any target-specific translations defined... */
303 if (bed->segsec_names_xlat)
304 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
305 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
306 for (sec = seg->sections; sec->mach_o_name; sec++)
307 if (strncmp (sec->mach_o_name, sectname,
308 BFD_MACH_O_SECTNAME_SIZE) == 0)
311 /* ... and then the Mach-O generic ones. */
312 for (seg = segsec_names_xlat; seg->segname; seg++)
313 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
314 for (sec = seg->sections; sec->mach_o_name; sec++)
315 if (strncmp (sec->mach_o_name, sectname,
316 BFD_MACH_O_SECTNAME_SIZE) == 0)
322 /* If the bfd_name for this section is a 'canonical' form for which we
323 know the Mach-O data, return the segment name and the data for the
324 Mach-O equivalent. Otherwise return NULL. */
326 const mach_o_section_name_xlat *
327 bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
328 const char **segname)
330 const struct mach_o_segment_name_xlat *seg;
331 const mach_o_section_name_xlat *sec;
332 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
335 if (bfd_name[0] != '.')
338 /* First try any target-specific translations defined... */
339 if (bed->segsec_names_xlat)
340 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
341 for (sec = seg->sections; sec->bfd_name; sec++)
342 if (strcmp (bfd_name, sec->bfd_name) == 0)
344 *segname = seg->segname;
348 /* ... and then the Mach-O generic ones. */
349 for (seg = segsec_names_xlat; seg->segname; seg++)
350 for (sec = seg->sections; sec->bfd_name; sec++)
351 if (strcmp (bfd_name, sec->bfd_name) == 0)
353 *segname = seg->segname;
360 /* Convert Mach-O section name to BFD.
362 Try to use standard/canonical names, for which we have tables including
363 default flag settings - which are returned. Otherwise forge a new name
364 in the form "<segmentname>.<sectionname>" this will be prefixed with
365 LC_SEGMENT. if the segment name does not begin with an underscore.
367 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
368 terminated if the name length is exactly 16 bytes - but must be if the name
369 length is less than 16 characters). */
372 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
373 const char *secname, const char **name,
376 const mach_o_section_name_xlat *xlat;
379 const char *pfx = "";
382 *flags = SEC_NO_FLAGS;
384 /* First search for a canonical name...
385 xlat will be non-null if there is an entry for segname, secname. */
386 xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
389 len = strlen (xlat->bfd_name);
390 res = bfd_alloc (abfd, len+1);
393 memcpy (res, xlat->bfd_name, len+1);
395 *flags = xlat->bfd_flags;
399 /* ... else we make up a bfd name from the segment concatenated with the
402 len = 16 + 1 + 16 + 1;
404 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
405 with an underscore. */
406 if (segname[0] != '_')
408 static const char seg_pfx[] = "LC_SEGMENT.";
411 len += sizeof (seg_pfx) - 1;
414 res = bfd_alloc (abfd, len);
417 snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
421 /* Convert a bfd section name to a Mach-O segment + section name.
423 If the name is a canonical one for which we have a Darwin match
424 return the translation table - which contains defaults for flags,
425 type, attribute and default alignment data.
427 Otherwise, expand the bfd_name (assumed to be in the form
428 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
430 static const mach_o_section_name_xlat *
431 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
433 bfd_mach_o_section *section)
435 const mach_o_section_name_xlat *xlat;
436 const char *name = bfd_get_section_name (abfd, sect);
443 memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
444 memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
446 /* See if is a canonical name ... */
447 xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
450 strcpy (section->segname, segname);
451 strcpy (section->sectname, xlat->mach_o_name);
455 /* .. else we convert our constructed one back to Mach-O.
456 Strip LC_SEGMENT. prefix, if present. */
457 if (strncmp (name, "LC_SEGMENT.", 11) == 0)
461 dot = strchr (name, '.');
464 /* Try to split name into segment and section names. */
465 if (dot && dot != name)
468 seclen = len - (dot + 1 - name);
470 if (seglen < 16 && seclen < 16)
472 memcpy (section->segname, name, seglen);
473 section->segname[seglen] = 0;
474 memcpy (section->sectname, dot + 1, seclen);
475 section->sectname[seclen] = 0;
480 /* The segment and section names are both missing - don't make them
482 if (dot && dot == name)
485 /* Just duplicate the name into both segment and section. */
488 memcpy (section->segname, name, len);
489 section->segname[len] = 0;
490 memcpy (section->sectname, name, len);
491 section->sectname[len] = 0;
495 /* Return the size of an entry for section SEC.
496 Must be called only for symbol pointer section and symbol stubs
500 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
502 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
504 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
505 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
506 return bfd_mach_o_wide_p (abfd) ? 8 : 4;
507 case BFD_MACH_O_S_SYMBOL_STUBS:
508 return sec->reserved2;
515 /* Return the number of indirect symbols for a section.
516 Must be called only for symbol pointer section and symbol stubs
520 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
524 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
528 return sec->size / elsz;
532 /* Copy any private info we understand from the input symbol
533 to the output symbol. */
536 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
538 bfd *obfd ATTRIBUTE_UNUSED,
541 bfd_mach_o_asymbol *os, *is;
542 os = (bfd_mach_o_asymbol *)osymbol;
543 is = (bfd_mach_o_asymbol *)isymbol;
544 os->n_type = is->n_type;
545 os->n_sect = is->n_sect;
546 os->n_desc = is->n_desc;
547 os->symbol.udata.i = is->symbol.udata.i;
551 /* Copy any private info we understand from the input section
552 to the output section. */
555 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
557 bfd *obfd ATTRIBUTE_UNUSED,
560 if (osection->used_by_bfd == NULL)
561 osection->used_by_bfd = isection->used_by_bfd;
563 if (isection->used_by_bfd != NULL)
564 memcpy (osection->used_by_bfd, isection->used_by_bfd,
565 sizeof (bfd_mach_o_section));
567 if (osection->used_by_bfd != NULL)
568 ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
573 /* Copy any private info we understand from the input bfd
574 to the output bfd. */
577 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
579 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
580 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
583 BFD_ASSERT (bfd_mach_o_valid (ibfd));
584 BFD_ASSERT (bfd_mach_o_valid (obfd));
586 /* FIXME: copy commands. */
591 /* This allows us to set up to 32 bits of flags (unless we invent some
592 fiendish scheme to subdivide). For now, we'll just set the file flags
593 without error checking - just overwrite. */
596 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
598 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
603 mdata->header.flags = flags;
607 /* Count the total number of symbols. */
610 bfd_mach_o_count_symbols (bfd *abfd)
612 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
614 if (mdata->symtab == NULL)
616 return mdata->symtab->nsyms;
620 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
622 long nsyms = bfd_mach_o_count_symbols (abfd);
624 return ((nsyms + 1) * sizeof (asymbol *));
628 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
630 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
631 long nsyms = bfd_mach_o_count_symbols (abfd);
632 bfd_mach_o_symtab_command *sym = mdata->symtab;
640 /* Do not try to read symbols if there are none. */
645 if (!bfd_mach_o_read_symtab_symbols (abfd))
647 (*_bfd_error_handler)
648 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
652 BFD_ASSERT (sym->symbols != NULL);
654 for (j = 0; j < sym->nsyms; j++)
655 alocation[j] = &sym->symbols[j].symbol;
662 /* Create synthetic symbols for indirect symbols. */
665 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
666 long symcount ATTRIBUTE_UNUSED,
667 asymbol **syms ATTRIBUTE_UNUSED,
668 long dynsymcount ATTRIBUTE_UNUSED,
669 asymbol **dynsyms ATTRIBUTE_UNUSED,
672 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
673 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
674 bfd_mach_o_symtab_command *symtab = mdata->symtab;
676 unsigned long count, i, j, n;
683 /* Stop now if no symbols or no indirect symbols. */
684 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
687 if (dysymtab->nindirectsyms == 0)
690 /* We need to allocate a bfd symbol for every indirect symbol and to
691 allocate the memory for its name. */
692 count = dysymtab->nindirectsyms;
693 size = count * sizeof (asymbol) + 1;
695 for (j = 0; j < count; j++)
697 unsigned int isym = dysymtab->indirect_syms[j];
699 /* Some indirect symbols are anonymous. */
700 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
701 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
704 s = *ret = (asymbol *) bfd_malloc (size);
707 names = (char *) (s + count);
712 for (i = 0; i < mdata->nsects; i++)
714 bfd_mach_o_section *sec = mdata->sections[i];
715 unsigned int first, last;
719 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
721 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
722 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
723 case BFD_MACH_O_S_SYMBOL_STUBS:
724 /* Only these sections have indirect symbols. */
725 first = sec->reserved1;
726 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
728 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
729 for (j = first; j < last; j++)
731 unsigned int isym = dysymtab->indirect_syms[j];
733 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
734 s->section = sec->bfdsection;
735 s->value = addr - sec->addr;
738 if (isym < symtab->nsyms
739 && symtab->symbols[isym].symbol.name)
741 const char *sym = symtab->symbols[isym].symbol.name;
746 memcpy (names, sym, len);
748 memcpy (names, "$stub", sizeof ("$stub"));
749 names += sizeof ("$stub");
768 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
772 bfd_symbol_info (symbol, ret);
776 bfd_mach_o_print_symbol (bfd *abfd,
779 bfd_print_symbol_type how)
781 FILE *file = (FILE *) afile;
783 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
787 case bfd_print_symbol_name:
788 fprintf (file, "%s", symbol->name);
791 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
792 if (asym->n_type & BFD_MACH_O_N_STAB)
793 name = bfd_get_stab_name (asym->n_type);
795 switch (asym->n_type & BFD_MACH_O_N_TYPE)
797 case BFD_MACH_O_N_UNDF:
798 if (symbol->value == 0)
803 case BFD_MACH_O_N_ABS:
806 case BFD_MACH_O_N_INDR:
809 case BFD_MACH_O_N_PBUD:
812 case BFD_MACH_O_N_SECT:
821 fprintf (file, " %02x %-6s %02x %04x",
822 asym->n_type, name, asym->n_sect, asym->n_desc);
823 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
824 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
825 fprintf (file, " [%s]", symbol->section->name);
826 fprintf (file, " %s", symbol->name);
831 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
832 bfd_mach_o_cpu_subtype msubtype,
833 enum bfd_architecture *type,
834 unsigned long *subtype)
836 *subtype = bfd_arch_unknown;
840 case BFD_MACH_O_CPU_TYPE_VAX:
841 *type = bfd_arch_vax;
843 case BFD_MACH_O_CPU_TYPE_MC680x0:
844 *type = bfd_arch_m68k;
846 case BFD_MACH_O_CPU_TYPE_I386:
847 *type = bfd_arch_i386;
848 *subtype = bfd_mach_i386_i386;
850 case BFD_MACH_O_CPU_TYPE_X86_64:
851 *type = bfd_arch_i386;
852 *subtype = bfd_mach_x86_64;
854 case BFD_MACH_O_CPU_TYPE_MIPS:
855 *type = bfd_arch_mips;
857 case BFD_MACH_O_CPU_TYPE_MC98000:
858 *type = bfd_arch_m98k;
860 case BFD_MACH_O_CPU_TYPE_HPPA:
861 *type = bfd_arch_hppa;
863 case BFD_MACH_O_CPU_TYPE_ARM:
864 *type = bfd_arch_arm;
867 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
868 *subtype = bfd_mach_arm_4T;
870 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
871 *subtype = bfd_mach_arm_4T; /* Best fit ? */
873 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
874 *subtype = bfd_mach_arm_5TE;
876 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
877 *subtype = bfd_mach_arm_XScale;
879 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
880 *subtype = bfd_mach_arm_5TE; /* Best fit ? */
882 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
887 case BFD_MACH_O_CPU_TYPE_MC88000:
888 *type = bfd_arch_m88k;
890 case BFD_MACH_O_CPU_TYPE_SPARC:
891 *type = bfd_arch_sparc;
892 *subtype = bfd_mach_sparc;
894 case BFD_MACH_O_CPU_TYPE_I860:
895 *type = bfd_arch_i860;
897 case BFD_MACH_O_CPU_TYPE_ALPHA:
898 *type = bfd_arch_alpha;
900 case BFD_MACH_O_CPU_TYPE_POWERPC:
901 *type = bfd_arch_powerpc;
902 *subtype = bfd_mach_ppc;
904 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
905 *type = bfd_arch_powerpc;
906 *subtype = bfd_mach_ppc64;
909 *type = bfd_arch_unknown;
915 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
917 struct mach_o_header_external raw;
920 size = mach_o_wide_p (header) ?
921 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
923 bfd_h_put_32 (abfd, header->magic, raw.magic);
924 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
925 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
926 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
927 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
928 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
929 bfd_h_put_32 (abfd, header->flags, raw.flags);
931 if (mach_o_wide_p (header))
932 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
934 if (bfd_seek (abfd, 0, SEEK_SET) != 0
935 || bfd_bwrite (&raw, size, abfd) != size)
942 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
944 bfd_mach_o_thread_command *cmd = &command->command.thread;
946 struct mach_o_thread_command_external raw;
949 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
950 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
953 for (i = 0; i < cmd->nflavours; i++)
955 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
956 BFD_ASSERT (cmd->flavours[i].offset ==
957 (command->offset + offset + BFD_MACH_O_LC_SIZE));
959 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
960 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
962 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
963 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
966 offset += cmd->flavours[i].size + sizeof (raw);
973 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
976 return (asect->reloc_count + 1) * sizeof (arelent *);
979 /* In addition to the need to byte-swap the symbol number, the bit positions
980 of the fields in the relocation information vary per target endian-ness. */
983 bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
984 unsigned char *fields)
986 unsigned char info = fields[3];
988 if (bfd_big_endian (abfd))
990 rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
991 rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
992 rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
993 rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
994 & BFD_MACH_O_LENGTH_MASK;
995 rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
999 rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1000 rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1001 rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1002 rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1003 & BFD_MACH_O_LENGTH_MASK;
1004 rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1009 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
1010 struct mach_o_reloc_info_external *raw,
1011 arelent *res, asymbol **syms)
1013 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1014 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1015 bfd_mach_o_reloc_info reloc;
1019 addr = bfd_get_32 (abfd, raw->r_address);
1020 res->sym_ptr_ptr = NULL;
1023 if (addr & BFD_MACH_O_SR_SCATTERED)
1026 bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1028 /* Scattered relocation, can't be extern. */
1029 reloc.r_scattered = 1;
1032 /* Extract section and offset from r_value (symnum). */
1033 reloc.r_value = symnum;
1034 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1035 end of the data for the section (e.g. in a calculation of section
1036 data length). At present, the symbol will end up associated with
1037 the following section or, if it falls within alignment padding, as
1038 null - which will assert later. */
1039 for (j = 0; j < mdata->nsects; j++)
1041 bfd_mach_o_section *sect = mdata->sections[j];
1042 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1044 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1045 res->addend = symnum - sect->addr;
1050 /* Extract the info and address fields from r_address. */
1051 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1052 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1053 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1054 reloc.r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1055 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1061 /* Non-scattered relocation. */
1062 reloc.r_scattered = 0;
1064 /* The value and info fields have to be extracted dependent on target
1066 bfd_mach_o_swap_in_non_scattered_reloc (abfd, &reloc, raw->r_symbolnum);
1067 num = reloc.r_value;
1071 /* An external symbol number. */
1074 else if (num == 0x00ffffff)
1076 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1077 is generic code, we don't know wether this is really a PAIR.
1078 This value is almost certainly not a valid section number, hence
1079 this specific case to avoid an assertion failure.
1080 Target specific swap_reloc_in routine should adjust that. */
1081 sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1085 /* A section number. */
1086 BFD_ASSERT (num != 0);
1087 BFD_ASSERT (num <= mdata->nsects);
1089 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1090 /* For a symbol defined in section S, the addend (stored in the
1091 binary) contains the address of the section. To comply with
1092 bfd convention, subtract the section address.
1093 Use the address from the header, so that the user can modify
1094 the vma of the section. */
1095 res->addend = -mdata->sections[num - 1]->addr;
1097 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1098 in the lower 16bits of the address value. So we have to find the
1099 'symbol' from the preceding reloc. We do this even though the
1100 section symbol is probably not needed here, because NULL symbol
1101 values cause an assert in generic BFD code. This must be done in
1102 the PPC swap_reloc_in routine. */
1103 res->sym_ptr_ptr = sym;
1105 /* The 'address' is just r_address.
1106 ??? maybe this should be masked with 0xffffff for safety. */
1107 res->address = addr;
1108 reloc.r_address = addr;
1111 /* We have set up a reloc with all the information present, so the swapper
1112 can modify address, value and addend fields, if necessary, to convey
1113 information in the generic BFD reloc that is mach-o specific. */
1115 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1121 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1122 unsigned long count,
1123 arelent *res, asymbol **syms)
1126 struct mach_o_reloc_info_external *native_relocs;
1127 bfd_size_type native_size;
1129 /* Allocate and read relocs. */
1130 native_size = count * BFD_MACH_O_RELENT_SIZE;
1132 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1133 if (native_relocs == NULL)
1136 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1137 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1140 for (i = 0; i < count; i++)
1142 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1146 free (native_relocs);
1149 free (native_relocs);
1154 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1155 arelent **rels, asymbol **syms)
1157 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1161 if (asect->reloc_count == 0)
1164 /* No need to go further if we don't know how to read relocs. */
1165 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1168 if (asect->relocation == NULL)
1170 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1174 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1175 asect->reloc_count, res, syms) < 0)
1180 asect->relocation = res;
1183 res = asect->relocation;
1184 for (i = 0; i < asect->reloc_count; i++)
1192 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1194 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1196 if (mdata->dysymtab == NULL)
1198 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1199 * sizeof (arelent *);
1203 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1204 struct bfd_symbol **syms)
1206 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1207 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1208 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1212 if (dysymtab == NULL)
1214 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1217 /* No need to go further if we don't know how to read relocs. */
1218 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1221 if (mdata->dyn_reloc_cache == NULL)
1223 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1224 * sizeof (arelent));
1228 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1229 dysymtab->nextrel, res, syms) < 0)
1235 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1237 res + dysymtab->nextrel, syms) < 0)
1243 mdata->dyn_reloc_cache = res;
1246 res = mdata->dyn_reloc_cache;
1247 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1253 /* In addition to the need to byte-swap the symbol number, the bit positions
1254 of the fields in the relocation information vary per target endian-ness. */
1257 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1258 bfd_mach_o_reloc_info *rel)
1260 unsigned char info = 0;
1262 BFD_ASSERT (rel->r_type <= 15);
1263 BFD_ASSERT (rel->r_length <= 3);
1265 if (bfd_big_endian (abfd))
1267 fields[0] = (rel->r_value >> 16) & 0xff;
1268 fields[1] = (rel->r_value >> 8) & 0xff;
1269 fields[2] = rel->r_value & 0xff;
1270 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1271 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1272 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1273 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1277 fields[2] = (rel->r_value >> 16) & 0xff;
1278 fields[1] = (rel->r_value >> 8) & 0xff;
1279 fields[0] = rel->r_value & 0xff;
1280 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1281 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1282 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1283 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1289 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1294 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1296 sec = section->bfdsection;
1297 if (sec->reloc_count == 0)
1300 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1303 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1306 /* Convert and write. */
1307 entries = section->bfdsection->orelocation;
1308 for (i = 0; i < section->nreloc; i++)
1310 arelent *rel = entries[i];
1311 struct mach_o_reloc_info_external raw;
1312 bfd_mach_o_reloc_info info, *pinfo = &info;
1314 /* Convert relocation to an intermediate representation. */
1315 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1318 /* Lower the relocation info. */
1319 if (pinfo->r_scattered)
1323 v = BFD_MACH_O_SR_SCATTERED
1324 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1325 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1326 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1327 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
1328 /* Note: scattered relocs have field in reverse order... */
1329 bfd_put_32 (abfd, v, raw.r_address);
1330 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1334 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1335 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1339 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1340 != BFD_MACH_O_RELENT_SIZE)
1347 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1349 struct mach_o_section_32_external raw;
1351 memcpy (raw.sectname, section->sectname, 16);
1352 memcpy (raw.segname, section->segname, 16);
1353 bfd_h_put_32 (abfd, section->addr, raw.addr);
1354 bfd_h_put_32 (abfd, section->size, raw.size);
1355 bfd_h_put_32 (abfd, section->offset, raw.offset);
1356 bfd_h_put_32 (abfd, section->align, raw.align);
1357 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1358 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1359 bfd_h_put_32 (abfd, section->flags, raw.flags);
1360 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1361 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1363 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1364 != BFD_MACH_O_SECTION_SIZE)
1371 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1373 struct mach_o_section_64_external raw;
1375 memcpy (raw.sectname, section->sectname, 16);
1376 memcpy (raw.segname, section->segname, 16);
1377 bfd_h_put_64 (abfd, section->addr, raw.addr);
1378 bfd_h_put_64 (abfd, section->size, raw.size);
1379 bfd_h_put_32 (abfd, section->offset, raw.offset);
1380 bfd_h_put_32 (abfd, section->align, raw.align);
1381 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1382 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1383 bfd_h_put_32 (abfd, section->flags, raw.flags);
1384 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1385 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1386 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1388 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1389 != BFD_MACH_O_SECTION_64_SIZE)
1396 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1398 struct mach_o_segment_command_32_external raw;
1399 bfd_mach_o_segment_command *seg = &command->command.segment;
1400 bfd_mach_o_section *sec;
1402 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1404 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1405 if (!bfd_mach_o_write_relocs (abfd, sec))
1408 memcpy (raw.segname, seg->segname, 16);
1409 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1410 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1411 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1412 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1413 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1414 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1415 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1416 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1418 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1419 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1422 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1423 if (bfd_mach_o_write_section_32 (abfd, sec))
1430 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1432 struct mach_o_segment_command_64_external raw;
1433 bfd_mach_o_segment_command *seg = &command->command.segment;
1434 bfd_mach_o_section *sec;
1436 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1438 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1439 if (!bfd_mach_o_write_relocs (abfd, sec))
1442 memcpy (raw.segname, seg->segname, 16);
1443 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1444 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1445 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1446 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1447 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1448 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1449 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1450 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1452 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1453 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1456 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1457 if (bfd_mach_o_write_section_64 (abfd, sec))
1464 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1466 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1467 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1469 unsigned int wide = bfd_mach_o_wide_p (abfd);
1470 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1471 struct bfd_strtab_hash *strtab;
1472 asymbol **symbols = bfd_get_outsymbols (abfd);
1474 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1476 /* Write the symbols first. */
1477 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1478 sym->symoff = mdata->filelen;
1479 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1482 sym->nsyms = bfd_get_symcount (abfd);
1483 mdata->filelen += sym->nsyms * symlen;
1485 strtab = _bfd_stringtab_init ();
1490 /* Although we don't strictly need to do this, for compatibility with
1491 Darwin system tools, actually output an empty string for the index
1493 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1495 for (i = 0; i < sym->nsyms; i++)
1497 bfd_size_type str_index;
1498 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1500 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1501 /* An index of 0 always means the empty string. */
1505 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1507 if (str_index == (bfd_size_type) -1)
1513 struct mach_o_nlist_64_external raw;
1515 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1516 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1517 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1518 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1519 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1522 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1527 struct mach_o_nlist_external raw;
1529 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1530 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1531 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1532 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1533 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1536 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1540 sym->strsize = _bfd_stringtab_size (strtab);
1541 sym->stroff = mdata->filelen;
1542 mdata->filelen += sym->strsize;
1544 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1546 _bfd_stringtab_free (strtab);
1550 struct mach_o_symtab_command_external raw;
1552 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1553 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1554 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1555 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1557 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1558 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1565 _bfd_stringtab_free (strtab);
1569 /* Write a dysymtab command.
1570 TODO: Possibly coalesce writes of smaller objects. */
1573 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1575 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1577 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1579 if (cmd->nmodtab != 0)
1583 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1586 for (i = 0; i < cmd->nmodtab; i++)
1588 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1592 iinit = module->iinit & 0xffff;
1593 iinit |= ((module->iterm & 0xffff) << 16);
1595 ninit = module->ninit & 0xffff;
1596 ninit |= ((module->nterm & 0xffff) << 16);
1598 if (bfd_mach_o_wide_p (abfd))
1600 struct mach_o_dylib_module_64_external w;
1602 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1603 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1604 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1605 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1606 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1607 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1608 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1609 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1610 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1611 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1612 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1613 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1614 &w.objc_module_info_addr);
1615 bfd_h_put_32 (abfd, module->objc_module_info_size,
1616 &w.objc_module_info_size);
1618 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1623 struct mach_o_dylib_module_external n;
1625 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1626 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1627 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1628 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1629 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1630 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1631 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1632 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1633 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1634 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1635 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1636 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1637 &n.objc_module_info_addr);
1638 bfd_h_put_32 (abfd, module->objc_module_info_size,
1639 &n.objc_module_info_size);
1641 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1651 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1654 for (i = 0; i < cmd->ntoc; i++)
1656 struct mach_o_dylib_table_of_contents_external raw;
1657 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1659 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1660 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1662 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1667 if (cmd->nindirectsyms > 0)
1671 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1674 for (i = 0; i < cmd->nindirectsyms; ++i)
1676 unsigned char raw[4];
1678 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1679 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1684 if (cmd->nextrefsyms != 0)
1688 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1691 for (i = 0; i < cmd->nextrefsyms; i++)
1694 unsigned char raw[4];
1695 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1697 /* Fields isym and flags are written as bit-fields, thus we need
1698 a specific processing for endianness. */
1700 if (bfd_big_endian (abfd))
1702 v = ((ref->isym & 0xffffff) << 8);
1703 v |= ref->flags & 0xff;
1707 v = ref->isym & 0xffffff;
1708 v |= ((ref->flags & 0xff) << 24);
1711 bfd_h_put_32 (abfd, v, raw);
1712 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1718 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1722 struct mach_o_dysymtab_command_external raw;
1724 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1725 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1726 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1727 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1728 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1729 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1730 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1731 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1732 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1733 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1734 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1735 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1736 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1737 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1738 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1739 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1740 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1741 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1743 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1751 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
1753 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
1755 /* Just leave debug symbols where they are (pretend they are local, and
1756 then they will just be sorted on position). */
1757 if (s->n_type & BFD_MACH_O_N_STAB)
1760 /* Local (we should never see an undefined local AFAICT). */
1761 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1764 /* Common symbols look like undefined externs. */
1765 if (mtyp == BFD_MACH_O_N_UNDF)
1768 /* A defined non-local, non-debug symbol. */
1773 bfd_mach_o_cf_symbols (const void *a, const void *b)
1775 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1776 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1777 unsigned int soa, sob;
1779 soa = bfd_mach_o_primary_symbol_sort_key (sa);
1780 sob = bfd_mach_o_primary_symbol_sort_key (sb);
1787 /* If it's local or stab, just preserve the input order. */
1790 if (sa->symbol.udata.i < sb->symbol.udata.i)
1792 if (sa->symbol.udata.i > sb->symbol.udata.i)
1795 /* This is probably an error. */
1799 /* The second sort key is name. */
1800 return strcmp (sa->symbol.name, sb->symbol.name);
1803 /* Process the symbols.
1805 This should be OK for single-module files - but it is not likely to work
1806 for multi-module shared libraries.
1808 (a) If the application has not filled in the relevant mach-o fields, make
1811 (b) Order them, like this:
1814 ( ii) external defined
1816 (iii) external undefined/common
1823 bfd_mach_o_mangle_symbols (bfd *abfd)
1826 asymbol **symbols = bfd_get_outsymbols (abfd);
1828 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1831 for (i = 0; i < bfd_get_symcount (abfd); i++)
1833 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1835 /* We use this value, which is out-of-range as a symbol index, to signal
1836 that the mach-o-specific data are not filled in and need to be created
1837 from the bfd values. It is much preferable for the application to do
1838 this, since more meaningful diagnostics can be made that way. */
1840 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1842 /* No symbol information has been set - therefore determine
1843 it from the bfd symbol flags/info. */
1844 if (s->symbol.section == bfd_abs_section_ptr)
1845 s->n_type = BFD_MACH_O_N_ABS;
1846 else if (s->symbol.section == bfd_und_section_ptr)
1848 s->n_type = BFD_MACH_O_N_UNDF;
1849 if (s->symbol.flags & BSF_WEAK)
1850 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1851 /* mach-o automatically makes undefined symbols extern. */
1852 s->n_type |= BFD_MACH_O_N_EXT;
1853 s->symbol.flags |= BSF_GLOBAL;
1855 else if (s->symbol.section == bfd_com_section_ptr)
1857 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1858 s->symbol.flags |= BSF_GLOBAL;
1861 s->n_type = BFD_MACH_O_N_SECT;
1863 if (s->symbol.flags & BSF_GLOBAL)
1864 s->n_type |= BFD_MACH_O_N_EXT;
1867 /* Put the section index in, where required. */
1868 if ((s->symbol.section != bfd_abs_section_ptr
1869 && s->symbol.section != bfd_und_section_ptr
1870 && s->symbol.section != bfd_com_section_ptr)
1871 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1872 && s->symbol.name == NULL))
1873 s->n_sect = s->symbol.section->target_index;
1875 /* Number to preserve order for local and debug syms. */
1876 s->symbol.udata.i = i;
1879 /* Sort the symbols. */
1880 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
1881 sizeof (asymbol *), bfd_mach_o_cf_symbols);
1883 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1885 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1886 s->symbol.udata.i = i; /* renumber. */
1892 /* We build a flat table of sections, which can be re-ordered if necessary.
1893 Fill in the section number and other mach-o-specific data. */
1896 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1899 unsigned target_index;
1902 nsect = bfd_count_sections (abfd);
1904 /* Don't do it if it's already set - assume the application knows what it's
1906 if (mdata->nsects == nsect
1907 && (mdata->nsects == 0 || mdata->sections != NULL))
1910 mdata->nsects = nsect;
1911 mdata->sections = bfd_alloc (abfd,
1912 mdata->nsects * sizeof (bfd_mach_o_section *));
1913 if (mdata->sections == NULL)
1916 /* We need to check that this can be done... */
1918 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1919 " maximum is 255,\n"), nsect);
1921 /* Create Mach-O sections.
1922 Section type, attribute and align should have been set when the
1923 section was created - either read in or specified. */
1925 for (sec = abfd->sections; sec; sec = sec->next)
1927 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1928 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1930 mdata->sections[target_index] = msect;
1932 msect->addr = bfd_get_section_vma (abfd, sec);
1933 msect->size = bfd_get_section_size (sec);
1935 /* Use the largest alignment set, in case it was bumped after the
1936 section was created. */
1937 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1940 sec->target_index = ++target_index;
1947 bfd_mach_o_write_contents (bfd *abfd)
1950 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1952 /* Make the commands, if not already present. */
1953 if (mdata->header.ncmds == 0)
1954 if (!bfd_mach_o_build_commands (abfd))
1957 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1960 for (i = 0; i < mdata->header.ncmds; i++)
1962 struct mach_o_load_command_external raw;
1963 bfd_mach_o_load_command *cur = &mdata->commands[i];
1964 unsigned long typeflag;
1966 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1968 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1969 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1971 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1972 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1977 case BFD_MACH_O_LC_SEGMENT:
1978 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1981 case BFD_MACH_O_LC_SEGMENT_64:
1982 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1985 case BFD_MACH_O_LC_SYMTAB:
1986 if (!bfd_mach_o_write_symtab (abfd, cur))
1989 case BFD_MACH_O_LC_DYSYMTAB:
1990 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1993 case BFD_MACH_O_LC_SYMSEG:
1995 case BFD_MACH_O_LC_THREAD:
1996 case BFD_MACH_O_LC_UNIXTHREAD:
1997 if (bfd_mach_o_write_thread (abfd, cur) != 0)
2000 case BFD_MACH_O_LC_LOADFVMLIB:
2001 case BFD_MACH_O_LC_IDFVMLIB:
2002 case BFD_MACH_O_LC_IDENT:
2003 case BFD_MACH_O_LC_FVMFILE:
2004 case BFD_MACH_O_LC_PREPAGE:
2005 case BFD_MACH_O_LC_LOAD_DYLIB:
2006 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2007 case BFD_MACH_O_LC_ID_DYLIB:
2008 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2009 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
2010 case BFD_MACH_O_LC_LOAD_DYLINKER:
2011 case BFD_MACH_O_LC_ID_DYLINKER:
2012 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2013 case BFD_MACH_O_LC_ROUTINES:
2014 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2017 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
2018 (unsigned long) cur->type);
2027 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2030 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
2031 if (seg->sect_head == NULL)
2034 seg->sect_tail->next = s;
2038 /* Create section Mach-O flags from BFD flags. */
2041 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2044 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2046 /* Create default flags. */
2047 bfd_flags = bfd_get_section_flags (abfd, sec);
2048 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2049 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2050 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2051 | BFD_MACH_O_S_REGULAR;
2052 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2053 s->flags = BFD_MACH_O_S_ZEROFILL;
2054 else if (bfd_flags & SEC_DEBUGGING)
2055 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2057 s->flags = BFD_MACH_O_S_REGULAR;
2060 /* Count the number of sections in the list for the segment named.
2062 The special case of NULL or "" for the segment name is valid for
2063 an MH_OBJECT file and means 'all sections available'.
2065 Requires that the sections table in mdata be filled in.
2067 Returns the number of sections (0 is valid).
2068 Any number > 255 signals an invalid section count, although we will,
2069 perhaps, allow the file to be written (in line with Darwin tools up
2072 A section count of (unsigned long) -1 signals a definite error. */
2074 static unsigned long
2075 bfd_mach_o_count_sections_for_seg (const char *segment,
2076 bfd_mach_o_data_struct *mdata)
2079 if (mdata == NULL || mdata->sections == NULL)
2080 return (unsigned long) -1;
2082 /* The MH_OBJECT case, all sections are considered; Although nsects is
2083 is an unsigned long, the maximum valid section count is 255 and this
2084 will have been checked already by mangle_sections. */
2085 if (segment == NULL || segment[0] == '\0')
2086 return mdata->nsects;
2088 /* Count the number of sections we see in this segment. */
2090 for (i = 0; i < mdata->nsects; ++i)
2092 bfd_mach_o_section *s = mdata->sections[i];
2093 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2100 bfd_mach_o_build_seg_command (const char *segment,
2101 bfd_mach_o_data_struct *mdata,
2102 bfd_mach_o_segment_command *seg)
2105 int is_mho = (segment == NULL || segment[0] == '\0');
2107 /* Fill segment command. */
2109 memset (seg->segname, 0, sizeof (seg->segname));
2111 strncpy (seg->segname, segment, sizeof (seg->segname));
2113 /* TODO: fix this up for non-MH_OBJECT cases. */
2117 seg->fileoff = mdata->filelen;
2119 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2120 | BFD_MACH_O_PROT_EXECUTE;
2121 seg->initprot = seg->maxprot;
2123 seg->sect_head = NULL;
2124 seg->sect_tail = NULL;
2126 /* Append sections to the segment.
2128 This is a little tedious, we have to honor the need to account zerofill
2129 sections after all the rest. This forces us to do the calculation of
2130 total vmsize in three passes so that any alignment increments are
2131 properly accounted. */
2133 for (i = 0; i < mdata->nsects; ++i)
2135 bfd_mach_o_section *s = mdata->sections[i];
2136 asection *sec = s->bfdsection;
2138 /* If we're not making an MH_OBJECT, check whether this section is from
2139 our segment, and skip if not. Otherwise, just add all sections. */
2141 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2144 /* Although we account for zerofill section sizes in vm order, they are
2145 placed in the file in source sequence. */
2146 bfd_mach_o_append_section_to_segment (seg, sec);
2149 /* Zerofill sections have zero file size & offset,
2150 and are not written. */
2151 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2152 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2153 == BFD_MACH_O_S_GB_ZEROFILL)
2158 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2159 seg->vmsize += s->size;
2161 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2162 seg->filesize += s->size;
2164 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2165 s->offset = mdata->filelen;
2168 sec->filepos = s->offset;
2169 mdata->filelen += s->size;
2172 /* Now pass through again, for zerofill, only now we just update the vmsize. */
2173 for (i = 0; i < mdata->nsects; ++i)
2175 bfd_mach_o_section *s = mdata->sections[i];
2177 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2181 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2186 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2187 seg->vmsize += s->size;
2191 /* Now pass through again, for zerofill_GB. */
2192 for (i = 0; i < mdata->nsects; ++i)
2194 bfd_mach_o_section *s = mdata->sections[i];
2196 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2200 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2205 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2206 seg->vmsize += s->size;
2210 /* Allocate space for the relocations. */
2211 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
2213 for (i = 0; i < mdata->nsects; ++i)
2215 bfd_mach_o_section *ms = mdata->sections[i];
2216 asection *sec = ms->bfdsection;
2218 if ((ms->nreloc = sec->reloc_count) == 0)
2223 sec->rel_filepos = mdata->filelen;
2224 ms->reloff = sec->rel_filepos;
2225 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2231 /* Count the number of indirect symbols in the image.
2232 Requires that the sections are in their final order. */
2235 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2238 unsigned int nisyms = 0;
2240 for (i = 0; i < mdata->nsects; ++i)
2242 bfd_mach_o_section *sec = mdata->sections[i];
2244 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2246 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2247 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2248 case BFD_MACH_O_S_SYMBOL_STUBS:
2249 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2259 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2260 bfd_mach_o_data_struct *mdata,
2261 bfd_mach_o_load_command *cmd)
2263 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2266 We are not going to try and fill these in yet and, moreover, we are
2267 going to bail if they are already set. */
2268 if (dsym->nmodtab != 0
2270 || dsym->nextrefsyms != 0)
2272 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2273 " implemented for dysymtab commands."));
2277 dsym->ilocalsym = 0;
2279 if (bfd_get_symcount (abfd) > 0)
2281 asymbol **symbols = bfd_get_outsymbols (abfd);
2284 /* Count the number of each kind of symbol. */
2285 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2287 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2288 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2291 dsym->nlocalsym = i;
2292 dsym->iextdefsym = i;
2293 for (; i < bfd_get_symcount (abfd); ++i)
2295 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2296 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2299 dsym->nextdefsym = i - dsym->nlocalsym;
2300 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2301 dsym->nundefsym = bfd_get_symcount (abfd)
2307 dsym->nlocalsym = 0;
2308 dsym->iextdefsym = 0;
2309 dsym->nextdefsym = 0;
2310 dsym->iundefsym = 0;
2311 dsym->nundefsym = 0;
2314 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2315 if (dsym->nindirectsyms > 0)
2320 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2321 dsym->indirectsymoff = mdata->filelen;
2322 mdata->filelen += dsym->nindirectsyms * 4;
2324 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2325 if (dsym->indirect_syms == NULL)
2329 for (i = 0; i < mdata->nsects; ++i)
2331 bfd_mach_o_section *sec = mdata->sections[i];
2333 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2335 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2336 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2337 case BFD_MACH_O_S_SYMBOL_STUBS:
2340 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2342 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2343 if (isyms == NULL || num == 0)
2345 /* Record the starting index in the reserved1 field. */
2347 for (j = 0; j < num; j++, n++)
2349 if (isyms[j] == NULL)
2350 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2351 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2352 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2353 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2354 | BFD_MACH_O_INDIRECT_SYM_ABS;
2356 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2369 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2370 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2371 and copy functionality. */
2374 bfd_mach_o_build_commands (bfd *abfd)
2376 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2377 unsigned wide = mach_o_wide_p (&mdata->header);
2378 int segcmd_idx = -1;
2379 int symtab_idx = -1;
2380 int dysymtab_idx = -1;
2381 unsigned long base_offset = 0;
2383 /* Return now if commands are already present. */
2384 if (mdata->header.ncmds)
2387 /* Fill in the file type, if not already set. */
2389 if (mdata->header.filetype == 0)
2391 if (abfd->flags & EXEC_P)
2392 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2393 else if (abfd->flags & DYNAMIC)
2394 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2396 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2399 /* If hasn't already been done, flatten sections list, and sort
2400 if/when required. Must be done before the symbol table is adjusted,
2401 since that depends on properly numbered sections. */
2402 if (mdata->nsects == 0 || mdata->sections == NULL)
2403 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2406 /* Order the symbol table, fill-in/check mach-o specific fields and
2407 partition out any indirect symbols. */
2408 if (!bfd_mach_o_mangle_symbols (abfd))
2411 /* Very simple command set (only really applicable to MH_OBJECTs):
2412 All the commands are optional - present only when there is suitable data.
2413 (i.e. it is valid to have an empty file)
2415 a command (segment) to contain all the sections,
2416 command for the symbol table,
2417 a command for the dysymtab.
2419 ??? maybe we should assert that this is an MH_OBJECT? */
2421 if (mdata->nsects > 0)
2424 mdata->header.ncmds = 1;
2427 if (bfd_get_symcount (abfd) > 0)
2429 mdata->header.ncmds++;
2430 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2434 This is a rather crude test for whether we should build a dysymtab. */
2435 if (bfd_mach_o_should_emit_dysymtab ()
2436 && bfd_get_symcount (abfd))
2438 mdata->header.ncmds++;
2439 /* If there should be a case where a dysymtab could be emitted without
2440 a symtab (seems improbable), this would need amending. */
2441 dysymtab_idx = symtab_idx + 1;
2445 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2447 base_offset = BFD_MACH_O_HEADER_SIZE;
2449 /* Well, we must have a header, at least. */
2450 mdata->filelen = base_offset;
2452 /* A bit unusual, but no content is valid;
2453 as -n empty.s -o empty.o */
2454 if (mdata->header.ncmds == 0)
2457 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2458 * sizeof (bfd_mach_o_load_command));
2459 if (mdata->commands == NULL)
2462 if (segcmd_idx >= 0)
2464 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2465 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2467 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2468 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2469 if (seg->nsects == (unsigned long) -1)
2472 /* Init segment command. */
2473 cmd->offset = base_offset;
2476 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2477 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2478 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2482 cmd->type = BFD_MACH_O_LC_SEGMENT;
2483 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2484 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2487 cmd->type_required = FALSE;
2488 mdata->header.sizeofcmds = cmd->len;
2489 mdata->filelen += cmd->len;
2492 if (symtab_idx >= 0)
2494 /* Init symtab command. */
2495 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2497 cmd->type = BFD_MACH_O_LC_SYMTAB;
2498 cmd->offset = base_offset;
2499 if (segcmd_idx >= 0)
2500 cmd->offset += mdata->commands[segcmd_idx].len;
2502 cmd->len = sizeof (struct mach_o_symtab_command_external)
2503 + BFD_MACH_O_LC_SIZE;
2504 cmd->type_required = FALSE;
2505 mdata->header.sizeofcmds += cmd->len;
2506 mdata->filelen += cmd->len;
2509 /* If required, setup symtab command, see comment above about the quality
2511 if (dysymtab_idx >= 0)
2513 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2515 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2516 if (symtab_idx >= 0)
2517 cmd->offset = mdata->commands[symtab_idx].offset
2518 + mdata->commands[symtab_idx].len;
2519 else if (segcmd_idx >= 0)
2520 cmd->offset = mdata->commands[segcmd_idx].offset
2521 + mdata->commands[segcmd_idx].len;
2523 cmd->offset = base_offset;
2525 cmd->type_required = FALSE;
2526 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2527 + BFD_MACH_O_LC_SIZE;
2529 mdata->header.sizeofcmds += cmd->len;
2530 mdata->filelen += cmd->len;
2533 /* So, now we have sized the commands and the filelen set to that.
2534 Now we can build the segment command and set the section file offsets. */
2536 && ! bfd_mach_o_build_seg_command
2537 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2540 /* If we're doing a dysymtab, cmd points to its load command. */
2541 if (dysymtab_idx >= 0
2542 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2543 &mdata->commands[dysymtab_idx]))
2546 /* The symtab command is filled in when the symtab is written. */
2550 /* Set the contents of a section. */
2553 bfd_mach_o_set_section_contents (bfd *abfd,
2555 const void * location,
2557 bfd_size_type count)
2561 /* Trying to write the first section contents will trigger the creation of
2562 the load commands if they are not already present. */
2563 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2569 pos = section->filepos + offset;
2570 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2571 || bfd_bwrite (location, count, abfd) != count)
2578 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2579 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2584 /* Make an empty symbol. This is required only because
2585 bfd_make_section_anyway wants to create a symbol for the section. */
2588 bfd_mach_o_make_empty_symbol (bfd *abfd)
2590 asymbol *new_symbol;
2592 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2593 if (new_symbol == NULL)
2595 new_symbol->the_bfd = abfd;
2596 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2601 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2603 struct mach_o_header_external raw;
2605 bfd_vma (*get32) (const void *) = NULL;
2607 /* Just read the magic number. */
2608 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2609 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2612 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2614 header->byteorder = BFD_ENDIAN_BIG;
2615 header->magic = BFD_MACH_O_MH_MAGIC;
2616 header->version = 1;
2619 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2621 header->byteorder = BFD_ENDIAN_LITTLE;
2622 header->magic = BFD_MACH_O_MH_MAGIC;
2623 header->version = 1;
2626 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2628 header->byteorder = BFD_ENDIAN_BIG;
2629 header->magic = BFD_MACH_O_MH_MAGIC_64;
2630 header->version = 2;
2633 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2635 header->byteorder = BFD_ENDIAN_LITTLE;
2636 header->magic = BFD_MACH_O_MH_MAGIC_64;
2637 header->version = 2;
2642 header->byteorder = BFD_ENDIAN_UNKNOWN;
2646 /* Once the size of the header is known, read the full header. */
2647 size = mach_o_wide_p (header) ?
2648 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2650 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2651 || bfd_bread (&raw, size, abfd) != size)
2654 header->cputype = (*get32) (raw.cputype);
2655 header->cpusubtype = (*get32) (raw.cpusubtype);
2656 header->filetype = (*get32) (raw.filetype);
2657 header->ncmds = (*get32) (raw.ncmds);
2658 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2659 header->flags = (*get32) (raw.flags);
2661 if (mach_o_wide_p (header))
2662 header->reserved = (*get32) (raw.reserved);
2664 header->reserved = 0;
2670 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2672 bfd_mach_o_section *s;
2673 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2675 s = bfd_mach_o_get_mach_o_section (sec);
2679 static const mach_o_section_name_xlat * xlat;
2681 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2684 sec->used_by_bfd = s;
2685 s->bfdsection = sec;
2687 /* Create the Darwin seg/sect name pair from the bfd name.
2688 If this is a canonical name for which a specific paiting exists
2689 there will also be defined flags, type, attribute and alignment
2691 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2694 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2695 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2697 (void) bfd_set_section_alignment (abfd, sec, s->align);
2698 bfd_flags = bfd_get_section_flags (abfd, sec);
2699 if (bfd_flags == SEC_NO_FLAGS)
2700 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2703 /* Create default flags. */
2704 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2707 return _bfd_generic_new_section_hook (abfd, sec);
2711 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2715 bfd_mach_o_section *section;
2717 flags = bfd_get_section_flags (abfd, sec);
2718 section = bfd_mach_o_get_mach_o_section (sec);
2720 /* TODO: see if we should use the xlat system for doing this by
2721 preference and fall back to this for unknown sections. */
2723 if (flags == SEC_NO_FLAGS)
2725 /* Try to guess flags. */
2726 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2727 flags = SEC_DEBUGGING;
2731 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2732 != BFD_MACH_O_S_ZEROFILL)
2735 if (prot & BFD_MACH_O_PROT_EXECUTE)
2737 if (prot & BFD_MACH_O_PROT_WRITE)
2739 else if (prot & BFD_MACH_O_PROT_READ)
2740 flags |= SEC_READONLY;
2746 if ((flags & SEC_DEBUGGING) == 0)
2750 if (section->offset != 0)
2751 flags |= SEC_HAS_CONTENTS;
2752 if (section->nreloc != 0)
2755 bfd_set_section_flags (abfd, sec, flags);
2757 sec->vma = section->addr;
2758 sec->lma = section->addr;
2759 sec->size = section->size;
2760 sec->filepos = section->offset;
2761 sec->alignment_power = section->align;
2762 sec->segment_mark = 0;
2763 sec->reloc_count = section->nreloc;
2764 sec->rel_filepos = section->reloff;
2768 bfd_mach_o_make_bfd_section (bfd *abfd,
2769 const unsigned char *segname,
2770 const unsigned char *sectname)
2775 bfd_mach_o_convert_section_name_to_bfd
2776 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2780 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2784 bfd_mach_o_read_section_32 (bfd *abfd,
2785 unsigned int offset,
2788 struct mach_o_section_32_external raw;
2790 bfd_mach_o_section *section;
2792 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2793 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2794 != BFD_MACH_O_SECTION_SIZE))
2797 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2801 section = bfd_mach_o_get_mach_o_section (sec);
2802 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2803 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2804 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2805 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2806 section->addr = bfd_h_get_32 (abfd, raw.addr);
2807 section->size = bfd_h_get_32 (abfd, raw.size);
2808 section->offset = bfd_h_get_32 (abfd, raw.offset);
2809 section->align = bfd_h_get_32 (abfd, raw.align);
2810 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2811 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2812 section->flags = bfd_h_get_32 (abfd, raw.flags);
2813 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2814 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2815 section->reserved3 = 0;
2817 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2823 bfd_mach_o_read_section_64 (bfd *abfd,
2824 unsigned int offset,
2827 struct mach_o_section_64_external raw;
2829 bfd_mach_o_section *section;
2831 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2832 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2833 != BFD_MACH_O_SECTION_64_SIZE))
2836 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2840 section = bfd_mach_o_get_mach_o_section (sec);
2841 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2842 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2843 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2844 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2845 section->addr = bfd_h_get_64 (abfd, raw.addr);
2846 section->size = bfd_h_get_64 (abfd, raw.size);
2847 section->offset = bfd_h_get_32 (abfd, raw.offset);
2848 section->align = bfd_h_get_32 (abfd, raw.align);
2849 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2850 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2851 section->flags = bfd_h_get_32 (abfd, raw.flags);
2852 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2853 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2854 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2856 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2862 bfd_mach_o_read_section (bfd *abfd,
2863 unsigned int offset,
2868 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2870 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2874 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2875 bfd_mach_o_symtab_command *sym,
2876 bfd_mach_o_asymbol *s,
2879 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2880 unsigned int wide = mach_o_wide_p (&mdata->header);
2881 unsigned int symwidth =
2882 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2883 unsigned int symoff = sym->symoff + (i * symwidth);
2884 struct mach_o_nlist_64_external raw;
2885 unsigned char type = -1;
2886 unsigned char section = -1;
2888 symvalue value = -1;
2889 unsigned long stroff = -1;
2890 unsigned int symtype = -1;
2892 BFD_ASSERT (sym->strtab != NULL);
2894 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2895 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2897 (*_bfd_error_handler)
2898 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2899 symwidth, (unsigned long) symoff);
2903 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2904 type = bfd_h_get_8 (abfd, raw.n_type);
2905 symtype = type & BFD_MACH_O_N_TYPE;
2906 section = bfd_h_get_8 (abfd, raw.n_sect);
2907 desc = bfd_h_get_16 (abfd, raw.n_desc);
2909 value = bfd_h_get_64 (abfd, raw.n_value);
2911 value = bfd_h_get_32 (abfd, raw.n_value);
2913 if (stroff >= sym->strsize)
2915 (*_bfd_error_handler)
2916 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2917 (unsigned long) stroff,
2918 (unsigned long) sym->strsize);
2922 s->symbol.the_bfd = abfd;
2923 s->symbol.name = sym->strtab + stroff;
2924 s->symbol.value = value;
2925 s->symbol.flags = 0x0;
2926 s->symbol.udata.i = i;
2928 s->n_sect = section;
2931 if (type & BFD_MACH_O_N_STAB)
2933 s->symbol.flags |= BSF_DEBUGGING;
2934 s->symbol.section = bfd_und_section_ptr;
2946 if ((section > 0) && (section <= mdata->nsects))
2948 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2950 s->symbol.value - mdata->sections[section - 1]->addr;
2957 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2958 s->symbol.flags |= BSF_GLOBAL;
2960 s->symbol.flags |= BSF_LOCAL;
2964 case BFD_MACH_O_N_UNDF:
2965 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2966 && s->symbol.value != 0)
2968 /* A common symbol. */
2969 s->symbol.section = bfd_com_section_ptr;
2970 s->symbol.flags = BSF_NO_FLAGS;
2974 s->symbol.section = bfd_und_section_ptr;
2975 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2976 s->symbol.flags |= BSF_WEAK;
2979 case BFD_MACH_O_N_PBUD:
2980 s->symbol.section = bfd_und_section_ptr;
2982 case BFD_MACH_O_N_ABS:
2983 s->symbol.section = bfd_abs_section_ptr;
2985 case BFD_MACH_O_N_SECT:
2986 if ((section > 0) && (section <= mdata->nsects))
2988 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2990 s->symbol.value - mdata->sections[section - 1]->addr;
2994 /* Mach-O uses 0 to mean "no section"; not an error. */
2997 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2998 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2999 s->symbol.name, section, mdata->nsects);
3001 s->symbol.section = bfd_und_section_ptr;
3004 case BFD_MACH_O_N_INDR:
3005 /* FIXME: we don't follow the BFD convention as this indirect symbol
3006 won't be followed by the referenced one. This looks harmless
3007 unless we start using the linker. */
3008 s->symbol.flags |= BSF_INDIRECT;
3009 s->symbol.section = bfd_ind_section_ptr;
3010 s->symbol.value = 0;
3013 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3014 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3015 s->symbol.name, symtype);
3016 s->symbol.section = bfd_und_section_ptr;
3025 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3027 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3028 bfd_mach_o_symtab_command *sym = mdata->symtab;
3030 /* Fail if there is no symtab. */
3034 /* Success if already loaded. */
3038 if (abfd->flags & BFD_IN_MEMORY)
3040 struct bfd_in_memory *b;
3042 b = (struct bfd_in_memory *) abfd->iostream;
3044 if ((sym->stroff + sym->strsize) > b->size)
3046 bfd_set_error (bfd_error_file_truncated);
3049 sym->strtab = (char *) b->buffer + sym->stroff;
3053 sym->strtab = bfd_alloc (abfd, sym->strsize);
3054 if (sym->strtab == NULL)
3057 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3058 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3060 bfd_set_error (bfd_error_file_truncated);
3069 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3071 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3072 bfd_mach_o_symtab_command *sym = mdata->symtab;
3075 if (sym == NULL || sym->symbols)
3077 /* Return now if there are no symbols or if already loaded. */
3081 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3083 if (sym->symbols == NULL)
3085 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3089 if (!bfd_mach_o_read_symtab_strtab (abfd))
3092 for (i = 0; i < sym->nsyms; i++)
3094 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3102 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3104 switch ((int) flavour)
3106 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3107 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3108 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3109 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3110 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3111 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3112 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3113 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3114 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3115 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3116 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3117 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3118 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3119 default: return "UNKNOWN";
3124 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3126 switch ((int) flavour)
3128 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3129 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3130 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3131 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3132 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3133 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3134 default: return "UNKNOWN";
3139 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3141 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3142 struct mach_o_str_command_external raw;
3143 unsigned int nameoff;
3145 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
3146 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
3148 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3149 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3152 nameoff = bfd_h_get_32 (abfd, raw.str);
3154 cmd->name_offset = command->offset + nameoff;
3155 cmd->name_len = command->len - nameoff;
3156 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3157 if (cmd->name_str == NULL)
3159 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3160 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3166 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3168 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3169 struct mach_o_dylib_command_external raw;
3170 unsigned int nameoff;
3172 switch (command->type)
3174 case BFD_MACH_O_LC_LOAD_DYLIB:
3175 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3176 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3177 case BFD_MACH_O_LC_ID_DYLIB:
3178 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3179 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3186 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3187 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3190 nameoff = bfd_h_get_32 (abfd, raw.name);
3191 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3192 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3193 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3195 cmd->name_offset = command->offset + nameoff;
3196 cmd->name_len = command->len - nameoff;
3197 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3198 if (cmd->name_str == NULL)
3200 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3201 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3207 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
3208 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3210 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3212 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3217 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3219 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3220 struct mach_o_fvmlib_command_external raw;
3221 unsigned int nameoff;
3223 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3224 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3227 nameoff = bfd_h_get_32 (abfd, raw.name);
3228 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3229 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3231 fvm->name_offset = command->offset + nameoff;
3232 fvm->name_len = command->len - nameoff;
3233 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3234 if (fvm->name_str == NULL)
3236 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3237 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3243 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3245 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3246 bfd_mach_o_thread_command *cmd = &command->command.thread;
3247 unsigned int offset;
3248 unsigned int nflavours;
3251 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3252 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3254 /* Count the number of threads. */
3257 while (offset != command->len)
3259 struct mach_o_thread_command_external raw;
3261 if (offset >= command->len)
3264 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3265 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3268 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3272 /* Allocate threads. */
3273 cmd->flavours = bfd_alloc
3274 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3275 if (cmd->flavours == NULL)
3277 cmd->nflavours = nflavours;
3281 while (offset != command->len)
3283 struct mach_o_thread_command_external raw;
3285 if (offset >= command->len)
3288 if (nflavours >= cmd->nflavours)
3291 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3292 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3295 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3296 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3297 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3298 offset += cmd->flavours[nflavours].size + sizeof (raw);
3302 for (i = 0; i < nflavours; i++)
3305 unsigned int snamelen;
3307 const char *flavourstr;
3308 const char *prefix = "LC_THREAD";
3311 switch (mdata->header.cputype)
3313 case BFD_MACH_O_CPU_TYPE_POWERPC:
3314 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3315 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3317 case BFD_MACH_O_CPU_TYPE_I386:
3318 case BFD_MACH_O_CPU_TYPE_X86_64:
3319 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3322 flavourstr = "UNKNOWN_ARCHITECTURE";
3326 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3327 sname = bfd_alloc (abfd, snamelen);
3333 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3334 if (bfd_get_section_by_name (abfd, sname) == NULL)
3339 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3343 bfdsec->size = cmd->flavours[i].size;
3344 bfdsec->filepos = cmd->flavours[i].offset;
3345 bfdsec->alignment_power = 0x0;
3347 cmd->section = bfdsec;
3354 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3356 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3357 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3359 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3362 struct mach_o_dysymtab_command_external raw;
3364 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3365 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3368 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3369 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3370 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3371 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3372 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3373 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3374 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3375 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3376 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3377 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3378 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3379 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3380 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3381 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3382 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3383 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3384 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3385 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3388 if (cmd->nmodtab != 0)
3391 int wide = bfd_mach_o_wide_p (abfd);
3392 unsigned int module_len = wide ? 56 : 52;
3395 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3396 if (cmd->dylib_module == NULL)
3399 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3402 for (i = 0; i < cmd->nmodtab; i++)
3404 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3406 unsigned char buf[56];
3408 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3411 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3412 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3413 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3414 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3415 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3416 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3417 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3418 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3419 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3420 v = bfd_h_get_32 (abfd, buf +36);
3421 module->iinit = v & 0xffff;
3422 module->iterm = (v >> 16) & 0xffff;
3423 v = bfd_h_get_32 (abfd, buf + 40);
3424 module->ninit = v & 0xffff;
3425 module->nterm = (v >> 16) & 0xffff;
3428 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3429 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3433 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3434 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3443 cmd->dylib_toc = bfd_alloc
3444 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3445 if (cmd->dylib_toc == NULL)
3448 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3451 for (i = 0; i < cmd->ntoc; i++)
3453 struct mach_o_dylib_table_of_contents_external raw;
3454 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3456 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3459 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3460 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3464 if (cmd->nindirectsyms != 0)
3468 cmd->indirect_syms = bfd_alloc
3469 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3470 if (cmd->indirect_syms == NULL)
3473 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3476 for (i = 0; i < cmd->nindirectsyms; i++)
3478 unsigned char raw[4];
3479 unsigned int *is = &cmd->indirect_syms[i];
3481 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3484 *is = bfd_h_get_32 (abfd, raw);
3488 if (cmd->nextrefsyms != 0)
3493 cmd->ext_refs = bfd_alloc
3494 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3495 if (cmd->ext_refs == NULL)
3498 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3501 for (i = 0; i < cmd->nextrefsyms; i++)
3503 unsigned char raw[4];
3504 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3506 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3509 /* Fields isym and flags are written as bit-fields, thus we need
3510 a specific processing for endianness. */
3511 v = bfd_h_get_32 (abfd, raw);
3512 if (bfd_big_endian (abfd))
3514 ref->isym = (v >> 8) & 0xffffff;
3515 ref->flags = v & 0xff;
3519 ref->isym = v & 0xffffff;
3520 ref->flags = (v >> 24) & 0xff;
3525 if (mdata->dysymtab)
3527 mdata->dysymtab = cmd;
3533 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3535 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3536 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3537 struct mach_o_symtab_command_external raw;
3539 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3541 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3542 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3545 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3546 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3547 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3548 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3549 symtab->symbols = NULL;
3550 symtab->strtab = NULL;
3552 if (symtab->nsyms != 0)
3553 abfd->flags |= HAS_SYMS;
3557 mdata->symtab = symtab;
3562 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3564 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3566 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3568 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3569 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3576 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3578 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3579 struct mach_o_linkedit_data_command_external raw;
3581 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3582 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3585 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3586 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3591 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3593 bfd_mach_o_str_command *cmd = &command->command.str;
3594 struct mach_o_str_command_external raw;
3597 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3598 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3601 off = bfd_get_32 (abfd, raw.str);
3602 cmd->stroff = command->offset + off;
3603 cmd->str_len = command->len - off;
3604 cmd->str = bfd_alloc (abfd, cmd->str_len);
3605 if (cmd->str == NULL)
3607 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3608 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3614 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3616 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3617 struct mach_o_dyld_info_command_external raw;
3619 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3620 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3623 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3624 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3625 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3626 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3627 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3628 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3629 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3630 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3631 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3632 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3637 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3639 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3640 struct mach_o_version_min_command_external raw;
3643 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3644 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3647 ver = bfd_get_32 (abfd, raw.version);
3648 cmd->rel = ver >> 16;
3649 cmd->maj = ver >> 8;
3651 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3656 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3658 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3659 struct mach_o_encryption_info_command_external raw;
3661 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3662 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3665 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3666 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3667 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3672 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3674 bfd_mach_o_main_command *cmd = &command->command.main;
3675 struct mach_o_entry_point_command_external raw;
3677 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3678 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3681 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3682 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3687 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3689 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3690 struct mach_o_source_version_command_external raw;
3693 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3694 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3697 ver = bfd_get_64 (abfd, raw.version);
3698 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3699 generates warnings) in case of the host doesn't support 64 bit
3701 cmd->e = ver & 0x3ff;
3703 cmd->d = ver & 0x3ff;
3705 cmd->c = ver & 0x3ff;
3707 cmd->b = ver & 0x3ff;
3709 cmd->a = ver & 0xffffff;
3714 bfd_mach_o_read_segment (bfd *abfd,
3715 bfd_mach_o_load_command *command,
3718 bfd_mach_o_segment_command *seg = &command->command.segment;
3723 struct mach_o_segment_command_64_external raw;
3725 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3727 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3728 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3731 memcpy (seg->segname, raw.segname, 16);
3732 seg->segname[16] = '\0';
3734 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3735 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3736 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3737 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3738 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3739 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3740 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3741 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3745 struct mach_o_segment_command_32_external raw;
3747 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3749 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3750 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3753 memcpy (seg->segname, raw.segname, 16);
3754 seg->segname[16] = '\0';
3756 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3757 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3758 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3759 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3760 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3761 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3762 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3763 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3765 seg->sect_head = NULL;
3766 seg->sect_tail = NULL;
3768 for (i = 0; i < seg->nsects; i++)
3774 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3775 + (i * BFD_MACH_O_SECTION_64_SIZE);
3777 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3778 + (i * BFD_MACH_O_SECTION_SIZE);
3780 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3784 bfd_mach_o_append_section_to_segment (seg, sec);
3791 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3793 return bfd_mach_o_read_segment (abfd, command, 0);
3797 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3799 return bfd_mach_o_read_segment (abfd, command, 1);
3803 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3805 struct mach_o_load_command_external raw;
3808 /* Read command type and length. */
3809 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3810 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3813 cmd = bfd_h_get_32 (abfd, raw.cmd);
3814 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3815 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3816 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3818 switch (command->type)
3820 case BFD_MACH_O_LC_SEGMENT:
3821 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3824 case BFD_MACH_O_LC_SEGMENT_64:
3825 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3828 case BFD_MACH_O_LC_SYMTAB:
3829 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3832 case BFD_MACH_O_LC_SYMSEG:
3834 case BFD_MACH_O_LC_THREAD:
3835 case BFD_MACH_O_LC_UNIXTHREAD:
3836 if (bfd_mach_o_read_thread (abfd, command) != 0)
3839 case BFD_MACH_O_LC_LOAD_DYLINKER:
3840 case BFD_MACH_O_LC_ID_DYLINKER:
3841 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3844 case BFD_MACH_O_LC_LOAD_DYLIB:
3845 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3846 case BFD_MACH_O_LC_ID_DYLIB:
3847 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3848 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3849 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3850 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3853 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3854 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3857 case BFD_MACH_O_LC_LOADFVMLIB:
3858 case BFD_MACH_O_LC_IDFVMLIB:
3859 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3862 case BFD_MACH_O_LC_IDENT:
3863 case BFD_MACH_O_LC_FVMFILE:
3864 case BFD_MACH_O_LC_PREPAGE:
3865 case BFD_MACH_O_LC_ROUTINES:
3866 case BFD_MACH_O_LC_ROUTINES_64:
3868 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3869 case BFD_MACH_O_LC_SUB_UMBRELLA:
3870 case BFD_MACH_O_LC_SUB_LIBRARY:
3871 case BFD_MACH_O_LC_SUB_CLIENT:
3872 case BFD_MACH_O_LC_RPATH:
3873 if (bfd_mach_o_read_str (abfd, command) != 0)
3876 case BFD_MACH_O_LC_DYSYMTAB:
3877 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3880 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3881 case BFD_MACH_O_LC_PREBIND_CKSUM:
3883 case BFD_MACH_O_LC_UUID:
3884 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3887 case BFD_MACH_O_LC_CODE_SIGNATURE:
3888 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3889 case BFD_MACH_O_LC_FUNCTION_STARTS:
3890 case BFD_MACH_O_LC_DATA_IN_CODE:
3891 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3892 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3895 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3896 if (!bfd_mach_o_read_encryption_info (abfd, command))
3899 case BFD_MACH_O_LC_DYLD_INFO:
3900 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3903 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3904 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3905 if (!bfd_mach_o_read_version_min (abfd, command))
3908 case BFD_MACH_O_LC_MAIN:
3909 if (!bfd_mach_o_read_main (abfd, command))
3912 case BFD_MACH_O_LC_SOURCE_VERSION:
3913 if (!bfd_mach_o_read_source_version (abfd, command))
3917 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3918 abfd, (unsigned long) command->type);
3926 bfd_mach_o_flatten_sections (bfd *abfd)
3928 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3932 /* Count total number of sections. */
3935 for (i = 0; i < mdata->header.ncmds; i++)
3937 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3938 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3940 bfd_mach_o_segment_command *seg;
3942 seg = &mdata->commands[i].command.segment;
3943 mdata->nsects += seg->nsects;
3947 /* Allocate sections array. */
3948 mdata->sections = bfd_alloc (abfd,
3949 mdata->nsects * sizeof (bfd_mach_o_section *));
3951 /* Fill the array. */
3954 for (i = 0; i < mdata->header.ncmds; i++)
3956 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3957 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3959 bfd_mach_o_segment_command *seg;
3960 bfd_mach_o_section *sec;
3962 seg = &mdata->commands[i].command.segment;
3963 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3965 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3966 mdata->sections[csect++] = sec;
3972 bfd_mach_o_scan_start_address (bfd *abfd)
3974 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3975 bfd_mach_o_thread_command *cmd = NULL;
3978 for (i = 0; i < mdata->header.ncmds; i++)
3979 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3980 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3982 cmd = &mdata->commands[i].command.thread;
3985 else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
3986 && mdata->nsects > 1)
3988 bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
3989 bfd_mach_o_section *text_sect = mdata->sections[0];
3992 abfd->start_address = main_cmd->entryoff
3993 + (text_sect->addr - text_sect->offset);
3998 /* An object file has no start address, so do not fail if not found. */
4002 /* FIXME: create a subtarget hook ? */
4003 for (i = 0; i < cmd->nflavours; i++)
4005 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4006 && (cmd->flavours[i].flavour
4007 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4009 unsigned char buf[4];
4011 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4012 || bfd_bread (buf, 4, abfd) != 4)
4015 abfd->start_address = bfd_h_get_32 (abfd, buf);
4017 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4018 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4020 unsigned char buf[4];
4022 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4023 || bfd_bread (buf, 4, abfd) != 4)
4026 abfd->start_address = bfd_h_get_32 (abfd, buf);
4028 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4029 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4031 unsigned char buf[8];
4033 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4034 || bfd_bread (buf, 8, abfd) != 8)
4037 abfd->start_address = bfd_h_get_64 (abfd, buf);
4039 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4040 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4042 unsigned char buf[8];
4044 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4045 || bfd_bread (buf, 8, abfd) != 8)
4048 abfd->start_address = bfd_h_get_64 (abfd, buf);
4056 bfd_mach_o_set_arch_mach (bfd *abfd,
4057 enum bfd_architecture arch,
4058 unsigned long machine)
4060 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4062 /* If this isn't the right architecture for this backend, and this
4063 isn't the generic backend, fail. */
4064 if (arch != bed->arch
4065 && arch != bfd_arch_unknown
4066 && bed->arch != bfd_arch_unknown)
4069 return bfd_default_set_arch_mach (abfd, arch, machine);
4073 bfd_mach_o_scan (bfd *abfd,
4074 bfd_mach_o_header *header,
4075 bfd_mach_o_data_struct *mdata)
4078 enum bfd_architecture cputype;
4079 unsigned long cpusubtype;
4080 unsigned int hdrsize;
4082 hdrsize = mach_o_wide_p (header) ?
4083 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4085 mdata->header = *header;
4087 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4088 switch (header->filetype)
4090 case BFD_MACH_O_MH_OBJECT:
4091 abfd->flags |= HAS_RELOC;
4093 case BFD_MACH_O_MH_EXECUTE:
4094 abfd->flags |= EXEC_P;
4096 case BFD_MACH_O_MH_DYLIB:
4097 case BFD_MACH_O_MH_BUNDLE:
4098 abfd->flags |= DYNAMIC;
4102 abfd->tdata.mach_o_data = mdata;
4104 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4105 &cputype, &cpusubtype);
4106 if (cputype == bfd_arch_unknown)
4108 (*_bfd_error_handler)
4109 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4110 header->cputype, header->cpusubtype);
4114 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4116 if (header->ncmds != 0)
4118 mdata->commands = bfd_alloc
4119 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4120 if (mdata->commands == NULL)
4123 for (i = 0; i < header->ncmds; i++)
4125 bfd_mach_o_load_command *cur = &mdata->commands[i];
4128 cur->offset = hdrsize;
4131 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4132 cur->offset = prev->offset + prev->len;
4135 if (bfd_mach_o_read_command (abfd, cur) < 0)
4140 /* Sections should be flatten before scanning start address. */
4141 bfd_mach_o_flatten_sections (abfd);
4142 if (!bfd_mach_o_scan_start_address (abfd))
4149 bfd_mach_o_mkobject_init (bfd *abfd)
4151 bfd_mach_o_data_struct *mdata = NULL;
4153 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4156 abfd->tdata.mach_o_data = mdata;
4158 mdata->header.magic = 0;
4159 mdata->header.cputype = 0;
4160 mdata->header.cpusubtype = 0;
4161 mdata->header.filetype = 0;
4162 mdata->header.ncmds = 0;
4163 mdata->header.sizeofcmds = 0;
4164 mdata->header.flags = 0;
4165 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4166 mdata->commands = NULL;
4168 mdata->sections = NULL;
4169 mdata->dyn_reloc_cache = NULL;
4175 bfd_mach_o_gen_mkobject (bfd *abfd)
4177 bfd_mach_o_data_struct *mdata;
4179 if (!bfd_mach_o_mkobject_init (abfd))
4182 mdata = bfd_mach_o_get_data (abfd);
4183 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4184 mdata->header.cputype = 0;
4185 mdata->header.cpusubtype = 0;
4186 mdata->header.byteorder = abfd->xvec->byteorder;
4187 mdata->header.version = 1;
4193 bfd_mach_o_header_p (bfd *abfd,
4194 bfd_mach_o_filetype filetype,
4195 bfd_mach_o_cpu_type cputype)
4197 bfd_mach_o_header header;
4198 bfd_mach_o_data_struct *mdata;
4200 if (!bfd_mach_o_read_header (abfd, &header))
4203 if (! (header.byteorder == BFD_ENDIAN_BIG
4204 || header.byteorder == BFD_ENDIAN_LITTLE))
4206 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4207 (unsigned long) header.byteorder);
4211 if (! ((header.byteorder == BFD_ENDIAN_BIG
4212 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4213 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4214 || (header.byteorder == BFD_ENDIAN_LITTLE
4215 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4216 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4219 /* Check cputype and filetype.
4220 In case of wildcard, do not accept magics that are handled by existing
4224 if (header.cputype != cputype)
4230 if (header.filetype != filetype)
4235 switch (header.filetype)
4237 case BFD_MACH_O_MH_CORE:
4238 /* Handled by core_p */
4245 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4249 if (!bfd_mach_o_scan (abfd, &header, mdata))
4255 bfd_set_error (bfd_error_wrong_format);
4261 static const bfd_target *
4262 bfd_mach_o_gen_object_p (bfd *abfd)
4264 return bfd_mach_o_header_p (abfd, 0, 0);
4267 static const bfd_target *
4268 bfd_mach_o_gen_core_p (bfd *abfd)
4270 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4273 typedef struct mach_o_fat_archentry
4275 unsigned long cputype;
4276 unsigned long cpusubtype;
4277 unsigned long offset;
4279 unsigned long align;
4280 } mach_o_fat_archentry;
4282 typedef struct mach_o_fat_data_struct
4284 unsigned long magic;
4285 unsigned long nfat_arch;
4286 mach_o_fat_archentry *archentries;
4287 } mach_o_fat_data_struct;
4290 bfd_mach_o_archive_p (bfd *abfd)
4292 mach_o_fat_data_struct *adata = NULL;
4293 struct mach_o_fat_header_external hdr;
4296 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4297 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4300 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4304 adata->magic = bfd_getb32 (hdr.magic);
4305 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4306 if (adata->magic != 0xcafebabe)
4308 /* Avoid matching Java bytecode files, which have the same magic number.
4309 In the Java bytecode file format this field contains the JVM version,
4310 which starts at 43.0. */
4311 if (adata->nfat_arch > 30)
4314 adata->archentries =
4315 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4316 if (adata->archentries == NULL)
4319 for (i = 0; i < adata->nfat_arch; i++)
4321 struct mach_o_fat_arch_external arch;
4322 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4324 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4325 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4326 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4327 adata->archentries[i].size = bfd_getb32 (arch.size);
4328 adata->archentries[i].align = bfd_getb32 (arch.align);
4331 abfd->tdata.mach_o_fat_data = adata;
4336 bfd_release (abfd, adata);
4337 bfd_set_error (bfd_error_wrong_format);
4341 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4342 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4343 Set arelt_data and origin fields too. */
4346 bfd_mach_o_fat_member_init (bfd *abfd,
4347 enum bfd_architecture arch_type,
4348 unsigned long arch_subtype,
4349 mach_o_fat_archentry *entry)
4351 struct areltdata *areltdata;
4352 /* Create the member filename. Use ARCH_NAME. */
4353 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4357 /* Use the architecture name if known. */
4358 abfd->filename = xstrdup (ap->printable_name);
4362 /* Forge a uniq id. */
4363 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4364 char *name = xmalloc (namelen);
4365 snprintf (name, namelen, "0x%lx-0x%lx",
4366 entry->cputype, entry->cpusubtype);
4367 abfd->filename = name;
4370 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4371 areltdata->parsed_size = entry->size;
4372 abfd->arelt_data = areltdata;
4373 abfd->iostream = NULL;
4374 abfd->origin = entry->offset;
4378 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4380 mach_o_fat_data_struct *adata;
4381 mach_o_fat_archentry *entry = NULL;
4384 enum bfd_architecture arch_type;
4385 unsigned long arch_subtype;
4387 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4388 BFD_ASSERT (adata != NULL);
4390 /* Find index of previous entry. */
4393 /* Start at first one. */
4398 /* Find index of PREV. */
4399 for (i = 0; i < adata->nfat_arch; i++)
4401 if (adata->archentries[i].offset == prev->origin)
4405 if (i == adata->nfat_arch)
4408 bfd_set_error (bfd_error_bad_value);
4412 /* Get next entry. */
4416 if (i >= adata->nfat_arch)
4418 bfd_set_error (bfd_error_no_more_archived_files);
4422 entry = &adata->archentries[i];
4423 nbfd = _bfd_new_bfd_contained_in (archive);
4427 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4428 &arch_type, &arch_subtype);
4430 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4432 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4437 /* Analogous to stat call. */
4440 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4442 if (abfd->arelt_data == NULL)
4444 bfd_set_error (bfd_error_invalid_operation);
4451 buf->st_mode = 0644;
4452 buf->st_size = arelt_size (abfd);
4457 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4458 If ABFD is a fat image containing a member that corresponds to FORMAT
4459 and ARCH, returns it.
4460 In other case, returns NULL.
4461 This function allows transparent uses of fat images. */
4464 bfd_mach_o_fat_extract (bfd *abfd,
4466 const bfd_arch_info_type *arch)
4469 mach_o_fat_data_struct *adata;
4472 if (bfd_check_format (abfd, format))
4474 if (bfd_get_arch_info (abfd) == arch)
4478 if (!bfd_check_format (abfd, bfd_archive)
4479 || abfd->xvec != &mach_o_fat_vec)
4482 /* This is a Mach-O fat image. */
4483 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4484 BFD_ASSERT (adata != NULL);
4486 for (i = 0; i < adata->nfat_arch; i++)
4488 struct mach_o_fat_archentry *e = &adata->archentries[i];
4489 enum bfd_architecture cpu_type;
4490 unsigned long cpu_subtype;
4492 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4493 &cpu_type, &cpu_subtype);
4494 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4497 /* The architecture is found. */
4498 res = _bfd_new_bfd_contained_in (abfd);
4502 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4504 if (bfd_check_format (res, format))
4506 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4517 bfd_mach_o_lookup_command (bfd *abfd,
4518 bfd_mach_o_load_command_type type,
4519 bfd_mach_o_load_command **mcommand)
4521 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4522 bfd_mach_o_load_command *ncmd = NULL;
4523 unsigned int i, num;
4525 BFD_ASSERT (md != NULL);
4526 BFD_ASSERT (mcommand != NULL);
4529 for (i = 0; i < md->header.ncmds; i++)
4531 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4533 if (cmd->type != type)
4546 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4550 case BFD_MACH_O_CPU_TYPE_MC680x0:
4552 case BFD_MACH_O_CPU_TYPE_MC88000:
4554 case BFD_MACH_O_CPU_TYPE_POWERPC:
4556 case BFD_MACH_O_CPU_TYPE_I386:
4558 case BFD_MACH_O_CPU_TYPE_SPARC:
4560 case BFD_MACH_O_CPU_TYPE_I860:
4562 case BFD_MACH_O_CPU_TYPE_HPPA:
4563 return 0xc0000000 - 0x04000000;
4569 /* The following two tables should be kept, as far as possible, in order of
4570 most frequently used entries to optimize their use from gas. */
4572 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4574 { "regular", BFD_MACH_O_S_REGULAR},
4575 { "coalesced", BFD_MACH_O_S_COALESCED},
4576 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4577 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4578 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4579 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4580 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4581 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4582 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4583 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4584 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4585 { "interposing", BFD_MACH_O_S_INTERPOSING},
4586 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4587 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4588 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4589 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4590 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4594 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4596 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4597 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4598 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4599 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4600 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4601 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4602 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4603 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4604 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4605 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4606 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4610 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4613 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4615 const bfd_mach_o_xlat_name *x;
4616 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4618 for (x = bfd_mach_o_section_type_name; x->name; x++)
4619 if (strcmp (x->name, name) == 0)
4621 /* We found it... does the target support it? */
4622 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4623 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4624 return x->val; /* OK. */
4626 break; /* Not supported. */
4628 /* Maximum section ID = 0xff. */
4632 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4635 bfd_mach_o_get_section_attribute_from_name (const char *name)
4637 const bfd_mach_o_xlat_name *x;
4639 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4640 if (strcmp (x->name, name) == 0)
4642 return (unsigned int)-1;
4646 bfd_mach_o_core_fetch_environment (bfd *abfd,
4647 unsigned char **rbuf,
4650 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4651 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4654 for (i = 0; i < mdata->header.ncmds; i++)
4656 bfd_mach_o_load_command *cur = &mdata->commands[i];
4657 bfd_mach_o_segment_command *seg = NULL;
4659 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4662 seg = &cur->command.segment;
4664 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4666 unsigned long start = seg->fileoff;
4667 unsigned long end = seg->fileoff + seg->filesize;
4668 unsigned char *buf = bfd_malloc (1024);
4669 unsigned long size = 1024;
4673 bfd_size_type nread = 0;
4674 unsigned long offset;
4675 int found_nonnull = 0;
4677 if (size > (end - start))
4678 size = (end - start);
4680 buf = bfd_realloc_or_free (buf, size);
4684 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4690 nread = bfd_bread (buf, size, abfd);
4698 for (offset = 4; offset <= size; offset += 4)
4702 val = *((unsigned long *) (buf + size - offset));
4703 if (! found_nonnull)
4708 else if (val == 0x0)
4710 unsigned long bottom;
4713 bottom = seg->fileoff + seg->filesize - offset;
4714 top = seg->fileoff + seg->filesize - 4;
4715 *rbuf = bfd_malloc (top - bottom);
4716 *rlen = top - bottom;
4718 memcpy (*rbuf, buf + size - *rlen, *rlen);
4724 if (size == (end - start))
4738 bfd_mach_o_core_file_failing_command (bfd *abfd)
4740 unsigned char *buf = NULL;
4741 unsigned int len = 0;
4744 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4748 return (char *) buf;
4752 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4757 static bfd_mach_o_uuid_command *
4758 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4760 bfd_mach_o_load_command *uuid_cmd;
4761 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4764 return &uuid_cmd->command.uuid;
4767 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4770 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4772 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4775 BFD_ASSERT (uuid_cmd);
4777 if (!bfd_check_format (abfd, bfd_object))
4780 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4781 || bfd_mach_o_get_data (abfd) == NULL
4782 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4785 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4786 if (dsym_uuid_cmd == NULL)
4789 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4790 sizeof (uuid_cmd->uuid)) != 0)
4796 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4797 The caller is responsible for closing the returned BFD object and
4798 its my_archive if the returned BFD is in a fat dSYM. */
4801 bfd_mach_o_find_dsym (const char *dsym_filename,
4802 const bfd_mach_o_uuid_command *uuid_cmd,
4803 const bfd_arch_info_type *arch)
4805 bfd *base_dsym_bfd, *dsym_bfd;
4807 BFD_ASSERT (uuid_cmd);
4809 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4810 if (base_dsym_bfd == NULL)
4813 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4814 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4817 bfd_close (dsym_bfd);
4818 if (base_dsym_bfd != dsym_bfd)
4819 bfd_close (base_dsym_bfd);
4824 /* Return a BFD created from a dSYM file for ABFD.
4825 The caller is responsible for closing the returned BFD object, its
4826 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4829 bfd_mach_o_follow_dsym (bfd *abfd)
4831 char *dsym_filename;
4832 bfd_mach_o_uuid_command *uuid_cmd;
4833 bfd *dsym_bfd, *base_bfd = abfd;
4834 const char *base_basename;
4836 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4839 if (abfd->my_archive)
4840 base_bfd = abfd->my_archive;
4841 /* BFD may have been opened from a stream. */
4842 if (base_bfd->filename == NULL)
4844 bfd_set_error (bfd_error_invalid_operation);
4847 base_basename = lbasename (base_bfd->filename);
4849 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4850 if (uuid_cmd == NULL)
4853 /* TODO: We assume the DWARF file has the same as the binary's.
4854 It seems apple's GDB checks all files in the dSYM bundle directory.
4855 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4857 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4858 + strlen (dsym_subdir) + 1
4859 + strlen (base_basename) + 1);
4860 sprintf (dsym_filename, "%s%s/%s",
4861 base_bfd->filename, dsym_subdir, base_basename);
4863 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4864 bfd_get_arch_info (abfd));
4865 if (dsym_bfd == NULL)
4866 free (dsym_filename);
4872 bfd_mach_o_find_nearest_line (bfd *abfd,
4876 const char **filename_ptr,
4877 const char **functionname_ptr,
4878 unsigned int *line_ptr)
4880 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4883 switch (mdata->header.filetype)
4885 case BFD_MACH_O_MH_OBJECT:
4887 case BFD_MACH_O_MH_EXECUTE:
4888 case BFD_MACH_O_MH_DYLIB:
4889 case BFD_MACH_O_MH_BUNDLE:
4890 case BFD_MACH_O_MH_KEXT_BUNDLE:
4891 if (mdata->dwarf2_find_line_info == NULL)
4893 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4894 /* When we couldn't find dSYM for this binary, we look for
4895 the debug information in the binary itself. In this way,
4896 we won't try finding separated dSYM again because
4897 mdata->dwarf2_find_line_info will be filled. */
4898 if (! mdata->dsym_bfd)
4900 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4901 dwarf_debug_sections, symbols,
4902 &mdata->dwarf2_find_line_info))
4909 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4910 section, symbols, offset,
4911 filename_ptr, functionname_ptr,
4913 &mdata->dwarf2_find_line_info))
4919 bfd_mach_o_close_and_cleanup (bfd *abfd)
4921 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4922 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4924 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4925 bfd_mach_o_free_cached_info (abfd);
4926 if (mdata->dsym_bfd != NULL)
4928 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4929 char *dsym_filename = (char *)(fat_bfd
4931 : mdata->dsym_bfd->filename);
4932 bfd_close (mdata->dsym_bfd);
4933 mdata->dsym_bfd = NULL;
4935 bfd_close (fat_bfd);
4936 free (dsym_filename);
4940 if (bfd_get_format (abfd) == bfd_archive
4941 && abfd->xvec == &mach_o_fat_vec)
4943 return _bfd_generic_close_and_cleanup (abfd);
4946 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4948 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4950 free (mdata->dyn_reloc_cache);
4951 mdata->dyn_reloc_cache = NULL;
4952 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4954 free (asect->relocation);
4955 asect->relocation = NULL;
4961 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4962 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4964 #define bfd_mach_o_swap_reloc_in NULL
4965 #define bfd_mach_o_swap_reloc_out NULL
4966 #define bfd_mach_o_print_thread NULL
4967 #define bfd_mach_o_tgt_seg_table NULL
4968 #define bfd_mach_o_section_type_valid_for_tgt NULL
4970 #define TARGET_NAME mach_o_be_vec
4971 #define TARGET_STRING "mach-o-be"
4972 #define TARGET_ARCHITECTURE bfd_arch_unknown
4973 #define TARGET_BIG_ENDIAN 1
4974 #define TARGET_ARCHIVE 0
4975 #define TARGET_PRIORITY 1
4976 #include "mach-o-target.c"
4979 #undef TARGET_STRING
4980 #undef TARGET_ARCHITECTURE
4981 #undef TARGET_BIG_ENDIAN
4982 #undef TARGET_ARCHIVE
4983 #undef TARGET_PRIORITY
4985 #define TARGET_NAME mach_o_le_vec
4986 #define TARGET_STRING "mach-o-le"
4987 #define TARGET_ARCHITECTURE bfd_arch_unknown
4988 #define TARGET_BIG_ENDIAN 0
4989 #define TARGET_ARCHIVE 0
4990 #define TARGET_PRIORITY 1
4992 #include "mach-o-target.c"
4995 #undef TARGET_STRING
4996 #undef TARGET_ARCHITECTURE
4997 #undef TARGET_BIG_ENDIAN
4998 #undef TARGET_ARCHIVE
4999 #undef TARGET_PRIORITY
5001 /* Not yet handled: creating an archive. */
5002 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5005 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5006 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5007 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5008 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5009 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5010 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5011 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5012 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5013 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5014 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5016 #define TARGET_NAME mach_o_fat_vec
5017 #define TARGET_STRING "mach-o-fat"
5018 #define TARGET_ARCHITECTURE bfd_arch_unknown
5019 #define TARGET_BIG_ENDIAN 1
5020 #define TARGET_ARCHIVE 1
5021 #define TARGET_PRIORITY 0
5023 #include "mach-o-target.c"
5026 #undef TARGET_STRING
5027 #undef TARGET_ARCHITECTURE
5028 #undef TARGET_BIG_ENDIAN
5029 #undef TARGET_ARCHIVE
5030 #undef TARGET_PRIORITY