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 || num == 0)
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 <= mdata->nsects);
1092 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1093 /* For a symbol defined in section S, the addend (stored in the
1094 binary) contains the address of the section. To comply with
1095 bfd convention, subtract the section address.
1096 Use the address from the header, so that the user can modify
1097 the vma of the section. */
1098 res->addend = -mdata->sections[num - 1]->addr;
1100 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1101 in the lower 16bits of the address value. So we have to find the
1102 'symbol' from the preceding reloc. We do this even though the
1103 section symbol is probably not needed here, because NULL symbol
1104 values cause an assert in generic BFD code. This must be done in
1105 the PPC swap_reloc_in routine. */
1106 res->sym_ptr_ptr = sym;
1108 /* The 'address' is just r_address.
1109 ??? maybe this should be masked with 0xffffff for safety. */
1110 res->address = addr;
1111 reloc.r_address = addr;
1114 /* We have set up a reloc with all the information present, so the swapper
1115 can modify address, value and addend fields, if necessary, to convey
1116 information in the generic BFD reloc that is mach-o specific. */
1118 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1124 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1125 unsigned long count,
1126 arelent *res, asymbol **syms)
1129 struct mach_o_reloc_info_external *native_relocs;
1130 bfd_size_type native_size;
1132 /* Allocate and read relocs. */
1133 native_size = count * BFD_MACH_O_RELENT_SIZE;
1135 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1136 if (native_relocs == NULL)
1139 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1140 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1143 for (i = 0; i < count; i++)
1145 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1149 free (native_relocs);
1152 free (native_relocs);
1157 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1158 arelent **rels, asymbol **syms)
1160 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1164 if (asect->reloc_count == 0)
1167 /* No need to go further if we don't know how to read relocs. */
1168 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1171 if (asect->relocation == NULL)
1173 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1177 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1178 asect->reloc_count, res, syms) < 0)
1183 asect->relocation = res;
1186 res = asect->relocation;
1187 for (i = 0; i < asect->reloc_count; i++)
1195 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1197 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1199 if (mdata->dysymtab == NULL)
1201 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1202 * sizeof (arelent *);
1206 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1207 struct bfd_symbol **syms)
1209 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1210 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1211 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1215 if (dysymtab == NULL)
1217 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1220 /* No need to go further if we don't know how to read relocs. */
1221 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1224 if (mdata->dyn_reloc_cache == NULL)
1226 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1227 * sizeof (arelent));
1231 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1232 dysymtab->nextrel, res, syms) < 0)
1238 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1240 res + dysymtab->nextrel, syms) < 0)
1246 mdata->dyn_reloc_cache = res;
1249 res = mdata->dyn_reloc_cache;
1250 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1256 /* In addition to the need to byte-swap the symbol number, the bit positions
1257 of the fields in the relocation information vary per target endian-ness. */
1260 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1261 bfd_mach_o_reloc_info *rel)
1263 unsigned char info = 0;
1265 BFD_ASSERT (rel->r_type <= 15);
1266 BFD_ASSERT (rel->r_length <= 3);
1268 if (bfd_big_endian (abfd))
1270 fields[0] = (rel->r_value >> 16) & 0xff;
1271 fields[1] = (rel->r_value >> 8) & 0xff;
1272 fields[2] = rel->r_value & 0xff;
1273 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1274 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1275 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1276 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1280 fields[2] = (rel->r_value >> 16) & 0xff;
1281 fields[1] = (rel->r_value >> 8) & 0xff;
1282 fields[0] = rel->r_value & 0xff;
1283 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1284 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1285 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1286 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1292 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1297 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1299 sec = section->bfdsection;
1300 if (sec->reloc_count == 0)
1303 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1306 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1309 /* Convert and write. */
1310 entries = section->bfdsection->orelocation;
1311 for (i = 0; i < section->nreloc; i++)
1313 arelent *rel = entries[i];
1314 struct mach_o_reloc_info_external raw;
1315 bfd_mach_o_reloc_info info, *pinfo = &info;
1317 /* Convert relocation to an intermediate representation. */
1318 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1321 /* Lower the relocation info. */
1322 if (pinfo->r_scattered)
1326 v = BFD_MACH_O_SR_SCATTERED
1327 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1328 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1329 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1330 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
1331 /* Note: scattered relocs have field in reverse order... */
1332 bfd_put_32 (abfd, v, raw.r_address);
1333 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1337 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1338 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1342 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1343 != BFD_MACH_O_RELENT_SIZE)
1350 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1352 struct mach_o_section_32_external raw;
1354 memcpy (raw.sectname, section->sectname, 16);
1355 memcpy (raw.segname, section->segname, 16);
1356 bfd_h_put_32 (abfd, section->addr, raw.addr);
1357 bfd_h_put_32 (abfd, section->size, raw.size);
1358 bfd_h_put_32 (abfd, section->offset, raw.offset);
1359 bfd_h_put_32 (abfd, section->align, raw.align);
1360 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1361 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1362 bfd_h_put_32 (abfd, section->flags, raw.flags);
1363 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1364 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1366 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1367 != BFD_MACH_O_SECTION_SIZE)
1374 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1376 struct mach_o_section_64_external raw;
1378 memcpy (raw.sectname, section->sectname, 16);
1379 memcpy (raw.segname, section->segname, 16);
1380 bfd_h_put_64 (abfd, section->addr, raw.addr);
1381 bfd_h_put_64 (abfd, section->size, raw.size);
1382 bfd_h_put_32 (abfd, section->offset, raw.offset);
1383 bfd_h_put_32 (abfd, section->align, raw.align);
1384 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1385 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1386 bfd_h_put_32 (abfd, section->flags, raw.flags);
1387 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1388 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1389 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1391 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1392 != BFD_MACH_O_SECTION_64_SIZE)
1399 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1401 struct mach_o_segment_command_32_external raw;
1402 bfd_mach_o_segment_command *seg = &command->command.segment;
1403 bfd_mach_o_section *sec;
1405 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1407 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1408 if (!bfd_mach_o_write_relocs (abfd, sec))
1411 memcpy (raw.segname, seg->segname, 16);
1412 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1413 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1414 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1415 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1416 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1417 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1418 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1419 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1421 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1422 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1425 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1426 if (bfd_mach_o_write_section_32 (abfd, sec))
1433 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1435 struct mach_o_segment_command_64_external raw;
1436 bfd_mach_o_segment_command *seg = &command->command.segment;
1437 bfd_mach_o_section *sec;
1439 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1441 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1442 if (!bfd_mach_o_write_relocs (abfd, sec))
1445 memcpy (raw.segname, seg->segname, 16);
1446 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1447 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1448 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1449 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1450 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1451 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1452 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1453 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1455 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1456 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1459 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1460 if (bfd_mach_o_write_section_64 (abfd, sec))
1467 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1469 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1470 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1472 unsigned int wide = bfd_mach_o_wide_p (abfd);
1473 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1474 struct bfd_strtab_hash *strtab;
1475 asymbol **symbols = bfd_get_outsymbols (abfd);
1477 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1479 /* Write the symbols first. */
1480 mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
1481 sym->symoff = mdata->filelen;
1482 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1485 sym->nsyms = bfd_get_symcount (abfd);
1486 mdata->filelen += sym->nsyms * symlen;
1488 strtab = _bfd_stringtab_init ();
1493 /* Although we don't strictly need to do this, for compatibility with
1494 Darwin system tools, actually output an empty string for the index
1496 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1498 for (i = 0; i < sym->nsyms; i++)
1500 bfd_size_type str_index;
1501 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1503 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1504 /* An index of 0 always means the empty string. */
1508 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1510 if (str_index == (bfd_size_type) -1)
1516 struct mach_o_nlist_64_external raw;
1518 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1519 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1520 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1521 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1522 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1525 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1530 struct mach_o_nlist_external raw;
1532 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1533 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1534 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1535 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1536 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1539 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1543 sym->strsize = _bfd_stringtab_size (strtab);
1544 sym->stroff = mdata->filelen;
1545 mdata->filelen += sym->strsize;
1547 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1549 _bfd_stringtab_free (strtab);
1553 struct mach_o_symtab_command_external raw;
1555 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1556 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1557 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1558 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1560 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1561 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1568 _bfd_stringtab_free (strtab);
1572 /* Write a dysymtab command.
1573 TODO: Possibly coalesce writes of smaller objects. */
1576 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1578 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1580 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1582 if (cmd->nmodtab != 0)
1586 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1589 for (i = 0; i < cmd->nmodtab; i++)
1591 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1595 iinit = module->iinit & 0xffff;
1596 iinit |= ((module->iterm & 0xffff) << 16);
1598 ninit = module->ninit & 0xffff;
1599 ninit |= ((module->nterm & 0xffff) << 16);
1601 if (bfd_mach_o_wide_p (abfd))
1603 struct mach_o_dylib_module_64_external w;
1605 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1606 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1607 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1608 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1609 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1610 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1611 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1612 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1613 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1614 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1615 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1616 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1617 &w.objc_module_info_addr);
1618 bfd_h_put_32 (abfd, module->objc_module_info_size,
1619 &w.objc_module_info_size);
1621 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1626 struct mach_o_dylib_module_external n;
1628 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1629 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1630 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1631 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1632 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1633 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1634 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1635 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1636 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1637 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1638 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1639 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1640 &n.objc_module_info_addr);
1641 bfd_h_put_32 (abfd, module->objc_module_info_size,
1642 &n.objc_module_info_size);
1644 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1654 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1657 for (i = 0; i < cmd->ntoc; i++)
1659 struct mach_o_dylib_table_of_contents_external raw;
1660 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1662 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1663 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1665 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1670 if (cmd->nindirectsyms > 0)
1674 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1677 for (i = 0; i < cmd->nindirectsyms; ++i)
1679 unsigned char raw[4];
1681 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1682 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1687 if (cmd->nextrefsyms != 0)
1691 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1694 for (i = 0; i < cmd->nextrefsyms; i++)
1697 unsigned char raw[4];
1698 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1700 /* Fields isym and flags are written as bit-fields, thus we need
1701 a specific processing for endianness. */
1703 if (bfd_big_endian (abfd))
1705 v = ((ref->isym & 0xffffff) << 8);
1706 v |= ref->flags & 0xff;
1710 v = ref->isym & 0xffffff;
1711 v |= ((ref->flags & 0xff) << 24);
1714 bfd_h_put_32 (abfd, v, raw);
1715 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1721 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1725 struct mach_o_dysymtab_command_external raw;
1727 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1728 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1729 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1730 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1731 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1732 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1733 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1734 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1735 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1736 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1737 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1738 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1739 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1740 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1741 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1742 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1743 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1744 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1746 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1754 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
1756 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
1758 /* Just leave debug symbols where they are (pretend they are local, and
1759 then they will just be sorted on position). */
1760 if (s->n_type & BFD_MACH_O_N_STAB)
1763 /* Local (we should never see an undefined local AFAICT). */
1764 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1767 /* Common symbols look like undefined externs. */
1768 if (mtyp == BFD_MACH_O_N_UNDF)
1771 /* A defined non-local, non-debug symbol. */
1776 bfd_mach_o_cf_symbols (const void *a, const void *b)
1778 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1779 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1780 unsigned int soa, sob;
1782 soa = bfd_mach_o_primary_symbol_sort_key (sa);
1783 sob = bfd_mach_o_primary_symbol_sort_key (sb);
1790 /* If it's local or stab, just preserve the input order. */
1793 if (sa->symbol.udata.i < sb->symbol.udata.i)
1795 if (sa->symbol.udata.i > sb->symbol.udata.i)
1798 /* This is probably an error. */
1802 /* The second sort key is name. */
1803 return strcmp (sa->symbol.name, sb->symbol.name);
1806 /* Process the symbols.
1808 This should be OK for single-module files - but it is not likely to work
1809 for multi-module shared libraries.
1811 (a) If the application has not filled in the relevant mach-o fields, make
1814 (b) Order them, like this:
1817 ( ii) external defined
1819 (iii) external undefined/common
1826 bfd_mach_o_mangle_symbols (bfd *abfd)
1829 asymbol **symbols = bfd_get_outsymbols (abfd);
1831 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1834 for (i = 0; i < bfd_get_symcount (abfd); i++)
1836 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1838 /* We use this value, which is out-of-range as a symbol index, to signal
1839 that the mach-o-specific data are not filled in and need to be created
1840 from the bfd values. It is much preferable for the application to do
1841 this, since more meaningful diagnostics can be made that way. */
1843 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1845 /* No symbol information has been set - therefore determine
1846 it from the bfd symbol flags/info. */
1847 if (s->symbol.section == bfd_abs_section_ptr)
1848 s->n_type = BFD_MACH_O_N_ABS;
1849 else if (s->symbol.section == bfd_und_section_ptr)
1851 s->n_type = BFD_MACH_O_N_UNDF;
1852 if (s->symbol.flags & BSF_WEAK)
1853 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1854 /* mach-o automatically makes undefined symbols extern. */
1855 s->n_type |= BFD_MACH_O_N_EXT;
1856 s->symbol.flags |= BSF_GLOBAL;
1858 else if (s->symbol.section == bfd_com_section_ptr)
1860 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1861 s->symbol.flags |= BSF_GLOBAL;
1864 s->n_type = BFD_MACH_O_N_SECT;
1866 if (s->symbol.flags & BSF_GLOBAL)
1867 s->n_type |= BFD_MACH_O_N_EXT;
1870 /* Put the section index in, where required. */
1871 if ((s->symbol.section != bfd_abs_section_ptr
1872 && s->symbol.section != bfd_und_section_ptr
1873 && s->symbol.section != bfd_com_section_ptr)
1874 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1875 && s->symbol.name == NULL))
1876 s->n_sect = s->symbol.section->target_index;
1878 /* Number to preserve order for local and debug syms. */
1879 s->symbol.udata.i = i;
1882 /* Sort the symbols. */
1883 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
1884 sizeof (asymbol *), bfd_mach_o_cf_symbols);
1886 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1888 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1889 s->symbol.udata.i = i; /* renumber. */
1895 /* We build a flat table of sections, which can be re-ordered if necessary.
1896 Fill in the section number and other mach-o-specific data. */
1899 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1902 unsigned target_index;
1905 nsect = bfd_count_sections (abfd);
1907 /* Don't do it if it's already set - assume the application knows what it's
1909 if (mdata->nsects == nsect
1910 && (mdata->nsects == 0 || mdata->sections != NULL))
1913 mdata->nsects = nsect;
1914 mdata->sections = bfd_alloc (abfd,
1915 mdata->nsects * sizeof (bfd_mach_o_section *));
1916 if (mdata->sections == NULL)
1919 /* We need to check that this can be done... */
1921 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1922 " maximum is 255,\n"), nsect);
1924 /* Create Mach-O sections.
1925 Section type, attribute and align should have been set when the
1926 section was created - either read in or specified. */
1928 for (sec = abfd->sections; sec; sec = sec->next)
1930 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1931 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1933 mdata->sections[target_index] = msect;
1935 msect->addr = bfd_get_section_vma (abfd, sec);
1936 msect->size = bfd_get_section_size (sec);
1938 /* Use the largest alignment set, in case it was bumped after the
1939 section was created. */
1940 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1943 sec->target_index = ++target_index;
1950 bfd_mach_o_write_contents (bfd *abfd)
1953 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1955 /* Make the commands, if not already present. */
1956 if (mdata->header.ncmds == 0)
1957 if (!bfd_mach_o_build_commands (abfd))
1960 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1963 for (i = 0; i < mdata->header.ncmds; i++)
1965 struct mach_o_load_command_external raw;
1966 bfd_mach_o_load_command *cur = &mdata->commands[i];
1967 unsigned long typeflag;
1969 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1971 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1972 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1974 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1975 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1980 case BFD_MACH_O_LC_SEGMENT:
1981 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1984 case BFD_MACH_O_LC_SEGMENT_64:
1985 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1988 case BFD_MACH_O_LC_SYMTAB:
1989 if (!bfd_mach_o_write_symtab (abfd, cur))
1992 case BFD_MACH_O_LC_DYSYMTAB:
1993 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1996 case BFD_MACH_O_LC_SYMSEG:
1998 case BFD_MACH_O_LC_THREAD:
1999 case BFD_MACH_O_LC_UNIXTHREAD:
2000 if (bfd_mach_o_write_thread (abfd, cur) != 0)
2003 case BFD_MACH_O_LC_LOADFVMLIB:
2004 case BFD_MACH_O_LC_IDFVMLIB:
2005 case BFD_MACH_O_LC_IDENT:
2006 case BFD_MACH_O_LC_FVMFILE:
2007 case BFD_MACH_O_LC_PREPAGE:
2008 case BFD_MACH_O_LC_LOAD_DYLIB:
2009 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2010 case BFD_MACH_O_LC_ID_DYLIB:
2011 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2012 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
2013 case BFD_MACH_O_LC_LOAD_DYLINKER:
2014 case BFD_MACH_O_LC_ID_DYLINKER:
2015 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2016 case BFD_MACH_O_LC_ROUTINES:
2017 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2020 (*_bfd_error_handler)
2021 (_("unable to write unknown load command 0x%lx"),
2022 (unsigned long) cur->type);
2031 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2034 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
2035 if (seg->sect_head == NULL)
2038 seg->sect_tail->next = s;
2042 /* Create section Mach-O flags from BFD flags. */
2045 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2049 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2051 /* Create default flags. */
2052 bfd_flags = bfd_get_section_flags (abfd, sec);
2053 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2054 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2055 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2056 | BFD_MACH_O_S_REGULAR;
2057 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2058 s->flags = BFD_MACH_O_S_ZEROFILL;
2059 else if (bfd_flags & SEC_DEBUGGING)
2060 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2062 s->flags = BFD_MACH_O_S_REGULAR;
2065 /* Count the number of sections in the list for the segment named.
2067 The special case of NULL or "" for the segment name is valid for
2068 an MH_OBJECT file and means 'all sections available'.
2070 Requires that the sections table in mdata be filled in.
2072 Returns the number of sections (0 is valid).
2073 Any number > 255 signals an invalid section count, although we will,
2074 perhaps, allow the file to be written (in line with Darwin tools up
2077 A section count of (unsigned long) -1 signals a definite error. */
2079 static unsigned long
2080 bfd_mach_o_count_sections_for_seg (const char *segment,
2081 bfd_mach_o_data_struct *mdata)
2084 if (mdata == NULL || mdata->sections == NULL)
2085 return (unsigned long) -1;
2087 /* The MH_OBJECT case, all sections are considered; Although nsects is
2088 is an unsigned long, the maximum valid section count is 255 and this
2089 will have been checked already by mangle_sections. */
2090 if (segment == NULL || segment[0] == '\0')
2091 return mdata->nsects;
2093 /* Count the number of sections we see in this segment. */
2095 for (i = 0; i < mdata->nsects; ++i)
2097 bfd_mach_o_section *s = mdata->sections[i];
2098 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2105 bfd_mach_o_build_seg_command (const char *segment,
2106 bfd_mach_o_data_struct *mdata,
2107 bfd_mach_o_segment_command *seg)
2110 int is_mho = (segment == NULL || segment[0] == '\0');
2112 /* Fill segment command. */
2114 memset (seg->segname, 0, sizeof (seg->segname));
2116 strncpy (seg->segname, segment, sizeof (seg->segname));
2118 /* TODO: fix this up for non-MH_OBJECT cases. */
2122 seg->fileoff = mdata->filelen;
2124 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2125 | BFD_MACH_O_PROT_EXECUTE;
2126 seg->initprot = seg->maxprot;
2128 seg->sect_head = NULL;
2129 seg->sect_tail = NULL;
2131 /* Append sections to the segment.
2133 This is a little tedious, we have to honor the need to account zerofill
2134 sections after all the rest. This forces us to do the calculation of
2135 total vmsize in three passes so that any alignment increments are
2136 properly accounted. */
2138 for (i = 0; i < mdata->nsects; ++i)
2140 bfd_mach_o_section *s = mdata->sections[i];
2141 asection *sec = s->bfdsection;
2143 /* If we're not making an MH_OBJECT, check whether this section is from
2144 our segment, and skip if not. Otherwise, just add all sections. */
2146 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2149 /* Although we account for zerofill section sizes in vm order, they are
2150 placed in the file in source sequence. */
2151 bfd_mach_o_append_section_to_segment (seg, sec);
2154 /* Zerofill sections have zero file size & offset,
2155 and are not written. */
2156 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2157 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2158 == BFD_MACH_O_S_GB_ZEROFILL)
2163 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2164 seg->vmsize += s->size;
2166 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2167 seg->filesize += s->size;
2169 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2170 s->offset = mdata->filelen;
2173 sec->filepos = s->offset;
2174 mdata->filelen += s->size;
2177 /* Now pass through again, for zerofill, only now we just update the
2179 for (i = 0; i < mdata->nsects; ++i)
2181 bfd_mach_o_section *s = mdata->sections[i];
2183 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2187 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2192 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2193 seg->vmsize += s->size;
2197 /* Now pass through again, for zerofill_GB. */
2198 for (i = 0; i < mdata->nsects; ++i)
2200 bfd_mach_o_section *s = mdata->sections[i];
2202 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2206 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2211 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2212 seg->vmsize += s->size;
2216 /* Allocate space for the relocations. */
2217 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
2219 for (i = 0; i < mdata->nsects; ++i)
2221 bfd_mach_o_section *ms = mdata->sections[i];
2222 asection *sec = ms->bfdsection;
2224 if ((ms->nreloc = sec->reloc_count) == 0)
2229 sec->rel_filepos = mdata->filelen;
2230 ms->reloff = sec->rel_filepos;
2231 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2237 /* Count the number of indirect symbols in the image.
2238 Requires that the sections are in their final order. */
2241 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2244 unsigned int nisyms = 0;
2246 for (i = 0; i < mdata->nsects; ++i)
2248 bfd_mach_o_section *sec = mdata->sections[i];
2250 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2252 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2253 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2254 case BFD_MACH_O_S_SYMBOL_STUBS:
2255 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2265 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2266 bfd_mach_o_data_struct *mdata,
2267 bfd_mach_o_load_command *cmd)
2269 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2272 We are not going to try and fill these in yet and, moreover, we are
2273 going to bail if they are already set. */
2274 if (dsym->nmodtab != 0
2276 || dsym->nextrefsyms != 0)
2278 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2279 " implemented for dysymtab commands."));
2283 dsym->ilocalsym = 0;
2285 if (bfd_get_symcount (abfd) > 0)
2287 asymbol **symbols = bfd_get_outsymbols (abfd);
2290 /* Count the number of each kind of symbol. */
2291 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2293 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2294 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2297 dsym->nlocalsym = i;
2298 dsym->iextdefsym = i;
2299 for (; i < bfd_get_symcount (abfd); ++i)
2301 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2302 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2305 dsym->nextdefsym = i - dsym->nlocalsym;
2306 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2307 dsym->nundefsym = bfd_get_symcount (abfd)
2313 dsym->nlocalsym = 0;
2314 dsym->iextdefsym = 0;
2315 dsym->nextdefsym = 0;
2316 dsym->iundefsym = 0;
2317 dsym->nundefsym = 0;
2320 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2321 if (dsym->nindirectsyms > 0)
2326 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2327 dsym->indirectsymoff = mdata->filelen;
2328 mdata->filelen += dsym->nindirectsyms * 4;
2330 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2331 if (dsym->indirect_syms == NULL)
2335 for (i = 0; i < mdata->nsects; ++i)
2337 bfd_mach_o_section *sec = mdata->sections[i];
2339 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2341 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2342 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2343 case BFD_MACH_O_S_SYMBOL_STUBS:
2346 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2348 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2349 if (isyms == NULL || num == 0)
2351 /* Record the starting index in the reserved1 field. */
2353 for (j = 0; j < num; j++, n++)
2355 if (isyms[j] == NULL)
2356 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2357 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2358 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2359 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2360 | BFD_MACH_O_INDIRECT_SYM_ABS;
2362 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2375 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2376 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2377 and copy functionality. */
2380 bfd_mach_o_build_commands (bfd *abfd)
2382 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2383 unsigned wide = mach_o_wide_p (&mdata->header);
2384 int segcmd_idx = -1;
2385 int symtab_idx = -1;
2386 int dysymtab_idx = -1;
2387 unsigned long base_offset = 0;
2389 /* Return now if commands are already present. */
2390 if (mdata->header.ncmds)
2393 /* Fill in the file type, if not already set. */
2395 if (mdata->header.filetype == 0)
2397 if (abfd->flags & EXEC_P)
2398 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2399 else if (abfd->flags & DYNAMIC)
2400 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2402 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2405 /* If hasn't already been done, flatten sections list, and sort
2406 if/when required. Must be done before the symbol table is adjusted,
2407 since that depends on properly numbered sections. */
2408 if (mdata->nsects == 0 || mdata->sections == NULL)
2409 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2412 /* Order the symbol table, fill-in/check mach-o specific fields and
2413 partition out any indirect symbols. */
2414 if (!bfd_mach_o_mangle_symbols (abfd))
2417 /* Very simple command set (only really applicable to MH_OBJECTs):
2418 All the commands are optional - present only when there is suitable data.
2419 (i.e. it is valid to have an empty file)
2421 a command (segment) to contain all the sections,
2422 command for the symbol table,
2423 a command for the dysymtab.
2425 ??? maybe we should assert that this is an MH_OBJECT? */
2427 if (mdata->nsects > 0)
2430 mdata->header.ncmds = 1;
2433 if (bfd_get_symcount (abfd) > 0)
2435 mdata->header.ncmds++;
2436 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2440 This is a rather crude test for whether we should build a dysymtab. */
2441 if (bfd_mach_o_should_emit_dysymtab ()
2442 && bfd_get_symcount (abfd))
2444 mdata->header.ncmds++;
2445 /* If there should be a case where a dysymtab could be emitted without
2446 a symtab (seems improbable), this would need amending. */
2447 dysymtab_idx = symtab_idx + 1;
2451 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2453 base_offset = BFD_MACH_O_HEADER_SIZE;
2455 /* Well, we must have a header, at least. */
2456 mdata->filelen = base_offset;
2458 /* A bit unusual, but no content is valid;
2459 as -n empty.s -o empty.o */
2460 if (mdata->header.ncmds == 0)
2463 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2464 * sizeof (bfd_mach_o_load_command));
2465 if (mdata->commands == NULL)
2468 if (segcmd_idx >= 0)
2470 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2471 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2473 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2474 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2475 if (seg->nsects == (unsigned long) -1)
2478 /* Init segment command. */
2479 cmd->offset = base_offset;
2482 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2483 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2484 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2488 cmd->type = BFD_MACH_O_LC_SEGMENT;
2489 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2490 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2493 cmd->type_required = FALSE;
2494 mdata->header.sizeofcmds = cmd->len;
2495 mdata->filelen += cmd->len;
2498 if (symtab_idx >= 0)
2500 /* Init symtab command. */
2501 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2503 cmd->type = BFD_MACH_O_LC_SYMTAB;
2504 cmd->offset = base_offset;
2505 if (segcmd_idx >= 0)
2506 cmd->offset += mdata->commands[segcmd_idx].len;
2508 cmd->len = sizeof (struct mach_o_symtab_command_external)
2509 + BFD_MACH_O_LC_SIZE;
2510 cmd->type_required = FALSE;
2511 mdata->header.sizeofcmds += cmd->len;
2512 mdata->filelen += cmd->len;
2515 /* If required, setup symtab command, see comment above about the quality
2517 if (dysymtab_idx >= 0)
2519 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2521 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2522 if (symtab_idx >= 0)
2523 cmd->offset = mdata->commands[symtab_idx].offset
2524 + mdata->commands[symtab_idx].len;
2525 else if (segcmd_idx >= 0)
2526 cmd->offset = mdata->commands[segcmd_idx].offset
2527 + mdata->commands[segcmd_idx].len;
2529 cmd->offset = base_offset;
2531 cmd->type_required = FALSE;
2532 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2533 + BFD_MACH_O_LC_SIZE;
2535 mdata->header.sizeofcmds += cmd->len;
2536 mdata->filelen += cmd->len;
2539 /* So, now we have sized the commands and the filelen set to that.
2540 Now we can build the segment command and set the section file offsets. */
2542 && ! bfd_mach_o_build_seg_command
2543 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2546 /* If we're doing a dysymtab, cmd points to its load command. */
2547 if (dysymtab_idx >= 0
2548 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2549 &mdata->commands[dysymtab_idx]))
2552 /* The symtab command is filled in when the symtab is written. */
2556 /* Set the contents of a section. */
2559 bfd_mach_o_set_section_contents (bfd *abfd,
2561 const void * location,
2563 bfd_size_type count)
2567 /* Trying to write the first section contents will trigger the creation of
2568 the load commands if they are not already present. */
2569 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2575 pos = section->filepos + offset;
2576 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2577 || bfd_bwrite (location, count, abfd) != count)
2584 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2585 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2590 /* Make an empty symbol. This is required only because
2591 bfd_make_section_anyway wants to create a symbol for the section. */
2594 bfd_mach_o_make_empty_symbol (bfd *abfd)
2596 asymbol *new_symbol;
2598 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2599 if (new_symbol == NULL)
2601 new_symbol->the_bfd = abfd;
2602 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2607 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2609 struct mach_o_header_external raw;
2611 bfd_vma (*get32) (const void *) = NULL;
2613 /* Just read the magic number. */
2614 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2615 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2618 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2620 header->byteorder = BFD_ENDIAN_BIG;
2621 header->magic = BFD_MACH_O_MH_MAGIC;
2622 header->version = 1;
2625 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2627 header->byteorder = BFD_ENDIAN_LITTLE;
2628 header->magic = BFD_MACH_O_MH_MAGIC;
2629 header->version = 1;
2632 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2634 header->byteorder = BFD_ENDIAN_BIG;
2635 header->magic = BFD_MACH_O_MH_MAGIC_64;
2636 header->version = 2;
2639 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2641 header->byteorder = BFD_ENDIAN_LITTLE;
2642 header->magic = BFD_MACH_O_MH_MAGIC_64;
2643 header->version = 2;
2648 header->byteorder = BFD_ENDIAN_UNKNOWN;
2652 /* Once the size of the header is known, read the full header. */
2653 size = mach_o_wide_p (header) ?
2654 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2656 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2657 || bfd_bread (&raw, size, abfd) != size)
2660 header->cputype = (*get32) (raw.cputype);
2661 header->cpusubtype = (*get32) (raw.cpusubtype);
2662 header->filetype = (*get32) (raw.filetype);
2663 header->ncmds = (*get32) (raw.ncmds);
2664 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2665 header->flags = (*get32) (raw.flags);
2667 if (mach_o_wide_p (header))
2668 header->reserved = (*get32) (raw.reserved);
2670 header->reserved = 0;
2676 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2678 bfd_mach_o_section *s;
2679 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2681 s = bfd_mach_o_get_mach_o_section (sec);
2685 static const mach_o_section_name_xlat * xlat;
2687 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2690 sec->used_by_bfd = s;
2691 s->bfdsection = sec;
2693 /* Create the Darwin seg/sect name pair from the bfd name.
2694 If this is a canonical name for which a specific paiting exists
2695 there will also be defined flags, type, attribute and alignment
2697 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2700 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2701 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2703 (void) bfd_set_section_alignment (abfd, sec, s->align);
2704 bfd_flags = bfd_get_section_flags (abfd, sec);
2705 if (bfd_flags == SEC_NO_FLAGS)
2706 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2709 /* Create default flags. */
2710 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2713 return _bfd_generic_new_section_hook (abfd, sec);
2717 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2721 bfd_mach_o_section *section;
2723 flags = bfd_get_section_flags (abfd, sec);
2724 section = bfd_mach_o_get_mach_o_section (sec);
2726 /* TODO: see if we should use the xlat system for doing this by
2727 preference and fall back to this for unknown sections. */
2729 if (flags == SEC_NO_FLAGS)
2731 /* Try to guess flags. */
2732 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2733 flags = SEC_DEBUGGING;
2737 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2738 != BFD_MACH_O_S_ZEROFILL)
2741 if (prot & BFD_MACH_O_PROT_EXECUTE)
2743 if (prot & BFD_MACH_O_PROT_WRITE)
2745 else if (prot & BFD_MACH_O_PROT_READ)
2746 flags |= SEC_READONLY;
2752 if ((flags & SEC_DEBUGGING) == 0)
2756 if (section->offset != 0)
2757 flags |= SEC_HAS_CONTENTS;
2758 if (section->nreloc != 0)
2761 bfd_set_section_flags (abfd, sec, flags);
2763 sec->vma = section->addr;
2764 sec->lma = section->addr;
2765 sec->size = section->size;
2766 sec->filepos = section->offset;
2767 sec->alignment_power = section->align;
2768 sec->segment_mark = 0;
2769 sec->reloc_count = section->nreloc;
2770 sec->rel_filepos = section->reloff;
2774 bfd_mach_o_make_bfd_section (bfd *abfd,
2775 const unsigned char *segname,
2776 const unsigned char *sectname)
2781 bfd_mach_o_convert_section_name_to_bfd
2782 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2786 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2790 bfd_mach_o_read_section_32 (bfd *abfd,
2791 unsigned int offset,
2794 struct mach_o_section_32_external raw;
2796 bfd_mach_o_section *section;
2798 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2799 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2800 != BFD_MACH_O_SECTION_SIZE))
2803 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2807 section = bfd_mach_o_get_mach_o_section (sec);
2808 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2809 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2810 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2811 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2812 section->addr = bfd_h_get_32 (abfd, raw.addr);
2813 section->size = bfd_h_get_32 (abfd, raw.size);
2814 section->offset = bfd_h_get_32 (abfd, raw.offset);
2815 section->align = bfd_h_get_32 (abfd, raw.align);
2816 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2817 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2818 section->flags = bfd_h_get_32 (abfd, raw.flags);
2819 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2820 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2821 section->reserved3 = 0;
2823 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2829 bfd_mach_o_read_section_64 (bfd *abfd,
2830 unsigned int offset,
2833 struct mach_o_section_64_external raw;
2835 bfd_mach_o_section *section;
2837 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2838 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2839 != BFD_MACH_O_SECTION_64_SIZE))
2842 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2846 section = bfd_mach_o_get_mach_o_section (sec);
2847 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2848 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2849 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2850 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2851 section->addr = bfd_h_get_64 (abfd, raw.addr);
2852 section->size = bfd_h_get_64 (abfd, raw.size);
2853 section->offset = bfd_h_get_32 (abfd, raw.offset);
2854 section->align = bfd_h_get_32 (abfd, raw.align);
2855 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2856 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2857 section->flags = bfd_h_get_32 (abfd, raw.flags);
2858 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2859 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2860 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2862 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2868 bfd_mach_o_read_section (bfd *abfd,
2869 unsigned int offset,
2874 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2876 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2880 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2881 bfd_mach_o_symtab_command *sym,
2882 bfd_mach_o_asymbol *s,
2885 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2886 unsigned int wide = mach_o_wide_p (&mdata->header);
2887 unsigned int symwidth =
2888 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2889 unsigned int symoff = sym->symoff + (i * symwidth);
2890 struct mach_o_nlist_64_external raw;
2891 unsigned char type = -1;
2892 unsigned char section = -1;
2894 symvalue value = -1;
2895 unsigned long stroff = -1;
2896 unsigned int symtype = -1;
2898 BFD_ASSERT (sym->strtab != NULL);
2900 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2901 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2903 (*_bfd_error_handler)
2904 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2905 symwidth, (unsigned long) symoff);
2909 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2910 type = bfd_h_get_8 (abfd, raw.n_type);
2911 symtype = type & BFD_MACH_O_N_TYPE;
2912 section = bfd_h_get_8 (abfd, raw.n_sect);
2913 desc = bfd_h_get_16 (abfd, raw.n_desc);
2915 value = bfd_h_get_64 (abfd, raw.n_value);
2917 value = bfd_h_get_32 (abfd, raw.n_value);
2919 if (stroff >= sym->strsize)
2921 (*_bfd_error_handler)
2922 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2923 (unsigned long) stroff,
2924 (unsigned long) sym->strsize);
2928 s->symbol.the_bfd = abfd;
2929 s->symbol.name = sym->strtab + stroff;
2930 s->symbol.value = value;
2931 s->symbol.flags = 0x0;
2932 s->symbol.udata.i = i;
2934 s->n_sect = section;
2937 if (type & BFD_MACH_O_N_STAB)
2939 s->symbol.flags |= BSF_DEBUGGING;
2940 s->symbol.section = bfd_und_section_ptr;
2952 if ((section > 0) && (section <= mdata->nsects))
2954 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2956 s->symbol.value - mdata->sections[section - 1]->addr;
2963 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2964 s->symbol.flags |= BSF_GLOBAL;
2966 s->symbol.flags |= BSF_LOCAL;
2970 case BFD_MACH_O_N_UNDF:
2971 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2972 && s->symbol.value != 0)
2974 /* A common symbol. */
2975 s->symbol.section = bfd_com_section_ptr;
2976 s->symbol.flags = BSF_NO_FLAGS;
2980 s->symbol.section = bfd_und_section_ptr;
2981 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2982 s->symbol.flags |= BSF_WEAK;
2985 case BFD_MACH_O_N_PBUD:
2986 s->symbol.section = bfd_und_section_ptr;
2988 case BFD_MACH_O_N_ABS:
2989 s->symbol.section = bfd_abs_section_ptr;
2991 case BFD_MACH_O_N_SECT:
2992 if ((section > 0) && (section <= mdata->nsects))
2994 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2996 s->symbol.value - mdata->sections[section - 1]->addr;
3000 /* Mach-O uses 0 to mean "no section"; not an error. */
3003 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3004 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3005 s->symbol.name, section, mdata->nsects);
3007 s->symbol.section = bfd_und_section_ptr;
3010 case BFD_MACH_O_N_INDR:
3011 /* FIXME: we don't follow the BFD convention as this indirect symbol
3012 won't be followed by the referenced one. This looks harmless
3013 unless we start using the linker. */
3014 s->symbol.flags |= BSF_INDIRECT;
3015 s->symbol.section = bfd_ind_section_ptr;
3016 s->symbol.value = 0;
3019 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3020 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3021 s->symbol.name, symtype);
3022 s->symbol.section = bfd_und_section_ptr;
3031 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3033 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3034 bfd_mach_o_symtab_command *sym = mdata->symtab;
3036 /* Fail if there is no symtab. */
3040 /* Success if already loaded. */
3044 if (abfd->flags & BFD_IN_MEMORY)
3046 struct bfd_in_memory *b;
3048 b = (struct bfd_in_memory *) abfd->iostream;
3050 if ((sym->stroff + sym->strsize) > b->size)
3052 bfd_set_error (bfd_error_file_truncated);
3055 sym->strtab = (char *) b->buffer + sym->stroff;
3059 sym->strtab = bfd_alloc (abfd, sym->strsize);
3060 if (sym->strtab == NULL)
3063 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3064 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3066 bfd_set_error (bfd_error_file_truncated);
3075 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3077 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3078 bfd_mach_o_symtab_command *sym = mdata->symtab;
3081 if (sym == NULL || sym->symbols)
3083 /* Return now if there are no symbols or if already loaded. */
3087 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3089 if (sym->symbols == NULL)
3091 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3095 if (!bfd_mach_o_read_symtab_strtab (abfd))
3098 for (i = 0; i < sym->nsyms; i++)
3100 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3108 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3110 switch ((int) flavour)
3112 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3113 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3114 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3115 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3116 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3117 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3118 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3119 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3120 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3121 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3122 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3123 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3124 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3125 default: return "UNKNOWN";
3130 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3132 switch ((int) flavour)
3134 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3135 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3136 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3137 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3138 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3139 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3140 default: return "UNKNOWN";
3145 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3147 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3148 struct mach_o_str_command_external raw;
3149 unsigned int nameoff;
3151 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3152 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3155 nameoff = bfd_h_get_32 (abfd, raw.str);
3157 cmd->name_offset = command->offset + nameoff;
3158 cmd->name_len = command->len - nameoff;
3159 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3160 if (cmd->name_str == NULL)
3162 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3163 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3169 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3171 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3172 struct mach_o_dylib_command_external raw;
3173 unsigned int nameoff;
3175 switch (command->type)
3177 case BFD_MACH_O_LC_LOAD_DYLIB:
3178 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3179 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3180 case BFD_MACH_O_LC_ID_DYLIB:
3181 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3182 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3189 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3190 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3193 nameoff = bfd_h_get_32 (abfd, raw.name);
3194 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3195 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3196 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3198 cmd->name_offset = command->offset + nameoff;
3199 cmd->name_len = command->len - nameoff;
3200 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3201 if (cmd->name_str == NULL)
3203 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3204 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3210 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3211 bfd_mach_o_load_command *command)
3213 bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3214 struct mach_o_prebound_dylib_command_external raw;
3215 unsigned int nameoff;
3216 unsigned int modoff;
3217 unsigned int str_len;
3220 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3221 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3224 nameoff = bfd_h_get_32 (abfd, raw.name);
3225 modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3226 if (nameoff > command->len || modoff > command->len)
3229 str_len = command->len - sizeof (raw);
3230 str = bfd_alloc (abfd, str_len);
3233 if (bfd_bread (str, str_len, abfd) != str_len)
3236 cmd->name_offset = command->offset + nameoff;
3237 cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3238 cmd->linked_modules_offset = command->offset + modoff;
3240 cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3241 cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3246 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3247 bfd_mach_o_load_command *command)
3249 bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3250 struct mach_o_prebind_cksum_command_external raw;
3252 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3253 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3256 cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3261 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3262 bfd_mach_o_load_command *command)
3264 bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3265 struct mach_o_twolevel_hints_command_external raw;
3267 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3268 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3271 cmd->offset = bfd_get_32 (abfd, raw.offset);
3272 cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3277 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3279 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3280 struct mach_o_fvmlib_command_external raw;
3281 unsigned int nameoff;
3283 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3284 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3287 nameoff = bfd_h_get_32 (abfd, raw.name);
3288 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3289 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3291 fvm->name_offset = command->offset + nameoff;
3292 fvm->name_len = command->len - nameoff;
3293 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3294 if (fvm->name_str == NULL)
3296 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3297 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3303 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3305 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3306 bfd_mach_o_thread_command *cmd = &command->command.thread;
3307 unsigned int offset;
3308 unsigned int nflavours;
3311 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3312 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3314 /* Count the number of threads. */
3317 while (offset != command->len)
3319 struct mach_o_thread_command_external raw;
3321 if (offset >= command->len)
3324 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3325 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3328 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3332 /* Allocate threads. */
3333 cmd->flavours = bfd_alloc
3334 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3335 if (cmd->flavours == NULL)
3337 cmd->nflavours = nflavours;
3341 while (offset != command->len)
3343 struct mach_o_thread_command_external raw;
3345 if (offset >= command->len)
3348 if (nflavours >= cmd->nflavours)
3351 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3352 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3355 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3356 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3357 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3358 offset += cmd->flavours[nflavours].size + sizeof (raw);
3362 for (i = 0; i < nflavours; i++)
3365 unsigned int snamelen;
3367 const char *flavourstr;
3368 const char *prefix = "LC_THREAD";
3371 switch (mdata->header.cputype)
3373 case BFD_MACH_O_CPU_TYPE_POWERPC:
3374 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3375 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3377 case BFD_MACH_O_CPU_TYPE_I386:
3378 case BFD_MACH_O_CPU_TYPE_X86_64:
3379 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3382 flavourstr = "UNKNOWN_ARCHITECTURE";
3386 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3387 sname = bfd_alloc (abfd, snamelen);
3393 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3394 if (bfd_get_section_by_name (abfd, sname) == NULL)
3399 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3403 bfdsec->size = cmd->flavours[i].size;
3404 bfdsec->filepos = cmd->flavours[i].offset;
3405 bfdsec->alignment_power = 0x0;
3407 cmd->section = bfdsec;
3414 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3416 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3417 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3419 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3422 struct mach_o_dysymtab_command_external raw;
3424 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3425 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3428 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3429 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3430 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3431 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3432 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3433 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3434 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3435 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3436 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3437 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3438 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3439 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3440 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3441 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3442 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3443 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3444 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3445 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3448 if (cmd->nmodtab != 0)
3451 int wide = bfd_mach_o_wide_p (abfd);
3452 unsigned int module_len = wide ? 56 : 52;
3455 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3456 if (cmd->dylib_module == NULL)
3459 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3462 for (i = 0; i < cmd->nmodtab; i++)
3464 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3466 unsigned char buf[56];
3468 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3471 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3472 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3473 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3474 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3475 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3476 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3477 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3478 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3479 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3480 v = bfd_h_get_32 (abfd, buf +36);
3481 module->iinit = v & 0xffff;
3482 module->iterm = (v >> 16) & 0xffff;
3483 v = bfd_h_get_32 (abfd, buf + 40);
3484 module->ninit = v & 0xffff;
3485 module->nterm = (v >> 16) & 0xffff;
3488 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3489 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3493 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3494 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3503 cmd->dylib_toc = bfd_alloc
3504 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3505 if (cmd->dylib_toc == NULL)
3508 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3511 for (i = 0; i < cmd->ntoc; i++)
3513 struct mach_o_dylib_table_of_contents_external raw;
3514 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3516 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3519 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3520 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3524 if (cmd->nindirectsyms != 0)
3528 cmd->indirect_syms = bfd_alloc
3529 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3530 if (cmd->indirect_syms == NULL)
3533 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3536 for (i = 0; i < cmd->nindirectsyms; i++)
3538 unsigned char raw[4];
3539 unsigned int *is = &cmd->indirect_syms[i];
3541 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3544 *is = bfd_h_get_32 (abfd, raw);
3548 if (cmd->nextrefsyms != 0)
3553 cmd->ext_refs = bfd_alloc
3554 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3555 if (cmd->ext_refs == NULL)
3558 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3561 for (i = 0; i < cmd->nextrefsyms; i++)
3563 unsigned char raw[4];
3564 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3566 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3569 /* Fields isym and flags are written as bit-fields, thus we need
3570 a specific processing for endianness. */
3571 v = bfd_h_get_32 (abfd, raw);
3572 if (bfd_big_endian (abfd))
3574 ref->isym = (v >> 8) & 0xffffff;
3575 ref->flags = v & 0xff;
3579 ref->isym = v & 0xffffff;
3580 ref->flags = (v >> 24) & 0xff;
3585 if (mdata->dysymtab)
3587 mdata->dysymtab = cmd;
3593 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3595 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3596 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3597 struct mach_o_symtab_command_external raw;
3599 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
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 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3606 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3607 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3608 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3609 symtab->symbols = NULL;
3610 symtab->strtab = NULL;
3612 if (symtab->nsyms != 0)
3613 abfd->flags |= HAS_SYMS;
3617 mdata->symtab = symtab;
3622 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3624 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3626 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3628 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3629 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3636 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3638 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3639 struct mach_o_linkedit_data_command_external raw;
3641 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3642 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3645 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3646 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3651 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3653 bfd_mach_o_str_command *cmd = &command->command.str;
3654 struct mach_o_str_command_external raw;
3657 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3658 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3661 off = bfd_get_32 (abfd, raw.str);
3662 cmd->stroff = command->offset + off;
3663 cmd->str_len = command->len - off;
3664 cmd->str = bfd_alloc (abfd, cmd->str_len);
3665 if (cmd->str == NULL)
3667 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3668 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3674 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3676 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3677 struct mach_o_dyld_info_command_external raw;
3679 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3680 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3683 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3684 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3685 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3686 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3687 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3688 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3689 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3690 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3691 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3692 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3697 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3699 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3700 struct mach_o_version_min_command_external raw;
3703 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3704 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3707 ver = bfd_get_32 (abfd, raw.version);
3708 cmd->rel = ver >> 16;
3709 cmd->maj = ver >> 8;
3711 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3716 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3718 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3719 struct mach_o_encryption_info_command_external raw;
3721 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3722 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3725 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3726 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3727 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3732 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3734 bfd_mach_o_main_command *cmd = &command->command.main;
3735 struct mach_o_entry_point_command_external raw;
3737 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3738 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3741 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3742 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3747 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3749 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3750 struct mach_o_source_version_command_external raw;
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 ver = bfd_get_64 (abfd, raw.version);
3758 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3759 generates warnings) in case of the host doesn't support 64 bit
3761 cmd->e = ver & 0x3ff;
3763 cmd->d = ver & 0x3ff;
3765 cmd->c = ver & 0x3ff;
3767 cmd->b = ver & 0x3ff;
3769 cmd->a = ver & 0xffffff;
3774 bfd_mach_o_read_segment (bfd *abfd,
3775 bfd_mach_o_load_command *command,
3778 bfd_mach_o_segment_command *seg = &command->command.segment;
3783 struct mach_o_segment_command_64_external raw;
3785 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3787 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3788 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3791 memcpy (seg->segname, raw.segname, 16);
3792 seg->segname[16] = '\0';
3794 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3795 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3796 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3797 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3798 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3799 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3800 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3801 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3805 struct mach_o_segment_command_32_external raw;
3807 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3809 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3810 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3813 memcpy (seg->segname, raw.segname, 16);
3814 seg->segname[16] = '\0';
3816 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3817 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3818 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3819 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3820 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3821 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3822 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3823 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3825 seg->sect_head = NULL;
3826 seg->sect_tail = NULL;
3828 for (i = 0; i < seg->nsects; i++)
3834 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3835 + (i * BFD_MACH_O_SECTION_64_SIZE);
3837 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3838 + (i * BFD_MACH_O_SECTION_SIZE);
3840 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3844 bfd_mach_o_append_section_to_segment (seg, sec);
3851 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3853 return bfd_mach_o_read_segment (abfd, command, 0);
3857 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3859 return bfd_mach_o_read_segment (abfd, command, 1);
3863 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3865 struct mach_o_load_command_external raw;
3868 /* Read command type and length. */
3869 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3870 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3873 cmd = bfd_h_get_32 (abfd, raw.cmd);
3874 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3875 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3876 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3878 switch (command->type)
3880 case BFD_MACH_O_LC_SEGMENT:
3881 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3884 case BFD_MACH_O_LC_SEGMENT_64:
3885 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3888 case BFD_MACH_O_LC_SYMTAB:
3889 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3892 case BFD_MACH_O_LC_SYMSEG:
3894 case BFD_MACH_O_LC_THREAD:
3895 case BFD_MACH_O_LC_UNIXTHREAD:
3896 if (bfd_mach_o_read_thread (abfd, command) != 0)
3899 case BFD_MACH_O_LC_LOAD_DYLINKER:
3900 case BFD_MACH_O_LC_ID_DYLINKER:
3901 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
3902 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3905 case BFD_MACH_O_LC_LOAD_DYLIB:
3906 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3907 case BFD_MACH_O_LC_ID_DYLIB:
3908 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3909 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3910 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3911 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3914 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3915 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3918 case BFD_MACH_O_LC_LOADFVMLIB:
3919 case BFD_MACH_O_LC_IDFVMLIB:
3920 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3923 case BFD_MACH_O_LC_IDENT:
3924 case BFD_MACH_O_LC_FVMFILE:
3925 case BFD_MACH_O_LC_PREPAGE:
3926 case BFD_MACH_O_LC_ROUTINES:
3927 case BFD_MACH_O_LC_ROUTINES_64:
3929 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3930 case BFD_MACH_O_LC_SUB_UMBRELLA:
3931 case BFD_MACH_O_LC_SUB_LIBRARY:
3932 case BFD_MACH_O_LC_SUB_CLIENT:
3933 case BFD_MACH_O_LC_RPATH:
3934 if (bfd_mach_o_read_str (abfd, command) != 0)
3937 case BFD_MACH_O_LC_DYSYMTAB:
3938 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3941 case BFD_MACH_O_LC_PREBIND_CKSUM:
3942 if (bfd_mach_o_read_prebind_cksum (abfd, command) != 0)
3945 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3946 if (bfd_mach_o_read_twolevel_hints (abfd, command) != 0)
3949 case BFD_MACH_O_LC_UUID:
3950 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3953 case BFD_MACH_O_LC_CODE_SIGNATURE:
3954 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3955 case BFD_MACH_O_LC_FUNCTION_STARTS:
3956 case BFD_MACH_O_LC_DATA_IN_CODE:
3957 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3958 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3961 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3962 if (!bfd_mach_o_read_encryption_info (abfd, command))
3965 case BFD_MACH_O_LC_DYLD_INFO:
3966 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3969 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3970 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3971 if (!bfd_mach_o_read_version_min (abfd, command))
3974 case BFD_MACH_O_LC_MAIN:
3975 if (!bfd_mach_o_read_main (abfd, command))
3978 case BFD_MACH_O_LC_SOURCE_VERSION:
3979 if (!bfd_mach_o_read_source_version (abfd, command))
3983 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3984 abfd, (unsigned long) command->type);
3992 bfd_mach_o_flatten_sections (bfd *abfd)
3994 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3998 /* Count total number of sections. */
4001 for (i = 0; i < mdata->header.ncmds; i++)
4003 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4004 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4006 bfd_mach_o_segment_command *seg;
4008 seg = &mdata->commands[i].command.segment;
4009 mdata->nsects += seg->nsects;
4013 /* Allocate sections array. */
4014 mdata->sections = bfd_alloc (abfd,
4015 mdata->nsects * sizeof (bfd_mach_o_section *));
4017 /* Fill the array. */
4020 for (i = 0; i < mdata->header.ncmds; i++)
4022 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4023 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4025 bfd_mach_o_segment_command *seg;
4026 bfd_mach_o_section *sec;
4028 seg = &mdata->commands[i].command.segment;
4029 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4031 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4032 mdata->sections[csect++] = sec;
4038 bfd_mach_o_scan_start_address (bfd *abfd)
4040 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4041 bfd_mach_o_thread_command *cmd = NULL;
4044 for (i = 0; i < mdata->header.ncmds; i++)
4045 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
4046 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
4048 cmd = &mdata->commands[i].command.thread;
4051 else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
4052 && mdata->nsects > 1)
4054 bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
4055 bfd_mach_o_section *text_sect = mdata->sections[0];
4058 abfd->start_address = main_cmd->entryoff
4059 + (text_sect->addr - text_sect->offset);
4064 /* An object file has no start address, so do not fail if not found. */
4068 /* FIXME: create a subtarget hook ? */
4069 for (i = 0; i < cmd->nflavours; i++)
4071 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4072 && (cmd->flavours[i].flavour
4073 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4075 unsigned char buf[4];
4077 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4078 || bfd_bread (buf, 4, abfd) != 4)
4081 abfd->start_address = bfd_h_get_32 (abfd, buf);
4083 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4084 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4086 unsigned char buf[4];
4088 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4089 || bfd_bread (buf, 4, abfd) != 4)
4092 abfd->start_address = bfd_h_get_32 (abfd, buf);
4094 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4095 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4097 unsigned char buf[8];
4099 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4100 || bfd_bread (buf, 8, abfd) != 8)
4103 abfd->start_address = bfd_h_get_64 (abfd, buf);
4105 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4106 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4108 unsigned char buf[8];
4110 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4111 || bfd_bread (buf, 8, abfd) != 8)
4114 abfd->start_address = bfd_h_get_64 (abfd, buf);
4122 bfd_mach_o_set_arch_mach (bfd *abfd,
4123 enum bfd_architecture arch,
4124 unsigned long machine)
4126 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4128 /* If this isn't the right architecture for this backend, and this
4129 isn't the generic backend, fail. */
4130 if (arch != bed->arch
4131 && arch != bfd_arch_unknown
4132 && bed->arch != bfd_arch_unknown)
4135 return bfd_default_set_arch_mach (abfd, arch, machine);
4139 bfd_mach_o_scan (bfd *abfd,
4140 bfd_mach_o_header *header,
4141 bfd_mach_o_data_struct *mdata)
4144 enum bfd_architecture cputype;
4145 unsigned long cpusubtype;
4146 unsigned int hdrsize;
4148 hdrsize = mach_o_wide_p (header) ?
4149 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4151 mdata->header = *header;
4153 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4154 switch (header->filetype)
4156 case BFD_MACH_O_MH_OBJECT:
4157 abfd->flags |= HAS_RELOC;
4159 case BFD_MACH_O_MH_EXECUTE:
4160 abfd->flags |= EXEC_P;
4162 case BFD_MACH_O_MH_DYLIB:
4163 case BFD_MACH_O_MH_BUNDLE:
4164 abfd->flags |= DYNAMIC;
4168 abfd->tdata.mach_o_data = mdata;
4170 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4171 &cputype, &cpusubtype);
4172 if (cputype == bfd_arch_unknown)
4174 (*_bfd_error_handler)
4175 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4176 header->cputype, header->cpusubtype);
4180 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4182 if (header->ncmds != 0)
4184 mdata->commands = bfd_alloc
4185 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4186 if (mdata->commands == NULL)
4189 for (i = 0; i < header->ncmds; i++)
4191 bfd_mach_o_load_command *cur = &mdata->commands[i];
4194 cur->offset = hdrsize;
4197 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4198 cur->offset = prev->offset + prev->len;
4201 if (bfd_mach_o_read_command (abfd, cur) < 0)
4206 /* Sections should be flatten before scanning start address. */
4207 bfd_mach_o_flatten_sections (abfd);
4208 if (!bfd_mach_o_scan_start_address (abfd))
4215 bfd_mach_o_mkobject_init (bfd *abfd)
4217 bfd_mach_o_data_struct *mdata = NULL;
4219 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4222 abfd->tdata.mach_o_data = mdata;
4224 mdata->header.magic = 0;
4225 mdata->header.cputype = 0;
4226 mdata->header.cpusubtype = 0;
4227 mdata->header.filetype = 0;
4228 mdata->header.ncmds = 0;
4229 mdata->header.sizeofcmds = 0;
4230 mdata->header.flags = 0;
4231 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4232 mdata->commands = NULL;
4234 mdata->sections = NULL;
4235 mdata->dyn_reloc_cache = NULL;
4241 bfd_mach_o_gen_mkobject (bfd *abfd)
4243 bfd_mach_o_data_struct *mdata;
4245 if (!bfd_mach_o_mkobject_init (abfd))
4248 mdata = bfd_mach_o_get_data (abfd);
4249 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4250 mdata->header.cputype = 0;
4251 mdata->header.cpusubtype = 0;
4252 mdata->header.byteorder = abfd->xvec->byteorder;
4253 mdata->header.version = 1;
4259 bfd_mach_o_header_p (bfd *abfd,
4260 bfd_mach_o_filetype filetype,
4261 bfd_mach_o_cpu_type cputype)
4263 bfd_mach_o_header header;
4264 bfd_mach_o_data_struct *mdata;
4266 if (!bfd_mach_o_read_header (abfd, &header))
4269 if (! (header.byteorder == BFD_ENDIAN_BIG
4270 || header.byteorder == BFD_ENDIAN_LITTLE))
4272 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4273 (unsigned long) header.byteorder);
4277 if (! ((header.byteorder == BFD_ENDIAN_BIG
4278 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4279 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4280 || (header.byteorder == BFD_ENDIAN_LITTLE
4281 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4282 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4285 /* Check cputype and filetype.
4286 In case of wildcard, do not accept magics that are handled by existing
4290 if (header.cputype != cputype)
4296 if (header.filetype != filetype)
4301 switch (header.filetype)
4303 case BFD_MACH_O_MH_CORE:
4304 /* Handled by core_p */
4311 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4315 if (!bfd_mach_o_scan (abfd, &header, mdata))
4321 bfd_set_error (bfd_error_wrong_format);
4327 static const bfd_target *
4328 bfd_mach_o_gen_object_p (bfd *abfd)
4330 return bfd_mach_o_header_p (abfd, 0, 0);
4333 static const bfd_target *
4334 bfd_mach_o_gen_core_p (bfd *abfd)
4336 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4339 /* Return the base address of ABFD, ie the address at which the image is
4340 mapped. The possible initial pagezero is ignored. */
4343 bfd_mach_o_get_base_address (bfd *abfd)
4345 bfd_mach_o_data_struct *mdata;
4348 /* Check for Mach-O. */
4349 if (!bfd_mach_o_valid (abfd))
4351 mdata = bfd_mach_o_get_data (abfd);
4353 for (i = 0; i < mdata->header.ncmds; i++)
4355 bfd_mach_o_load_command *cmd = &mdata->commands[i];
4356 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
4357 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
4359 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
4361 if (segcmd->initprot != 0)
4362 return segcmd->vmaddr;
4368 typedef struct mach_o_fat_archentry
4370 unsigned long cputype;
4371 unsigned long cpusubtype;
4372 unsigned long offset;
4374 unsigned long align;
4375 } mach_o_fat_archentry;
4377 typedef struct mach_o_fat_data_struct
4379 unsigned long magic;
4380 unsigned long nfat_arch;
4381 mach_o_fat_archentry *archentries;
4382 } mach_o_fat_data_struct;
4385 bfd_mach_o_archive_p (bfd *abfd)
4387 mach_o_fat_data_struct *adata = NULL;
4388 struct mach_o_fat_header_external hdr;
4391 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4392 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4395 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4399 adata->magic = bfd_getb32 (hdr.magic);
4400 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4401 if (adata->magic != 0xcafebabe)
4403 /* Avoid matching Java bytecode files, which have the same magic number.
4404 In the Java bytecode file format this field contains the JVM version,
4405 which starts at 43.0. */
4406 if (adata->nfat_arch > 30)
4409 adata->archentries =
4410 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4411 if (adata->archentries == NULL)
4414 for (i = 0; i < adata->nfat_arch; i++)
4416 struct mach_o_fat_arch_external arch;
4417 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4419 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4420 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4421 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4422 adata->archentries[i].size = bfd_getb32 (arch.size);
4423 adata->archentries[i].align = bfd_getb32 (arch.align);
4426 abfd->tdata.mach_o_fat_data = adata;
4431 bfd_release (abfd, adata);
4432 bfd_set_error (bfd_error_wrong_format);
4436 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4437 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4438 Set arelt_data and origin fields too. */
4441 bfd_mach_o_fat_member_init (bfd *abfd,
4442 enum bfd_architecture arch_type,
4443 unsigned long arch_subtype,
4444 mach_o_fat_archentry *entry)
4446 struct areltdata *areltdata;
4447 /* Create the member filename. Use ARCH_NAME. */
4448 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4452 /* Use the architecture name if known. */
4453 abfd->filename = xstrdup (ap->printable_name);
4457 /* Forge a uniq id. */
4458 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4459 char *name = xmalloc (namelen);
4460 snprintf (name, namelen, "0x%lx-0x%lx",
4461 entry->cputype, entry->cpusubtype);
4462 abfd->filename = name;
4465 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4466 areltdata->parsed_size = entry->size;
4467 abfd->arelt_data = areltdata;
4468 abfd->iostream = NULL;
4469 abfd->origin = entry->offset;
4473 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4475 mach_o_fat_data_struct *adata;
4476 mach_o_fat_archentry *entry = NULL;
4479 enum bfd_architecture arch_type;
4480 unsigned long arch_subtype;
4482 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4483 BFD_ASSERT (adata != NULL);
4485 /* Find index of previous entry. */
4488 /* Start at first one. */
4493 /* Find index of PREV. */
4494 for (i = 0; i < adata->nfat_arch; i++)
4496 if (adata->archentries[i].offset == prev->origin)
4500 if (i == adata->nfat_arch)
4503 bfd_set_error (bfd_error_bad_value);
4507 /* Get next entry. */
4511 if (i >= adata->nfat_arch)
4513 bfd_set_error (bfd_error_no_more_archived_files);
4517 entry = &adata->archentries[i];
4518 nbfd = _bfd_new_bfd_contained_in (archive);
4522 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4523 &arch_type, &arch_subtype);
4525 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4527 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4532 /* Analogous to stat call. */
4535 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4537 if (abfd->arelt_data == NULL)
4539 bfd_set_error (bfd_error_invalid_operation);
4546 buf->st_mode = 0644;
4547 buf->st_size = arelt_size (abfd);
4552 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4553 If ABFD is a fat image containing a member that corresponds to FORMAT
4554 and ARCH, returns it.
4555 In other case, returns NULL.
4556 This function allows transparent uses of fat images. */
4559 bfd_mach_o_fat_extract (bfd *abfd,
4561 const bfd_arch_info_type *arch)
4564 mach_o_fat_data_struct *adata;
4567 if (bfd_check_format (abfd, format))
4569 if (bfd_get_arch_info (abfd) == arch)
4573 if (!bfd_check_format (abfd, bfd_archive)
4574 || abfd->xvec != &mach_o_fat_vec)
4577 /* This is a Mach-O fat image. */
4578 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4579 BFD_ASSERT (adata != NULL);
4581 for (i = 0; i < adata->nfat_arch; i++)
4583 struct mach_o_fat_archentry *e = &adata->archentries[i];
4584 enum bfd_architecture cpu_type;
4585 unsigned long cpu_subtype;
4587 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4588 &cpu_type, &cpu_subtype);
4589 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4592 /* The architecture is found. */
4593 res = _bfd_new_bfd_contained_in (abfd);
4597 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4599 if (bfd_check_format (res, format))
4601 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4612 bfd_mach_o_lookup_command (bfd *abfd,
4613 bfd_mach_o_load_command_type type,
4614 bfd_mach_o_load_command **mcommand)
4616 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4617 bfd_mach_o_load_command *ncmd = NULL;
4618 unsigned int i, num;
4620 BFD_ASSERT (md != NULL);
4621 BFD_ASSERT (mcommand != NULL);
4624 for (i = 0; i < md->header.ncmds; i++)
4626 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4628 if (cmd->type != type)
4641 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4645 case BFD_MACH_O_CPU_TYPE_MC680x0:
4647 case BFD_MACH_O_CPU_TYPE_MC88000:
4649 case BFD_MACH_O_CPU_TYPE_POWERPC:
4651 case BFD_MACH_O_CPU_TYPE_I386:
4653 case BFD_MACH_O_CPU_TYPE_SPARC:
4655 case BFD_MACH_O_CPU_TYPE_I860:
4657 case BFD_MACH_O_CPU_TYPE_HPPA:
4658 return 0xc0000000 - 0x04000000;
4664 /* The following two tables should be kept, as far as possible, in order of
4665 most frequently used entries to optimize their use from gas. */
4667 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4669 { "regular", BFD_MACH_O_S_REGULAR},
4670 { "coalesced", BFD_MACH_O_S_COALESCED},
4671 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4672 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4673 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4674 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4675 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4676 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4677 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4678 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4679 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4680 { "interposing", BFD_MACH_O_S_INTERPOSING},
4681 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4682 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4683 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4684 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4685 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4689 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4691 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4692 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4693 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4694 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4695 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4696 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4697 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4698 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4699 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4700 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4701 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4705 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4708 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4710 const bfd_mach_o_xlat_name *x;
4711 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4713 for (x = bfd_mach_o_section_type_name; x->name; x++)
4714 if (strcmp (x->name, name) == 0)
4716 /* We found it... does the target support it? */
4717 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4718 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4719 return x->val; /* OK. */
4721 break; /* Not supported. */
4723 /* Maximum section ID = 0xff. */
4727 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4730 bfd_mach_o_get_section_attribute_from_name (const char *name)
4732 const bfd_mach_o_xlat_name *x;
4734 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4735 if (strcmp (x->name, name) == 0)
4737 return (unsigned int)-1;
4741 bfd_mach_o_core_fetch_environment (bfd *abfd,
4742 unsigned char **rbuf,
4745 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4746 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4749 for (i = 0; i < mdata->header.ncmds; i++)
4751 bfd_mach_o_load_command *cur = &mdata->commands[i];
4752 bfd_mach_o_segment_command *seg = NULL;
4754 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4757 seg = &cur->command.segment;
4759 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4761 unsigned long start = seg->fileoff;
4762 unsigned long end = seg->fileoff + seg->filesize;
4763 unsigned char *buf = bfd_malloc (1024);
4764 unsigned long size = 1024;
4768 bfd_size_type nread = 0;
4769 unsigned long offset;
4770 int found_nonnull = 0;
4772 if (size > (end - start))
4773 size = (end - start);
4775 buf = bfd_realloc_or_free (buf, size);
4779 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4785 nread = bfd_bread (buf, size, abfd);
4793 for (offset = 4; offset <= size; offset += 4)
4797 val = *((unsigned long *) (buf + size - offset));
4798 if (! found_nonnull)
4803 else if (val == 0x0)
4805 unsigned long bottom;
4808 bottom = seg->fileoff + seg->filesize - offset;
4809 top = seg->fileoff + seg->filesize - 4;
4810 *rbuf = bfd_malloc (top - bottom);
4811 *rlen = top - bottom;
4813 memcpy (*rbuf, buf + size - *rlen, *rlen);
4819 if (size == (end - start))
4833 bfd_mach_o_core_file_failing_command (bfd *abfd)
4835 unsigned char *buf = NULL;
4836 unsigned int len = 0;
4839 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4843 return (char *) buf;
4847 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4852 static bfd_mach_o_uuid_command *
4853 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4855 bfd_mach_o_load_command *uuid_cmd;
4856 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4859 return &uuid_cmd->command.uuid;
4862 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4865 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4867 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4870 BFD_ASSERT (uuid_cmd);
4872 if (!bfd_check_format (abfd, bfd_object))
4875 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4876 || bfd_mach_o_get_data (abfd) == NULL
4877 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4880 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4881 if (dsym_uuid_cmd == NULL)
4884 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4885 sizeof (uuid_cmd->uuid)) != 0)
4891 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4892 The caller is responsible for closing the returned BFD object and
4893 its my_archive if the returned BFD is in a fat dSYM. */
4896 bfd_mach_o_find_dsym (const char *dsym_filename,
4897 const bfd_mach_o_uuid_command *uuid_cmd,
4898 const bfd_arch_info_type *arch)
4900 bfd *base_dsym_bfd, *dsym_bfd;
4902 BFD_ASSERT (uuid_cmd);
4904 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4905 if (base_dsym_bfd == NULL)
4908 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4909 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4912 bfd_close (dsym_bfd);
4913 if (base_dsym_bfd != dsym_bfd)
4914 bfd_close (base_dsym_bfd);
4919 /* Return a BFD created from a dSYM file for ABFD.
4920 The caller is responsible for closing the returned BFD object, its
4921 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4924 bfd_mach_o_follow_dsym (bfd *abfd)
4926 char *dsym_filename;
4927 bfd_mach_o_uuid_command *uuid_cmd;
4928 bfd *dsym_bfd, *base_bfd = abfd;
4929 const char *base_basename;
4931 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4934 if (abfd->my_archive)
4935 base_bfd = abfd->my_archive;
4936 /* BFD may have been opened from a stream. */
4937 if (base_bfd->filename == NULL)
4939 bfd_set_error (bfd_error_invalid_operation);
4942 base_basename = lbasename (base_bfd->filename);
4944 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4945 if (uuid_cmd == NULL)
4948 /* TODO: We assume the DWARF file has the same as the binary's.
4949 It seems apple's GDB checks all files in the dSYM bundle directory.
4950 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4952 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4953 + strlen (dsym_subdir) + 1
4954 + strlen (base_basename) + 1);
4955 sprintf (dsym_filename, "%s%s/%s",
4956 base_bfd->filename, dsym_subdir, base_basename);
4958 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4959 bfd_get_arch_info (abfd));
4960 if (dsym_bfd == NULL)
4961 free (dsym_filename);
4967 bfd_mach_o_find_nearest_line (bfd *abfd,
4971 const char **filename_ptr,
4972 const char **functionname_ptr,
4973 unsigned int *line_ptr)
4975 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4978 switch (mdata->header.filetype)
4980 case BFD_MACH_O_MH_OBJECT:
4982 case BFD_MACH_O_MH_EXECUTE:
4983 case BFD_MACH_O_MH_DYLIB:
4984 case BFD_MACH_O_MH_BUNDLE:
4985 case BFD_MACH_O_MH_KEXT_BUNDLE:
4986 if (mdata->dwarf2_find_line_info == NULL)
4988 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4989 /* When we couldn't find dSYM for this binary, we look for
4990 the debug information in the binary itself. In this way,
4991 we won't try finding separated dSYM again because
4992 mdata->dwarf2_find_line_info will be filled. */
4993 if (! mdata->dsym_bfd)
4995 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4996 dwarf_debug_sections, symbols,
4997 &mdata->dwarf2_find_line_info))
5004 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
5005 section, symbols, offset,
5006 filename_ptr, functionname_ptr,
5008 &mdata->dwarf2_find_line_info))
5014 bfd_mach_o_close_and_cleanup (bfd *abfd)
5016 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5017 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5019 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5020 bfd_mach_o_free_cached_info (abfd);
5021 if (mdata->dsym_bfd != NULL)
5023 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5024 char *dsym_filename = (char *)(fat_bfd
5026 : mdata->dsym_bfd->filename);
5027 bfd_close (mdata->dsym_bfd);
5028 mdata->dsym_bfd = NULL;
5030 bfd_close (fat_bfd);
5031 free (dsym_filename);
5035 if (bfd_get_format (abfd) == bfd_archive
5036 && abfd->xvec == &mach_o_fat_vec)
5038 return _bfd_generic_close_and_cleanup (abfd);
5041 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5043 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5045 free (mdata->dyn_reloc_cache);
5046 mdata->dyn_reloc_cache = NULL;
5047 for (asect = abfd->sections; asect != NULL; asect = asect->next)
5049 free (asect->relocation);
5050 asect->relocation = NULL;
5056 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5057 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5059 #define bfd_mach_o_swap_reloc_in NULL
5060 #define bfd_mach_o_swap_reloc_out NULL
5061 #define bfd_mach_o_print_thread NULL
5062 #define bfd_mach_o_tgt_seg_table NULL
5063 #define bfd_mach_o_section_type_valid_for_tgt NULL
5065 #define TARGET_NAME mach_o_be_vec
5066 #define TARGET_STRING "mach-o-be"
5067 #define TARGET_ARCHITECTURE bfd_arch_unknown
5068 #define TARGET_BIG_ENDIAN 1
5069 #define TARGET_ARCHIVE 0
5070 #define TARGET_PRIORITY 1
5071 #include "mach-o-target.c"
5074 #undef TARGET_STRING
5075 #undef TARGET_ARCHITECTURE
5076 #undef TARGET_BIG_ENDIAN
5077 #undef TARGET_ARCHIVE
5078 #undef TARGET_PRIORITY
5080 #define TARGET_NAME mach_o_le_vec
5081 #define TARGET_STRING "mach-o-le"
5082 #define TARGET_ARCHITECTURE bfd_arch_unknown
5083 #define TARGET_BIG_ENDIAN 0
5084 #define TARGET_ARCHIVE 0
5085 #define TARGET_PRIORITY 1
5087 #include "mach-o-target.c"
5090 #undef TARGET_STRING
5091 #undef TARGET_ARCHITECTURE
5092 #undef TARGET_BIG_ENDIAN
5093 #undef TARGET_ARCHIVE
5094 #undef TARGET_PRIORITY
5096 /* Not yet handled: creating an archive. */
5097 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5100 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5101 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5102 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5103 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5104 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5105 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5106 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5107 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5108 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5109 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5111 #define TARGET_NAME mach_o_fat_vec
5112 #define TARGET_STRING "mach-o-fat"
5113 #define TARGET_ARCHITECTURE bfd_arch_unknown
5114 #define TARGET_BIG_ENDIAN 1
5115 #define TARGET_ARCHIVE 1
5116 #define TARGET_PRIORITY 0
5118 #include "mach-o-target.c"
5121 #undef TARGET_STRING
5122 #undef TARGET_ARCHITECTURE
5123 #undef TARGET_BIG_ENDIAN
5124 #undef TARGET_ARCHIVE
5125 #undef TARGET_PRIORITY