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 <= BFD_MACH_O_SEGNAME_SIZE
471 && seclen <= BFD_MACH_O_SECTNAME_SIZE)
473 memcpy (section->segname, name, seglen);
474 section->segname[seglen] = 0;
475 memcpy (section->sectname, dot + 1, seclen);
476 section->sectname[seclen] = 0;
481 /* The segment and section names are both missing - don't make them
483 if (dot && dot == name)
486 /* Just duplicate the name into both segment and section. */
489 memcpy (section->segname, name, len);
490 section->segname[len] = 0;
491 memcpy (section->sectname, name, len);
492 section->sectname[len] = 0;
496 /* Return the size of an entry for section SEC.
497 Must be called only for symbol pointer section and symbol stubs
501 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
503 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
505 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
506 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
507 return bfd_mach_o_wide_p (abfd) ? 8 : 4;
508 case BFD_MACH_O_S_SYMBOL_STUBS:
509 return sec->reserved2;
516 /* Return the number of indirect symbols for a section.
517 Must be called only for symbol pointer section and symbol stubs
521 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
525 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
529 return sec->size / elsz;
533 /* Copy any private info we understand from the input symbol
534 to the output symbol. */
537 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
539 bfd *obfd ATTRIBUTE_UNUSED,
542 bfd_mach_o_asymbol *os, *is;
543 os = (bfd_mach_o_asymbol *)osymbol;
544 is = (bfd_mach_o_asymbol *)isymbol;
545 os->n_type = is->n_type;
546 os->n_sect = is->n_sect;
547 os->n_desc = is->n_desc;
548 os->symbol.udata.i = is->symbol.udata.i;
552 /* Copy any private info we understand from the input section
553 to the output section. */
556 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
558 bfd *obfd ATTRIBUTE_UNUSED,
561 if (osection->used_by_bfd == NULL)
562 osection->used_by_bfd = isection->used_by_bfd;
564 if (isection->used_by_bfd != NULL)
565 memcpy (osection->used_by_bfd, isection->used_by_bfd,
566 sizeof (bfd_mach_o_section));
568 if (osection->used_by_bfd != NULL)
569 ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
574 /* Copy any private info we understand from the input bfd
575 to the output bfd. */
578 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
580 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
581 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
584 BFD_ASSERT (bfd_mach_o_valid (ibfd));
585 BFD_ASSERT (bfd_mach_o_valid (obfd));
587 /* FIXME: copy commands. */
592 /* This allows us to set up to 32 bits of flags (unless we invent some
593 fiendish scheme to subdivide). For now, we'll just set the file flags
594 without error checking - just overwrite. */
597 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
599 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
604 mdata->header.flags = flags;
608 /* Count the total number of symbols. */
611 bfd_mach_o_count_symbols (bfd *abfd)
613 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
615 if (mdata->symtab == NULL)
617 return mdata->symtab->nsyms;
621 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
623 long nsyms = bfd_mach_o_count_symbols (abfd);
625 return ((nsyms + 1) * sizeof (asymbol *));
629 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
631 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
632 long nsyms = bfd_mach_o_count_symbols (abfd);
633 bfd_mach_o_symtab_command *sym = mdata->symtab;
641 /* Do not try to read symbols if there are none. */
646 if (!bfd_mach_o_read_symtab_symbols (abfd))
648 (*_bfd_error_handler)
649 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
653 BFD_ASSERT (sym->symbols != NULL);
655 for (j = 0; j < sym->nsyms; j++)
656 alocation[j] = &sym->symbols[j].symbol;
663 /* Create synthetic symbols for indirect symbols. */
666 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
667 long symcount ATTRIBUTE_UNUSED,
668 asymbol **syms ATTRIBUTE_UNUSED,
669 long dynsymcount ATTRIBUTE_UNUSED,
670 asymbol **dynsyms ATTRIBUTE_UNUSED,
673 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
674 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
675 bfd_mach_o_symtab_command *symtab = mdata->symtab;
677 unsigned long count, i, j, n;
684 /* Stop now if no symbols or no indirect symbols. */
685 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
688 if (dysymtab->nindirectsyms == 0)
691 /* We need to allocate a bfd symbol for every indirect symbol and to
692 allocate the memory for its name. */
693 count = dysymtab->nindirectsyms;
694 size = count * sizeof (asymbol) + 1;
696 for (j = 0; j < count; j++)
698 unsigned int isym = dysymtab->indirect_syms[j];
700 /* Some indirect symbols are anonymous. */
701 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
702 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
705 s = *ret = (asymbol *) bfd_malloc (size);
708 names = (char *) (s + count);
713 for (i = 0; i < mdata->nsects; i++)
715 bfd_mach_o_section *sec = mdata->sections[i];
716 unsigned int first, last;
720 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
722 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
723 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
724 case BFD_MACH_O_S_SYMBOL_STUBS:
725 /* Only these sections have indirect symbols. */
726 first = sec->reserved1;
727 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
729 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
730 for (j = first; j < last; j++)
732 unsigned int isym = dysymtab->indirect_syms[j];
734 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
735 s->section = sec->bfdsection;
736 s->value = addr - sec->addr;
739 if (isym < symtab->nsyms
740 && symtab->symbols[isym].symbol.name)
742 const char *sym = symtab->symbols[isym].symbol.name;
747 memcpy (names, sym, len);
749 memcpy (names, "$stub", sizeof ("$stub"));
750 names += sizeof ("$stub");
769 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
773 bfd_symbol_info (symbol, ret);
777 bfd_mach_o_print_symbol (bfd *abfd,
780 bfd_print_symbol_type how)
782 FILE *file = (FILE *) afile;
784 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
788 case bfd_print_symbol_name:
789 fprintf (file, "%s", symbol->name);
792 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
793 if (asym->n_type & BFD_MACH_O_N_STAB)
794 name = bfd_get_stab_name (asym->n_type);
796 switch (asym->n_type & BFD_MACH_O_N_TYPE)
798 case BFD_MACH_O_N_UNDF:
799 if (symbol->value == 0)
804 case BFD_MACH_O_N_ABS:
807 case BFD_MACH_O_N_INDR:
810 case BFD_MACH_O_N_PBUD:
813 case BFD_MACH_O_N_SECT:
822 fprintf (file, " %02x %-6s %02x %04x",
823 asym->n_type, name, asym->n_sect, asym->n_desc);
824 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
825 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
826 fprintf (file, " [%s]", symbol->section->name);
827 fprintf (file, " %s", symbol->name);
832 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
833 bfd_mach_o_cpu_subtype msubtype,
834 enum bfd_architecture *type,
835 unsigned long *subtype)
837 *subtype = bfd_arch_unknown;
841 case BFD_MACH_O_CPU_TYPE_VAX:
842 *type = bfd_arch_vax;
844 case BFD_MACH_O_CPU_TYPE_MC680x0:
845 *type = bfd_arch_m68k;
847 case BFD_MACH_O_CPU_TYPE_I386:
848 *type = bfd_arch_i386;
849 *subtype = bfd_mach_i386_i386;
851 case BFD_MACH_O_CPU_TYPE_X86_64:
852 *type = bfd_arch_i386;
853 *subtype = bfd_mach_x86_64;
855 case BFD_MACH_O_CPU_TYPE_MIPS:
856 *type = bfd_arch_mips;
858 case BFD_MACH_O_CPU_TYPE_MC98000:
859 *type = bfd_arch_m98k;
861 case BFD_MACH_O_CPU_TYPE_HPPA:
862 *type = bfd_arch_hppa;
864 case BFD_MACH_O_CPU_TYPE_ARM:
865 *type = bfd_arch_arm;
868 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
869 *subtype = bfd_mach_arm_4T;
871 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
872 *subtype = bfd_mach_arm_4T; /* Best fit ? */
874 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
875 *subtype = bfd_mach_arm_5TE;
877 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
878 *subtype = bfd_mach_arm_XScale;
880 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
881 *subtype = bfd_mach_arm_5TE; /* Best fit ? */
883 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
888 case BFD_MACH_O_CPU_TYPE_MC88000:
889 *type = bfd_arch_m88k;
891 case BFD_MACH_O_CPU_TYPE_SPARC:
892 *type = bfd_arch_sparc;
893 *subtype = bfd_mach_sparc;
895 case BFD_MACH_O_CPU_TYPE_I860:
896 *type = bfd_arch_i860;
898 case BFD_MACH_O_CPU_TYPE_ALPHA:
899 *type = bfd_arch_alpha;
901 case BFD_MACH_O_CPU_TYPE_POWERPC:
902 *type = bfd_arch_powerpc;
903 *subtype = bfd_mach_ppc;
905 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
906 *type = bfd_arch_powerpc;
907 *subtype = bfd_mach_ppc64;
909 case BFD_MACH_O_CPU_TYPE_ARM64:
910 *type = bfd_arch_aarch64;
911 *subtype = bfd_mach_aarch64;
914 *type = bfd_arch_unknown;
920 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
922 struct mach_o_header_external raw;
925 size = mach_o_wide_p (header) ?
926 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
928 bfd_h_put_32 (abfd, header->magic, raw.magic);
929 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
930 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
931 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
932 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
933 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
934 bfd_h_put_32 (abfd, header->flags, raw.flags);
936 if (mach_o_wide_p (header))
937 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
939 if (bfd_seek (abfd, 0, SEEK_SET) != 0
940 || bfd_bwrite (&raw, size, abfd) != size)
947 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
949 bfd_mach_o_thread_command *cmd = &command->command.thread;
951 struct mach_o_thread_command_external raw;
954 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
955 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
958 for (i = 0; i < cmd->nflavours; i++)
960 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
961 BFD_ASSERT (cmd->flavours[i].offset ==
962 (command->offset + offset + BFD_MACH_O_LC_SIZE));
964 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
965 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
967 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
968 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
971 offset += cmd->flavours[i].size + sizeof (raw);
978 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
981 return (asect->reloc_count + 1) * sizeof (arelent *);
984 /* In addition to the need to byte-swap the symbol number, the bit positions
985 of the fields in the relocation information vary per target endian-ness. */
988 bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
989 unsigned char *fields)
991 unsigned char info = fields[3];
993 if (bfd_big_endian (abfd))
995 rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
996 rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
997 rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
998 rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
999 & BFD_MACH_O_LENGTH_MASK;
1000 rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
1004 rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1005 rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1006 rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1007 rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1008 & BFD_MACH_O_LENGTH_MASK;
1009 rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1014 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
1015 struct mach_o_reloc_info_external *raw,
1016 arelent *res, asymbol **syms)
1018 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1019 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1020 bfd_mach_o_reloc_info reloc;
1024 addr = bfd_get_32 (abfd, raw->r_address);
1025 res->sym_ptr_ptr = NULL;
1028 if (addr & BFD_MACH_O_SR_SCATTERED)
1031 bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1033 /* Scattered relocation, can't be extern. */
1034 reloc.r_scattered = 1;
1037 /* Extract section and offset from r_value (symnum). */
1038 reloc.r_value = symnum;
1039 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1040 end of the data for the section (e.g. in a calculation of section
1041 data length). At present, the symbol will end up associated with
1042 the following section or, if it falls within alignment padding, as
1043 null - which will assert later. */
1044 for (j = 0; j < mdata->nsects; j++)
1046 bfd_mach_o_section *sect = mdata->sections[j];
1047 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1049 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1050 res->addend = symnum - sect->addr;
1055 /* Extract the info and address fields from r_address. */
1056 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1057 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1058 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1059 reloc.r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1060 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1066 /* Non-scattered relocation. */
1067 reloc.r_scattered = 0;
1069 /* The value and info fields have to be extracted dependent on target
1071 bfd_mach_o_swap_in_non_scattered_reloc (abfd, &reloc, raw->r_symbolnum);
1072 num = reloc.r_value;
1076 /* An external symbol number. */
1079 else if (num == 0x00ffffff || num == 0)
1081 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1082 is generic code, we don't know wether this is really a PAIR.
1083 This value is almost certainly not a valid section number, hence
1084 this specific case to avoid an assertion failure.
1085 Target specific swap_reloc_in routine should adjust that. */
1086 sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1090 /* A section number. */
1091 BFD_ASSERT (num <= mdata->nsects);
1093 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1094 /* For a symbol defined in section S, the addend (stored in the
1095 binary) contains the address of the section. To comply with
1096 bfd convention, subtract the section address.
1097 Use the address from the header, so that the user can modify
1098 the vma of the section. */
1099 res->addend = -mdata->sections[num - 1]->addr;
1101 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1102 in the lower 16bits of the address value. So we have to find the
1103 'symbol' from the preceding reloc. We do this even though the
1104 section symbol is probably not needed here, because NULL symbol
1105 values cause an assert in generic BFD code. This must be done in
1106 the PPC swap_reloc_in routine. */
1107 res->sym_ptr_ptr = sym;
1109 /* The 'address' is just r_address.
1110 ??? maybe this should be masked with 0xffffff for safety. */
1111 res->address = addr;
1112 reloc.r_address = addr;
1115 /* We have set up a reloc with all the information present, so the swapper
1116 can modify address, value and addend fields, if necessary, to convey
1117 information in the generic BFD reloc that is mach-o specific. */
1119 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1125 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1126 unsigned long count,
1127 arelent *res, asymbol **syms)
1130 struct mach_o_reloc_info_external *native_relocs;
1131 bfd_size_type native_size;
1133 /* Allocate and read relocs. */
1134 native_size = count * BFD_MACH_O_RELENT_SIZE;
1136 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1137 if (native_relocs == NULL)
1140 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1141 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1144 for (i = 0; i < count; i++)
1146 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1150 free (native_relocs);
1153 free (native_relocs);
1158 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1159 arelent **rels, asymbol **syms)
1161 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1165 if (asect->reloc_count == 0)
1168 /* No need to go further if we don't know how to read relocs. */
1169 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1172 if (asect->relocation == NULL)
1174 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1178 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1179 asect->reloc_count, res, syms) < 0)
1184 asect->relocation = res;
1187 res = asect->relocation;
1188 for (i = 0; i < asect->reloc_count; i++)
1196 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1198 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1200 if (mdata->dysymtab == NULL)
1202 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1203 * sizeof (arelent *);
1207 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1208 struct bfd_symbol **syms)
1210 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1211 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1212 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1216 if (dysymtab == NULL)
1218 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1221 /* No need to go further if we don't know how to read relocs. */
1222 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1225 if (mdata->dyn_reloc_cache == NULL)
1227 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1228 * sizeof (arelent));
1232 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1233 dysymtab->nextrel, res, syms) < 0)
1239 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1241 res + dysymtab->nextrel, syms) < 0)
1247 mdata->dyn_reloc_cache = res;
1250 res = mdata->dyn_reloc_cache;
1251 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1257 /* In addition to the need to byte-swap the symbol number, the bit positions
1258 of the fields in the relocation information vary per target endian-ness. */
1261 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1262 bfd_mach_o_reloc_info *rel)
1264 unsigned char info = 0;
1266 BFD_ASSERT (rel->r_type <= 15);
1267 BFD_ASSERT (rel->r_length <= 3);
1269 if (bfd_big_endian (abfd))
1271 fields[0] = (rel->r_value >> 16) & 0xff;
1272 fields[1] = (rel->r_value >> 8) & 0xff;
1273 fields[2] = rel->r_value & 0xff;
1274 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1275 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1276 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1277 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1281 fields[2] = (rel->r_value >> 16) & 0xff;
1282 fields[1] = (rel->r_value >> 8) & 0xff;
1283 fields[0] = rel->r_value & 0xff;
1284 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1285 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1286 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1287 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1293 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1298 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1300 sec = section->bfdsection;
1301 if (sec->reloc_count == 0)
1304 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1307 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1310 /* Convert and write. */
1311 entries = section->bfdsection->orelocation;
1312 for (i = 0; i < section->nreloc; i++)
1314 arelent *rel = entries[i];
1315 struct mach_o_reloc_info_external raw;
1316 bfd_mach_o_reloc_info info, *pinfo = &info;
1318 /* Convert relocation to an intermediate representation. */
1319 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1322 /* Lower the relocation info. */
1323 if (pinfo->r_scattered)
1327 v = BFD_MACH_O_SR_SCATTERED
1328 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1329 | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
1330 | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
1331 | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
1332 /* Note: scattered relocs have field in reverse order... */
1333 bfd_put_32 (abfd, v, raw.r_address);
1334 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1338 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1339 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1343 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1344 != BFD_MACH_O_RELENT_SIZE)
1351 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1353 struct mach_o_section_32_external raw;
1355 memcpy (raw.sectname, section->sectname, 16);
1356 memcpy (raw.segname, section->segname, 16);
1357 bfd_h_put_32 (abfd, section->addr, raw.addr);
1358 bfd_h_put_32 (abfd, section->size, raw.size);
1359 bfd_h_put_32 (abfd, section->offset, raw.offset);
1360 bfd_h_put_32 (abfd, section->align, raw.align);
1361 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1362 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1363 bfd_h_put_32 (abfd, section->flags, raw.flags);
1364 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1365 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1367 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1368 != BFD_MACH_O_SECTION_SIZE)
1375 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1377 struct mach_o_section_64_external raw;
1379 memcpy (raw.sectname, section->sectname, 16);
1380 memcpy (raw.segname, section->segname, 16);
1381 bfd_h_put_64 (abfd, section->addr, raw.addr);
1382 bfd_h_put_64 (abfd, section->size, raw.size);
1383 bfd_h_put_32 (abfd, section->offset, raw.offset);
1384 bfd_h_put_32 (abfd, section->align, raw.align);
1385 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1386 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1387 bfd_h_put_32 (abfd, section->flags, raw.flags);
1388 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1389 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1390 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1392 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1393 != BFD_MACH_O_SECTION_64_SIZE)
1400 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1402 struct mach_o_segment_command_32_external raw;
1403 bfd_mach_o_segment_command *seg = &command->command.segment;
1404 bfd_mach_o_section *sec;
1406 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1408 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1409 if (!bfd_mach_o_write_relocs (abfd, sec))
1412 memcpy (raw.segname, seg->segname, 16);
1413 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1414 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1415 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1416 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1417 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1418 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1419 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1420 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1422 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1423 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1426 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1427 if (!bfd_mach_o_write_section_32 (abfd, sec))
1434 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1436 struct mach_o_segment_command_64_external raw;
1437 bfd_mach_o_segment_command *seg = &command->command.segment;
1438 bfd_mach_o_section *sec;
1440 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1442 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1443 if (!bfd_mach_o_write_relocs (abfd, sec))
1446 memcpy (raw.segname, seg->segname, 16);
1447 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1448 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1449 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1450 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1451 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1452 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1453 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1454 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1456 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1457 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1460 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1461 if (!bfd_mach_o_write_section_64 (abfd, sec))
1468 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1470 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1471 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1473 unsigned int wide = bfd_mach_o_wide_p (abfd);
1474 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1475 struct bfd_strtab_hash *strtab;
1476 asymbol **symbols = bfd_get_outsymbols (abfd);
1478 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1480 /* Write the symbols first. */
1481 mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
1482 sym->symoff = mdata->filelen;
1483 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1486 sym->nsyms = bfd_get_symcount (abfd);
1487 mdata->filelen += sym->nsyms * symlen;
1489 strtab = _bfd_stringtab_init ();
1494 /* Although we don't strictly need to do this, for compatibility with
1495 Darwin system tools, actually output an empty string for the index
1497 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1499 for (i = 0; i < sym->nsyms; i++)
1501 bfd_size_type str_index;
1502 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1504 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1505 /* An index of 0 always means the empty string. */
1509 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1511 if (str_index == (bfd_size_type) -1)
1517 struct mach_o_nlist_64_external raw;
1519 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1520 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1521 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1522 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1523 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1526 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1531 struct mach_o_nlist_external raw;
1533 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1534 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1535 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1536 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1537 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1540 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1544 sym->strsize = _bfd_stringtab_size (strtab);
1545 sym->stroff = mdata->filelen;
1546 mdata->filelen += sym->strsize;
1548 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1550 _bfd_stringtab_free (strtab);
1554 struct mach_o_symtab_command_external raw;
1556 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1557 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1558 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1559 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1561 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1562 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1569 _bfd_stringtab_free (strtab);
1573 /* Write a dysymtab command.
1574 TODO: Possibly coalesce writes of smaller objects. */
1577 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1579 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1581 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1583 if (cmd->nmodtab != 0)
1587 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1590 for (i = 0; i < cmd->nmodtab; i++)
1592 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1596 iinit = module->iinit & 0xffff;
1597 iinit |= ((module->iterm & 0xffff) << 16);
1599 ninit = module->ninit & 0xffff;
1600 ninit |= ((module->nterm & 0xffff) << 16);
1602 if (bfd_mach_o_wide_p (abfd))
1604 struct mach_o_dylib_module_64_external w;
1606 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1607 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1608 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1609 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1610 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1611 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1612 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1613 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1614 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1615 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1616 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1617 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1618 &w.objc_module_info_addr);
1619 bfd_h_put_32 (abfd, module->objc_module_info_size,
1620 &w.objc_module_info_size);
1622 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1627 struct mach_o_dylib_module_external n;
1629 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1630 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1631 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1632 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1633 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1634 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1635 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1636 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1637 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1638 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1639 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1640 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1641 &n.objc_module_info_addr);
1642 bfd_h_put_32 (abfd, module->objc_module_info_size,
1643 &n.objc_module_info_size);
1645 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1655 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1658 for (i = 0; i < cmd->ntoc; i++)
1660 struct mach_o_dylib_table_of_contents_external raw;
1661 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1663 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1664 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1666 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1671 if (cmd->nindirectsyms > 0)
1675 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1678 for (i = 0; i < cmd->nindirectsyms; ++i)
1680 unsigned char raw[4];
1682 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1683 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1688 if (cmd->nextrefsyms != 0)
1692 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1695 for (i = 0; i < cmd->nextrefsyms; i++)
1698 unsigned char raw[4];
1699 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1701 /* Fields isym and flags are written as bit-fields, thus we need
1702 a specific processing for endianness. */
1704 if (bfd_big_endian (abfd))
1706 v = ((ref->isym & 0xffffff) << 8);
1707 v |= ref->flags & 0xff;
1711 v = ref->isym & 0xffffff;
1712 v |= ((ref->flags & 0xff) << 24);
1715 bfd_h_put_32 (abfd, v, raw);
1716 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1722 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1726 struct mach_o_dysymtab_command_external raw;
1728 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1729 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1730 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1731 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1732 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1733 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1734 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1735 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1736 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1737 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1738 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1739 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1740 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1741 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1742 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1743 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1744 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1745 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1747 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1755 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
1757 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
1759 /* Just leave debug symbols where they are (pretend they are local, and
1760 then they will just be sorted on position). */
1761 if (s->n_type & BFD_MACH_O_N_STAB)
1764 /* Local (we should never see an undefined local AFAICT). */
1765 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1768 /* Common symbols look like undefined externs. */
1769 if (mtyp == BFD_MACH_O_N_UNDF)
1772 /* A defined non-local, non-debug symbol. */
1777 bfd_mach_o_cf_symbols (const void *a, const void *b)
1779 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1780 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1781 unsigned int soa, sob;
1783 soa = bfd_mach_o_primary_symbol_sort_key (sa);
1784 sob = bfd_mach_o_primary_symbol_sort_key (sb);
1791 /* If it's local or stab, just preserve the input order. */
1794 if (sa->symbol.udata.i < sb->symbol.udata.i)
1796 if (sa->symbol.udata.i > sb->symbol.udata.i)
1799 /* This is probably an error. */
1803 /* The second sort key is name. */
1804 return strcmp (sa->symbol.name, sb->symbol.name);
1807 /* Process the symbols.
1809 This should be OK for single-module files - but it is not likely to work
1810 for multi-module shared libraries.
1812 (a) If the application has not filled in the relevant mach-o fields, make
1815 (b) Order them, like this:
1818 ( ii) external defined
1820 (iii) external undefined/common
1827 bfd_mach_o_mangle_symbols (bfd *abfd)
1830 asymbol **symbols = bfd_get_outsymbols (abfd);
1832 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1835 for (i = 0; i < bfd_get_symcount (abfd); i++)
1837 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1839 /* We use this value, which is out-of-range as a symbol index, to signal
1840 that the mach-o-specific data are not filled in and need to be created
1841 from the bfd values. It is much preferable for the application to do
1842 this, since more meaningful diagnostics can be made that way. */
1844 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1846 /* No symbol information has been set - therefore determine
1847 it from the bfd symbol flags/info. */
1848 if (s->symbol.section == bfd_abs_section_ptr)
1849 s->n_type = BFD_MACH_O_N_ABS;
1850 else if (s->symbol.section == bfd_und_section_ptr)
1852 s->n_type = BFD_MACH_O_N_UNDF;
1853 if (s->symbol.flags & BSF_WEAK)
1854 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1855 /* mach-o automatically makes undefined symbols extern. */
1856 s->n_type |= BFD_MACH_O_N_EXT;
1857 s->symbol.flags |= BSF_GLOBAL;
1859 else if (s->symbol.section == bfd_com_section_ptr)
1861 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1862 s->symbol.flags |= BSF_GLOBAL;
1865 s->n_type = BFD_MACH_O_N_SECT;
1867 if (s->symbol.flags & BSF_GLOBAL)
1868 s->n_type |= BFD_MACH_O_N_EXT;
1871 /* Put the section index in, where required. */
1872 if ((s->symbol.section != bfd_abs_section_ptr
1873 && s->symbol.section != bfd_und_section_ptr
1874 && s->symbol.section != bfd_com_section_ptr)
1875 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1876 && s->symbol.name == NULL))
1877 s->n_sect = s->symbol.section->output_section->target_index;
1879 /* Number to preserve order for local and debug syms. */
1880 s->symbol.udata.i = i;
1883 /* Sort the symbols. */
1884 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
1885 sizeof (asymbol *), bfd_mach_o_cf_symbols);
1887 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1889 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1890 s->symbol.udata.i = i; /* renumber. */
1896 /* We build a flat table of sections, which can be re-ordered if necessary.
1897 Fill in the section number and other mach-o-specific data. */
1900 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1903 unsigned target_index;
1906 nsect = bfd_count_sections (abfd);
1908 /* Don't do it if it's already set - assume the application knows what it's
1910 if (mdata->nsects == nsect
1911 && (mdata->nsects == 0 || mdata->sections != NULL))
1914 mdata->nsects = nsect;
1915 mdata->sections = bfd_alloc (abfd,
1916 mdata->nsects * sizeof (bfd_mach_o_section *));
1917 if (mdata->sections == NULL)
1920 /* We need to check that this can be done... */
1922 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1923 " maximum is 255,\n"), nsect);
1925 /* Create Mach-O sections.
1926 Section type, attribute and align should have been set when the
1927 section was created - either read in or specified. */
1929 for (sec = abfd->sections; sec; sec = sec->next)
1931 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1932 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1934 mdata->sections[target_index] = msect;
1936 msect->addr = bfd_get_section_vma (abfd, sec);
1937 msect->size = bfd_get_section_size (sec);
1939 /* Use the largest alignment set, in case it was bumped after the
1940 section was created. */
1941 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1944 sec->target_index = ++target_index;
1951 bfd_mach_o_write_contents (bfd *abfd)
1954 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1956 /* Make the commands, if not already present. */
1957 if (mdata->header.ncmds == 0)
1958 if (!bfd_mach_o_build_commands (abfd))
1961 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1964 for (i = 0; i < mdata->header.ncmds; i++)
1966 struct mach_o_load_command_external raw;
1967 bfd_mach_o_load_command *cur = &mdata->commands[i];
1968 unsigned long typeflag;
1970 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1972 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1973 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1975 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1976 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1981 case BFD_MACH_O_LC_SEGMENT:
1982 if (!bfd_mach_o_write_segment_32 (abfd, cur))
1985 case BFD_MACH_O_LC_SEGMENT_64:
1986 if (!bfd_mach_o_write_segment_64 (abfd, cur))
1989 case BFD_MACH_O_LC_SYMTAB:
1990 if (!bfd_mach_o_write_symtab (abfd, cur))
1993 case BFD_MACH_O_LC_DYSYMTAB:
1994 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1997 case BFD_MACH_O_LC_SYMSEG:
1999 case BFD_MACH_O_LC_THREAD:
2000 case BFD_MACH_O_LC_UNIXTHREAD:
2001 if (!bfd_mach_o_write_thread (abfd, cur))
2004 case BFD_MACH_O_LC_LOADFVMLIB:
2005 case BFD_MACH_O_LC_IDFVMLIB:
2006 case BFD_MACH_O_LC_IDENT:
2007 case BFD_MACH_O_LC_FVMFILE:
2008 case BFD_MACH_O_LC_PREPAGE:
2009 case BFD_MACH_O_LC_LOAD_DYLIB:
2010 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2011 case BFD_MACH_O_LC_ID_DYLIB:
2012 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2013 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
2014 case BFD_MACH_O_LC_LOAD_DYLINKER:
2015 case BFD_MACH_O_LC_ID_DYLINKER:
2016 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2017 case BFD_MACH_O_LC_ROUTINES:
2018 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2021 (*_bfd_error_handler)
2022 (_("unable to write unknown load command 0x%lx"),
2023 (unsigned long) cur->type);
2032 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2035 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
2036 if (seg->sect_head == NULL)
2039 seg->sect_tail->next = s;
2043 /* Create section Mach-O flags from BFD flags. */
2046 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2050 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2052 /* Create default flags. */
2053 bfd_flags = bfd_get_section_flags (abfd, sec);
2054 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2055 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2056 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2057 | BFD_MACH_O_S_REGULAR;
2058 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2059 s->flags = BFD_MACH_O_S_ZEROFILL;
2060 else if (bfd_flags & SEC_DEBUGGING)
2061 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2063 s->flags = BFD_MACH_O_S_REGULAR;
2066 /* Count the number of sections in the list for the segment named.
2068 The special case of NULL or "" for the segment name is valid for
2069 an MH_OBJECT file and means 'all sections available'.
2071 Requires that the sections table in mdata be filled in.
2073 Returns the number of sections (0 is valid).
2074 Any number > 255 signals an invalid section count, although we will,
2075 perhaps, allow the file to be written (in line with Darwin tools up
2078 A section count of (unsigned long) -1 signals a definite error. */
2080 static unsigned long
2081 bfd_mach_o_count_sections_for_seg (const char *segment,
2082 bfd_mach_o_data_struct *mdata)
2085 if (mdata == NULL || mdata->sections == NULL)
2086 return (unsigned long) -1;
2088 /* The MH_OBJECT case, all sections are considered; Although nsects is
2089 is an unsigned long, the maximum valid section count is 255 and this
2090 will have been checked already by mangle_sections. */
2091 if (segment == NULL || segment[0] == '\0')
2092 return mdata->nsects;
2094 /* Count the number of sections we see in this segment. */
2096 for (i = 0; i < mdata->nsects; ++i)
2098 bfd_mach_o_section *s = mdata->sections[i];
2099 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2106 bfd_mach_o_build_seg_command (const char *segment,
2107 bfd_mach_o_data_struct *mdata,
2108 bfd_mach_o_segment_command *seg)
2111 int is_mho = (segment == NULL || segment[0] == '\0');
2113 /* Fill segment command. */
2115 memset (seg->segname, 0, sizeof (seg->segname));
2117 strncpy (seg->segname, segment, sizeof (seg->segname));
2119 /* TODO: fix this up for non-MH_OBJECT cases. */
2123 seg->fileoff = mdata->filelen;
2125 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2126 | BFD_MACH_O_PROT_EXECUTE;
2127 seg->initprot = seg->maxprot;
2129 seg->sect_head = NULL;
2130 seg->sect_tail = NULL;
2132 /* Append sections to the segment.
2134 This is a little tedious, we have to honor the need to account zerofill
2135 sections after all the rest. This forces us to do the calculation of
2136 total vmsize in three passes so that any alignment increments are
2137 properly accounted. */
2139 for (i = 0; i < mdata->nsects; ++i)
2141 bfd_mach_o_section *s = mdata->sections[i];
2142 asection *sec = s->bfdsection;
2144 /* If we're not making an MH_OBJECT, check whether this section is from
2145 our segment, and skip if not. Otherwise, just add all sections. */
2147 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2150 /* Although we account for zerofill section sizes in vm order, they are
2151 placed in the file in source sequence. */
2152 bfd_mach_o_append_section_to_segment (seg, sec);
2155 /* Zerofill sections have zero file size & offset,
2156 and are not written. */
2157 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2158 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2159 == BFD_MACH_O_S_GB_ZEROFILL)
2164 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2165 seg->vmsize += s->size;
2167 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2168 seg->filesize += s->size;
2170 /* Note: follow alignment even for object file. */
2171 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2172 s->offset = mdata->filelen;
2175 sec->filepos = s->offset;
2176 mdata->filelen += s->size;
2179 /* Be sure the file offset of the segment is the file offset of its first
2180 section (may have changed due to alignment). */
2181 if (seg->sect_head != NULL)
2182 seg->fileoff = seg->sect_head->offset;
2184 /* Now pass through again, for zerofill, only now we just update the
2186 for (i = 0; i < mdata->nsects; ++i)
2188 bfd_mach_o_section *s = mdata->sections[i];
2190 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2194 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2199 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2200 seg->vmsize += s->size;
2204 /* Now pass through again, for zerofill_GB. */
2205 for (i = 0; i < mdata->nsects; ++i)
2207 bfd_mach_o_section *s = mdata->sections[i];
2209 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2213 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2218 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2219 seg->vmsize += s->size;
2223 /* Allocate space for the relocations. */
2224 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2226 for (i = 0; i < mdata->nsects; ++i)
2228 bfd_mach_o_section *ms = mdata->sections[i];
2229 asection *sec = ms->bfdsection;
2231 if ((ms->nreloc = sec->reloc_count) == 0)
2236 sec->rel_filepos = mdata->filelen;
2237 ms->reloff = sec->rel_filepos;
2238 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2244 /* Count the number of indirect symbols in the image.
2245 Requires that the sections are in their final order. */
2248 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2251 unsigned int nisyms = 0;
2253 for (i = 0; i < mdata->nsects; ++i)
2255 bfd_mach_o_section *sec = mdata->sections[i];
2257 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2259 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2260 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2261 case BFD_MACH_O_S_SYMBOL_STUBS:
2262 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2272 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2273 bfd_mach_o_data_struct *mdata,
2274 bfd_mach_o_load_command *cmd)
2276 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2279 We are not going to try and fill these in yet and, moreover, we are
2280 going to bail if they are already set. */
2281 if (dsym->nmodtab != 0
2283 || dsym->nextrefsyms != 0)
2285 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2286 " implemented for dysymtab commands."));
2290 dsym->ilocalsym = 0;
2292 if (bfd_get_symcount (abfd) > 0)
2294 asymbol **symbols = bfd_get_outsymbols (abfd);
2297 /* Count the number of each kind of symbol. */
2298 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2300 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2301 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2304 dsym->nlocalsym = i;
2305 dsym->iextdefsym = i;
2306 for (; i < bfd_get_symcount (abfd); ++i)
2308 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2309 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2312 dsym->nextdefsym = i - dsym->nlocalsym;
2313 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2314 dsym->nundefsym = bfd_get_symcount (abfd)
2320 dsym->nlocalsym = 0;
2321 dsym->iextdefsym = 0;
2322 dsym->nextdefsym = 0;
2323 dsym->iundefsym = 0;
2324 dsym->nundefsym = 0;
2327 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2328 if (dsym->nindirectsyms > 0)
2333 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2334 dsym->indirectsymoff = mdata->filelen;
2335 mdata->filelen += dsym->nindirectsyms * 4;
2337 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2338 if (dsym->indirect_syms == NULL)
2342 for (i = 0; i < mdata->nsects; ++i)
2344 bfd_mach_o_section *sec = mdata->sections[i];
2346 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2348 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2349 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2350 case BFD_MACH_O_S_SYMBOL_STUBS:
2353 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2355 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2356 if (isyms == NULL || num == 0)
2358 /* Record the starting index in the reserved1 field. */
2360 for (j = 0; j < num; j++, n++)
2362 if (isyms[j] == NULL)
2363 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2364 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2365 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2366 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2367 | BFD_MACH_O_INDIRECT_SYM_ABS;
2369 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2382 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2383 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2384 and copy functionality. */
2387 bfd_mach_o_build_commands (bfd *abfd)
2389 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2390 unsigned wide = mach_o_wide_p (&mdata->header);
2391 int segcmd_idx = -1;
2392 int symtab_idx = -1;
2393 int dysymtab_idx = -1;
2394 unsigned long base_offset = 0;
2396 /* Return now if commands are already present. */
2397 if (mdata->header.ncmds)
2400 /* Fill in the file type, if not already set. */
2402 if (mdata->header.filetype == 0)
2404 if (abfd->flags & EXEC_P)
2405 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2406 else if (abfd->flags & DYNAMIC)
2407 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2409 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2412 /* If hasn't already been done, flatten sections list, and sort
2413 if/when required. Must be done before the symbol table is adjusted,
2414 since that depends on properly numbered sections. */
2415 if (mdata->nsects == 0 || mdata->sections == NULL)
2416 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2419 /* Order the symbol table, fill-in/check mach-o specific fields and
2420 partition out any indirect symbols. */
2421 if (!bfd_mach_o_mangle_symbols (abfd))
2424 /* Very simple command set (only really applicable to MH_OBJECTs):
2425 All the commands are optional - present only when there is suitable data.
2426 (i.e. it is valid to have an empty file)
2428 a command (segment) to contain all the sections,
2429 command for the symbol table,
2430 a command for the dysymtab.
2432 ??? maybe we should assert that this is an MH_OBJECT? */
2434 if (mdata->nsects > 0)
2437 mdata->header.ncmds = 1;
2440 if (bfd_get_symcount (abfd) > 0)
2442 mdata->header.ncmds++;
2443 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2447 This is a rather crude test for whether we should build a dysymtab. */
2448 if (bfd_mach_o_should_emit_dysymtab ()
2449 && bfd_get_symcount (abfd))
2451 mdata->header.ncmds++;
2452 /* If there should be a case where a dysymtab could be emitted without
2453 a symtab (seems improbable), this would need amending. */
2454 dysymtab_idx = symtab_idx + 1;
2458 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2460 base_offset = BFD_MACH_O_HEADER_SIZE;
2462 /* Well, we must have a header, at least. */
2463 mdata->filelen = base_offset;
2465 /* A bit unusual, but no content is valid;
2466 as -n empty.s -o empty.o */
2467 if (mdata->header.ncmds == 0)
2470 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2471 * sizeof (bfd_mach_o_load_command));
2472 if (mdata->commands == NULL)
2475 if (segcmd_idx >= 0)
2477 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2478 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2480 /* Count the segctions in the special blank segment used
2482 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2483 if (seg->nsects == (unsigned long) -1)
2486 /* Init segment command. */
2487 cmd->offset = base_offset;
2490 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2491 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2492 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2496 cmd->type = BFD_MACH_O_LC_SEGMENT;
2497 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2498 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2501 cmd->type_required = FALSE;
2502 mdata->header.sizeofcmds = cmd->len;
2503 mdata->filelen += cmd->len;
2506 if (symtab_idx >= 0)
2508 /* Init symtab command. */
2509 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2511 cmd->type = BFD_MACH_O_LC_SYMTAB;
2512 cmd->offset = base_offset;
2513 if (segcmd_idx >= 0)
2514 cmd->offset += mdata->commands[segcmd_idx].len;
2516 cmd->len = sizeof (struct mach_o_symtab_command_external)
2517 + BFD_MACH_O_LC_SIZE;
2518 cmd->type_required = FALSE;
2519 mdata->header.sizeofcmds += cmd->len;
2520 mdata->filelen += cmd->len;
2523 /* If required, setup symtab command, see comment above about the quality
2525 if (dysymtab_idx >= 0)
2527 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2529 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2530 if (symtab_idx >= 0)
2531 cmd->offset = mdata->commands[symtab_idx].offset
2532 + mdata->commands[symtab_idx].len;
2533 else if (segcmd_idx >= 0)
2534 cmd->offset = mdata->commands[segcmd_idx].offset
2535 + mdata->commands[segcmd_idx].len;
2537 cmd->offset = base_offset;
2539 cmd->type_required = FALSE;
2540 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2541 + BFD_MACH_O_LC_SIZE;
2543 mdata->header.sizeofcmds += cmd->len;
2544 mdata->filelen += cmd->len;
2547 /* So, now we have sized the commands and the filelen set to that.
2548 Now we can build the segment command and set the section file offsets. */
2550 && ! bfd_mach_o_build_seg_command
2551 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2554 /* If we're doing a dysymtab, cmd points to its load command. */
2555 if (dysymtab_idx >= 0
2556 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2557 &mdata->commands[dysymtab_idx]))
2560 /* The symtab command is filled in when the symtab is written. */
2564 /* Set the contents of a section. */
2567 bfd_mach_o_set_section_contents (bfd *abfd,
2569 const void * location,
2571 bfd_size_type count)
2575 /* Trying to write the first section contents will trigger the creation of
2576 the load commands if they are not already present. */
2577 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2583 pos = section->filepos + offset;
2584 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2585 || bfd_bwrite (location, count, abfd) != count)
2592 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2593 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2598 /* Make an empty symbol. This is required only because
2599 bfd_make_section_anyway wants to create a symbol for the section. */
2602 bfd_mach_o_make_empty_symbol (bfd *abfd)
2604 asymbol *new_symbol;
2606 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2607 if (new_symbol == NULL)
2609 new_symbol->the_bfd = abfd;
2610 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2615 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2617 struct mach_o_header_external raw;
2619 bfd_vma (*get32) (const void *) = NULL;
2621 /* Just read the magic number. */
2622 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2623 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2626 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2628 header->byteorder = BFD_ENDIAN_BIG;
2629 header->magic = BFD_MACH_O_MH_MAGIC;
2630 header->version = 1;
2633 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2635 header->byteorder = BFD_ENDIAN_LITTLE;
2636 header->magic = BFD_MACH_O_MH_MAGIC;
2637 header->version = 1;
2640 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2642 header->byteorder = BFD_ENDIAN_BIG;
2643 header->magic = BFD_MACH_O_MH_MAGIC_64;
2644 header->version = 2;
2647 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2649 header->byteorder = BFD_ENDIAN_LITTLE;
2650 header->magic = BFD_MACH_O_MH_MAGIC_64;
2651 header->version = 2;
2656 header->byteorder = BFD_ENDIAN_UNKNOWN;
2660 /* Once the size of the header is known, read the full header. */
2661 size = mach_o_wide_p (header) ?
2662 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2664 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2665 || bfd_bread (&raw, size, abfd) != size)
2668 header->cputype = (*get32) (raw.cputype);
2669 header->cpusubtype = (*get32) (raw.cpusubtype);
2670 header->filetype = (*get32) (raw.filetype);
2671 header->ncmds = (*get32) (raw.ncmds);
2672 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2673 header->flags = (*get32) (raw.flags);
2675 if (mach_o_wide_p (header))
2676 header->reserved = (*get32) (raw.reserved);
2678 header->reserved = 0;
2684 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2686 bfd_mach_o_section *s;
2687 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2689 s = bfd_mach_o_get_mach_o_section (sec);
2693 static const mach_o_section_name_xlat * xlat;
2695 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2698 sec->used_by_bfd = s;
2699 s->bfdsection = sec;
2701 /* Create the Darwin seg/sect name pair from the bfd name.
2702 If this is a canonical name for which a specific paiting exists
2703 there will also be defined flags, type, attribute and alignment
2705 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2708 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2709 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2711 (void) bfd_set_section_alignment (abfd, sec, s->align);
2712 bfd_flags = bfd_get_section_flags (abfd, sec);
2713 if (bfd_flags == SEC_NO_FLAGS)
2714 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2717 /* Create default flags. */
2718 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2721 return _bfd_generic_new_section_hook (abfd, sec);
2725 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2729 bfd_mach_o_section *section;
2731 flags = bfd_get_section_flags (abfd, sec);
2732 section = bfd_mach_o_get_mach_o_section (sec);
2734 /* TODO: see if we should use the xlat system for doing this by
2735 preference and fall back to this for unknown sections. */
2737 if (flags == SEC_NO_FLAGS)
2739 /* Try to guess flags. */
2740 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2741 flags = SEC_DEBUGGING;
2745 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2746 != BFD_MACH_O_S_ZEROFILL)
2749 if (prot & BFD_MACH_O_PROT_EXECUTE)
2751 if (prot & BFD_MACH_O_PROT_WRITE)
2753 else if (prot & BFD_MACH_O_PROT_READ)
2754 flags |= SEC_READONLY;
2760 if ((flags & SEC_DEBUGGING) == 0)
2764 if (section->offset != 0)
2765 flags |= SEC_HAS_CONTENTS;
2766 if (section->nreloc != 0)
2769 bfd_set_section_flags (abfd, sec, flags);
2771 sec->vma = section->addr;
2772 sec->lma = section->addr;
2773 sec->size = section->size;
2774 sec->filepos = section->offset;
2775 sec->alignment_power = section->align;
2776 sec->segment_mark = 0;
2777 sec->reloc_count = section->nreloc;
2778 sec->rel_filepos = section->reloff;
2782 bfd_mach_o_make_bfd_section (bfd *abfd,
2783 const unsigned char *segname,
2784 const unsigned char *sectname)
2789 bfd_mach_o_convert_section_name_to_bfd
2790 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2794 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2798 bfd_mach_o_read_section_32 (bfd *abfd,
2799 unsigned int offset,
2802 struct mach_o_section_32_external raw;
2804 bfd_mach_o_section *section;
2806 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2807 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2808 != BFD_MACH_O_SECTION_SIZE))
2811 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2815 section = bfd_mach_o_get_mach_o_section (sec);
2816 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2817 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2818 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2819 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2820 section->addr = bfd_h_get_32 (abfd, raw.addr);
2821 section->size = bfd_h_get_32 (abfd, raw.size);
2822 section->offset = bfd_h_get_32 (abfd, raw.offset);
2823 section->align = bfd_h_get_32 (abfd, raw.align);
2824 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2825 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2826 section->flags = bfd_h_get_32 (abfd, raw.flags);
2827 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2828 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2829 section->reserved3 = 0;
2831 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2837 bfd_mach_o_read_section_64 (bfd *abfd,
2838 unsigned int offset,
2841 struct mach_o_section_64_external raw;
2843 bfd_mach_o_section *section;
2845 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2846 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2847 != BFD_MACH_O_SECTION_64_SIZE))
2850 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2854 section = bfd_mach_o_get_mach_o_section (sec);
2855 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2856 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2857 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2858 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2859 section->addr = bfd_h_get_64 (abfd, raw.addr);
2860 section->size = bfd_h_get_64 (abfd, raw.size);
2861 section->offset = bfd_h_get_32 (abfd, raw.offset);
2862 section->align = bfd_h_get_32 (abfd, raw.align);
2863 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2864 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2865 section->flags = bfd_h_get_32 (abfd, raw.flags);
2866 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2867 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2868 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2870 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2876 bfd_mach_o_read_section (bfd *abfd,
2877 unsigned int offset,
2882 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2884 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2888 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2889 bfd_mach_o_symtab_command *sym,
2890 bfd_mach_o_asymbol *s,
2893 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2894 unsigned int wide = mach_o_wide_p (&mdata->header);
2895 unsigned int symwidth =
2896 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2897 unsigned int symoff = sym->symoff + (i * symwidth);
2898 struct mach_o_nlist_64_external raw;
2899 unsigned char type = -1;
2900 unsigned char section = -1;
2902 symvalue value = -1;
2903 unsigned long stroff = -1;
2904 unsigned int symtype = -1;
2906 BFD_ASSERT (sym->strtab != NULL);
2908 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2909 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2911 (*_bfd_error_handler)
2912 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2913 symwidth, (unsigned long) symoff);
2917 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2918 type = bfd_h_get_8 (abfd, raw.n_type);
2919 symtype = type & BFD_MACH_O_N_TYPE;
2920 section = bfd_h_get_8 (abfd, raw.n_sect);
2921 desc = bfd_h_get_16 (abfd, raw.n_desc);
2923 value = bfd_h_get_64 (abfd, raw.n_value);
2925 value = bfd_h_get_32 (abfd, raw.n_value);
2927 if (stroff >= sym->strsize)
2929 (*_bfd_error_handler)
2930 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2931 (unsigned long) stroff,
2932 (unsigned long) sym->strsize);
2936 s->symbol.the_bfd = abfd;
2937 s->symbol.name = sym->strtab + stroff;
2938 s->symbol.value = value;
2939 s->symbol.flags = 0x0;
2940 s->symbol.udata.i = i;
2942 s->n_sect = section;
2945 if (type & BFD_MACH_O_N_STAB)
2947 s->symbol.flags |= BSF_DEBUGGING;
2948 s->symbol.section = bfd_und_section_ptr;
2960 if ((section > 0) && (section <= mdata->nsects))
2962 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2964 s->symbol.value - mdata->sections[section - 1]->addr;
2971 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2972 s->symbol.flags |= BSF_GLOBAL;
2974 s->symbol.flags |= BSF_LOCAL;
2978 case BFD_MACH_O_N_UNDF:
2979 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2980 && s->symbol.value != 0)
2982 /* A common symbol. */
2983 s->symbol.section = bfd_com_section_ptr;
2984 s->symbol.flags = BSF_NO_FLAGS;
2988 s->symbol.section = bfd_und_section_ptr;
2989 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2990 s->symbol.flags |= BSF_WEAK;
2993 case BFD_MACH_O_N_PBUD:
2994 s->symbol.section = bfd_und_section_ptr;
2996 case BFD_MACH_O_N_ABS:
2997 s->symbol.section = bfd_abs_section_ptr;
2999 case BFD_MACH_O_N_SECT:
3000 if ((section > 0) && (section <= mdata->nsects))
3002 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3004 s->symbol.value - mdata->sections[section - 1]->addr;
3008 /* Mach-O uses 0 to mean "no section"; not an error. */
3011 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3012 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3013 s->symbol.name, section, mdata->nsects);
3015 s->symbol.section = bfd_und_section_ptr;
3018 case BFD_MACH_O_N_INDR:
3019 /* FIXME: we don't follow the BFD convention as this indirect symbol
3020 won't be followed by the referenced one. This looks harmless
3021 unless we start using the linker. */
3022 s->symbol.flags |= BSF_INDIRECT;
3023 s->symbol.section = bfd_ind_section_ptr;
3024 s->symbol.value = 0;
3027 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3028 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3029 s->symbol.name, symtype);
3030 s->symbol.section = bfd_und_section_ptr;
3039 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3041 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3042 bfd_mach_o_symtab_command *sym = mdata->symtab;
3044 /* Fail if there is no symtab. */
3048 /* Success if already loaded. */
3052 if (abfd->flags & BFD_IN_MEMORY)
3054 struct bfd_in_memory *b;
3056 b = (struct bfd_in_memory *) abfd->iostream;
3058 if ((sym->stroff + sym->strsize) > b->size)
3060 bfd_set_error (bfd_error_file_truncated);
3063 sym->strtab = (char *) b->buffer + sym->stroff;
3067 sym->strtab = bfd_alloc (abfd, sym->strsize);
3068 if (sym->strtab == NULL)
3071 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3072 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3074 bfd_set_error (bfd_error_file_truncated);
3083 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3085 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3086 bfd_mach_o_symtab_command *sym = mdata->symtab;
3089 if (sym == NULL || sym->symbols)
3091 /* Return now if there are no symbols or if already loaded. */
3095 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3097 if (sym->symbols == NULL)
3099 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3103 if (!bfd_mach_o_read_symtab_strtab (abfd))
3106 for (i = 0; i < sym->nsyms; i++)
3108 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3116 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3118 switch ((int) flavour)
3120 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3121 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3122 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3123 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3124 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3125 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3126 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3127 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3128 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3129 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3130 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3131 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3132 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3133 default: return "UNKNOWN";
3138 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3140 switch ((int) flavour)
3142 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3143 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3144 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3145 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3146 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3147 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3148 default: return "UNKNOWN";
3153 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3155 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3156 struct mach_o_str_command_external raw;
3157 unsigned int nameoff;
3159 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3160 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3163 nameoff = bfd_h_get_32 (abfd, raw.str);
3165 cmd->name_offset = command->offset + nameoff;
3166 cmd->name_len = command->len - nameoff;
3167 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3168 if (cmd->name_str == NULL)
3170 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3171 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3177 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3179 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3180 struct mach_o_dylib_command_external raw;
3181 unsigned int nameoff;
3183 switch (command->type)
3185 case BFD_MACH_O_LC_LOAD_DYLIB:
3186 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3187 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3188 case BFD_MACH_O_LC_ID_DYLIB:
3189 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3190 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3197 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3198 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3201 nameoff = bfd_h_get_32 (abfd, raw.name);
3202 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3203 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3204 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3206 cmd->name_offset = command->offset + nameoff;
3207 cmd->name_len = command->len - nameoff;
3208 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3209 if (cmd->name_str == NULL)
3211 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3212 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3218 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3219 bfd_mach_o_load_command *command)
3221 bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3222 struct mach_o_prebound_dylib_command_external raw;
3223 unsigned int nameoff;
3224 unsigned int modoff;
3225 unsigned int str_len;
3228 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3229 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3232 nameoff = bfd_h_get_32 (abfd, raw.name);
3233 modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3234 if (nameoff > command->len || modoff > command->len)
3237 str_len = command->len - sizeof (raw);
3238 str = bfd_alloc (abfd, str_len);
3241 if (bfd_bread (str, str_len, abfd) != str_len)
3244 cmd->name_offset = command->offset + nameoff;
3245 cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3246 cmd->linked_modules_offset = command->offset + modoff;
3248 cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3249 cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3254 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3255 bfd_mach_o_load_command *command)
3257 bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3258 struct mach_o_prebind_cksum_command_external raw;
3260 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3261 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3264 cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3269 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3270 bfd_mach_o_load_command *command)
3272 bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3273 struct mach_o_twolevel_hints_command_external raw;
3275 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3276 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3279 cmd->offset = bfd_get_32 (abfd, raw.offset);
3280 cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3285 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3287 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3288 struct mach_o_fvmlib_command_external raw;
3289 unsigned int nameoff;
3291 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3292 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3295 nameoff = bfd_h_get_32 (abfd, raw.name);
3296 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3297 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3299 fvm->name_offset = command->offset + nameoff;
3300 fvm->name_len = command->len - nameoff;
3301 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3302 if (fvm->name_str == NULL)
3304 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3305 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3311 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3313 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3314 bfd_mach_o_thread_command *cmd = &command->command.thread;
3315 unsigned int offset;
3316 unsigned int nflavours;
3319 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3320 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3322 /* Count the number of threads. */
3325 while (offset != command->len)
3327 struct mach_o_thread_command_external raw;
3329 if (offset >= command->len)
3332 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3333 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3336 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3340 /* Allocate threads. */
3341 cmd->flavours = bfd_alloc
3342 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3343 if (cmd->flavours == NULL)
3345 cmd->nflavours = nflavours;
3349 while (offset != command->len)
3351 struct mach_o_thread_command_external raw;
3353 if (offset >= command->len)
3356 if (nflavours >= cmd->nflavours)
3359 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3360 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3363 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3364 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3365 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3366 offset += cmd->flavours[nflavours].size + sizeof (raw);
3370 for (i = 0; i < nflavours; i++)
3373 unsigned int snamelen;
3375 const char *flavourstr;
3376 const char *prefix = "LC_THREAD";
3379 switch (mdata->header.cputype)
3381 case BFD_MACH_O_CPU_TYPE_POWERPC:
3382 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3384 bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3386 case BFD_MACH_O_CPU_TYPE_I386:
3387 case BFD_MACH_O_CPU_TYPE_X86_64:
3389 bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3392 flavourstr = "UNKNOWN_ARCHITECTURE";
3396 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3397 sname = bfd_alloc (abfd, snamelen);
3403 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3404 if (bfd_get_section_by_name (abfd, sname) == NULL)
3409 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3413 bfdsec->size = cmd->flavours[i].size;
3414 bfdsec->filepos = cmd->flavours[i].offset;
3415 bfdsec->alignment_power = 0x0;
3417 cmd->section = bfdsec;
3424 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3426 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3427 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3429 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3432 struct mach_o_dysymtab_command_external raw;
3434 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3435 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3438 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3439 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3440 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3441 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3442 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3443 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3444 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3445 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3446 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3447 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3448 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3449 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3450 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3451 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3452 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3453 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3454 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3455 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3458 if (cmd->nmodtab != 0)
3461 int wide = bfd_mach_o_wide_p (abfd);
3462 unsigned int module_len = wide ? 56 : 52;
3465 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3466 if (cmd->dylib_module == NULL)
3469 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3472 for (i = 0; i < cmd->nmodtab; i++)
3474 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3476 unsigned char buf[56];
3478 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3481 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3482 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3483 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3484 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3485 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3486 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3487 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3488 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3489 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3490 v = bfd_h_get_32 (abfd, buf +36);
3491 module->iinit = v & 0xffff;
3492 module->iterm = (v >> 16) & 0xffff;
3493 v = bfd_h_get_32 (abfd, buf + 40);
3494 module->ninit = v & 0xffff;
3495 module->nterm = (v >> 16) & 0xffff;
3498 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3499 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3503 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3504 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3513 cmd->dylib_toc = bfd_alloc
3514 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3515 if (cmd->dylib_toc == NULL)
3518 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3521 for (i = 0; i < cmd->ntoc; i++)
3523 struct mach_o_dylib_table_of_contents_external raw;
3524 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3526 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3529 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3530 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3534 if (cmd->nindirectsyms != 0)
3538 cmd->indirect_syms = bfd_alloc
3539 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3540 if (cmd->indirect_syms == NULL)
3543 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3546 for (i = 0; i < cmd->nindirectsyms; i++)
3548 unsigned char raw[4];
3549 unsigned int *is = &cmd->indirect_syms[i];
3551 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3554 *is = bfd_h_get_32 (abfd, raw);
3558 if (cmd->nextrefsyms != 0)
3563 cmd->ext_refs = bfd_alloc
3564 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3565 if (cmd->ext_refs == NULL)
3568 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3571 for (i = 0; i < cmd->nextrefsyms; i++)
3573 unsigned char raw[4];
3574 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3576 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3579 /* Fields isym and flags are written as bit-fields, thus we need
3580 a specific processing for endianness. */
3581 v = bfd_h_get_32 (abfd, raw);
3582 if (bfd_big_endian (abfd))
3584 ref->isym = (v >> 8) & 0xffffff;
3585 ref->flags = v & 0xff;
3589 ref->isym = v & 0xffffff;
3590 ref->flags = (v >> 24) & 0xff;
3595 if (mdata->dysymtab)
3597 mdata->dysymtab = cmd;
3603 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3605 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3606 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3607 struct mach_o_symtab_command_external raw;
3609 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3611 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3612 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3615 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3616 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3617 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3618 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3619 symtab->symbols = NULL;
3620 symtab->strtab = NULL;
3622 if (symtab->nsyms != 0)
3623 abfd->flags |= HAS_SYMS;
3627 mdata->symtab = symtab;
3632 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3634 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3636 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3638 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3639 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3646 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3648 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3649 struct mach_o_linkedit_data_command_external raw;
3651 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3652 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3655 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3656 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3661 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3663 bfd_mach_o_str_command *cmd = &command->command.str;
3664 struct mach_o_str_command_external raw;
3667 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3668 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3671 off = bfd_get_32 (abfd, raw.str);
3672 cmd->stroff = command->offset + off;
3673 cmd->str_len = command->len - off;
3674 cmd->str = bfd_alloc (abfd, cmd->str_len);
3675 if (cmd->str == NULL)
3677 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3678 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3684 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3686 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3687 struct mach_o_dyld_info_command_external raw;
3689 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3690 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3693 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3694 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3695 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3696 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3697 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3698 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3699 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3700 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3701 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3702 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3707 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3709 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3710 struct mach_o_version_min_command_external raw;
3713 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3714 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3717 ver = bfd_get_32 (abfd, raw.version);
3718 cmd->rel = ver >> 16;
3719 cmd->maj = ver >> 8;
3721 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3726 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3728 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3729 struct mach_o_encryption_info_command_external raw;
3731 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3732 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3735 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3736 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3737 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3742 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3744 bfd_mach_o_main_command *cmd = &command->command.main;
3745 struct mach_o_entry_point_command_external raw;
3747 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3748 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3751 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3752 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3757 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3759 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3760 struct mach_o_source_version_command_external raw;
3763 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3764 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3767 ver = bfd_get_64 (abfd, raw.version);
3768 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3769 generates warnings) in case of the host doesn't support 64 bit
3771 cmd->e = ver & 0x3ff;
3773 cmd->d = ver & 0x3ff;
3775 cmd->c = ver & 0x3ff;
3777 cmd->b = ver & 0x3ff;
3779 cmd->a = ver & 0xffffff;
3784 bfd_mach_o_read_segment (bfd *abfd,
3785 bfd_mach_o_load_command *command,
3788 bfd_mach_o_segment_command *seg = &command->command.segment;
3793 struct mach_o_segment_command_64_external raw;
3795 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3797 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3798 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3801 memcpy (seg->segname, raw.segname, 16);
3802 seg->segname[16] = '\0';
3804 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3805 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3806 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3807 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3808 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3809 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3810 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3811 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3815 struct mach_o_segment_command_32_external raw;
3817 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3819 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3820 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3823 memcpy (seg->segname, raw.segname, 16);
3824 seg->segname[16] = '\0';
3826 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3827 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3828 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3829 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3830 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3831 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3832 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3833 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3835 seg->sect_head = NULL;
3836 seg->sect_tail = NULL;
3838 for (i = 0; i < seg->nsects; i++)
3844 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3845 + (i * BFD_MACH_O_SECTION_64_SIZE);
3847 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3848 + (i * BFD_MACH_O_SECTION_SIZE);
3850 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3854 bfd_mach_o_append_section_to_segment (seg, sec);
3861 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3863 return bfd_mach_o_read_segment (abfd, command, 0);
3867 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3869 return bfd_mach_o_read_segment (abfd, command, 1);
3873 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3875 struct mach_o_load_command_external raw;
3878 /* Read command type and length. */
3879 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3880 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3883 cmd = bfd_h_get_32 (abfd, raw.cmd);
3884 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3885 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3886 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3888 switch (command->type)
3890 case BFD_MACH_O_LC_SEGMENT:
3891 if (!bfd_mach_o_read_segment_32 (abfd, command))
3894 case BFD_MACH_O_LC_SEGMENT_64:
3895 if (!bfd_mach_o_read_segment_64 (abfd, command))
3898 case BFD_MACH_O_LC_SYMTAB:
3899 if (!bfd_mach_o_read_symtab (abfd, command))
3902 case BFD_MACH_O_LC_SYMSEG:
3904 case BFD_MACH_O_LC_THREAD:
3905 case BFD_MACH_O_LC_UNIXTHREAD:
3906 if (!bfd_mach_o_read_thread (abfd, command))
3909 case BFD_MACH_O_LC_LOAD_DYLINKER:
3910 case BFD_MACH_O_LC_ID_DYLINKER:
3911 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
3912 if (!bfd_mach_o_read_dylinker (abfd, command))
3915 case BFD_MACH_O_LC_LOAD_DYLIB:
3916 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3917 case BFD_MACH_O_LC_ID_DYLIB:
3918 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3919 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3920 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3921 if (!bfd_mach_o_read_dylib (abfd, command))
3924 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3925 if (!bfd_mach_o_read_prebound_dylib (abfd, command))
3928 case BFD_MACH_O_LC_LOADFVMLIB:
3929 case BFD_MACH_O_LC_IDFVMLIB:
3930 if (!bfd_mach_o_read_fvmlib (abfd, command))
3933 case BFD_MACH_O_LC_IDENT:
3934 case BFD_MACH_O_LC_FVMFILE:
3935 case BFD_MACH_O_LC_PREPAGE:
3936 case BFD_MACH_O_LC_ROUTINES:
3937 case BFD_MACH_O_LC_ROUTINES_64:
3939 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3940 case BFD_MACH_O_LC_SUB_UMBRELLA:
3941 case BFD_MACH_O_LC_SUB_LIBRARY:
3942 case BFD_MACH_O_LC_SUB_CLIENT:
3943 case BFD_MACH_O_LC_RPATH:
3944 if (!bfd_mach_o_read_str (abfd, command))
3947 case BFD_MACH_O_LC_DYSYMTAB:
3948 if (!bfd_mach_o_read_dysymtab (abfd, command))
3951 case BFD_MACH_O_LC_PREBIND_CKSUM:
3952 if (!bfd_mach_o_read_prebind_cksum (abfd, command))
3955 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3956 if (!bfd_mach_o_read_twolevel_hints (abfd, command))
3959 case BFD_MACH_O_LC_UUID:
3960 if (!bfd_mach_o_read_uuid (abfd, command))
3963 case BFD_MACH_O_LC_CODE_SIGNATURE:
3964 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3965 case BFD_MACH_O_LC_FUNCTION_STARTS:
3966 case BFD_MACH_O_LC_DATA_IN_CODE:
3967 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3968 if (!bfd_mach_o_read_linkedit (abfd, command))
3971 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3972 if (!bfd_mach_o_read_encryption_info (abfd, command))
3975 case BFD_MACH_O_LC_DYLD_INFO:
3976 if (!bfd_mach_o_read_dyld_info (abfd, command))
3979 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3980 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3981 if (!bfd_mach_o_read_version_min (abfd, command))
3984 case BFD_MACH_O_LC_MAIN:
3985 if (!bfd_mach_o_read_main (abfd, command))
3988 case BFD_MACH_O_LC_SOURCE_VERSION:
3989 if (!bfd_mach_o_read_source_version (abfd, command))
3993 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3994 abfd, (unsigned long) command->type);
4002 bfd_mach_o_flatten_sections (bfd *abfd)
4004 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4008 /* Count total number of sections. */
4011 for (i = 0; i < mdata->header.ncmds; i++)
4013 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4014 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4016 bfd_mach_o_segment_command *seg;
4018 seg = &mdata->commands[i].command.segment;
4019 mdata->nsects += seg->nsects;
4023 /* Allocate sections array. */
4024 mdata->sections = bfd_alloc (abfd,
4025 mdata->nsects * sizeof (bfd_mach_o_section *));
4027 /* Fill the array. */
4030 for (i = 0; i < mdata->header.ncmds; i++)
4032 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4033 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4035 bfd_mach_o_segment_command *seg;
4036 bfd_mach_o_section *sec;
4038 seg = &mdata->commands[i].command.segment;
4039 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4041 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4042 mdata->sections[csect++] = sec;
4048 bfd_mach_o_scan_start_address (bfd *abfd)
4050 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4051 bfd_mach_o_thread_command *cmd = NULL;
4054 for (i = 0; i < mdata->header.ncmds; i++)
4055 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
4056 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
4058 cmd = &mdata->commands[i].command.thread;
4061 else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
4062 && mdata->nsects > 1)
4064 bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
4065 bfd_mach_o_section *text_sect = mdata->sections[0];
4068 abfd->start_address = main_cmd->entryoff
4069 + (text_sect->addr - text_sect->offset);
4074 /* An object file has no start address, so do not fail if not found. */
4078 /* FIXME: create a subtarget hook ? */
4079 for (i = 0; i < cmd->nflavours; i++)
4081 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4082 && (cmd->flavours[i].flavour
4083 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4085 unsigned char buf[4];
4087 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4088 || bfd_bread (buf, 4, abfd) != 4)
4091 abfd->start_address = bfd_h_get_32 (abfd, buf);
4093 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4094 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4096 unsigned char buf[4];
4098 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4099 || bfd_bread (buf, 4, abfd) != 4)
4102 abfd->start_address = bfd_h_get_32 (abfd, buf);
4104 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4105 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4107 unsigned char buf[8];
4109 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4110 || bfd_bread (buf, 8, abfd) != 8)
4113 abfd->start_address = bfd_h_get_64 (abfd, buf);
4115 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4116 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4118 unsigned char buf[8];
4120 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4121 || bfd_bread (buf, 8, abfd) != 8)
4124 abfd->start_address = bfd_h_get_64 (abfd, buf);
4132 bfd_mach_o_set_arch_mach (bfd *abfd,
4133 enum bfd_architecture arch,
4134 unsigned long machine)
4136 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4138 /* If this isn't the right architecture for this backend, and this
4139 isn't the generic backend, fail. */
4140 if (arch != bed->arch
4141 && arch != bfd_arch_unknown
4142 && bed->arch != bfd_arch_unknown)
4145 return bfd_default_set_arch_mach (abfd, arch, machine);
4149 bfd_mach_o_scan (bfd *abfd,
4150 bfd_mach_o_header *header,
4151 bfd_mach_o_data_struct *mdata)
4154 enum bfd_architecture cputype;
4155 unsigned long cpusubtype;
4156 unsigned int hdrsize;
4158 hdrsize = mach_o_wide_p (header) ?
4159 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4161 mdata->header = *header;
4163 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4164 switch (header->filetype)
4166 case BFD_MACH_O_MH_OBJECT:
4167 abfd->flags |= HAS_RELOC;
4169 case BFD_MACH_O_MH_EXECUTE:
4170 abfd->flags |= EXEC_P;
4172 case BFD_MACH_O_MH_DYLIB:
4173 case BFD_MACH_O_MH_BUNDLE:
4174 abfd->flags |= DYNAMIC;
4178 abfd->tdata.mach_o_data = mdata;
4180 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4181 &cputype, &cpusubtype);
4182 if (cputype == bfd_arch_unknown)
4184 (*_bfd_error_handler)
4185 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4186 header->cputype, header->cpusubtype);
4190 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4192 if (header->ncmds != 0)
4194 mdata->commands = bfd_alloc
4195 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4196 if (mdata->commands == NULL)
4199 for (i = 0; i < header->ncmds; i++)
4201 bfd_mach_o_load_command *cur = &mdata->commands[i];
4204 cur->offset = hdrsize;
4207 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4208 cur->offset = prev->offset + prev->len;
4211 if (!bfd_mach_o_read_command (abfd, cur))
4216 /* Sections should be flatten before scanning start address. */
4217 bfd_mach_o_flatten_sections (abfd);
4218 if (!bfd_mach_o_scan_start_address (abfd))
4225 bfd_mach_o_mkobject_init (bfd *abfd)
4227 bfd_mach_o_data_struct *mdata = NULL;
4229 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4232 abfd->tdata.mach_o_data = mdata;
4234 mdata->header.magic = 0;
4235 mdata->header.cputype = 0;
4236 mdata->header.cpusubtype = 0;
4237 mdata->header.filetype = 0;
4238 mdata->header.ncmds = 0;
4239 mdata->header.sizeofcmds = 0;
4240 mdata->header.flags = 0;
4241 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4242 mdata->commands = NULL;
4244 mdata->sections = NULL;
4245 mdata->dyn_reloc_cache = NULL;
4251 bfd_mach_o_gen_mkobject (bfd *abfd)
4253 bfd_mach_o_data_struct *mdata;
4255 if (!bfd_mach_o_mkobject_init (abfd))
4258 mdata = bfd_mach_o_get_data (abfd);
4259 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4260 mdata->header.cputype = 0;
4261 mdata->header.cpusubtype = 0;
4262 mdata->header.byteorder = abfd->xvec->byteorder;
4263 mdata->header.version = 1;
4269 bfd_mach_o_header_p (bfd *abfd,
4270 bfd_mach_o_filetype filetype,
4271 bfd_mach_o_cpu_type cputype)
4273 bfd_mach_o_header header;
4274 bfd_mach_o_data_struct *mdata;
4276 if (!bfd_mach_o_read_header (abfd, &header))
4279 if (! (header.byteorder == BFD_ENDIAN_BIG
4280 || header.byteorder == BFD_ENDIAN_LITTLE))
4282 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4283 (unsigned long) header.byteorder);
4287 if (! ((header.byteorder == BFD_ENDIAN_BIG
4288 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4289 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4290 || (header.byteorder == BFD_ENDIAN_LITTLE
4291 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4292 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4295 /* Check cputype and filetype.
4296 In case of wildcard, do not accept magics that are handled by existing
4300 if (header.cputype != cputype)
4306 /* Do not recognize 64 architectures if not configured for 64bit targets.
4307 This could happen only for generic targets. */
4308 if (mach_o_wide_p (&header))
4315 if (header.filetype != filetype)
4320 switch (header.filetype)
4322 case BFD_MACH_O_MH_CORE:
4323 /* Handled by core_p */
4330 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4334 if (!bfd_mach_o_scan (abfd, &header, mdata))
4340 bfd_set_error (bfd_error_wrong_format);
4346 static const bfd_target *
4347 bfd_mach_o_gen_object_p (bfd *abfd)
4349 return bfd_mach_o_header_p (abfd, 0, 0);
4352 static const bfd_target *
4353 bfd_mach_o_gen_core_p (bfd *abfd)
4355 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4358 /* Return the base address of ABFD, ie the address at which the image is
4359 mapped. The possible initial pagezero is ignored. */
4362 bfd_mach_o_get_base_address (bfd *abfd)
4364 bfd_mach_o_data_struct *mdata;
4367 /* Check for Mach-O. */
4368 if (!bfd_mach_o_valid (abfd))
4370 mdata = bfd_mach_o_get_data (abfd);
4372 for (i = 0; i < mdata->header.ncmds; i++)
4374 bfd_mach_o_load_command *cmd = &mdata->commands[i];
4375 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
4376 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
4378 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
4380 if (segcmd->initprot != 0)
4381 return segcmd->vmaddr;
4387 typedef struct mach_o_fat_archentry
4389 unsigned long cputype;
4390 unsigned long cpusubtype;
4391 unsigned long offset;
4393 unsigned long align;
4394 } mach_o_fat_archentry;
4396 typedef struct mach_o_fat_data_struct
4398 unsigned long magic;
4399 unsigned long nfat_arch;
4400 mach_o_fat_archentry *archentries;
4401 } mach_o_fat_data_struct;
4404 bfd_mach_o_archive_p (bfd *abfd)
4406 mach_o_fat_data_struct *adata = NULL;
4407 struct mach_o_fat_header_external hdr;
4410 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4411 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4414 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4418 adata->magic = bfd_getb32 (hdr.magic);
4419 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4420 if (adata->magic != 0xcafebabe)
4422 /* Avoid matching Java bytecode files, which have the same magic number.
4423 In the Java bytecode file format this field contains the JVM version,
4424 which starts at 43.0. */
4425 if (adata->nfat_arch > 30)
4428 adata->archentries =
4429 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4430 if (adata->archentries == NULL)
4433 for (i = 0; i < adata->nfat_arch; i++)
4435 struct mach_o_fat_arch_external arch;
4436 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4438 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4439 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4440 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4441 adata->archentries[i].size = bfd_getb32 (arch.size);
4442 adata->archentries[i].align = bfd_getb32 (arch.align);
4445 abfd->tdata.mach_o_fat_data = adata;
4450 bfd_release (abfd, adata);
4451 bfd_set_error (bfd_error_wrong_format);
4455 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4456 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4457 Set arelt_data and origin fields too. */
4460 bfd_mach_o_fat_member_init (bfd *abfd,
4461 enum bfd_architecture arch_type,
4462 unsigned long arch_subtype,
4463 mach_o_fat_archentry *entry)
4465 struct areltdata *areltdata;
4466 /* Create the member filename. Use ARCH_NAME. */
4467 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4471 /* Use the architecture name if known. */
4472 abfd->filename = xstrdup (ap->printable_name);
4476 /* Forge a uniq id. */
4477 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4478 char *name = xmalloc (namelen);
4479 snprintf (name, namelen, "0x%lx-0x%lx",
4480 entry->cputype, entry->cpusubtype);
4481 abfd->filename = name;
4484 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4485 areltdata->parsed_size = entry->size;
4486 abfd->arelt_data = areltdata;
4487 abfd->iostream = NULL;
4488 abfd->origin = entry->offset;
4492 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4494 mach_o_fat_data_struct *adata;
4495 mach_o_fat_archentry *entry = NULL;
4498 enum bfd_architecture arch_type;
4499 unsigned long arch_subtype;
4501 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4502 BFD_ASSERT (adata != NULL);
4504 /* Find index of previous entry. */
4507 /* Start at first one. */
4512 /* Find index of PREV. */
4513 for (i = 0; i < adata->nfat_arch; i++)
4515 if (adata->archentries[i].offset == prev->origin)
4519 if (i == adata->nfat_arch)
4522 bfd_set_error (bfd_error_bad_value);
4526 /* Get next entry. */
4530 if (i >= adata->nfat_arch)
4532 bfd_set_error (bfd_error_no_more_archived_files);
4536 entry = &adata->archentries[i];
4537 nbfd = _bfd_new_bfd_contained_in (archive);
4541 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4542 &arch_type, &arch_subtype);
4544 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4546 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4551 /* Analogous to stat call. */
4554 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4556 if (abfd->arelt_data == NULL)
4558 bfd_set_error (bfd_error_invalid_operation);
4565 buf->st_mode = 0644;
4566 buf->st_size = arelt_size (abfd);
4571 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4572 If ABFD is a fat image containing a member that corresponds to FORMAT
4573 and ARCH, returns it.
4574 In other case, returns NULL.
4575 This function allows transparent uses of fat images. */
4578 bfd_mach_o_fat_extract (bfd *abfd,
4580 const bfd_arch_info_type *arch)
4583 mach_o_fat_data_struct *adata;
4586 if (bfd_check_format (abfd, format))
4588 if (bfd_get_arch_info (abfd) == arch)
4592 if (!bfd_check_format (abfd, bfd_archive)
4593 || abfd->xvec != &mach_o_fat_vec)
4596 /* This is a Mach-O fat image. */
4597 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4598 BFD_ASSERT (adata != NULL);
4600 for (i = 0; i < adata->nfat_arch; i++)
4602 struct mach_o_fat_archentry *e = &adata->archentries[i];
4603 enum bfd_architecture cpu_type;
4604 unsigned long cpu_subtype;
4606 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4607 &cpu_type, &cpu_subtype);
4608 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4611 /* The architecture is found. */
4612 res = _bfd_new_bfd_contained_in (abfd);
4616 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4618 if (bfd_check_format (res, format))
4620 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4631 bfd_mach_o_lookup_command (bfd *abfd,
4632 bfd_mach_o_load_command_type type,
4633 bfd_mach_o_load_command **mcommand)
4635 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4636 bfd_mach_o_load_command *ncmd = NULL;
4637 unsigned int i, num;
4639 BFD_ASSERT (md != NULL);
4640 BFD_ASSERT (mcommand != NULL);
4643 for (i = 0; i < md->header.ncmds; i++)
4645 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4647 if (cmd->type != type)
4660 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4664 case BFD_MACH_O_CPU_TYPE_MC680x0:
4666 case BFD_MACH_O_CPU_TYPE_MC88000:
4668 case BFD_MACH_O_CPU_TYPE_POWERPC:
4670 case BFD_MACH_O_CPU_TYPE_I386:
4672 case BFD_MACH_O_CPU_TYPE_SPARC:
4674 case BFD_MACH_O_CPU_TYPE_I860:
4676 case BFD_MACH_O_CPU_TYPE_HPPA:
4677 return 0xc0000000 - 0x04000000;
4683 /* The following two tables should be kept, as far as possible, in order of
4684 most frequently used entries to optimize their use from gas. */
4686 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4688 { "regular", BFD_MACH_O_S_REGULAR},
4689 { "coalesced", BFD_MACH_O_S_COALESCED},
4690 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4691 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4692 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4693 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4694 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4695 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4696 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4697 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4698 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4699 { "interposing", BFD_MACH_O_S_INTERPOSING},
4700 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4701 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4702 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4703 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4704 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4708 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4710 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4711 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4712 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4713 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4714 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4715 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4716 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4717 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4718 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4719 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4720 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4724 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4727 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4729 const bfd_mach_o_xlat_name *x;
4730 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4732 for (x = bfd_mach_o_section_type_name; x->name; x++)
4733 if (strcmp (x->name, name) == 0)
4735 /* We found it... does the target support it? */
4736 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4737 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4738 return x->val; /* OK. */
4740 break; /* Not supported. */
4742 /* Maximum section ID = 0xff. */
4746 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4749 bfd_mach_o_get_section_attribute_from_name (const char *name)
4751 const bfd_mach_o_xlat_name *x;
4753 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4754 if (strcmp (x->name, name) == 0)
4756 return (unsigned int)-1;
4760 bfd_mach_o_core_fetch_environment (bfd *abfd,
4761 unsigned char **rbuf,
4764 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4765 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4768 for (i = 0; i < mdata->header.ncmds; i++)
4770 bfd_mach_o_load_command *cur = &mdata->commands[i];
4771 bfd_mach_o_segment_command *seg = NULL;
4773 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4776 seg = &cur->command.segment;
4778 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4780 unsigned long start = seg->fileoff;
4781 unsigned long end = seg->fileoff + seg->filesize;
4782 unsigned char *buf = bfd_malloc (1024);
4783 unsigned long size = 1024;
4787 bfd_size_type nread = 0;
4788 unsigned long offset;
4789 int found_nonnull = 0;
4791 if (size > (end - start))
4792 size = (end - start);
4794 buf = bfd_realloc_or_free (buf, size);
4798 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4804 nread = bfd_bread (buf, size, abfd);
4812 for (offset = 4; offset <= size; offset += 4)
4816 val = *((unsigned long *) (buf + size - offset));
4817 if (! found_nonnull)
4822 else if (val == 0x0)
4824 unsigned long bottom;
4827 bottom = seg->fileoff + seg->filesize - offset;
4828 top = seg->fileoff + seg->filesize - 4;
4829 *rbuf = bfd_malloc (top - bottom);
4830 *rlen = top - bottom;
4832 memcpy (*rbuf, buf + size - *rlen, *rlen);
4838 if (size == (end - start))
4852 bfd_mach_o_core_file_failing_command (bfd *abfd)
4854 unsigned char *buf = NULL;
4855 unsigned int len = 0;
4858 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4862 return (char *) buf;
4866 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4871 static bfd_mach_o_uuid_command *
4872 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4874 bfd_mach_o_load_command *uuid_cmd;
4875 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4878 return &uuid_cmd->command.uuid;
4881 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4884 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4886 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4889 BFD_ASSERT (uuid_cmd);
4891 if (!bfd_check_format (abfd, bfd_object))
4894 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4895 || bfd_mach_o_get_data (abfd) == NULL
4896 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4899 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4900 if (dsym_uuid_cmd == NULL)
4903 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4904 sizeof (uuid_cmd->uuid)) != 0)
4910 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4911 The caller is responsible for closing the returned BFD object and
4912 its my_archive if the returned BFD is in a fat dSYM. */
4915 bfd_mach_o_find_dsym (const char *dsym_filename,
4916 const bfd_mach_o_uuid_command *uuid_cmd,
4917 const bfd_arch_info_type *arch)
4919 bfd *base_dsym_bfd, *dsym_bfd;
4921 BFD_ASSERT (uuid_cmd);
4923 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4924 if (base_dsym_bfd == NULL)
4927 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4928 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4931 bfd_close (dsym_bfd);
4932 if (base_dsym_bfd != dsym_bfd)
4933 bfd_close (base_dsym_bfd);
4938 /* Return a BFD created from a dSYM file for ABFD.
4939 The caller is responsible for closing the returned BFD object, its
4940 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4943 bfd_mach_o_follow_dsym (bfd *abfd)
4945 char *dsym_filename;
4946 bfd_mach_o_uuid_command *uuid_cmd;
4947 bfd *dsym_bfd, *base_bfd = abfd;
4948 const char *base_basename;
4950 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4953 if (abfd->my_archive)
4954 base_bfd = abfd->my_archive;
4955 /* BFD may have been opened from a stream. */
4956 if (base_bfd->filename == NULL)
4958 bfd_set_error (bfd_error_invalid_operation);
4961 base_basename = lbasename (base_bfd->filename);
4963 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4964 if (uuid_cmd == NULL)
4967 /* TODO: We assume the DWARF file has the same as the binary's.
4968 It seems apple's GDB checks all files in the dSYM bundle directory.
4969 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4971 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4972 + strlen (dsym_subdir) + 1
4973 + strlen (base_basename) + 1);
4974 sprintf (dsym_filename, "%s%s/%s",
4975 base_bfd->filename, dsym_subdir, base_basename);
4977 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4978 bfd_get_arch_info (abfd));
4979 if (dsym_bfd == NULL)
4980 free (dsym_filename);
4986 bfd_mach_o_find_nearest_line (bfd *abfd,
4990 const char **filename_ptr,
4991 const char **functionname_ptr,
4992 unsigned int *line_ptr)
4994 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4997 switch (mdata->header.filetype)
4999 case BFD_MACH_O_MH_OBJECT:
5001 case BFD_MACH_O_MH_EXECUTE:
5002 case BFD_MACH_O_MH_DYLIB:
5003 case BFD_MACH_O_MH_BUNDLE:
5004 case BFD_MACH_O_MH_KEXT_BUNDLE:
5005 if (mdata->dwarf2_find_line_info == NULL)
5007 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5008 /* When we couldn't find dSYM for this binary, we look for
5009 the debug information in the binary itself. In this way,
5010 we won't try finding separated dSYM again because
5011 mdata->dwarf2_find_line_info will be filled. */
5012 if (! mdata->dsym_bfd)
5014 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5015 dwarf_debug_sections, symbols,
5016 &mdata->dwarf2_find_line_info))
5023 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
5024 section, symbols, offset,
5025 filename_ptr, functionname_ptr,
5027 &mdata->dwarf2_find_line_info))
5033 bfd_mach_o_close_and_cleanup (bfd *abfd)
5035 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5036 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5038 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5039 bfd_mach_o_free_cached_info (abfd);
5040 if (mdata->dsym_bfd != NULL)
5042 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5043 char *dsym_filename = (char *)(fat_bfd
5045 : mdata->dsym_bfd->filename);
5046 bfd_close (mdata->dsym_bfd);
5047 mdata->dsym_bfd = NULL;
5049 bfd_close (fat_bfd);
5050 free (dsym_filename);
5054 if (bfd_get_format (abfd) == bfd_archive
5055 && abfd->xvec == &mach_o_fat_vec)
5057 return _bfd_generic_close_and_cleanup (abfd);
5060 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5062 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5064 free (mdata->dyn_reloc_cache);
5065 mdata->dyn_reloc_cache = NULL;
5066 for (asect = abfd->sections; asect != NULL; asect = asect->next)
5068 free (asect->relocation);
5069 asect->relocation = NULL;
5075 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5076 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5078 #define bfd_mach_o_swap_reloc_in NULL
5079 #define bfd_mach_o_swap_reloc_out NULL
5080 #define bfd_mach_o_print_thread NULL
5081 #define bfd_mach_o_tgt_seg_table NULL
5082 #define bfd_mach_o_section_type_valid_for_tgt NULL
5084 #define TARGET_NAME mach_o_be_vec
5085 #define TARGET_STRING "mach-o-be"
5086 #define TARGET_ARCHITECTURE bfd_arch_unknown
5087 #define TARGET_BIG_ENDIAN 1
5088 #define TARGET_ARCHIVE 0
5089 #define TARGET_PRIORITY 1
5090 #include "mach-o-target.c"
5093 #undef TARGET_STRING
5094 #undef TARGET_ARCHITECTURE
5095 #undef TARGET_BIG_ENDIAN
5096 #undef TARGET_ARCHIVE
5097 #undef TARGET_PRIORITY
5099 #define TARGET_NAME mach_o_le_vec
5100 #define TARGET_STRING "mach-o-le"
5101 #define TARGET_ARCHITECTURE bfd_arch_unknown
5102 #define TARGET_BIG_ENDIAN 0
5103 #define TARGET_ARCHIVE 0
5104 #define TARGET_PRIORITY 1
5106 #include "mach-o-target.c"
5109 #undef TARGET_STRING
5110 #undef TARGET_ARCHITECTURE
5111 #undef TARGET_BIG_ENDIAN
5112 #undef TARGET_ARCHIVE
5113 #undef TARGET_PRIORITY
5115 /* Not yet handled: creating an archive. */
5116 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5119 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5120 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5121 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5122 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5123 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5124 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5125 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5126 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5127 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5128 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5130 #define TARGET_NAME mach_o_fat_vec
5131 #define TARGET_STRING "mach-o-fat"
5132 #define TARGET_ARCHITECTURE bfd_arch_unknown
5133 #define TARGET_BIG_ENDIAN 1
5134 #define TARGET_ARCHIVE 1
5135 #define TARGET_PRIORITY 0
5137 #include "mach-o-target.c"
5140 #undef TARGET_STRING
5141 #undef TARGET_ARCHITECTURE
5142 #undef TARGET_BIG_ENDIAN
5143 #undef TARGET_ARCHIVE
5144 #undef TARGET_PRIORITY