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;
908 case BFD_MACH_O_CPU_TYPE_ARM64:
909 *type = bfd_arch_aarch64;
910 *subtype = bfd_mach_aarch64;
913 *type = bfd_arch_unknown;
919 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
921 struct mach_o_header_external raw;
924 size = mach_o_wide_p (header) ?
925 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
927 bfd_h_put_32 (abfd, header->magic, raw.magic);
928 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
929 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
930 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
931 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
932 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
933 bfd_h_put_32 (abfd, header->flags, raw.flags);
935 if (mach_o_wide_p (header))
936 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
938 if (bfd_seek (abfd, 0, SEEK_SET) != 0
939 || bfd_bwrite (&raw, size, abfd) != size)
946 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
948 bfd_mach_o_thread_command *cmd = &command->command.thread;
950 struct mach_o_thread_command_external raw;
953 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
954 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
957 for (i = 0; i < cmd->nflavours; i++)
959 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
960 BFD_ASSERT (cmd->flavours[i].offset ==
961 (command->offset + offset + BFD_MACH_O_LC_SIZE));
963 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
964 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
966 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
967 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
970 offset += cmd->flavours[i].size + sizeof (raw);
977 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
980 return (asect->reloc_count + 1) * sizeof (arelent *);
983 /* In addition to the need to byte-swap the symbol number, the bit positions
984 of the fields in the relocation information vary per target endian-ness. */
987 bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
988 unsigned char *fields)
990 unsigned char info = fields[3];
992 if (bfd_big_endian (abfd))
994 rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
995 rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
996 rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
997 rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
998 & BFD_MACH_O_LENGTH_MASK;
999 rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
1003 rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1004 rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1005 rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1006 rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1007 & BFD_MACH_O_LENGTH_MASK;
1008 rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1013 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
1014 struct mach_o_reloc_info_external *raw,
1015 arelent *res, asymbol **syms)
1017 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1018 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1019 bfd_mach_o_reloc_info reloc;
1023 addr = bfd_get_32 (abfd, raw->r_address);
1024 res->sym_ptr_ptr = NULL;
1027 if (addr & BFD_MACH_O_SR_SCATTERED)
1030 bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1032 /* Scattered relocation, can't be extern. */
1033 reloc.r_scattered = 1;
1036 /* Extract section and offset from r_value (symnum). */
1037 reloc.r_value = symnum;
1038 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1039 end of the data for the section (e.g. in a calculation of section
1040 data length). At present, the symbol will end up associated with
1041 the following section or, if it falls within alignment padding, as
1042 null - which will assert later. */
1043 for (j = 0; j < mdata->nsects; j++)
1045 bfd_mach_o_section *sect = mdata->sections[j];
1046 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1048 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1049 res->addend = symnum - sect->addr;
1054 /* Extract the info and address fields from r_address. */
1055 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1056 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1057 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1058 reloc.r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1059 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1065 /* Non-scattered relocation. */
1066 reloc.r_scattered = 0;
1068 /* The value and info fields have to be extracted dependent on target
1070 bfd_mach_o_swap_in_non_scattered_reloc (abfd, &reloc, raw->r_symbolnum);
1071 num = reloc.r_value;
1075 /* An external symbol number. */
1078 else if (num == 0x00ffffff)
1080 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1081 is generic code, we don't know wether this is really a PAIR.
1082 This value is almost certainly not a valid section number, hence
1083 this specific case to avoid an assertion failure.
1084 Target specific swap_reloc_in routine should adjust that. */
1085 sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1089 /* A section number. */
1090 BFD_ASSERT (num != 0);
1091 BFD_ASSERT (num <= mdata->nsects);
1093 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1094 /* For a symbol defined in section S, the addend (stored in the
1095 binary) contains the address of the section. To comply with
1096 bfd convention, subtract the section address.
1097 Use the address from the header, so that the user can modify
1098 the vma of the section. */
1099 res->addend = -mdata->sections[num - 1]->addr;
1101 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1102 in the lower 16bits of the address value. So we have to find the
1103 'symbol' from the preceding reloc. We do this even though the
1104 section symbol is probably not needed here, because NULL symbol
1105 values cause an assert in generic BFD code. This must be done in
1106 the PPC swap_reloc_in routine. */
1107 res->sym_ptr_ptr = sym;
1109 /* The 'address' is just r_address.
1110 ??? maybe this should be masked with 0xffffff for safety. */
1111 res->address = addr;
1112 reloc.r_address = addr;
1115 /* We have set up a reloc with all the information present, so the swapper
1116 can modify address, value and addend fields, if necessary, to convey
1117 information in the generic BFD reloc that is mach-o specific. */
1119 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1125 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1126 unsigned long count,
1127 arelent *res, asymbol **syms)
1130 struct mach_o_reloc_info_external *native_relocs;
1131 bfd_size_type native_size;
1133 /* Allocate and read relocs. */
1134 native_size = count * BFD_MACH_O_RELENT_SIZE;
1136 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1137 if (native_relocs == NULL)
1140 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1141 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1144 for (i = 0; i < count; i++)
1146 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1150 free (native_relocs);
1153 free (native_relocs);
1158 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1159 arelent **rels, asymbol **syms)
1161 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1165 if (asect->reloc_count == 0)
1168 /* No need to go further if we don't know how to read relocs. */
1169 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1172 if (asect->relocation == NULL)
1174 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1178 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1179 asect->reloc_count, res, syms) < 0)
1184 asect->relocation = res;
1187 res = asect->relocation;
1188 for (i = 0; i < asect->reloc_count; i++)
1196 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1198 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1200 if (mdata->dysymtab == NULL)
1202 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1203 * sizeof (arelent *);
1207 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1208 struct bfd_symbol **syms)
1210 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1211 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1212 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1216 if (dysymtab == NULL)
1218 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1221 /* No need to go further if we don't know how to read relocs. */
1222 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1225 if (mdata->dyn_reloc_cache == NULL)
1227 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1228 * sizeof (arelent));
1232 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1233 dysymtab->nextrel, res, syms) < 0)
1239 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1241 res + dysymtab->nextrel, syms) < 0)
1247 mdata->dyn_reloc_cache = res;
1250 res = mdata->dyn_reloc_cache;
1251 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1257 /* In addition to the need to byte-swap the symbol number, the bit positions
1258 of the fields in the relocation information vary per target endian-ness. */
1261 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1262 bfd_mach_o_reloc_info *rel)
1264 unsigned char info = 0;
1266 BFD_ASSERT (rel->r_type <= 15);
1267 BFD_ASSERT (rel->r_length <= 3);
1269 if (bfd_big_endian (abfd))
1271 fields[0] = (rel->r_value >> 16) & 0xff;
1272 fields[1] = (rel->r_value >> 8) & 0xff;
1273 fields[2] = rel->r_value & 0xff;
1274 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1275 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1276 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1277 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1281 fields[2] = (rel->r_value >> 16) & 0xff;
1282 fields[1] = (rel->r_value >> 8) & 0xff;
1283 fields[0] = rel->r_value & 0xff;
1284 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1285 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1286 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1287 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1293 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1298 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1300 sec = section->bfdsection;
1301 if (sec->reloc_count == 0)
1304 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1307 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1310 /* Convert and write. */
1311 entries = section->bfdsection->orelocation;
1312 for (i = 0; i < section->nreloc; i++)
1314 arelent *rel = entries[i];
1315 struct mach_o_reloc_info_external raw;
1316 bfd_mach_o_reloc_info info, *pinfo = &info;
1318 /* Convert relocation to an intermediate representation. */
1319 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1322 /* Lower the relocation info. */
1323 if (pinfo->r_scattered)
1327 v = BFD_MACH_O_SR_SCATTERED
1328 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1329 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1330 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1331 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
1332 /* Note: scattered relocs have field in reverse order... */
1333 bfd_put_32 (abfd, v, raw.r_address);
1334 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1338 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1339 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1343 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1344 != BFD_MACH_O_RELENT_SIZE)
1351 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1353 struct mach_o_section_32_external raw;
1355 memcpy (raw.sectname, section->sectname, 16);
1356 memcpy (raw.segname, section->segname, 16);
1357 bfd_h_put_32 (abfd, section->addr, raw.addr);
1358 bfd_h_put_32 (abfd, section->size, raw.size);
1359 bfd_h_put_32 (abfd, section->offset, raw.offset);
1360 bfd_h_put_32 (abfd, section->align, raw.align);
1361 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1362 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1363 bfd_h_put_32 (abfd, section->flags, raw.flags);
1364 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1365 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1367 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1368 != BFD_MACH_O_SECTION_SIZE)
1375 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1377 struct mach_o_section_64_external raw;
1379 memcpy (raw.sectname, section->sectname, 16);
1380 memcpy (raw.segname, section->segname, 16);
1381 bfd_h_put_64 (abfd, section->addr, raw.addr);
1382 bfd_h_put_64 (abfd, section->size, raw.size);
1383 bfd_h_put_32 (abfd, section->offset, raw.offset);
1384 bfd_h_put_32 (abfd, section->align, raw.align);
1385 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1386 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1387 bfd_h_put_32 (abfd, section->flags, raw.flags);
1388 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1389 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1390 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1392 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1393 != BFD_MACH_O_SECTION_64_SIZE)
1400 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1402 struct mach_o_segment_command_32_external raw;
1403 bfd_mach_o_segment_command *seg = &command->command.segment;
1404 bfd_mach_o_section *sec;
1406 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1408 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1409 if (!bfd_mach_o_write_relocs (abfd, sec))
1412 memcpy (raw.segname, seg->segname, 16);
1413 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1414 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1415 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1416 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1417 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1418 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1419 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1420 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1422 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1423 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1426 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1427 if (bfd_mach_o_write_section_32 (abfd, sec))
1434 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1436 struct mach_o_segment_command_64_external raw;
1437 bfd_mach_o_segment_command *seg = &command->command.segment;
1438 bfd_mach_o_section *sec;
1440 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1442 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1443 if (!bfd_mach_o_write_relocs (abfd, sec))
1446 memcpy (raw.segname, seg->segname, 16);
1447 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1448 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1449 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1450 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1451 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1452 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1453 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1454 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1456 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1457 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1460 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1461 if (bfd_mach_o_write_section_64 (abfd, sec))
1468 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1470 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1471 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1473 unsigned int wide = bfd_mach_o_wide_p (abfd);
1474 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1475 struct bfd_strtab_hash *strtab;
1476 asymbol **symbols = bfd_get_outsymbols (abfd);
1478 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1480 /* Write the symbols first. */
1481 mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
1482 sym->symoff = mdata->filelen;
1483 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1486 sym->nsyms = bfd_get_symcount (abfd);
1487 mdata->filelen += sym->nsyms * symlen;
1489 strtab = _bfd_stringtab_init ();
1494 /* Although we don't strictly need to do this, for compatibility with
1495 Darwin system tools, actually output an empty string for the index
1497 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1499 for (i = 0; i < sym->nsyms; i++)
1501 bfd_size_type str_index;
1502 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1504 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1505 /* An index of 0 always means the empty string. */
1509 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1511 if (str_index == (bfd_size_type) -1)
1517 struct mach_o_nlist_64_external raw;
1519 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1520 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1521 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1522 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1523 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1526 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1531 struct mach_o_nlist_external raw;
1533 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1534 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1535 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1536 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1537 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1540 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1544 sym->strsize = _bfd_stringtab_size (strtab);
1545 sym->stroff = mdata->filelen;
1546 mdata->filelen += sym->strsize;
1548 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1550 _bfd_stringtab_free (strtab);
1554 struct mach_o_symtab_command_external raw;
1556 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1557 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1558 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1559 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1561 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1562 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1569 _bfd_stringtab_free (strtab);
1573 /* Write a dysymtab command.
1574 TODO: Possibly coalesce writes of smaller objects. */
1577 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1579 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1581 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1583 if (cmd->nmodtab != 0)
1587 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1590 for (i = 0; i < cmd->nmodtab; i++)
1592 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1596 iinit = module->iinit & 0xffff;
1597 iinit |= ((module->iterm & 0xffff) << 16);
1599 ninit = module->ninit & 0xffff;
1600 ninit |= ((module->nterm & 0xffff) << 16);
1602 if (bfd_mach_o_wide_p (abfd))
1604 struct mach_o_dylib_module_64_external w;
1606 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1607 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1608 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1609 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1610 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1611 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1612 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1613 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1614 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1615 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1616 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1617 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1618 &w.objc_module_info_addr);
1619 bfd_h_put_32 (abfd, module->objc_module_info_size,
1620 &w.objc_module_info_size);
1622 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1627 struct mach_o_dylib_module_external n;
1629 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1630 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1631 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1632 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1633 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1634 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1635 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1636 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1637 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1638 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1639 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1640 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1641 &n.objc_module_info_addr);
1642 bfd_h_put_32 (abfd, module->objc_module_info_size,
1643 &n.objc_module_info_size);
1645 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1655 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1658 for (i = 0; i < cmd->ntoc; i++)
1660 struct mach_o_dylib_table_of_contents_external raw;
1661 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1663 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1664 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1666 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1671 if (cmd->nindirectsyms > 0)
1675 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1678 for (i = 0; i < cmd->nindirectsyms; ++i)
1680 unsigned char raw[4];
1682 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1683 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1688 if (cmd->nextrefsyms != 0)
1692 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1695 for (i = 0; i < cmd->nextrefsyms; i++)
1698 unsigned char raw[4];
1699 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1701 /* Fields isym and flags are written as bit-fields, thus we need
1702 a specific processing for endianness. */
1704 if (bfd_big_endian (abfd))
1706 v = ((ref->isym & 0xffffff) << 8);
1707 v |= ref->flags & 0xff;
1711 v = ref->isym & 0xffffff;
1712 v |= ((ref->flags & 0xff) << 24);
1715 bfd_h_put_32 (abfd, v, raw);
1716 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1722 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1726 struct mach_o_dysymtab_command_external raw;
1728 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1729 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1730 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1731 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1732 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1733 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1734 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1735 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1736 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1737 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1738 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1739 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1740 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1741 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1742 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1743 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1744 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1745 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1747 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1755 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
1757 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
1759 /* Just leave debug symbols where they are (pretend they are local, and
1760 then they will just be sorted on position). */
1761 if (s->n_type & BFD_MACH_O_N_STAB)
1764 /* Local (we should never see an undefined local AFAICT). */
1765 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1768 /* Common symbols look like undefined externs. */
1769 if (mtyp == BFD_MACH_O_N_UNDF)
1772 /* A defined non-local, non-debug symbol. */
1777 bfd_mach_o_cf_symbols (const void *a, const void *b)
1779 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1780 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1781 unsigned int soa, sob;
1783 soa = bfd_mach_o_primary_symbol_sort_key (sa);
1784 sob = bfd_mach_o_primary_symbol_sort_key (sb);
1791 /* If it's local or stab, just preserve the input order. */
1794 if (sa->symbol.udata.i < sb->symbol.udata.i)
1796 if (sa->symbol.udata.i > sb->symbol.udata.i)
1799 /* This is probably an error. */
1803 /* The second sort key is name. */
1804 return strcmp (sa->symbol.name, sb->symbol.name);
1807 /* Process the symbols.
1809 This should be OK for single-module files - but it is not likely to work
1810 for multi-module shared libraries.
1812 (a) If the application has not filled in the relevant mach-o fields, make
1815 (b) Order them, like this:
1818 ( ii) external defined
1820 (iii) external undefined/common
1827 bfd_mach_o_mangle_symbols (bfd *abfd)
1830 asymbol **symbols = bfd_get_outsymbols (abfd);
1832 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1835 for (i = 0; i < bfd_get_symcount (abfd); i++)
1837 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1839 /* We use this value, which is out-of-range as a symbol index, to signal
1840 that the mach-o-specific data are not filled in and need to be created
1841 from the bfd values. It is much preferable for the application to do
1842 this, since more meaningful diagnostics can be made that way. */
1844 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1846 /* No symbol information has been set - therefore determine
1847 it from the bfd symbol flags/info. */
1848 if (s->symbol.section == bfd_abs_section_ptr)
1849 s->n_type = BFD_MACH_O_N_ABS;
1850 else if (s->symbol.section == bfd_und_section_ptr)
1852 s->n_type = BFD_MACH_O_N_UNDF;
1853 if (s->symbol.flags & BSF_WEAK)
1854 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1855 /* mach-o automatically makes undefined symbols extern. */
1856 s->n_type |= BFD_MACH_O_N_EXT;
1857 s->symbol.flags |= BSF_GLOBAL;
1859 else if (s->symbol.section == bfd_com_section_ptr)
1861 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1862 s->symbol.flags |= BSF_GLOBAL;
1865 s->n_type = BFD_MACH_O_N_SECT;
1867 if (s->symbol.flags & BSF_GLOBAL)
1868 s->n_type |= BFD_MACH_O_N_EXT;
1871 /* Put the section index in, where required. */
1872 if ((s->symbol.section != bfd_abs_section_ptr
1873 && s->symbol.section != bfd_und_section_ptr
1874 && s->symbol.section != bfd_com_section_ptr)
1875 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1876 && s->symbol.name == NULL))
1877 s->n_sect = s->symbol.section->target_index;
1879 /* Number to preserve order for local and debug syms. */
1880 s->symbol.udata.i = i;
1883 /* Sort the symbols. */
1884 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
1885 sizeof (asymbol *), bfd_mach_o_cf_symbols);
1887 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1889 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1890 s->symbol.udata.i = i; /* renumber. */
1896 /* We build a flat table of sections, which can be re-ordered if necessary.
1897 Fill in the section number and other mach-o-specific data. */
1900 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1903 unsigned target_index;
1906 nsect = bfd_count_sections (abfd);
1908 /* Don't do it if it's already set - assume the application knows what it's
1910 if (mdata->nsects == nsect
1911 && (mdata->nsects == 0 || mdata->sections != NULL))
1914 mdata->nsects = nsect;
1915 mdata->sections = bfd_alloc (abfd,
1916 mdata->nsects * sizeof (bfd_mach_o_section *));
1917 if (mdata->sections == NULL)
1920 /* We need to check that this can be done... */
1922 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1923 " maximum is 255,\n"), nsect);
1925 /* Create Mach-O sections.
1926 Section type, attribute and align should have been set when the
1927 section was created - either read in or specified. */
1929 for (sec = abfd->sections; sec; sec = sec->next)
1931 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1932 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1934 mdata->sections[target_index] = msect;
1936 msect->addr = bfd_get_section_vma (abfd, sec);
1937 msect->size = bfd_get_section_size (sec);
1939 /* Use the largest alignment set, in case it was bumped after the
1940 section was created. */
1941 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1944 sec->target_index = ++target_index;
1951 bfd_mach_o_write_contents (bfd *abfd)
1954 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1956 /* Make the commands, if not already present. */
1957 if (mdata->header.ncmds == 0)
1958 if (!bfd_mach_o_build_commands (abfd))
1961 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1964 for (i = 0; i < mdata->header.ncmds; i++)
1966 struct mach_o_load_command_external raw;
1967 bfd_mach_o_load_command *cur = &mdata->commands[i];
1968 unsigned long typeflag;
1970 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1972 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1973 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1975 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1976 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1981 case BFD_MACH_O_LC_SEGMENT:
1982 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1985 case BFD_MACH_O_LC_SEGMENT_64:
1986 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1989 case BFD_MACH_O_LC_SYMTAB:
1990 if (!bfd_mach_o_write_symtab (abfd, cur))
1993 case BFD_MACH_O_LC_DYSYMTAB:
1994 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1997 case BFD_MACH_O_LC_SYMSEG:
1999 case BFD_MACH_O_LC_THREAD:
2000 case BFD_MACH_O_LC_UNIXTHREAD:
2001 if (bfd_mach_o_write_thread (abfd, cur) != 0)
2004 case BFD_MACH_O_LC_LOADFVMLIB:
2005 case BFD_MACH_O_LC_IDFVMLIB:
2006 case BFD_MACH_O_LC_IDENT:
2007 case BFD_MACH_O_LC_FVMFILE:
2008 case BFD_MACH_O_LC_PREPAGE:
2009 case BFD_MACH_O_LC_LOAD_DYLIB:
2010 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2011 case BFD_MACH_O_LC_ID_DYLIB:
2012 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2013 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
2014 case BFD_MACH_O_LC_LOAD_DYLINKER:
2015 case BFD_MACH_O_LC_ID_DYLINKER:
2016 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2017 case BFD_MACH_O_LC_ROUTINES:
2018 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2021 (*_bfd_error_handler)
2022 (_("unable to write unknown load command 0x%lx"),
2023 (unsigned long) cur->type);
2032 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2035 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
2036 if (seg->sect_head == NULL)
2039 seg->sect_tail->next = s;
2043 /* Create section Mach-O flags from BFD flags. */
2046 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2050 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2052 /* Create default flags. */
2053 bfd_flags = bfd_get_section_flags (abfd, sec);
2054 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2055 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2056 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2057 | BFD_MACH_O_S_REGULAR;
2058 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2059 s->flags = BFD_MACH_O_S_ZEROFILL;
2060 else if (bfd_flags & SEC_DEBUGGING)
2061 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2063 s->flags = BFD_MACH_O_S_REGULAR;
2066 /* Count the number of sections in the list for the segment named.
2068 The special case of NULL or "" for the segment name is valid for
2069 an MH_OBJECT file and means 'all sections available'.
2071 Requires that the sections table in mdata be filled in.
2073 Returns the number of sections (0 is valid).
2074 Any number > 255 signals an invalid section count, although we will,
2075 perhaps, allow the file to be written (in line with Darwin tools up
2078 A section count of (unsigned long) -1 signals a definite error. */
2080 static unsigned long
2081 bfd_mach_o_count_sections_for_seg (const char *segment,
2082 bfd_mach_o_data_struct *mdata)
2085 if (mdata == NULL || mdata->sections == NULL)
2086 return (unsigned long) -1;
2088 /* The MH_OBJECT case, all sections are considered; Although nsects is
2089 is an unsigned long, the maximum valid section count is 255 and this
2090 will have been checked already by mangle_sections. */
2091 if (segment == NULL || segment[0] == '\0')
2092 return mdata->nsects;
2094 /* Count the number of sections we see in this segment. */
2096 for (i = 0; i < mdata->nsects; ++i)
2098 bfd_mach_o_section *s = mdata->sections[i];
2099 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2106 bfd_mach_o_build_seg_command (const char *segment,
2107 bfd_mach_o_data_struct *mdata,
2108 bfd_mach_o_segment_command *seg)
2111 int is_mho = (segment == NULL || segment[0] == '\0');
2113 /* Fill segment command. */
2115 memset (seg->segname, 0, sizeof (seg->segname));
2117 strncpy (seg->segname, segment, sizeof (seg->segname));
2119 /* TODO: fix this up for non-MH_OBJECT cases. */
2123 seg->fileoff = mdata->filelen;
2125 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2126 | BFD_MACH_O_PROT_EXECUTE;
2127 seg->initprot = seg->maxprot;
2129 seg->sect_head = NULL;
2130 seg->sect_tail = NULL;
2132 /* Append sections to the segment.
2134 This is a little tedious, we have to honor the need to account zerofill
2135 sections after all the rest. This forces us to do the calculation of
2136 total vmsize in three passes so that any alignment increments are
2137 properly accounted. */
2139 for (i = 0; i < mdata->nsects; ++i)
2141 bfd_mach_o_section *s = mdata->sections[i];
2142 asection *sec = s->bfdsection;
2144 /* If we're not making an MH_OBJECT, check whether this section is from
2145 our segment, and skip if not. Otherwise, just add all sections. */
2147 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2150 /* Although we account for zerofill section sizes in vm order, they are
2151 placed in the file in source sequence. */
2152 bfd_mach_o_append_section_to_segment (seg, sec);
2155 /* Zerofill sections have zero file size & offset,
2156 and are not written. */
2157 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2158 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2159 == BFD_MACH_O_S_GB_ZEROFILL)
2164 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2165 seg->vmsize += s->size;
2167 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2168 seg->filesize += s->size;
2170 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2171 s->offset = mdata->filelen;
2174 sec->filepos = s->offset;
2175 mdata->filelen += s->size;
2178 /* Now pass through again, for zerofill, only now we just update the
2180 for (i = 0; i < mdata->nsects; ++i)
2182 bfd_mach_o_section *s = mdata->sections[i];
2184 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2188 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2193 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2194 seg->vmsize += s->size;
2198 /* Now pass through again, for zerofill_GB. */
2199 for (i = 0; i < mdata->nsects; ++i)
2201 bfd_mach_o_section *s = mdata->sections[i];
2203 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2207 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2212 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2213 seg->vmsize += s->size;
2217 /* Allocate space for the relocations. */
2218 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
2220 for (i = 0; i < mdata->nsects; ++i)
2222 bfd_mach_o_section *ms = mdata->sections[i];
2223 asection *sec = ms->bfdsection;
2225 if ((ms->nreloc = sec->reloc_count) == 0)
2230 sec->rel_filepos = mdata->filelen;
2231 ms->reloff = sec->rel_filepos;
2232 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2238 /* Count the number of indirect symbols in the image.
2239 Requires that the sections are in their final order. */
2242 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2245 unsigned int nisyms = 0;
2247 for (i = 0; i < mdata->nsects; ++i)
2249 bfd_mach_o_section *sec = mdata->sections[i];
2251 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2253 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2254 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2255 case BFD_MACH_O_S_SYMBOL_STUBS:
2256 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2266 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2267 bfd_mach_o_data_struct *mdata,
2268 bfd_mach_o_load_command *cmd)
2270 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2273 We are not going to try and fill these in yet and, moreover, we are
2274 going to bail if they are already set. */
2275 if (dsym->nmodtab != 0
2277 || dsym->nextrefsyms != 0)
2279 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2280 " implemented for dysymtab commands."));
2284 dsym->ilocalsym = 0;
2286 if (bfd_get_symcount (abfd) > 0)
2288 asymbol **symbols = bfd_get_outsymbols (abfd);
2291 /* Count the number of each kind of symbol. */
2292 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2294 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2295 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2298 dsym->nlocalsym = i;
2299 dsym->iextdefsym = i;
2300 for (; i < bfd_get_symcount (abfd); ++i)
2302 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2303 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2306 dsym->nextdefsym = i - dsym->nlocalsym;
2307 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2308 dsym->nundefsym = bfd_get_symcount (abfd)
2314 dsym->nlocalsym = 0;
2315 dsym->iextdefsym = 0;
2316 dsym->nextdefsym = 0;
2317 dsym->iundefsym = 0;
2318 dsym->nundefsym = 0;
2321 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2322 if (dsym->nindirectsyms > 0)
2327 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2328 dsym->indirectsymoff = mdata->filelen;
2329 mdata->filelen += dsym->nindirectsyms * 4;
2331 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2332 if (dsym->indirect_syms == NULL)
2336 for (i = 0; i < mdata->nsects; ++i)
2338 bfd_mach_o_section *sec = mdata->sections[i];
2340 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2342 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2343 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2344 case BFD_MACH_O_S_SYMBOL_STUBS:
2347 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2349 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2350 if (isyms == NULL || num == 0)
2352 /* Record the starting index in the reserved1 field. */
2354 for (j = 0; j < num; j++, n++)
2356 if (isyms[j] == NULL)
2357 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2358 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2359 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2360 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2361 | BFD_MACH_O_INDIRECT_SYM_ABS;
2363 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2376 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2377 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2378 and copy functionality. */
2381 bfd_mach_o_build_commands (bfd *abfd)
2383 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2384 unsigned wide = mach_o_wide_p (&mdata->header);
2385 int segcmd_idx = -1;
2386 int symtab_idx = -1;
2387 int dysymtab_idx = -1;
2388 unsigned long base_offset = 0;
2390 /* Return now if commands are already present. */
2391 if (mdata->header.ncmds)
2394 /* Fill in the file type, if not already set. */
2396 if (mdata->header.filetype == 0)
2398 if (abfd->flags & EXEC_P)
2399 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2400 else if (abfd->flags & DYNAMIC)
2401 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2403 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2406 /* If hasn't already been done, flatten sections list, and sort
2407 if/when required. Must be done before the symbol table is adjusted,
2408 since that depends on properly numbered sections. */
2409 if (mdata->nsects == 0 || mdata->sections == NULL)
2410 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2413 /* Order the symbol table, fill-in/check mach-o specific fields and
2414 partition out any indirect symbols. */
2415 if (!bfd_mach_o_mangle_symbols (abfd))
2418 /* Very simple command set (only really applicable to MH_OBJECTs):
2419 All the commands are optional - present only when there is suitable data.
2420 (i.e. it is valid to have an empty file)
2422 a command (segment) to contain all the sections,
2423 command for the symbol table,
2424 a command for the dysymtab.
2426 ??? maybe we should assert that this is an MH_OBJECT? */
2428 if (mdata->nsects > 0)
2431 mdata->header.ncmds = 1;
2434 if (bfd_get_symcount (abfd) > 0)
2436 mdata->header.ncmds++;
2437 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2441 This is a rather crude test for whether we should build a dysymtab. */
2442 if (bfd_mach_o_should_emit_dysymtab ()
2443 && bfd_get_symcount (abfd))
2445 mdata->header.ncmds++;
2446 /* If there should be a case where a dysymtab could be emitted without
2447 a symtab (seems improbable), this would need amending. */
2448 dysymtab_idx = symtab_idx + 1;
2452 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2454 base_offset = BFD_MACH_O_HEADER_SIZE;
2456 /* Well, we must have a header, at least. */
2457 mdata->filelen = base_offset;
2459 /* A bit unusual, but no content is valid;
2460 as -n empty.s -o empty.o */
2461 if (mdata->header.ncmds == 0)
2464 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2465 * sizeof (bfd_mach_o_load_command));
2466 if (mdata->commands == NULL)
2469 if (segcmd_idx >= 0)
2471 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2472 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2474 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2475 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2476 if (seg->nsects == (unsigned long) -1)
2479 /* Init segment command. */
2480 cmd->offset = base_offset;
2483 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2484 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2485 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2489 cmd->type = BFD_MACH_O_LC_SEGMENT;
2490 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2491 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2494 cmd->type_required = FALSE;
2495 mdata->header.sizeofcmds = cmd->len;
2496 mdata->filelen += cmd->len;
2499 if (symtab_idx >= 0)
2501 /* Init symtab command. */
2502 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2504 cmd->type = BFD_MACH_O_LC_SYMTAB;
2505 cmd->offset = base_offset;
2506 if (segcmd_idx >= 0)
2507 cmd->offset += mdata->commands[segcmd_idx].len;
2509 cmd->len = sizeof (struct mach_o_symtab_command_external)
2510 + BFD_MACH_O_LC_SIZE;
2511 cmd->type_required = FALSE;
2512 mdata->header.sizeofcmds += cmd->len;
2513 mdata->filelen += cmd->len;
2516 /* If required, setup symtab command, see comment above about the quality
2518 if (dysymtab_idx >= 0)
2520 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2522 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2523 if (symtab_idx >= 0)
2524 cmd->offset = mdata->commands[symtab_idx].offset
2525 + mdata->commands[symtab_idx].len;
2526 else if (segcmd_idx >= 0)
2527 cmd->offset = mdata->commands[segcmd_idx].offset
2528 + mdata->commands[segcmd_idx].len;
2530 cmd->offset = base_offset;
2532 cmd->type_required = FALSE;
2533 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2534 + BFD_MACH_O_LC_SIZE;
2536 mdata->header.sizeofcmds += cmd->len;
2537 mdata->filelen += cmd->len;
2540 /* So, now we have sized the commands and the filelen set to that.
2541 Now we can build the segment command and set the section file offsets. */
2543 && ! bfd_mach_o_build_seg_command
2544 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2547 /* If we're doing a dysymtab, cmd points to its load command. */
2548 if (dysymtab_idx >= 0
2549 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2550 &mdata->commands[dysymtab_idx]))
2553 /* The symtab command is filled in when the symtab is written. */
2557 /* Set the contents of a section. */
2560 bfd_mach_o_set_section_contents (bfd *abfd,
2562 const void * location,
2564 bfd_size_type count)
2568 /* Trying to write the first section contents will trigger the creation of
2569 the load commands if they are not already present. */
2570 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2576 pos = section->filepos + offset;
2577 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2578 || bfd_bwrite (location, count, abfd) != count)
2585 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2586 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2591 /* Make an empty symbol. This is required only because
2592 bfd_make_section_anyway wants to create a symbol for the section. */
2595 bfd_mach_o_make_empty_symbol (bfd *abfd)
2597 asymbol *new_symbol;
2599 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2600 if (new_symbol == NULL)
2602 new_symbol->the_bfd = abfd;
2603 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2608 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2610 struct mach_o_header_external raw;
2612 bfd_vma (*get32) (const void *) = NULL;
2614 /* Just read the magic number. */
2615 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2616 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2619 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2621 header->byteorder = BFD_ENDIAN_BIG;
2622 header->magic = BFD_MACH_O_MH_MAGIC;
2623 header->version = 1;
2626 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2628 header->byteorder = BFD_ENDIAN_LITTLE;
2629 header->magic = BFD_MACH_O_MH_MAGIC;
2630 header->version = 1;
2633 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2635 header->byteorder = BFD_ENDIAN_BIG;
2636 header->magic = BFD_MACH_O_MH_MAGIC_64;
2637 header->version = 2;
2640 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2642 header->byteorder = BFD_ENDIAN_LITTLE;
2643 header->magic = BFD_MACH_O_MH_MAGIC_64;
2644 header->version = 2;
2649 header->byteorder = BFD_ENDIAN_UNKNOWN;
2653 /* Once the size of the header is known, read the full header. */
2654 size = mach_o_wide_p (header) ?
2655 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2657 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2658 || bfd_bread (&raw, size, abfd) != size)
2661 header->cputype = (*get32) (raw.cputype);
2662 header->cpusubtype = (*get32) (raw.cpusubtype);
2663 header->filetype = (*get32) (raw.filetype);
2664 header->ncmds = (*get32) (raw.ncmds);
2665 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2666 header->flags = (*get32) (raw.flags);
2668 if (mach_o_wide_p (header))
2669 header->reserved = (*get32) (raw.reserved);
2671 header->reserved = 0;
2677 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2679 bfd_mach_o_section *s;
2680 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2682 s = bfd_mach_o_get_mach_o_section (sec);
2686 static const mach_o_section_name_xlat * xlat;
2688 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2691 sec->used_by_bfd = s;
2692 s->bfdsection = sec;
2694 /* Create the Darwin seg/sect name pair from the bfd name.
2695 If this is a canonical name for which a specific paiting exists
2696 there will also be defined flags, type, attribute and alignment
2698 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2701 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2702 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2704 (void) bfd_set_section_alignment (abfd, sec, s->align);
2705 bfd_flags = bfd_get_section_flags (abfd, sec);
2706 if (bfd_flags == SEC_NO_FLAGS)
2707 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2710 /* Create default flags. */
2711 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2714 return _bfd_generic_new_section_hook (abfd, sec);
2718 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2722 bfd_mach_o_section *section;
2724 flags = bfd_get_section_flags (abfd, sec);
2725 section = bfd_mach_o_get_mach_o_section (sec);
2727 /* TODO: see if we should use the xlat system for doing this by
2728 preference and fall back to this for unknown sections. */
2730 if (flags == SEC_NO_FLAGS)
2732 /* Try to guess flags. */
2733 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2734 flags = SEC_DEBUGGING;
2738 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2739 != BFD_MACH_O_S_ZEROFILL)
2742 if (prot & BFD_MACH_O_PROT_EXECUTE)
2744 if (prot & BFD_MACH_O_PROT_WRITE)
2746 else if (prot & BFD_MACH_O_PROT_READ)
2747 flags |= SEC_READONLY;
2753 if ((flags & SEC_DEBUGGING) == 0)
2757 if (section->offset != 0)
2758 flags |= SEC_HAS_CONTENTS;
2759 if (section->nreloc != 0)
2762 bfd_set_section_flags (abfd, sec, flags);
2764 sec->vma = section->addr;
2765 sec->lma = section->addr;
2766 sec->size = section->size;
2767 sec->filepos = section->offset;
2768 sec->alignment_power = section->align;
2769 sec->segment_mark = 0;
2770 sec->reloc_count = section->nreloc;
2771 sec->rel_filepos = section->reloff;
2775 bfd_mach_o_make_bfd_section (bfd *abfd,
2776 const unsigned char *segname,
2777 const unsigned char *sectname)
2782 bfd_mach_o_convert_section_name_to_bfd
2783 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2787 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2791 bfd_mach_o_read_section_32 (bfd *abfd,
2792 unsigned int offset,
2795 struct mach_o_section_32_external raw;
2797 bfd_mach_o_section *section;
2799 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2800 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2801 != BFD_MACH_O_SECTION_SIZE))
2804 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2808 section = bfd_mach_o_get_mach_o_section (sec);
2809 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2810 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2811 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2812 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2813 section->addr = bfd_h_get_32 (abfd, raw.addr);
2814 section->size = bfd_h_get_32 (abfd, raw.size);
2815 section->offset = bfd_h_get_32 (abfd, raw.offset);
2816 section->align = bfd_h_get_32 (abfd, raw.align);
2817 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2818 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2819 section->flags = bfd_h_get_32 (abfd, raw.flags);
2820 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2821 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2822 section->reserved3 = 0;
2824 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2830 bfd_mach_o_read_section_64 (bfd *abfd,
2831 unsigned int offset,
2834 struct mach_o_section_64_external raw;
2836 bfd_mach_o_section *section;
2838 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2839 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2840 != BFD_MACH_O_SECTION_64_SIZE))
2843 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2847 section = bfd_mach_o_get_mach_o_section (sec);
2848 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2849 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2850 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2851 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2852 section->addr = bfd_h_get_64 (abfd, raw.addr);
2853 section->size = bfd_h_get_64 (abfd, raw.size);
2854 section->offset = bfd_h_get_32 (abfd, raw.offset);
2855 section->align = bfd_h_get_32 (abfd, raw.align);
2856 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2857 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2858 section->flags = bfd_h_get_32 (abfd, raw.flags);
2859 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2860 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2861 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2863 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2869 bfd_mach_o_read_section (bfd *abfd,
2870 unsigned int offset,
2875 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2877 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2881 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2882 bfd_mach_o_symtab_command *sym,
2883 bfd_mach_o_asymbol *s,
2886 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2887 unsigned int wide = mach_o_wide_p (&mdata->header);
2888 unsigned int symwidth =
2889 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2890 unsigned int symoff = sym->symoff + (i * symwidth);
2891 struct mach_o_nlist_64_external raw;
2892 unsigned char type = -1;
2893 unsigned char section = -1;
2895 symvalue value = -1;
2896 unsigned long stroff = -1;
2897 unsigned int symtype = -1;
2899 BFD_ASSERT (sym->strtab != NULL);
2901 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2902 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2904 (*_bfd_error_handler)
2905 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2906 symwidth, (unsigned long) symoff);
2910 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2911 type = bfd_h_get_8 (abfd, raw.n_type);
2912 symtype = type & BFD_MACH_O_N_TYPE;
2913 section = bfd_h_get_8 (abfd, raw.n_sect);
2914 desc = bfd_h_get_16 (abfd, raw.n_desc);
2916 value = bfd_h_get_64 (abfd, raw.n_value);
2918 value = bfd_h_get_32 (abfd, raw.n_value);
2920 if (stroff >= sym->strsize)
2922 (*_bfd_error_handler)
2923 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2924 (unsigned long) stroff,
2925 (unsigned long) sym->strsize);
2929 s->symbol.the_bfd = abfd;
2930 s->symbol.name = sym->strtab + stroff;
2931 s->symbol.value = value;
2932 s->symbol.flags = 0x0;
2933 s->symbol.udata.i = i;
2935 s->n_sect = section;
2938 if (type & BFD_MACH_O_N_STAB)
2940 s->symbol.flags |= BSF_DEBUGGING;
2941 s->symbol.section = bfd_und_section_ptr;
2953 if ((section > 0) && (section <= mdata->nsects))
2955 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2957 s->symbol.value - mdata->sections[section - 1]->addr;
2964 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2965 s->symbol.flags |= BSF_GLOBAL;
2967 s->symbol.flags |= BSF_LOCAL;
2971 case BFD_MACH_O_N_UNDF:
2972 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2973 && s->symbol.value != 0)
2975 /* A common symbol. */
2976 s->symbol.section = bfd_com_section_ptr;
2977 s->symbol.flags = BSF_NO_FLAGS;
2981 s->symbol.section = bfd_und_section_ptr;
2982 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2983 s->symbol.flags |= BSF_WEAK;
2986 case BFD_MACH_O_N_PBUD:
2987 s->symbol.section = bfd_und_section_ptr;
2989 case BFD_MACH_O_N_ABS:
2990 s->symbol.section = bfd_abs_section_ptr;
2992 case BFD_MACH_O_N_SECT:
2993 if ((section > 0) && (section <= mdata->nsects))
2995 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2997 s->symbol.value - mdata->sections[section - 1]->addr;
3001 /* Mach-O uses 0 to mean "no section"; not an error. */
3004 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3005 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3006 s->symbol.name, section, mdata->nsects);
3008 s->symbol.section = bfd_und_section_ptr;
3011 case BFD_MACH_O_N_INDR:
3012 /* FIXME: we don't follow the BFD convention as this indirect symbol
3013 won't be followed by the referenced one. This looks harmless
3014 unless we start using the linker. */
3015 s->symbol.flags |= BSF_INDIRECT;
3016 s->symbol.section = bfd_ind_section_ptr;
3017 s->symbol.value = 0;
3020 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3021 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3022 s->symbol.name, symtype);
3023 s->symbol.section = bfd_und_section_ptr;
3032 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3034 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3035 bfd_mach_o_symtab_command *sym = mdata->symtab;
3037 /* Fail if there is no symtab. */
3041 /* Success if already loaded. */
3045 if (abfd->flags & BFD_IN_MEMORY)
3047 struct bfd_in_memory *b;
3049 b = (struct bfd_in_memory *) abfd->iostream;
3051 if ((sym->stroff + sym->strsize) > b->size)
3053 bfd_set_error (bfd_error_file_truncated);
3056 sym->strtab = (char *) b->buffer + sym->stroff;
3060 sym->strtab = bfd_alloc (abfd, sym->strsize);
3061 if (sym->strtab == NULL)
3064 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3065 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3067 bfd_set_error (bfd_error_file_truncated);
3076 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3078 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3079 bfd_mach_o_symtab_command *sym = mdata->symtab;
3082 if (sym == NULL || sym->symbols)
3084 /* Return now if there are no symbols or if already loaded. */
3088 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3090 if (sym->symbols == NULL)
3092 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3096 if (!bfd_mach_o_read_symtab_strtab (abfd))
3099 for (i = 0; i < sym->nsyms; i++)
3101 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3109 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3111 switch ((int) flavour)
3113 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3114 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3115 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3116 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3117 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3118 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3119 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3120 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3121 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3122 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3123 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3124 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3125 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3126 default: return "UNKNOWN";
3131 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3133 switch ((int) flavour)
3135 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3136 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3137 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3138 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3139 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3140 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3141 default: return "UNKNOWN";
3146 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3148 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3149 struct mach_o_str_command_external raw;
3150 unsigned int nameoff;
3152 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3153 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3156 nameoff = bfd_h_get_32 (abfd, raw.str);
3158 cmd->name_offset = command->offset + nameoff;
3159 cmd->name_len = command->len - nameoff;
3160 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3161 if (cmd->name_str == NULL)
3163 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3164 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3170 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3172 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3173 struct mach_o_dylib_command_external raw;
3174 unsigned int nameoff;
3176 switch (command->type)
3178 case BFD_MACH_O_LC_LOAD_DYLIB:
3179 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3180 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3181 case BFD_MACH_O_LC_ID_DYLIB:
3182 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3183 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3190 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3191 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3194 nameoff = bfd_h_get_32 (abfd, raw.name);
3195 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3196 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3197 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3199 cmd->name_offset = command->offset + nameoff;
3200 cmd->name_len = command->len - nameoff;
3201 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3202 if (cmd->name_str == NULL)
3204 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3205 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3211 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
3212 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3214 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3216 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3221 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3223 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3224 struct mach_o_fvmlib_command_external raw;
3225 unsigned int nameoff;
3227 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3228 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3231 nameoff = bfd_h_get_32 (abfd, raw.name);
3232 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3233 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3235 fvm->name_offset = command->offset + nameoff;
3236 fvm->name_len = command->len - nameoff;
3237 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3238 if (fvm->name_str == NULL)
3240 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3241 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3247 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3249 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3250 bfd_mach_o_thread_command *cmd = &command->command.thread;
3251 unsigned int offset;
3252 unsigned int nflavours;
3255 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3256 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3258 /* Count the number of threads. */
3261 while (offset != command->len)
3263 struct mach_o_thread_command_external raw;
3265 if (offset >= command->len)
3268 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3269 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3272 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3276 /* Allocate threads. */
3277 cmd->flavours = bfd_alloc
3278 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3279 if (cmd->flavours == NULL)
3281 cmd->nflavours = nflavours;
3285 while (offset != command->len)
3287 struct mach_o_thread_command_external raw;
3289 if (offset >= command->len)
3292 if (nflavours >= cmd->nflavours)
3295 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3296 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3299 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3300 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3301 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3302 offset += cmd->flavours[nflavours].size + sizeof (raw);
3306 for (i = 0; i < nflavours; i++)
3309 unsigned int snamelen;
3311 const char *flavourstr;
3312 const char *prefix = "LC_THREAD";
3315 switch (mdata->header.cputype)
3317 case BFD_MACH_O_CPU_TYPE_POWERPC:
3318 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3319 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3321 case BFD_MACH_O_CPU_TYPE_I386:
3322 case BFD_MACH_O_CPU_TYPE_X86_64:
3323 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3326 flavourstr = "UNKNOWN_ARCHITECTURE";
3330 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3331 sname = bfd_alloc (abfd, snamelen);
3337 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3338 if (bfd_get_section_by_name (abfd, sname) == NULL)
3343 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3347 bfdsec->size = cmd->flavours[i].size;
3348 bfdsec->filepos = cmd->flavours[i].offset;
3349 bfdsec->alignment_power = 0x0;
3351 cmd->section = bfdsec;
3358 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3360 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3361 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3363 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3366 struct mach_o_dysymtab_command_external raw;
3368 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3369 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3372 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3373 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3374 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3375 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3376 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3377 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3378 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3379 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3380 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3381 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3382 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3383 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3384 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3385 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3386 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3387 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3388 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3389 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3392 if (cmd->nmodtab != 0)
3395 int wide = bfd_mach_o_wide_p (abfd);
3396 unsigned int module_len = wide ? 56 : 52;
3399 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3400 if (cmd->dylib_module == NULL)
3403 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3406 for (i = 0; i < cmd->nmodtab; i++)
3408 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3410 unsigned char buf[56];
3412 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3415 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3416 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3417 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3418 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3419 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3420 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3421 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3422 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3423 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3424 v = bfd_h_get_32 (abfd, buf +36);
3425 module->iinit = v & 0xffff;
3426 module->iterm = (v >> 16) & 0xffff;
3427 v = bfd_h_get_32 (abfd, buf + 40);
3428 module->ninit = v & 0xffff;
3429 module->nterm = (v >> 16) & 0xffff;
3432 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3433 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3437 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3438 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3447 cmd->dylib_toc = bfd_alloc
3448 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3449 if (cmd->dylib_toc == NULL)
3452 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3455 for (i = 0; i < cmd->ntoc; i++)
3457 struct mach_o_dylib_table_of_contents_external raw;
3458 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3460 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3463 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3464 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3468 if (cmd->nindirectsyms != 0)
3472 cmd->indirect_syms = bfd_alloc
3473 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3474 if (cmd->indirect_syms == NULL)
3477 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3480 for (i = 0; i < cmd->nindirectsyms; i++)
3482 unsigned char raw[4];
3483 unsigned int *is = &cmd->indirect_syms[i];
3485 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3488 *is = bfd_h_get_32 (abfd, raw);
3492 if (cmd->nextrefsyms != 0)
3497 cmd->ext_refs = bfd_alloc
3498 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3499 if (cmd->ext_refs == NULL)
3502 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3505 for (i = 0; i < cmd->nextrefsyms; i++)
3507 unsigned char raw[4];
3508 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3510 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3513 /* Fields isym and flags are written as bit-fields, thus we need
3514 a specific processing for endianness. */
3515 v = bfd_h_get_32 (abfd, raw);
3516 if (bfd_big_endian (abfd))
3518 ref->isym = (v >> 8) & 0xffffff;
3519 ref->flags = v & 0xff;
3523 ref->isym = v & 0xffffff;
3524 ref->flags = (v >> 24) & 0xff;
3529 if (mdata->dysymtab)
3531 mdata->dysymtab = cmd;
3537 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3539 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3540 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3541 struct mach_o_symtab_command_external raw;
3543 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3545 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3546 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3549 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3550 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3551 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3552 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3553 symtab->symbols = NULL;
3554 symtab->strtab = NULL;
3556 if (symtab->nsyms != 0)
3557 abfd->flags |= HAS_SYMS;
3561 mdata->symtab = symtab;
3566 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3568 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3570 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3572 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3573 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3580 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3582 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3583 struct mach_o_linkedit_data_command_external raw;
3585 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3586 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3589 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3590 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3595 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3597 bfd_mach_o_str_command *cmd = &command->command.str;
3598 struct mach_o_str_command_external raw;
3601 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3602 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3605 off = bfd_get_32 (abfd, raw.str);
3606 cmd->stroff = command->offset + off;
3607 cmd->str_len = command->len - off;
3608 cmd->str = bfd_alloc (abfd, cmd->str_len);
3609 if (cmd->str == NULL)
3611 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3612 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3618 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3620 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3621 struct mach_o_dyld_info_command_external raw;
3623 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3624 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3627 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3628 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3629 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3630 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3631 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3632 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3633 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3634 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3635 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3636 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3641 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3643 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3644 struct mach_o_version_min_command_external raw;
3647 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3648 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3651 ver = bfd_get_32 (abfd, raw.version);
3652 cmd->rel = ver >> 16;
3653 cmd->maj = ver >> 8;
3655 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3660 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3662 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3663 struct mach_o_encryption_info_command_external raw;
3665 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3666 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3669 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3670 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3671 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3676 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3678 bfd_mach_o_main_command *cmd = &command->command.main;
3679 struct mach_o_entry_point_command_external raw;
3681 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3682 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3685 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3686 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3691 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3693 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3694 struct mach_o_source_version_command_external raw;
3697 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3698 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3701 ver = bfd_get_64 (abfd, raw.version);
3702 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3703 generates warnings) in case of the host doesn't support 64 bit
3705 cmd->e = ver & 0x3ff;
3707 cmd->d = ver & 0x3ff;
3709 cmd->c = ver & 0x3ff;
3711 cmd->b = ver & 0x3ff;
3713 cmd->a = ver & 0xffffff;
3718 bfd_mach_o_read_segment (bfd *abfd,
3719 bfd_mach_o_load_command *command,
3722 bfd_mach_o_segment_command *seg = &command->command.segment;
3727 struct mach_o_segment_command_64_external raw;
3729 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3731 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3732 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3735 memcpy (seg->segname, raw.segname, 16);
3736 seg->segname[16] = '\0';
3738 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3739 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3740 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3741 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3742 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3743 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3744 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3745 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3749 struct mach_o_segment_command_32_external raw;
3751 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3753 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3754 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3757 memcpy (seg->segname, raw.segname, 16);
3758 seg->segname[16] = '\0';
3760 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3761 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3762 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3763 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3764 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3765 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3766 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3767 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3769 seg->sect_head = NULL;
3770 seg->sect_tail = NULL;
3772 for (i = 0; i < seg->nsects; i++)
3778 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3779 + (i * BFD_MACH_O_SECTION_64_SIZE);
3781 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3782 + (i * BFD_MACH_O_SECTION_SIZE);
3784 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3788 bfd_mach_o_append_section_to_segment (seg, sec);
3795 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3797 return bfd_mach_o_read_segment (abfd, command, 0);
3801 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3803 return bfd_mach_o_read_segment (abfd, command, 1);
3807 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3809 struct mach_o_load_command_external raw;
3812 /* Read command type and length. */
3813 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3814 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3817 cmd = bfd_h_get_32 (abfd, raw.cmd);
3818 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3819 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3820 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3822 switch (command->type)
3824 case BFD_MACH_O_LC_SEGMENT:
3825 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3828 case BFD_MACH_O_LC_SEGMENT_64:
3829 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3832 case BFD_MACH_O_LC_SYMTAB:
3833 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3836 case BFD_MACH_O_LC_SYMSEG:
3838 case BFD_MACH_O_LC_THREAD:
3839 case BFD_MACH_O_LC_UNIXTHREAD:
3840 if (bfd_mach_o_read_thread (abfd, command) != 0)
3843 case BFD_MACH_O_LC_LOAD_DYLINKER:
3844 case BFD_MACH_O_LC_ID_DYLINKER:
3845 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
3846 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3849 case BFD_MACH_O_LC_LOAD_DYLIB:
3850 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3851 case BFD_MACH_O_LC_ID_DYLIB:
3852 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3853 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3854 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3855 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3858 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3859 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3862 case BFD_MACH_O_LC_LOADFVMLIB:
3863 case BFD_MACH_O_LC_IDFVMLIB:
3864 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3867 case BFD_MACH_O_LC_IDENT:
3868 case BFD_MACH_O_LC_FVMFILE:
3869 case BFD_MACH_O_LC_PREPAGE:
3870 case BFD_MACH_O_LC_ROUTINES:
3871 case BFD_MACH_O_LC_ROUTINES_64:
3873 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3874 case BFD_MACH_O_LC_SUB_UMBRELLA:
3875 case BFD_MACH_O_LC_SUB_LIBRARY:
3876 case BFD_MACH_O_LC_SUB_CLIENT:
3877 case BFD_MACH_O_LC_RPATH:
3878 if (bfd_mach_o_read_str (abfd, command) != 0)
3881 case BFD_MACH_O_LC_DYSYMTAB:
3882 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3885 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3886 case BFD_MACH_O_LC_PREBIND_CKSUM:
3888 case BFD_MACH_O_LC_UUID:
3889 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3892 case BFD_MACH_O_LC_CODE_SIGNATURE:
3893 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3894 case BFD_MACH_O_LC_FUNCTION_STARTS:
3895 case BFD_MACH_O_LC_DATA_IN_CODE:
3896 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3897 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3900 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3901 if (!bfd_mach_o_read_encryption_info (abfd, command))
3904 case BFD_MACH_O_LC_DYLD_INFO:
3905 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3908 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3909 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3910 if (!bfd_mach_o_read_version_min (abfd, command))
3913 case BFD_MACH_O_LC_MAIN:
3914 if (!bfd_mach_o_read_main (abfd, command))
3917 case BFD_MACH_O_LC_SOURCE_VERSION:
3918 if (!bfd_mach_o_read_source_version (abfd, command))
3922 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3923 abfd, (unsigned long) command->type);
3931 bfd_mach_o_flatten_sections (bfd *abfd)
3933 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3937 /* Count total number of sections. */
3940 for (i = 0; i < mdata->header.ncmds; i++)
3942 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3943 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3945 bfd_mach_o_segment_command *seg;
3947 seg = &mdata->commands[i].command.segment;
3948 mdata->nsects += seg->nsects;
3952 /* Allocate sections array. */
3953 mdata->sections = bfd_alloc (abfd,
3954 mdata->nsects * sizeof (bfd_mach_o_section *));
3956 /* Fill the array. */
3959 for (i = 0; i < mdata->header.ncmds; i++)
3961 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3962 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3964 bfd_mach_o_segment_command *seg;
3965 bfd_mach_o_section *sec;
3967 seg = &mdata->commands[i].command.segment;
3968 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3970 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3971 mdata->sections[csect++] = sec;
3977 bfd_mach_o_scan_start_address (bfd *abfd)
3979 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3980 bfd_mach_o_thread_command *cmd = NULL;
3983 for (i = 0; i < mdata->header.ncmds; i++)
3984 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3985 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3987 cmd = &mdata->commands[i].command.thread;
3990 else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
3991 && mdata->nsects > 1)
3993 bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
3994 bfd_mach_o_section *text_sect = mdata->sections[0];
3997 abfd->start_address = main_cmd->entryoff
3998 + (text_sect->addr - text_sect->offset);
4003 /* An object file has no start address, so do not fail if not found. */
4007 /* FIXME: create a subtarget hook ? */
4008 for (i = 0; i < cmd->nflavours; i++)
4010 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4011 && (cmd->flavours[i].flavour
4012 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4014 unsigned char buf[4];
4016 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4017 || bfd_bread (buf, 4, abfd) != 4)
4020 abfd->start_address = bfd_h_get_32 (abfd, buf);
4022 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4023 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4025 unsigned char buf[4];
4027 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4028 || bfd_bread (buf, 4, abfd) != 4)
4031 abfd->start_address = bfd_h_get_32 (abfd, buf);
4033 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4034 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4036 unsigned char buf[8];
4038 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4039 || bfd_bread (buf, 8, abfd) != 8)
4042 abfd->start_address = bfd_h_get_64 (abfd, buf);
4044 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4045 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4047 unsigned char buf[8];
4049 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4050 || bfd_bread (buf, 8, abfd) != 8)
4053 abfd->start_address = bfd_h_get_64 (abfd, buf);
4061 bfd_mach_o_set_arch_mach (bfd *abfd,
4062 enum bfd_architecture arch,
4063 unsigned long machine)
4065 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4067 /* If this isn't the right architecture for this backend, and this
4068 isn't the generic backend, fail. */
4069 if (arch != bed->arch
4070 && arch != bfd_arch_unknown
4071 && bed->arch != bfd_arch_unknown)
4074 return bfd_default_set_arch_mach (abfd, arch, machine);
4078 bfd_mach_o_scan (bfd *abfd,
4079 bfd_mach_o_header *header,
4080 bfd_mach_o_data_struct *mdata)
4083 enum bfd_architecture cputype;
4084 unsigned long cpusubtype;
4085 unsigned int hdrsize;
4087 hdrsize = mach_o_wide_p (header) ?
4088 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4090 mdata->header = *header;
4092 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4093 switch (header->filetype)
4095 case BFD_MACH_O_MH_OBJECT:
4096 abfd->flags |= HAS_RELOC;
4098 case BFD_MACH_O_MH_EXECUTE:
4099 abfd->flags |= EXEC_P;
4101 case BFD_MACH_O_MH_DYLIB:
4102 case BFD_MACH_O_MH_BUNDLE:
4103 abfd->flags |= DYNAMIC;
4107 abfd->tdata.mach_o_data = mdata;
4109 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4110 &cputype, &cpusubtype);
4111 if (cputype == bfd_arch_unknown)
4113 (*_bfd_error_handler)
4114 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4115 header->cputype, header->cpusubtype);
4119 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4121 if (header->ncmds != 0)
4123 mdata->commands = bfd_alloc
4124 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4125 if (mdata->commands == NULL)
4128 for (i = 0; i < header->ncmds; i++)
4130 bfd_mach_o_load_command *cur = &mdata->commands[i];
4133 cur->offset = hdrsize;
4136 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4137 cur->offset = prev->offset + prev->len;
4140 if (bfd_mach_o_read_command (abfd, cur) < 0)
4145 /* Sections should be flatten before scanning start address. */
4146 bfd_mach_o_flatten_sections (abfd);
4147 if (!bfd_mach_o_scan_start_address (abfd))
4154 bfd_mach_o_mkobject_init (bfd *abfd)
4156 bfd_mach_o_data_struct *mdata = NULL;
4158 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4161 abfd->tdata.mach_o_data = mdata;
4163 mdata->header.magic = 0;
4164 mdata->header.cputype = 0;
4165 mdata->header.cpusubtype = 0;
4166 mdata->header.filetype = 0;
4167 mdata->header.ncmds = 0;
4168 mdata->header.sizeofcmds = 0;
4169 mdata->header.flags = 0;
4170 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4171 mdata->commands = NULL;
4173 mdata->sections = NULL;
4174 mdata->dyn_reloc_cache = NULL;
4180 bfd_mach_o_gen_mkobject (bfd *abfd)
4182 bfd_mach_o_data_struct *mdata;
4184 if (!bfd_mach_o_mkobject_init (abfd))
4187 mdata = bfd_mach_o_get_data (abfd);
4188 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4189 mdata->header.cputype = 0;
4190 mdata->header.cpusubtype = 0;
4191 mdata->header.byteorder = abfd->xvec->byteorder;
4192 mdata->header.version = 1;
4198 bfd_mach_o_header_p (bfd *abfd,
4199 bfd_mach_o_filetype filetype,
4200 bfd_mach_o_cpu_type cputype)
4202 bfd_mach_o_header header;
4203 bfd_mach_o_data_struct *mdata;
4205 if (!bfd_mach_o_read_header (abfd, &header))
4208 if (! (header.byteorder == BFD_ENDIAN_BIG
4209 || header.byteorder == BFD_ENDIAN_LITTLE))
4211 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4212 (unsigned long) header.byteorder);
4216 if (! ((header.byteorder == BFD_ENDIAN_BIG
4217 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4218 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4219 || (header.byteorder == BFD_ENDIAN_LITTLE
4220 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4221 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4224 /* Check cputype and filetype.
4225 In case of wildcard, do not accept magics that are handled by existing
4229 if (header.cputype != cputype)
4235 if (header.filetype != filetype)
4240 switch (header.filetype)
4242 case BFD_MACH_O_MH_CORE:
4243 /* Handled by core_p */
4250 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4254 if (!bfd_mach_o_scan (abfd, &header, mdata))
4260 bfd_set_error (bfd_error_wrong_format);
4266 static const bfd_target *
4267 bfd_mach_o_gen_object_p (bfd *abfd)
4269 return bfd_mach_o_header_p (abfd, 0, 0);
4272 static const bfd_target *
4273 bfd_mach_o_gen_core_p (bfd *abfd)
4275 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4278 /* Return the base address of ABFD, ie the address at which the image is
4279 mapped. The possible initial pagezero is ignored. */
4282 bfd_mach_o_get_base_address (bfd *abfd)
4284 bfd_mach_o_data_struct *mdata;
4287 /* Check for Mach-O. */
4288 if (!bfd_mach_o_valid (abfd))
4290 mdata = bfd_mach_o_get_data (abfd);
4292 for (i = 0; i < mdata->header.ncmds; i++)
4294 bfd_mach_o_load_command *cmd = &mdata->commands[i];
4295 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
4296 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
4298 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
4300 if (segcmd->initprot != 0)
4301 return segcmd->vmaddr;
4307 typedef struct mach_o_fat_archentry
4309 unsigned long cputype;
4310 unsigned long cpusubtype;
4311 unsigned long offset;
4313 unsigned long align;
4314 } mach_o_fat_archentry;
4316 typedef struct mach_o_fat_data_struct
4318 unsigned long magic;
4319 unsigned long nfat_arch;
4320 mach_o_fat_archentry *archentries;
4321 } mach_o_fat_data_struct;
4324 bfd_mach_o_archive_p (bfd *abfd)
4326 mach_o_fat_data_struct *adata = NULL;
4327 struct mach_o_fat_header_external hdr;
4330 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4331 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4334 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4338 adata->magic = bfd_getb32 (hdr.magic);
4339 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4340 if (adata->magic != 0xcafebabe)
4342 /* Avoid matching Java bytecode files, which have the same magic number.
4343 In the Java bytecode file format this field contains the JVM version,
4344 which starts at 43.0. */
4345 if (adata->nfat_arch > 30)
4348 adata->archentries =
4349 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4350 if (adata->archentries == NULL)
4353 for (i = 0; i < adata->nfat_arch; i++)
4355 struct mach_o_fat_arch_external arch;
4356 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4358 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4359 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4360 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4361 adata->archentries[i].size = bfd_getb32 (arch.size);
4362 adata->archentries[i].align = bfd_getb32 (arch.align);
4365 abfd->tdata.mach_o_fat_data = adata;
4370 bfd_release (abfd, adata);
4371 bfd_set_error (bfd_error_wrong_format);
4375 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4376 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4377 Set arelt_data and origin fields too. */
4380 bfd_mach_o_fat_member_init (bfd *abfd,
4381 enum bfd_architecture arch_type,
4382 unsigned long arch_subtype,
4383 mach_o_fat_archentry *entry)
4385 struct areltdata *areltdata;
4386 /* Create the member filename. Use ARCH_NAME. */
4387 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4391 /* Use the architecture name if known. */
4392 abfd->filename = xstrdup (ap->printable_name);
4396 /* Forge a uniq id. */
4397 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4398 char *name = xmalloc (namelen);
4399 snprintf (name, namelen, "0x%lx-0x%lx",
4400 entry->cputype, entry->cpusubtype);
4401 abfd->filename = name;
4404 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4405 areltdata->parsed_size = entry->size;
4406 abfd->arelt_data = areltdata;
4407 abfd->iostream = NULL;
4408 abfd->origin = entry->offset;
4412 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4414 mach_o_fat_data_struct *adata;
4415 mach_o_fat_archentry *entry = NULL;
4418 enum bfd_architecture arch_type;
4419 unsigned long arch_subtype;
4421 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4422 BFD_ASSERT (adata != NULL);
4424 /* Find index of previous entry. */
4427 /* Start at first one. */
4432 /* Find index of PREV. */
4433 for (i = 0; i < adata->nfat_arch; i++)
4435 if (adata->archentries[i].offset == prev->origin)
4439 if (i == adata->nfat_arch)
4442 bfd_set_error (bfd_error_bad_value);
4446 /* Get next entry. */
4450 if (i >= adata->nfat_arch)
4452 bfd_set_error (bfd_error_no_more_archived_files);
4456 entry = &adata->archentries[i];
4457 nbfd = _bfd_new_bfd_contained_in (archive);
4461 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4462 &arch_type, &arch_subtype);
4464 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4466 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4471 /* Analogous to stat call. */
4474 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4476 if (abfd->arelt_data == NULL)
4478 bfd_set_error (bfd_error_invalid_operation);
4485 buf->st_mode = 0644;
4486 buf->st_size = arelt_size (abfd);
4491 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4492 If ABFD is a fat image containing a member that corresponds to FORMAT
4493 and ARCH, returns it.
4494 In other case, returns NULL.
4495 This function allows transparent uses of fat images. */
4498 bfd_mach_o_fat_extract (bfd *abfd,
4500 const bfd_arch_info_type *arch)
4503 mach_o_fat_data_struct *adata;
4506 if (bfd_check_format (abfd, format))
4508 if (bfd_get_arch_info (abfd) == arch)
4512 if (!bfd_check_format (abfd, bfd_archive)
4513 || abfd->xvec != &mach_o_fat_vec)
4516 /* This is a Mach-O fat image. */
4517 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4518 BFD_ASSERT (adata != NULL);
4520 for (i = 0; i < adata->nfat_arch; i++)
4522 struct mach_o_fat_archentry *e = &adata->archentries[i];
4523 enum bfd_architecture cpu_type;
4524 unsigned long cpu_subtype;
4526 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4527 &cpu_type, &cpu_subtype);
4528 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4531 /* The architecture is found. */
4532 res = _bfd_new_bfd_contained_in (abfd);
4536 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4538 if (bfd_check_format (res, format))
4540 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4551 bfd_mach_o_lookup_command (bfd *abfd,
4552 bfd_mach_o_load_command_type type,
4553 bfd_mach_o_load_command **mcommand)
4555 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4556 bfd_mach_o_load_command *ncmd = NULL;
4557 unsigned int i, num;
4559 BFD_ASSERT (md != NULL);
4560 BFD_ASSERT (mcommand != NULL);
4563 for (i = 0; i < md->header.ncmds; i++)
4565 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4567 if (cmd->type != type)
4580 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4584 case BFD_MACH_O_CPU_TYPE_MC680x0:
4586 case BFD_MACH_O_CPU_TYPE_MC88000:
4588 case BFD_MACH_O_CPU_TYPE_POWERPC:
4590 case BFD_MACH_O_CPU_TYPE_I386:
4592 case BFD_MACH_O_CPU_TYPE_SPARC:
4594 case BFD_MACH_O_CPU_TYPE_I860:
4596 case BFD_MACH_O_CPU_TYPE_HPPA:
4597 return 0xc0000000 - 0x04000000;
4603 /* The following two tables should be kept, as far as possible, in order of
4604 most frequently used entries to optimize their use from gas. */
4606 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4608 { "regular", BFD_MACH_O_S_REGULAR},
4609 { "coalesced", BFD_MACH_O_S_COALESCED},
4610 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4611 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4612 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4613 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4614 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4615 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4616 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4617 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4618 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4619 { "interposing", BFD_MACH_O_S_INTERPOSING},
4620 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4621 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4622 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4623 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4624 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4628 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4630 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4631 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4632 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4633 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4634 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4635 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4636 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4637 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4638 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4639 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4640 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4644 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4647 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4649 const bfd_mach_o_xlat_name *x;
4650 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4652 for (x = bfd_mach_o_section_type_name; x->name; x++)
4653 if (strcmp (x->name, name) == 0)
4655 /* We found it... does the target support it? */
4656 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4657 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4658 return x->val; /* OK. */
4660 break; /* Not supported. */
4662 /* Maximum section ID = 0xff. */
4666 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4669 bfd_mach_o_get_section_attribute_from_name (const char *name)
4671 const bfd_mach_o_xlat_name *x;
4673 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4674 if (strcmp (x->name, name) == 0)
4676 return (unsigned int)-1;
4680 bfd_mach_o_core_fetch_environment (bfd *abfd,
4681 unsigned char **rbuf,
4684 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4685 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4688 for (i = 0; i < mdata->header.ncmds; i++)
4690 bfd_mach_o_load_command *cur = &mdata->commands[i];
4691 bfd_mach_o_segment_command *seg = NULL;
4693 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4696 seg = &cur->command.segment;
4698 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4700 unsigned long start = seg->fileoff;
4701 unsigned long end = seg->fileoff + seg->filesize;
4702 unsigned char *buf = bfd_malloc (1024);
4703 unsigned long size = 1024;
4707 bfd_size_type nread = 0;
4708 unsigned long offset;
4709 int found_nonnull = 0;
4711 if (size > (end - start))
4712 size = (end - start);
4714 buf = bfd_realloc_or_free (buf, size);
4718 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4724 nread = bfd_bread (buf, size, abfd);
4732 for (offset = 4; offset <= size; offset += 4)
4736 val = *((unsigned long *) (buf + size - offset));
4737 if (! found_nonnull)
4742 else if (val == 0x0)
4744 unsigned long bottom;
4747 bottom = seg->fileoff + seg->filesize - offset;
4748 top = seg->fileoff + seg->filesize - 4;
4749 *rbuf = bfd_malloc (top - bottom);
4750 *rlen = top - bottom;
4752 memcpy (*rbuf, buf + size - *rlen, *rlen);
4758 if (size == (end - start))
4772 bfd_mach_o_core_file_failing_command (bfd *abfd)
4774 unsigned char *buf = NULL;
4775 unsigned int len = 0;
4778 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4782 return (char *) buf;
4786 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4791 static bfd_mach_o_uuid_command *
4792 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4794 bfd_mach_o_load_command *uuid_cmd;
4795 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4798 return &uuid_cmd->command.uuid;
4801 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4804 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4806 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4809 BFD_ASSERT (uuid_cmd);
4811 if (!bfd_check_format (abfd, bfd_object))
4814 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4815 || bfd_mach_o_get_data (abfd) == NULL
4816 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4819 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4820 if (dsym_uuid_cmd == NULL)
4823 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4824 sizeof (uuid_cmd->uuid)) != 0)
4830 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4831 The caller is responsible for closing the returned BFD object and
4832 its my_archive if the returned BFD is in a fat dSYM. */
4835 bfd_mach_o_find_dsym (const char *dsym_filename,
4836 const bfd_mach_o_uuid_command *uuid_cmd,
4837 const bfd_arch_info_type *arch)
4839 bfd *base_dsym_bfd, *dsym_bfd;
4841 BFD_ASSERT (uuid_cmd);
4843 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4844 if (base_dsym_bfd == NULL)
4847 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4848 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4851 bfd_close (dsym_bfd);
4852 if (base_dsym_bfd != dsym_bfd)
4853 bfd_close (base_dsym_bfd);
4858 /* Return a BFD created from a dSYM file for ABFD.
4859 The caller is responsible for closing the returned BFD object, its
4860 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4863 bfd_mach_o_follow_dsym (bfd *abfd)
4865 char *dsym_filename;
4866 bfd_mach_o_uuid_command *uuid_cmd;
4867 bfd *dsym_bfd, *base_bfd = abfd;
4868 const char *base_basename;
4870 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4873 if (abfd->my_archive)
4874 base_bfd = abfd->my_archive;
4875 /* BFD may have been opened from a stream. */
4876 if (base_bfd->filename == NULL)
4878 bfd_set_error (bfd_error_invalid_operation);
4881 base_basename = lbasename (base_bfd->filename);
4883 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4884 if (uuid_cmd == NULL)
4887 /* TODO: We assume the DWARF file has the same as the binary's.
4888 It seems apple's GDB checks all files in the dSYM bundle directory.
4889 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4891 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4892 + strlen (dsym_subdir) + 1
4893 + strlen (base_basename) + 1);
4894 sprintf (dsym_filename, "%s%s/%s",
4895 base_bfd->filename, dsym_subdir, base_basename);
4897 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4898 bfd_get_arch_info (abfd));
4899 if (dsym_bfd == NULL)
4900 free (dsym_filename);
4906 bfd_mach_o_find_nearest_line (bfd *abfd,
4910 const char **filename_ptr,
4911 const char **functionname_ptr,
4912 unsigned int *line_ptr)
4914 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4917 switch (mdata->header.filetype)
4919 case BFD_MACH_O_MH_OBJECT:
4921 case BFD_MACH_O_MH_EXECUTE:
4922 case BFD_MACH_O_MH_DYLIB:
4923 case BFD_MACH_O_MH_BUNDLE:
4924 case BFD_MACH_O_MH_KEXT_BUNDLE:
4925 if (mdata->dwarf2_find_line_info == NULL)
4927 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4928 /* When we couldn't find dSYM for this binary, we look for
4929 the debug information in the binary itself. In this way,
4930 we won't try finding separated dSYM again because
4931 mdata->dwarf2_find_line_info will be filled. */
4932 if (! mdata->dsym_bfd)
4934 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4935 dwarf_debug_sections, symbols,
4936 &mdata->dwarf2_find_line_info))
4943 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4944 section, symbols, offset,
4945 filename_ptr, functionname_ptr,
4947 &mdata->dwarf2_find_line_info))
4953 bfd_mach_o_close_and_cleanup (bfd *abfd)
4955 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4956 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4958 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4959 bfd_mach_o_free_cached_info (abfd);
4960 if (mdata->dsym_bfd != NULL)
4962 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4963 char *dsym_filename = (char *)(fat_bfd
4965 : mdata->dsym_bfd->filename);
4966 bfd_close (mdata->dsym_bfd);
4967 mdata->dsym_bfd = NULL;
4969 bfd_close (fat_bfd);
4970 free (dsym_filename);
4974 if (bfd_get_format (abfd) == bfd_archive
4975 && abfd->xvec == &mach_o_fat_vec)
4977 return _bfd_generic_close_and_cleanup (abfd);
4980 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4982 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4984 free (mdata->dyn_reloc_cache);
4985 mdata->dyn_reloc_cache = NULL;
4986 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4988 free (asect->relocation);
4989 asect->relocation = NULL;
4995 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4996 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4998 #define bfd_mach_o_swap_reloc_in NULL
4999 #define bfd_mach_o_swap_reloc_out NULL
5000 #define bfd_mach_o_print_thread NULL
5001 #define bfd_mach_o_tgt_seg_table NULL
5002 #define bfd_mach_o_section_type_valid_for_tgt NULL
5004 #define TARGET_NAME mach_o_be_vec
5005 #define TARGET_STRING "mach-o-be"
5006 #define TARGET_ARCHITECTURE bfd_arch_unknown
5007 #define TARGET_BIG_ENDIAN 1
5008 #define TARGET_ARCHIVE 0
5009 #define TARGET_PRIORITY 1
5010 #include "mach-o-target.c"
5013 #undef TARGET_STRING
5014 #undef TARGET_ARCHITECTURE
5015 #undef TARGET_BIG_ENDIAN
5016 #undef TARGET_ARCHIVE
5017 #undef TARGET_PRIORITY
5019 #define TARGET_NAME mach_o_le_vec
5020 #define TARGET_STRING "mach-o-le"
5021 #define TARGET_ARCHITECTURE bfd_arch_unknown
5022 #define TARGET_BIG_ENDIAN 0
5023 #define TARGET_ARCHIVE 0
5024 #define TARGET_PRIORITY 1
5026 #include "mach-o-target.c"
5029 #undef TARGET_STRING
5030 #undef TARGET_ARCHITECTURE
5031 #undef TARGET_BIG_ENDIAN
5032 #undef TARGET_ARCHIVE
5033 #undef TARGET_PRIORITY
5035 /* Not yet handled: creating an archive. */
5036 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5039 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5040 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5041 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5042 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5043 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5044 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5045 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5046 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5047 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5048 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5050 #define TARGET_NAME mach_o_fat_vec
5051 #define TARGET_STRING "mach-o-fat"
5052 #define TARGET_ARCHITECTURE bfd_arch_unknown
5053 #define TARGET_BIG_ENDIAN 1
5054 #define TARGET_ARCHIVE 1
5055 #define TARGET_PRIORITY 0
5057 #include "mach-o-target.c"
5060 #undef TARGET_STRING
5061 #undef TARGET_ARCHITECTURE
5062 #undef TARGET_BIG_ENDIAN
5063 #undef TARGET_ARCHIVE
5064 #undef TARGET_PRIORITY