1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
28 #include "aout/stab_gnu.h"
29 #include "mach-o/reloc.h"
30 #include "mach-o/external.h"
35 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
36 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
37 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
39 #define FILE_ALIGN(off, algn) \
40 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
43 bfd_mach_o_version (bfd *abfd)
45 bfd_mach_o_data_struct *mdata = NULL;
47 BFD_ASSERT (bfd_mach_o_valid (abfd));
48 mdata = bfd_mach_o_get_data (abfd);
50 return mdata->header.version;
54 bfd_mach_o_valid (bfd *abfd)
56 if (abfd == NULL || abfd->xvec == NULL)
59 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
62 if (bfd_mach_o_get_data (abfd) == NULL)
67 static INLINE bfd_boolean
68 mach_o_wide_p (bfd_mach_o_header *header)
70 switch (header->version)
82 static INLINE bfd_boolean
83 bfd_mach_o_wide_p (bfd *abfd)
85 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
88 /* Tables to translate well known Mach-O segment/section names to bfd
89 names. Use of canonical names (such as .text or .debug_frame) is required
93 static const mach_o_section_name_xlat text_section_names_xlat[] =
96 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
97 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS, 0},
98 { ".const", "__const",
99 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
100 BFD_MACH_O_S_ATTR_NONE, 0},
101 { ".static_const", "__static_const",
102 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
103 BFD_MACH_O_S_ATTR_NONE, 0},
104 { ".cstring", "__cstring",
105 SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
106 BFD_MACH_O_S_CSTRING_LITERALS,
107 BFD_MACH_O_S_ATTR_NONE, 0},
108 { ".literal4", "__literal4",
109 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_4BYTE_LITERALS,
110 BFD_MACH_O_S_ATTR_NONE, 2},
111 { ".literal8", "__literal8",
112 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_8BYTE_LITERALS,
113 BFD_MACH_O_S_ATTR_NONE, 3},
114 { ".literal16", "__literal16",
115 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_16BYTE_LITERALS,
116 BFD_MACH_O_S_ATTR_NONE, 4},
117 { ".constructor", "__constructor",
118 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
119 BFD_MACH_O_S_ATTR_NONE, 0},
120 { ".destructor", "__destructor",
121 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
122 BFD_MACH_O_S_ATTR_NONE, 0},
123 { ".eh_frame", "__eh_frame",
124 SEC_READONLY | SEC_LOAD, BFD_MACH_O_S_COALESCED,
125 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
126 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
127 | BFD_MACH_O_S_ATTR_NO_TOC, 3},
128 { NULL, NULL, 0, 0, 0, 0}
131 /* __DATA Segment. */
132 static const mach_o_section_name_xlat data_section_names_xlat[] =
135 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
136 BFD_MACH_O_S_ATTR_NONE, 0},
138 SEC_NO_FLAGS, BFD_MACH_O_S_ZEROFILL,
139 BFD_MACH_O_S_ATTR_NONE, 0},
140 { ".const_data", "__const",
141 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
142 BFD_MACH_O_S_ATTR_NONE, 0},
143 { ".static_data", "__static_data",
144 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
145 BFD_MACH_O_S_ATTR_NONE, 0},
146 { ".mod_init_func", "__mod_init_func",
147 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
148 BFD_MACH_O_S_ATTR_NONE, 2},
149 { ".mod_term_func", "__mod_term_func",
150 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
151 BFD_MACH_O_S_ATTR_NONE, 2},
153 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
154 BFD_MACH_O_S_ATTR_NONE, 0},
155 { ".cfstring", "__cfstring",
156 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
157 BFD_MACH_O_S_ATTR_NONE, 2},
158 { NULL, NULL, 0, 0, 0, 0}
161 /* __DWARF Segment. */
162 static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
164 { ".debug_frame", "__debug_frame",
165 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
166 BFD_MACH_O_S_ATTR_DEBUG, 0},
167 { ".debug_info", "__debug_info",
168 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
169 BFD_MACH_O_S_ATTR_DEBUG, 0},
170 { ".debug_abbrev", "__debug_abbrev",
171 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
172 BFD_MACH_O_S_ATTR_DEBUG, 0},
173 { ".debug_aranges", "__debug_aranges",
174 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
175 BFD_MACH_O_S_ATTR_DEBUG, 0},
176 { ".debug_macinfo", "__debug_macinfo",
177 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
178 BFD_MACH_O_S_ATTR_DEBUG, 0},
179 { ".debug_line", "__debug_line",
180 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
181 BFD_MACH_O_S_ATTR_DEBUG, 0},
182 { ".debug_loc", "__debug_loc",
183 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
184 BFD_MACH_O_S_ATTR_DEBUG, 0},
185 { ".debug_pubnames", "__debug_pubnames",
186 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
187 BFD_MACH_O_S_ATTR_DEBUG, 0},
188 { ".debug_pubtypes", "__debug_pubtypes",
189 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
190 BFD_MACH_O_S_ATTR_DEBUG, 0},
191 { ".debug_str", "__debug_str",
192 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
193 BFD_MACH_O_S_ATTR_DEBUG, 0},
194 { ".debug_ranges", "__debug_ranges",
195 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
196 BFD_MACH_O_S_ATTR_DEBUG, 0},
197 { ".debug_macro", "__debug_macro",
198 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
199 BFD_MACH_O_S_ATTR_DEBUG, 0},
200 { NULL, NULL, 0, 0, 0, 0}
203 /* __OBJC Segment. */
204 static const mach_o_section_name_xlat objc_section_names_xlat[] =
206 { ".objc_class", "__class",
207 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
208 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
209 { ".objc_meta_class", "__meta_class",
210 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
211 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
212 { ".objc_cat_cls_meth", "__cat_cls_meth",
213 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
214 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
215 { ".objc_cat_inst_meth", "__cat_inst_meth",
216 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
217 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
218 { ".objc_protocol", "__protocol",
219 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
220 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
221 { ".objc_string_object", "__string_object",
222 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
223 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
224 { ".objc_cls_meth", "__cls_meth",
225 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
226 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
227 { ".objc_inst_meth", "__inst_meth",
228 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
229 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
230 { ".objc_cls_refs", "__cls_refs",
231 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
232 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
233 { ".objc_message_refs", "__message_refs",
234 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
235 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
236 { ".objc_symbols", "__symbols",
237 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
238 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
239 { ".objc_category", "__category",
240 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
241 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
242 { ".objc_class_vars", "__class_vars",
243 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
244 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
245 { ".objc_instance_vars", "__instance_vars",
246 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
247 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
248 { ".objc_module_info", "__module_info",
249 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
250 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
251 { ".objc_selector_strs", "__selector_strs",
252 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_CSTRING_LITERALS,
253 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
254 { ".objc_image_info", "__image_info",
255 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
256 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
257 { ".objc_selector_fixup", "__sel_fixup",
258 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
259 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
261 { ".objc1_class_ext", "__class_ext",
262 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
263 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
264 { ".objc1_property_list", "__property",
265 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
266 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
267 { ".objc1_protocol_ext", "__protocol_ext",
268 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
269 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
270 { NULL, NULL, 0, 0, 0, 0}
273 static const mach_o_segment_name_xlat segsec_names_xlat[] =
275 { "__TEXT", text_section_names_xlat },
276 { "__DATA", data_section_names_xlat },
277 { "__DWARF", dwarf_section_names_xlat },
278 { "__OBJC", objc_section_names_xlat },
282 static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
284 /* For both cases bfd-name => mach-o name and vice versa, the specific target
285 is checked before the generic. This allows a target (e.g. ppc for cstring)
286 to override the generic definition with a more specific one. */
288 /* Fetch the translation from a Mach-O section designation (segment, section)
289 as a bfd short name, if one exists. Otherwise return NULL.
291 Allow the segment and section names to be unterminated 16 byte arrays. */
293 const mach_o_section_name_xlat *
294 bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
295 const char *sectname)
297 const struct mach_o_segment_name_xlat *seg;
298 const mach_o_section_name_xlat *sec;
299 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
301 /* First try any target-specific translations defined... */
302 if (bed->segsec_names_xlat)
303 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
304 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
305 for (sec = seg->sections; sec->mach_o_name; sec++)
306 if (strncmp (sec->mach_o_name, sectname,
307 BFD_MACH_O_SECTNAME_SIZE) == 0)
310 /* ... and then the Mach-O generic ones. */
311 for (seg = segsec_names_xlat; seg->segname; seg++)
312 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
313 for (sec = seg->sections; sec->mach_o_name; sec++)
314 if (strncmp (sec->mach_o_name, sectname,
315 BFD_MACH_O_SECTNAME_SIZE) == 0)
321 /* If the bfd_name for this section is a 'canonical' form for which we
322 know the Mach-O data, return the segment name and the data for the
323 Mach-O equivalent. Otherwise return NULL. */
325 const mach_o_section_name_xlat *
326 bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
327 const char **segname)
329 const struct mach_o_segment_name_xlat *seg;
330 const mach_o_section_name_xlat *sec;
331 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
334 if (bfd_name[0] != '.')
337 /* First try any target-specific translations defined... */
338 if (bed->segsec_names_xlat)
339 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
340 for (sec = seg->sections; sec->bfd_name; sec++)
341 if (strcmp (bfd_name, sec->bfd_name) == 0)
343 *segname = seg->segname;
347 /* ... and then the Mach-O generic ones. */
348 for (seg = segsec_names_xlat; seg->segname; seg++)
349 for (sec = seg->sections; sec->bfd_name; sec++)
350 if (strcmp (bfd_name, sec->bfd_name) == 0)
352 *segname = seg->segname;
359 /* Convert Mach-O section name to BFD.
361 Try to use standard/canonical names, for which we have tables including
362 default flag settings - which are returned. Otherwise forge a new name
363 in the form "<segmentname>.<sectionname>" this will be prefixed with
364 LC_SEGMENT. if the segment name does not begin with an underscore.
366 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
367 terminated if the name length is exactly 16 bytes - but must be if the name
368 length is less than 16 characters). */
371 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
372 const char *secname, const char **name,
375 const mach_o_section_name_xlat *xlat;
378 const char *pfx = "";
381 *flags = SEC_NO_FLAGS;
383 /* First search for a canonical name...
384 xlat will be non-null if there is an entry for segname, secname. */
385 xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
388 len = strlen (xlat->bfd_name);
389 res = bfd_alloc (abfd, len+1);
392 memcpy (res, xlat->bfd_name, len+1);
394 *flags = xlat->bfd_flags;
398 /* ... else we make up a bfd name from the segment concatenated with the
401 len = 16 + 1 + 16 + 1;
403 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
404 with an underscore. */
405 if (segname[0] != '_')
407 static const char seg_pfx[] = "LC_SEGMENT.";
410 len += sizeof (seg_pfx) - 1;
413 res = bfd_alloc (abfd, len);
416 snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
420 /* Convert a bfd section name to a Mach-O segment + section name.
422 If the name is a canonical one for which we have a Darwin match
423 return the translation table - which contains defaults for flags,
424 type, attribute and default alignment data.
426 Otherwise, expand the bfd_name (assumed to be in the form
427 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
429 static const mach_o_section_name_xlat *
430 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
432 bfd_mach_o_section *section)
434 const mach_o_section_name_xlat *xlat;
435 const char *name = bfd_get_section_name (abfd, sect);
442 memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
443 memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
445 /* See if is a canonical name ... */
446 xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
449 strcpy (section->segname, segname);
450 strcpy (section->sectname, xlat->mach_o_name);
454 /* .. else we convert our constructed one back to Mach-O.
455 Strip LC_SEGMENT. prefix, if present. */
456 if (strncmp (name, "LC_SEGMENT.", 11) == 0)
460 dot = strchr (name, '.');
463 /* Try to split name into segment and section names. */
464 if (dot && dot != name)
467 seclen = len - (dot + 1 - name);
469 if (seglen < 16 && seclen < 16)
471 memcpy (section->segname, name, seglen);
472 section->segname[seglen] = 0;
473 memcpy (section->sectname, dot + 1, seclen);
474 section->sectname[seclen] = 0;
479 /* The segment and section names are both missing - don't make them
481 if (dot && dot == name)
484 /* Just duplicate the name into both segment and section. */
487 memcpy (section->segname, name, len);
488 section->segname[len] = 0;
489 memcpy (section->sectname, name, len);
490 section->sectname[len] = 0;
494 /* Return the size of an entry for section SEC.
495 Must be called only for symbol pointer section and symbol stubs
499 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
501 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
503 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
504 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
505 return bfd_mach_o_wide_p (abfd) ? 8 : 4;
506 case BFD_MACH_O_S_SYMBOL_STUBS:
507 return sec->reserved2;
514 /* Return the number of indirect symbols for a section.
515 Must be called only for symbol pointer section and symbol stubs
519 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
523 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
527 return sec->size / elsz;
531 /* Copy any private info we understand from the input symbol
532 to the output symbol. */
535 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
536 asymbol *isymbol ATTRIBUTE_UNUSED,
537 bfd *obfd ATTRIBUTE_UNUSED,
538 asymbol *osymbol ATTRIBUTE_UNUSED)
543 /* Copy any private info we understand from the input section
544 to the output section. */
547 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
549 bfd *obfd ATTRIBUTE_UNUSED,
552 if (osection->used_by_bfd == NULL)
553 osection->used_by_bfd = isection->used_by_bfd;
555 if (isection->used_by_bfd != NULL)
556 memcpy (osection->used_by_bfd, isection->used_by_bfd,
557 sizeof (bfd_mach_o_section));
559 if (osection->used_by_bfd != NULL)
560 ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
565 /* Copy any private info we understand from the input bfd
566 to the output bfd. */
569 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
571 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
572 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
575 BFD_ASSERT (bfd_mach_o_valid (ibfd));
576 BFD_ASSERT (bfd_mach_o_valid (obfd));
578 /* FIXME: copy commands. */
583 /* This allows us to set up to 32 bits of flags (unless we invent some
584 fiendish scheme to subdivide). For now, we'll just set the file flags
585 without error checking - just overwrite. */
588 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
590 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
595 mdata->header.flags = flags;
599 /* Count the total number of symbols. */
602 bfd_mach_o_count_symbols (bfd *abfd)
604 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
606 if (mdata->symtab == NULL)
608 return mdata->symtab->nsyms;
612 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
614 long nsyms = bfd_mach_o_count_symbols (abfd);
616 return ((nsyms + 1) * sizeof (asymbol *));
620 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
622 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
623 long nsyms = bfd_mach_o_count_symbols (abfd);
624 bfd_mach_o_symtab_command *sym = mdata->symtab;
632 /* Do not try to read symbols if there are none. */
637 if (!bfd_mach_o_read_symtab_symbols (abfd))
639 (*_bfd_error_handler)
640 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
644 BFD_ASSERT (sym->symbols != NULL);
646 for (j = 0; j < sym->nsyms; j++)
647 alocation[j] = &sym->symbols[j].symbol;
655 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
656 long symcount ATTRIBUTE_UNUSED,
657 asymbol **syms ATTRIBUTE_UNUSED,
658 long dynsymcount ATTRIBUTE_UNUSED,
659 asymbol **dynsyms ATTRIBUTE_UNUSED,
662 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
663 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
664 bfd_mach_o_symtab_command *symtab = mdata->symtab;
666 unsigned long count, i, j, n;
673 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
676 if (dysymtab->nindirectsyms == 0)
679 count = dysymtab->nindirectsyms;
680 size = count * sizeof (asymbol) + 1;
682 for (j = 0; j < count; j++)
684 unsigned int isym = dysymtab->indirect_syms[j];
686 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
687 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
690 s = *ret = (asymbol *) bfd_malloc (size);
693 names = (char *) (s + count);
698 for (i = 0; i < mdata->nsects; i++)
700 bfd_mach_o_section *sec = mdata->sections[i];
701 unsigned int first, last;
705 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
707 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
708 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
709 case BFD_MACH_O_S_SYMBOL_STUBS:
710 first = sec->reserved1;
711 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
713 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
714 for (j = first; j < last; j++)
716 unsigned int isym = dysymtab->indirect_syms[j];
718 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
719 s->section = sec->bfdsection;
720 s->value = addr - sec->addr;
723 if (isym < symtab->nsyms
724 && symtab->symbols[isym].symbol.name)
726 const char *sym = symtab->symbols[isym].symbol.name;
731 memcpy (names, sym, len);
733 memcpy (names, "$stub", sizeof ("$stub"));
734 names += sizeof ("$stub");
753 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
757 bfd_symbol_info (symbol, ret);
761 bfd_mach_o_print_symbol (bfd *abfd,
764 bfd_print_symbol_type how)
766 FILE *file = (FILE *) afile;
768 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
772 case bfd_print_symbol_name:
773 fprintf (file, "%s", symbol->name);
776 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
777 if (asym->n_type & BFD_MACH_O_N_STAB)
778 name = bfd_get_stab_name (asym->n_type);
780 switch (asym->n_type & BFD_MACH_O_N_TYPE)
782 case BFD_MACH_O_N_UNDF:
783 if (symbol->value == 0)
788 case BFD_MACH_O_N_ABS:
791 case BFD_MACH_O_N_INDR:
794 case BFD_MACH_O_N_PBUD:
797 case BFD_MACH_O_N_SECT:
806 fprintf (file, " %02x %-6s %02x %04x",
807 asym->n_type, name, asym->n_sect, asym->n_desc);
808 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
809 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
810 fprintf (file, " [%s]", symbol->section->name);
811 fprintf (file, " %s", symbol->name);
816 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
817 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED,
818 enum bfd_architecture *type,
819 unsigned long *subtype)
821 *subtype = bfd_arch_unknown;
825 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
826 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
827 case BFD_MACH_O_CPU_TYPE_I386:
828 *type = bfd_arch_i386;
829 *subtype = bfd_mach_i386_i386;
831 case BFD_MACH_O_CPU_TYPE_X86_64:
832 *type = bfd_arch_i386;
833 *subtype = bfd_mach_x86_64;
835 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
836 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
837 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
838 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
839 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
840 case BFD_MACH_O_CPU_TYPE_SPARC:
841 *type = bfd_arch_sparc;
842 *subtype = bfd_mach_sparc;
844 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
845 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
846 case BFD_MACH_O_CPU_TYPE_POWERPC:
847 *type = bfd_arch_powerpc;
848 *subtype = bfd_mach_ppc;
850 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
851 *type = bfd_arch_powerpc;
852 *subtype = bfd_mach_ppc64;
855 *type = bfd_arch_unknown;
861 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
863 struct mach_o_header_external raw;
866 size = mach_o_wide_p (header) ?
867 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
869 bfd_h_put_32 (abfd, header->magic, raw.magic);
870 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
871 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
872 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
873 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
874 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
875 bfd_h_put_32 (abfd, header->flags, raw.flags);
877 if (mach_o_wide_p (header))
878 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
880 if (bfd_seek (abfd, 0, SEEK_SET) != 0
881 || bfd_bwrite (&raw, size, abfd) != size)
888 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
890 bfd_mach_o_thread_command *cmd = &command->command.thread;
892 struct mach_o_thread_command_external raw;
895 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
896 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
899 for (i = 0; i < cmd->nflavours; i++)
901 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
902 BFD_ASSERT (cmd->flavours[i].offset ==
903 (command->offset + offset + BFD_MACH_O_LC_SIZE));
905 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
906 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
908 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
909 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
912 offset += cmd->flavours[i].size + sizeof (raw);
919 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
922 return (asect->reloc_count + 1) * sizeof (arelent *);
926 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
927 struct mach_o_reloc_info_external *raw,
928 arelent *res, asymbol **syms)
930 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
931 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
932 bfd_mach_o_reloc_info reloc;
937 addr = bfd_get_32 (abfd, raw->r_address);
938 symnum = bfd_get_32 (abfd, raw->r_symbolnum);
940 if (addr & BFD_MACH_O_SR_SCATTERED)
944 /* Scattered relocation.
945 Extract section and offset from r_value. */
946 res->sym_ptr_ptr = NULL;
948 for (j = 0; j < mdata->nsects; j++)
950 bfd_mach_o_section *sect = mdata->sections[j];
951 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
953 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
954 res->addend = symnum - sect->addr;
958 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
959 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
960 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
961 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
962 reloc.r_scattered = 1;
966 unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);
969 if (symnum & BFD_MACH_O_R_EXTERN)
976 BFD_ASSERT (num != 0);
977 BFD_ASSERT (num <= mdata->nsects);
978 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
979 /* For a symbol defined in section S, the addend (stored in the
980 binary) contains the address of the section. To comply with
981 bfd conventio, substract the section address.
982 Use the address from the header, so that the user can modify
983 the vma of the section. */
984 res->addend = -mdata->sections[num - 1]->addr;
987 res->sym_ptr_ptr = sym;
988 reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
989 reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);
990 reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;
991 reloc.r_scattered = 0;
994 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1000 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1001 unsigned long count,
1002 arelent *res, asymbol **syms)
1005 struct mach_o_reloc_info_external *native_relocs;
1006 bfd_size_type native_size;
1008 /* Allocate and read relocs. */
1009 native_size = count * BFD_MACH_O_RELENT_SIZE;
1011 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1012 if (native_relocs == NULL)
1015 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1016 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1019 for (i = 0; i < count; i++)
1021 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1025 free (native_relocs);
1028 free (native_relocs);
1033 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1034 arelent **rels, asymbol **syms)
1036 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1040 if (asect->reloc_count == 0)
1043 /* No need to go further if we don't know how to read relocs. */
1044 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1047 if (asect->relocation == NULL)
1049 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1053 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1054 asect->reloc_count, res, syms) < 0)
1059 asect->relocation = res;
1062 res = asect->relocation;
1063 for (i = 0; i < asect->reloc_count; i++)
1071 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1073 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1075 if (mdata->dysymtab == NULL)
1077 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1078 * sizeof (arelent *);
1082 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1083 struct bfd_symbol **syms)
1085 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1086 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1087 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1091 if (dysymtab == NULL)
1093 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1096 /* No need to go further if we don't know how to read relocs. */
1097 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1100 if (mdata->dyn_reloc_cache == NULL)
1102 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1103 * sizeof (arelent));
1107 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1108 dysymtab->nextrel, res, syms) < 0)
1114 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1116 res + dysymtab->nextrel, syms) < 0)
1122 mdata->dyn_reloc_cache = res;
1125 res = mdata->dyn_reloc_cache;
1126 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1133 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1135 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1139 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1141 sec = section->bfdsection;
1142 if (sec->reloc_count == 0)
1145 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1148 /* Allocate relocation room. */
1149 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
1150 section->nreloc = sec->reloc_count;
1151 sec->rel_filepos = mdata->filelen;
1152 section->reloff = sec->rel_filepos;
1153 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
1155 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1158 /* Convert and write. */
1159 entries = section->bfdsection->orelocation;
1160 for (i = 0; i < section->nreloc; i++)
1162 arelent *rel = entries[i];
1163 struct mach_o_reloc_info_external raw;
1164 bfd_mach_o_reloc_info info, *pinfo = &info;
1166 /* Convert relocation to an intermediate representation. */
1167 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1170 /* Lower the relocation info. */
1171 if (pinfo->r_scattered)
1175 v = BFD_MACH_O_SR_SCATTERED
1176 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1177 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1178 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1179 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
1180 /* Note: scattered relocs have field in reverse order... */
1181 bfd_put_32 (abfd, v, raw.r_address);
1182 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1188 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1189 v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value)
1190 | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0)
1191 | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length)
1192 | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0)
1193 | BFD_MACH_O_SET_R_TYPE (pinfo->r_type);
1194 bfd_put_32 (abfd, v, raw.r_symbolnum);
1197 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1198 != BFD_MACH_O_RELENT_SIZE)
1205 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1207 struct mach_o_section_32_external raw;
1209 memcpy (raw.sectname, section->sectname, 16);
1210 memcpy (raw.segname, section->segname, 16);
1211 bfd_h_put_32 (abfd, section->addr, raw.addr);
1212 bfd_h_put_32 (abfd, section->size, raw.size);
1213 bfd_h_put_32 (abfd, section->offset, raw.offset);
1214 bfd_h_put_32 (abfd, section->align, raw.align);
1215 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1216 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1217 bfd_h_put_32 (abfd, section->flags, raw.flags);
1218 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1219 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1221 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1222 != BFD_MACH_O_SECTION_SIZE)
1229 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1231 struct mach_o_section_64_external raw;
1233 memcpy (raw.sectname, section->sectname, 16);
1234 memcpy (raw.segname, section->segname, 16);
1235 bfd_h_put_64 (abfd, section->addr, raw.addr);
1236 bfd_h_put_64 (abfd, section->size, raw.size);
1237 bfd_h_put_32 (abfd, section->offset, raw.offset);
1238 bfd_h_put_32 (abfd, section->align, raw.align);
1239 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1240 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1241 bfd_h_put_32 (abfd, section->flags, raw.flags);
1242 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1243 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1244 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1246 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1247 != BFD_MACH_O_SECTION_64_SIZE)
1254 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1256 struct mach_o_segment_command_32_external raw;
1257 bfd_mach_o_segment_command *seg = &command->command.segment;
1258 bfd_mach_o_section *sec;
1260 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1262 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1263 if (!bfd_mach_o_write_relocs (abfd, sec))
1266 memcpy (raw.segname, seg->segname, 16);
1267 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1268 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1269 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1270 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1271 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1272 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1273 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1274 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1276 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1277 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1280 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1281 if (bfd_mach_o_write_section_32 (abfd, sec))
1288 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1290 struct mach_o_segment_command_64_external raw;
1291 bfd_mach_o_segment_command *seg = &command->command.segment;
1292 bfd_mach_o_section *sec;
1294 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1296 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1297 if (!bfd_mach_o_write_relocs (abfd, sec))
1300 memcpy (raw.segname, seg->segname, 16);
1301 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1302 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1303 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1304 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1305 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1306 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1307 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1308 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1310 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1311 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1314 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1315 if (bfd_mach_o_write_section_64 (abfd, sec))
1322 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1324 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1325 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1327 unsigned int wide = bfd_mach_o_wide_p (abfd);
1328 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1329 struct bfd_strtab_hash *strtab;
1330 asymbol **symbols = bfd_get_outsymbols (abfd);
1332 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1334 /* Write the symbols first. */
1335 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1336 sym->symoff = mdata->filelen;
1337 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1340 sym->nsyms = bfd_get_symcount (abfd);
1341 mdata->filelen += sym->nsyms * symlen;
1343 strtab = _bfd_stringtab_init ();
1348 /* Although we don't strictly need to do this, for compatibility with
1349 Darwin system tools, actually output an empty string for the index
1351 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1353 for (i = 0; i < sym->nsyms; i++)
1355 bfd_size_type str_index;
1356 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1358 /* For a bare indirect symbol, the system tools expect that the symbol
1359 value will be the string table offset for its referenced counterpart.
1361 Normally, indirect syms will not be written this way, but rather as
1362 part of the dysymtab command.
1364 In either case, correct operation depends on the symbol table being
1365 sorted such that the indirect symbols are at the end (since the
1366 string table index is filled in below). */
1368 if (IS_MACHO_INDIRECT (s->n_type))
1369 /* A pointer to the referenced symbol will be stored in the udata
1370 field. Use that to find the string index. */
1372 ((bfd_mach_o_asymbol *)s->symbol.udata.p)->symbol.udata.i;
1374 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1375 /* An index of 0 always means the empty string. */
1379 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1380 /* Record the string index. This can be looked up by an indirect sym
1381 which retains a pointer to its referenced counterpart, until it is
1383 if (IS_MACHO_INDIRECT (s->n_type))
1384 s->symbol.udata.i = str_index;
1386 if (str_index == (bfd_size_type) -1)
1392 struct mach_o_nlist_64_external raw;
1394 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1395 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1396 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1397 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1398 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1401 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1406 struct mach_o_nlist_external raw;
1408 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1409 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1410 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1411 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1412 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1415 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1419 sym->strsize = _bfd_stringtab_size (strtab);
1420 sym->stroff = mdata->filelen;
1421 mdata->filelen += sym->strsize;
1423 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1425 _bfd_stringtab_free (strtab);
1429 struct mach_o_symtab_command_external raw;
1431 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1432 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1433 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1434 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1436 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1437 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1444 _bfd_stringtab_free (strtab);
1448 /* Write a dysymtab command.
1449 TODO: Possibly coalesce writes of smaller objects. */
1452 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1454 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1456 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1458 if (cmd->nmodtab != 0)
1462 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1465 for (i = 0; i < cmd->nmodtab; i++)
1467 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1471 iinit = module->iinit & 0xffff;
1472 iinit |= ((module->iterm & 0xffff) << 16);
1474 ninit = module->ninit & 0xffff;
1475 ninit |= ((module->nterm & 0xffff) << 16);
1477 if (bfd_mach_o_wide_p (abfd))
1479 struct mach_o_dylib_module_64_external w;
1481 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1482 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1483 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1484 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1485 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1486 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1487 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1488 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1489 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1490 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1491 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1492 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1493 &w.objc_module_info_addr);
1494 bfd_h_put_32 (abfd, module->objc_module_info_size,
1495 &w.objc_module_info_size);
1497 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1502 struct mach_o_dylib_module_external n;
1504 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1505 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1506 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1507 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1508 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1509 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1510 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1511 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1512 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1513 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1514 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1515 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1516 &n.objc_module_info_addr);
1517 bfd_h_put_32 (abfd, module->objc_module_info_size,
1518 &n.objc_module_info_size);
1520 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1530 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1533 for (i = 0; i < cmd->ntoc; i++)
1535 struct mach_o_dylib_table_of_contents_external raw;
1536 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1538 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1539 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1541 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1546 if (cmd->nindirectsyms > 0)
1550 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1553 for (i = 0; i < cmd->nindirectsyms; ++i)
1555 unsigned char raw[4];
1557 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1558 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1563 if (cmd->nextrefsyms != 0)
1567 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1570 for (i = 0; i < cmd->nextrefsyms; i++)
1573 unsigned char raw[4];
1574 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1576 /* Fields isym and flags are written as bit-fields, thus we need
1577 a specific processing for endianness. */
1579 if (bfd_big_endian (abfd))
1581 v = ((ref->isym & 0xffffff) << 8);
1582 v |= ref->flags & 0xff;
1586 v = ref->isym & 0xffffff;
1587 v |= ((ref->flags & 0xff) << 24);
1590 bfd_h_put_32 (abfd, v, raw);
1591 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1597 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1601 struct mach_o_dysymtab_command_external raw;
1603 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1604 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1605 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1606 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1607 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1608 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1609 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1610 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1611 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1612 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1613 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1614 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1615 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1616 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1617 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1618 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1619 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1620 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1622 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1630 bfd_mach_o_primary_symbol_sort_key (unsigned type)
1632 unsigned mtyp = type & BFD_MACH_O_N_TYPE;
1634 /* Just leave debug symbols where they are (pretend they are local, and
1635 then they will just be sorted on position). */
1636 if (type & BFD_MACH_O_N_STAB)
1639 /* Sort indirects to last. */
1640 if (mtyp == BFD_MACH_O_N_INDR)
1643 /* Local (we should never see an undefined local AFAICT). */
1644 if (! (type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1647 /* Common symbols look like undefined externs. */
1648 if (mtyp == BFD_MACH_O_N_UNDF)
1651 /* A defined symbol that's not indirect or extern. */
1656 bfd_mach_o_cf_symbols (const void *a, const void *b)
1658 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1659 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1660 unsigned int soa, sob;
1662 soa = bfd_mach_o_primary_symbol_sort_key (sa->n_type);
1663 sob = bfd_mach_o_primary_symbol_sort_key (sb->n_type);
1670 /* If it's local or stab, just preserve the input order. */
1673 if (sa->symbol.udata.i < sb->symbol.udata.i)
1675 if (sa->symbol.udata.i > sb->symbol.udata.i)
1680 /* Unless it's an indirect the second sort key is name. */
1682 return strcmp (sa->symbol.name, sb->symbol.name);
1684 /* Here be indirect symbols, which have different sort rules. */
1686 /* Next sort key for indirect, is the section index. */
1687 if (sa->n_sect < sb->n_sect)
1690 if (sa->n_sect > sb->n_sect)
1693 /* Last sort key is the order of definition - which should be in line with
1694 the value, since a stub size of 0 is meaninglesss. */
1696 if (sa->symbol.value < sb->symbol.value)
1699 if (sa->symbol.value > sb->symbol.value)
1702 /* In the final analysis, this is probably an error ... but leave it alone
1707 /* When this is finished, return the number of non-indirect symbols. */
1710 bfd_mach_o_sort_symbol_table (asymbol **symbols, unsigned int nin)
1712 qsort (symbols, (size_t) nin, sizeof (void *), bfd_mach_o_cf_symbols);
1714 /* Find the last non-indirect symbol.
1715 There must be at least one non-indirect symbol otherwise there's
1716 nothing for the indirect(s) to refer to. */
1719 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[nin - 1];
1720 if (IS_MACHO_INDIRECT (s->n_type))
1724 } while (nin - 1 > 0);
1728 /* Process the symbols.
1730 This should be OK for single-module files - but it is not likely to work
1731 for multi-module shared libraries.
1733 (a) If the application has not filled in the relevant mach-o fields, make
1736 (b) Order them, like this:
1739 ( ii) external defined
1741 (iii) external undefined
1747 (by position within section).
1749 (c) Indirect symbols are moved to the end of the list. */
1752 bfd_mach_o_mangle_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
1755 asymbol **symbols = bfd_get_outsymbols (abfd);
1757 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1760 for (i = 0; i < bfd_get_symcount (abfd); i++)
1762 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1764 if (s->n_type == BFD_MACH_O_N_UNDF && !(s->symbol.flags & BSF_DEBUGGING))
1766 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1767 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1768 values haven't been set. */
1769 if (s->symbol.section == bfd_abs_section_ptr)
1770 s->n_type = BFD_MACH_O_N_ABS;
1771 else if (s->symbol.section == bfd_und_section_ptr)
1773 s->n_type = BFD_MACH_O_N_UNDF;
1774 if (s->symbol.flags & BSF_WEAK)
1775 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1776 /* mach-o automatically makes undefined symbols extern. */
1777 s->n_type |= BFD_MACH_O_N_EXT;
1779 else if (s->symbol.section == bfd_com_section_ptr)
1780 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1782 s->n_type = BFD_MACH_O_N_SECT;
1784 if (s->symbol.flags & BSF_GLOBAL)
1785 s->n_type |= BFD_MACH_O_N_EXT;
1788 /* Put the section index in, where required. */
1789 if ((s->symbol.section != bfd_abs_section_ptr
1790 && s->symbol.section != bfd_und_section_ptr
1791 && s->symbol.section != bfd_com_section_ptr)
1792 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1793 && s->symbol.name == NULL))
1794 s->n_sect = s->symbol.section->target_index;
1796 /* Unless we're looking at an indirect sym, note the input ordering.
1797 We use this to keep local symbols ordered as per the input. */
1798 if (! IS_MACHO_INDIRECT (s->n_type))
1799 s->symbol.udata.i = i;
1802 /* Sort the symbols and determine how many will remain in the main symbol
1803 table, and how many will be emitted as indirect (assuming that we will
1804 be emitting a dysymtab). Renumber the sorted symbols so that the right
1805 index will be found during indirection. */
1806 i = bfd_mach_o_sort_symbol_table (symbols, bfd_get_symcount (abfd));
1807 if (bfd_mach_o_should_emit_dysymtab ())
1809 /* Point at the first indirect symbol. */
1810 if (i < bfd_get_symcount (abfd))
1812 mdata->indirect_syms = &symbols[i];
1813 mdata->nindirect = bfd_get_symcount (abfd) - i;
1814 /* This is, essentially, local to the output section of mach-o,
1815 and therefore should be safe. */
1819 /* Now setup the counts for each type of symbol. */
1820 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1822 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1823 s->symbol.udata.i = i; /* renumber. */
1824 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
1828 for (; i < bfd_get_symcount (abfd); ++i)
1830 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1831 s->symbol.udata.i = i; /* renumber. */
1832 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
1835 mdata->ndefext = i - mdata->nlocal;
1836 mdata->nundefext = bfd_get_symcount (abfd)
1839 for (; i < bfd_get_symcount (abfd); ++i)
1841 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1842 s->symbol.udata.i = i; /* renumber. */
1849 /* We build a flat table of sections, which can be re-ordered if necessary.
1850 Fill in the section number and other mach-o-specific data. */
1853 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1856 unsigned target_index;
1859 nsect = bfd_count_sections (abfd);
1861 /* Don't do it if it's already set - assume the application knows what it's
1863 if (mdata->nsects == nsect
1864 && (mdata->nsects == 0 || mdata->sections != NULL))
1867 mdata->nsects = nsect;
1868 mdata->sections = bfd_alloc (abfd,
1869 mdata->nsects * sizeof (bfd_mach_o_section *));
1870 if (mdata->sections == NULL)
1873 /* We need to check that this can be done... */
1875 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1876 " maximum is 255,\n"), nsect);
1878 /* Create Mach-O sections.
1879 Section type, attribute and align should have been set when the
1880 section was created - either read in or specified. */
1882 for (sec = abfd->sections; sec; sec = sec->next)
1884 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1885 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1887 mdata->sections[target_index] = msect;
1889 msect->addr = bfd_get_section_vma (abfd, sec);
1890 msect->size = bfd_get_section_size (sec);
1892 /* Use the largest alignment set, in case it was bumped after the
1893 section was created. */
1894 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1897 sec->target_index = ++target_index;
1904 bfd_mach_o_write_contents (bfd *abfd)
1907 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1909 /* Make the commands, if not already present. */
1910 if (mdata->header.ncmds == 0)
1911 if (!bfd_mach_o_build_commands (abfd))
1914 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1917 for (i = 0; i < mdata->header.ncmds; i++)
1919 struct mach_o_load_command_external raw;
1920 bfd_mach_o_load_command *cur = &mdata->commands[i];
1921 unsigned long typeflag;
1923 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1925 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1926 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1928 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1929 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1934 case BFD_MACH_O_LC_SEGMENT:
1935 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1938 case BFD_MACH_O_LC_SEGMENT_64:
1939 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1942 case BFD_MACH_O_LC_SYMTAB:
1943 if (!bfd_mach_o_write_symtab (abfd, cur))
1946 case BFD_MACH_O_LC_DYSYMTAB:
1947 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1950 case BFD_MACH_O_LC_SYMSEG:
1952 case BFD_MACH_O_LC_THREAD:
1953 case BFD_MACH_O_LC_UNIXTHREAD:
1954 if (bfd_mach_o_write_thread (abfd, cur) != 0)
1957 case BFD_MACH_O_LC_LOADFVMLIB:
1958 case BFD_MACH_O_LC_IDFVMLIB:
1959 case BFD_MACH_O_LC_IDENT:
1960 case BFD_MACH_O_LC_FVMFILE:
1961 case BFD_MACH_O_LC_PREPAGE:
1962 case BFD_MACH_O_LC_LOAD_DYLIB:
1963 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1964 case BFD_MACH_O_LC_ID_DYLIB:
1965 case BFD_MACH_O_LC_REEXPORT_DYLIB:
1966 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
1967 case BFD_MACH_O_LC_LOAD_DYLINKER:
1968 case BFD_MACH_O_LC_ID_DYLINKER:
1969 case BFD_MACH_O_LC_PREBOUND_DYLIB:
1970 case BFD_MACH_O_LC_ROUTINES:
1971 case BFD_MACH_O_LC_SUB_FRAMEWORK:
1974 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
1975 (unsigned long) cur->type);
1984 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
1987 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
1988 if (seg->sect_head == NULL)
1991 seg->sect_tail->next = s;
1995 /* Create section Mach-O flags from BFD flags. */
1998 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2001 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2003 /* Create default flags. */
2004 bfd_flags = bfd_get_section_flags (abfd, sec);
2005 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2006 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2007 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2008 | BFD_MACH_O_S_REGULAR;
2009 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2010 s->flags = BFD_MACH_O_S_ZEROFILL;
2011 else if (bfd_flags & SEC_DEBUGGING)
2012 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2014 s->flags = BFD_MACH_O_S_REGULAR;
2017 /* Count the number of sections in the list for the segment named.
2019 The special case of NULL or "" for the segment name is valid for
2020 an MH_OBJECT file and means 'all sections available'.
2022 Requires that the sections table in mdata be filled in.
2024 Returns the number of sections (0 is valid).
2025 Any number > 255 signals an invalid section count, although we will,
2026 perhaps, allow the file to be written (in line with Darwin tools up
2029 A section count of (unsigned long) -1 signals a definite error. */
2031 static unsigned long
2032 bfd_mach_o_count_sections_for_seg (const char *segment,
2033 bfd_mach_o_data_struct *mdata)
2036 if (mdata == NULL || mdata->sections == NULL)
2037 return (unsigned long) -1;
2039 /* The MH_OBJECT case, all sections are considered; Although nsects is
2040 is an unsigned long, the maximum valid section count is 255 and this
2041 will have been checked already by mangle_sections. */
2042 if (segment == NULL || segment[0] == '\0')
2043 return mdata->nsects;
2045 /* Count the number of sections we see in this segment. */
2047 for (i = 0; i < mdata->nsects; ++i)
2049 bfd_mach_o_section *s = mdata->sections[i];
2050 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2057 bfd_mach_o_build_seg_command (const char *segment,
2058 bfd_mach_o_data_struct *mdata,
2059 bfd_mach_o_segment_command *seg)
2062 int is_mho = (segment == NULL || segment[0] == '\0');
2064 /* Fill segment command. */
2066 memset (seg->segname, 0, sizeof (seg->segname));
2068 strncpy (seg->segname, segment, sizeof (seg->segname));
2070 /* TODO: fix this up for non-MH_OBJECT cases. */
2073 seg->fileoff = mdata->filelen;
2075 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2076 | BFD_MACH_O_PROT_EXECUTE;
2077 seg->initprot = seg->maxprot;
2079 seg->sect_head = NULL;
2080 seg->sect_tail = NULL;
2082 /* Append sections to the segment. */
2084 for (i = 0; i < mdata->nsects; ++i)
2086 bfd_mach_o_section *s = mdata->sections[i];
2087 asection *sec = s->bfdsection;
2089 /* If we're not making an MH_OBJECT, check whether this section is from
2090 our segment, and skip if not. Otherwise, just add all sections. */
2092 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2095 bfd_mach_o_append_section_to_segment (seg, sec);
2101 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2102 s->offset = mdata->filelen;
2105 sec->filepos = s->offset;
2107 mdata->filelen += s->size;
2110 seg->filesize = mdata->filelen - seg->fileoff;
2111 seg->vmsize = seg->filesize;
2117 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2118 bfd_mach_o_data_struct *mdata,
2119 bfd_mach_o_load_command *cmd)
2121 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2124 We are not going to try and fill these in yet and, moreover, we are
2125 going to bail if they are already set. */
2126 if (dsym->nmodtab != 0
2128 || dsym->nextrefsyms != 0)
2130 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2131 " implemented for dysymtab commands."));
2135 dsym->ilocalsym = 0;
2136 dsym->nlocalsym = mdata->nlocal;
2137 dsym->iextdefsym = dsym->nlocalsym;
2138 dsym->nextdefsym = mdata->ndefext;
2139 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2140 dsym->nundefsym = mdata->nundefext;
2142 if (mdata->nindirect > 0)
2146 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2147 dsym->indirectsymoff = mdata->filelen;
2148 mdata->filelen += mdata->nindirect * 4;
2150 dsym->indirect_syms = bfd_zalloc (abfd, mdata->nindirect * 4);
2151 if (dsym->indirect_syms == NULL)
2153 dsym->nindirectsyms = mdata->nindirect;
2155 /* So fill in the indices, and point the section reserved1 fields
2156 at the right one. */
2157 sect = (unsigned) -1;
2158 for (i = 0; i < mdata->nindirect; ++i)
2160 bfd_mach_o_asymbol *s =
2161 (bfd_mach_o_asymbol *) mdata->indirect_syms[i];
2162 /* Lookup the index of the referenced symbol. */
2163 dsym->indirect_syms[i] =
2164 ((bfd_mach_o_asymbol *) s->symbol.udata.p)->symbol.udata.i;
2165 if (s->n_sect != sect)
2167 /* Mach-o sections are 1-based, but the section table
2169 bfd_mach_o_section *sc = mdata->sections[s->n_sect-1];
2179 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2180 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2181 and copy functionality. */
2184 bfd_mach_o_build_commands (bfd *abfd)
2186 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2187 unsigned int wide = mach_o_wide_p (&mdata->header);
2188 bfd_mach_o_segment_command *seg;
2189 bfd_mach_o_load_command *cmd;
2190 bfd_mach_o_load_command *symtab_cmd;
2193 /* Return now if commands are already present. */
2194 if (mdata->header.ncmds)
2197 /* Fill in the file type, if not already set. */
2199 if (mdata->header.filetype == 0)
2201 if (abfd->flags & EXEC_P)
2202 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2203 else if (abfd->flags & DYNAMIC)
2204 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2206 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2209 /* If hasn't already been done, flatten sections list, and sort
2210 if/when required. Must be done before the symbol table is adjusted,
2211 since that depends on properly numbered sections. */
2212 if (mdata->nsects == 0 || mdata->sections == NULL)
2213 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2216 /* Order the symbol table, fill-in/check mach-o specific fields and
2217 partition out any indirect symbols. */
2218 if (!bfd_mach_o_mangle_symbols (abfd, mdata))
2221 /* It's valid to have a file with only absolute symbols... */
2222 if (mdata->nsects > 0)
2224 mdata->header.ncmds = 1;
2230 /* It's OK to have a file with only section statements. */
2231 if (bfd_get_symcount (abfd) > 0)
2232 mdata->header.ncmds += 1;
2234 /* Very simple version (only really applicable to MH_OBJECTs):
2235 a command (segment) to contain all the sections,
2236 a command for the symbol table
2237 a n (optional) command for the dysymtab.
2239 ??? maybe we should assert that this is an MH_OBJECT? */
2241 if (bfd_mach_o_should_emit_dysymtab ()
2242 && bfd_get_symcount (abfd) > 0)
2243 mdata->header.ncmds += 1;
2245 /* A bit weird, but looks like no content;
2246 as -n empty.s -o empty.o */
2247 if (mdata->header.ncmds == 0)
2250 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2251 * sizeof (bfd_mach_o_load_command));
2252 if (mdata->commands == NULL)
2255 if (mdata->nsects > 0)
2257 cmd = &mdata->commands[0];
2258 seg = &cmd->command.segment;
2260 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2261 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2262 if (seg->nsects == (unsigned long) -1)
2265 /* Init segment command. */
2268 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2269 cmd->offset = BFD_MACH_O_HEADER_64_SIZE;
2270 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2271 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2275 cmd->type = BFD_MACH_O_LC_SEGMENT;
2276 cmd->offset = BFD_MACH_O_HEADER_SIZE;
2277 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2278 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2280 cmd->type_required = FALSE;
2281 mdata->header.sizeofcmds = cmd->len;
2282 mdata->filelen = cmd->offset + cmd->len;
2285 if (bfd_get_symcount (abfd) > 0)
2287 /* Init symtab command. */
2288 symtab_cmd = &mdata->commands[symcind];
2290 symtab_cmd->type = BFD_MACH_O_LC_SYMTAB;
2292 symtab_cmd->offset = mdata->commands[0].offset
2293 + mdata->commands[0].len;
2295 symtab_cmd->offset = 0;
2296 symtab_cmd->len = 6 * 4;
2297 symtab_cmd->type_required = FALSE;
2299 mdata->header.sizeofcmds += symtab_cmd->len;
2300 mdata->filelen += symtab_cmd->len;
2303 /* If required, setup symtab command. */
2304 if (bfd_mach_o_should_emit_dysymtab ()
2305 && bfd_get_symcount (abfd) > 0)
2307 cmd = &mdata->commands[symcind+1];
2308 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2309 cmd->offset = symtab_cmd->offset + symtab_cmd->len;
2310 cmd->type_required = FALSE;
2311 cmd->len = 18 * 4 + BFD_MACH_O_LC_SIZE;
2313 mdata->header.sizeofcmds += cmd->len;
2314 mdata->filelen += cmd->len;
2317 /* So, now we have sized the commands and the filelen set to that.
2318 Now we can build the segment command and set the section file offsets. */
2319 if (mdata->nsects > 0
2320 && ! bfd_mach_o_build_seg_command (NULL, mdata, seg))
2323 /* If we're doing a dysymtab, cmd points to its load command. */
2324 if (bfd_mach_o_should_emit_dysymtab ()
2325 && bfd_get_symcount (abfd) > 0
2326 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2327 &mdata->commands[symcind+1]))
2330 /* The symtab command is filled in when the symtab is written. */
2334 /* Set the contents of a section. */
2337 bfd_mach_o_set_section_contents (bfd *abfd,
2339 const void * location,
2341 bfd_size_type count)
2345 /* Trying to write the first section contents will trigger the creation of
2346 the load commands if they are not already present. */
2347 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2353 pos = section->filepos + offset;
2354 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2355 || bfd_bwrite (location, count, abfd) != count)
2362 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2363 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2368 /* Make an empty symbol. This is required only because
2369 bfd_make_section_anyway wants to create a symbol for the section. */
2372 bfd_mach_o_make_empty_symbol (bfd *abfd)
2374 asymbol *new_symbol;
2376 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2377 if (new_symbol == NULL)
2379 new_symbol->the_bfd = abfd;
2380 new_symbol->udata.i = 0;
2385 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2387 struct mach_o_header_external raw;
2389 bfd_vma (*get32) (const void *) = NULL;
2391 /* Just read the magic number. */
2392 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2393 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2396 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2398 header->byteorder = BFD_ENDIAN_BIG;
2399 header->magic = BFD_MACH_O_MH_MAGIC;
2400 header->version = 1;
2403 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2405 header->byteorder = BFD_ENDIAN_LITTLE;
2406 header->magic = BFD_MACH_O_MH_MAGIC;
2407 header->version = 1;
2410 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2412 header->byteorder = BFD_ENDIAN_BIG;
2413 header->magic = BFD_MACH_O_MH_MAGIC_64;
2414 header->version = 2;
2417 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2419 header->byteorder = BFD_ENDIAN_LITTLE;
2420 header->magic = BFD_MACH_O_MH_MAGIC_64;
2421 header->version = 2;
2426 header->byteorder = BFD_ENDIAN_UNKNOWN;
2430 /* Once the size of the header is known, read the full header. */
2431 size = mach_o_wide_p (header) ?
2432 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2434 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2435 || bfd_bread (&raw, size, abfd) != size)
2438 header->cputype = (*get32) (raw.cputype);
2439 header->cpusubtype = (*get32) (raw.cpusubtype);
2440 header->filetype = (*get32) (raw.filetype);
2441 header->ncmds = (*get32) (raw.ncmds);
2442 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2443 header->flags = (*get32) (raw.flags);
2445 if (mach_o_wide_p (header))
2446 header->reserved = (*get32) (raw.reserved);
2452 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2454 bfd_mach_o_section *s;
2455 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2457 s = bfd_mach_o_get_mach_o_section (sec);
2461 static const mach_o_section_name_xlat * xlat;
2463 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2466 sec->used_by_bfd = s;
2467 s->bfdsection = sec;
2469 /* Create the Darwin seg/sect name pair from the bfd name.
2470 If this is a canonical name for which a specific paiting exists
2471 there will also be defined flags, type, attribute and alignment
2473 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2476 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2477 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2479 bfd_set_section_alignment (abfd, sec, s->align);
2480 bfd_flags = bfd_get_section_flags (abfd, sec);
2481 if (bfd_flags == SEC_NO_FLAGS)
2482 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2485 /* Create default flags. */
2486 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2489 return _bfd_generic_new_section_hook (abfd, sec);
2493 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2497 bfd_mach_o_section *section;
2499 flags = bfd_get_section_flags (abfd, sec);
2500 section = bfd_mach_o_get_mach_o_section (sec);
2502 /* TODO: see if we should use the xlat system for doing this by
2503 preference and fall back to this for unknown sections. */
2505 if (flags == SEC_NO_FLAGS)
2507 /* Try to guess flags. */
2508 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2509 flags = SEC_DEBUGGING;
2513 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2514 != BFD_MACH_O_S_ZEROFILL)
2517 if (prot & BFD_MACH_O_PROT_EXECUTE)
2519 if (prot & BFD_MACH_O_PROT_WRITE)
2521 else if (prot & BFD_MACH_O_PROT_READ)
2522 flags |= SEC_READONLY;
2528 if ((flags & SEC_DEBUGGING) == 0)
2532 if (section->offset != 0)
2533 flags |= SEC_HAS_CONTENTS;
2534 if (section->nreloc != 0)
2537 bfd_set_section_flags (abfd, sec, flags);
2539 sec->vma = section->addr;
2540 sec->lma = section->addr;
2541 sec->size = section->size;
2542 sec->filepos = section->offset;
2543 sec->alignment_power = section->align;
2544 sec->segment_mark = 0;
2545 sec->reloc_count = section->nreloc;
2546 sec->rel_filepos = section->reloff;
2550 bfd_mach_o_make_bfd_section (bfd *abfd,
2551 const unsigned char *segname,
2552 const unsigned char *sectname)
2557 bfd_mach_o_convert_section_name_to_bfd
2558 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2562 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2566 bfd_mach_o_read_section_32 (bfd *abfd,
2567 unsigned int offset,
2570 struct mach_o_section_32_external raw;
2572 bfd_mach_o_section *section;
2574 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2575 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2576 != BFD_MACH_O_SECTION_SIZE))
2579 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2583 section = bfd_mach_o_get_mach_o_section (sec);
2584 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2585 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2586 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2587 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2588 section->addr = bfd_h_get_32 (abfd, raw.addr);
2589 section->size = bfd_h_get_32 (abfd, raw.size);
2590 section->offset = bfd_h_get_32 (abfd, raw.offset);
2591 section->align = bfd_h_get_32 (abfd, raw.align);
2592 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2593 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2594 section->flags = bfd_h_get_32 (abfd, raw.flags);
2595 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2596 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2597 section->reserved3 = 0;
2599 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2605 bfd_mach_o_read_section_64 (bfd *abfd,
2606 unsigned int offset,
2609 struct mach_o_section_64_external raw;
2611 bfd_mach_o_section *section;
2613 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2614 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2615 != BFD_MACH_O_SECTION_64_SIZE))
2618 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2622 section = bfd_mach_o_get_mach_o_section (sec);
2623 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2624 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2625 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2626 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2627 section->addr = bfd_h_get_64 (abfd, raw.addr);
2628 section->size = bfd_h_get_64 (abfd, raw.size);
2629 section->offset = bfd_h_get_32 (abfd, raw.offset);
2630 section->align = bfd_h_get_32 (abfd, raw.align);
2631 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2632 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2633 section->flags = bfd_h_get_32 (abfd, raw.flags);
2634 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2635 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2636 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2638 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2644 bfd_mach_o_read_section (bfd *abfd,
2645 unsigned int offset,
2650 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2652 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2656 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2657 bfd_mach_o_symtab_command *sym,
2658 bfd_mach_o_asymbol *s,
2661 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2662 unsigned int wide = mach_o_wide_p (&mdata->header);
2663 unsigned int symwidth =
2664 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2665 unsigned int symoff = sym->symoff + (i * symwidth);
2666 struct mach_o_nlist_64_external raw;
2667 unsigned char type = -1;
2668 unsigned char section = -1;
2670 symvalue value = -1;
2671 unsigned long stroff = -1;
2672 unsigned int symtype = -1;
2674 BFD_ASSERT (sym->strtab != NULL);
2676 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2677 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2679 (*_bfd_error_handler)
2680 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2681 symwidth, (unsigned long) symoff);
2685 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2686 type = bfd_h_get_8 (abfd, raw.n_type);
2687 symtype = type & BFD_MACH_O_N_TYPE;
2688 section = bfd_h_get_8 (abfd, raw.n_sect);
2689 desc = bfd_h_get_16 (abfd, raw.n_desc);
2691 value = bfd_h_get_64 (abfd, raw.n_value);
2693 value = bfd_h_get_32 (abfd, raw.n_value);
2695 if (stroff >= sym->strsize)
2697 (*_bfd_error_handler)
2698 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2699 (unsigned long) stroff,
2700 (unsigned long) sym->strsize);
2704 s->symbol.the_bfd = abfd;
2705 s->symbol.name = sym->strtab + stroff;
2706 s->symbol.value = value;
2707 s->symbol.flags = 0x0;
2708 s->symbol.udata.i = 0;
2710 s->n_sect = section;
2713 if (type & BFD_MACH_O_N_STAB)
2715 s->symbol.flags |= BSF_DEBUGGING;
2716 s->symbol.section = bfd_und_section_ptr;
2728 if ((section > 0) && (section <= mdata->nsects))
2730 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2732 s->symbol.value - mdata->sections[section - 1]->addr;
2739 if (type & BFD_MACH_O_N_PEXT)
2740 s->symbol.flags |= BSF_GLOBAL;
2742 if (type & BFD_MACH_O_N_EXT)
2743 s->symbol.flags |= BSF_GLOBAL;
2745 if (!(type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
2746 s->symbol.flags |= BSF_LOCAL;
2750 case BFD_MACH_O_N_UNDF:
2751 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2752 && s->symbol.value != 0)
2754 /* A common symbol. */
2755 s->symbol.section = bfd_com_section_ptr;
2756 s->symbol.flags = BSF_NO_FLAGS;
2760 s->symbol.section = bfd_und_section_ptr;
2761 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2762 s->symbol.flags |= BSF_WEAK;
2765 case BFD_MACH_O_N_PBUD:
2766 s->symbol.section = bfd_und_section_ptr;
2768 case BFD_MACH_O_N_ABS:
2769 s->symbol.section = bfd_abs_section_ptr;
2771 case BFD_MACH_O_N_SECT:
2772 if ((section > 0) && (section <= mdata->nsects))
2774 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2776 s->symbol.value - mdata->sections[section - 1]->addr;
2780 /* Mach-O uses 0 to mean "no section"; not an error. */
2783 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2784 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2785 s->symbol.name, section, mdata->nsects);
2787 s->symbol.section = bfd_und_section_ptr;
2790 case BFD_MACH_O_N_INDR:
2791 /* FIXME: we don't follow the BFD convention as this indirect symbol
2792 won't be followed by the referenced one. This looks harmless
2793 unless we start using the linker. */
2794 s->symbol.flags |= BSF_INDIRECT;
2795 s->symbol.section = bfd_ind_section_ptr;
2796 s->symbol.value = 0;
2799 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2800 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2801 s->symbol.name, symtype);
2802 s->symbol.section = bfd_und_section_ptr;
2811 bfd_mach_o_read_symtab_strtab (bfd *abfd)
2813 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2814 bfd_mach_o_symtab_command *sym = mdata->symtab;
2816 /* Fail if there is no symtab. */
2820 /* Success if already loaded. */
2824 if (abfd->flags & BFD_IN_MEMORY)
2826 struct bfd_in_memory *b;
2828 b = (struct bfd_in_memory *) abfd->iostream;
2830 if ((sym->stroff + sym->strsize) > b->size)
2832 bfd_set_error (bfd_error_file_truncated);
2835 sym->strtab = (char *) b->buffer + sym->stroff;
2839 sym->strtab = bfd_alloc (abfd, sym->strsize);
2840 if (sym->strtab == NULL)
2843 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
2844 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
2846 bfd_set_error (bfd_error_file_truncated);
2855 bfd_mach_o_read_symtab_symbols (bfd *abfd)
2857 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2858 bfd_mach_o_symtab_command *sym = mdata->symtab;
2861 if (sym == NULL || sym->symbols)
2863 /* Return now if there are no symbols or if already loaded. */
2867 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
2869 if (sym->symbols == NULL)
2871 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2875 if (!bfd_mach_o_read_symtab_strtab (abfd))
2878 for (i = 0; i < sym->nsyms; i++)
2880 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
2888 bfd_mach_o_i386_flavour_string (unsigned int flavour)
2890 switch ((int) flavour)
2892 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
2893 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
2894 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
2895 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
2896 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
2897 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
2898 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
2899 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
2900 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
2901 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
2902 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
2903 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
2904 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
2905 default: return "UNKNOWN";
2910 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
2912 switch ((int) flavour)
2914 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
2915 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
2916 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
2917 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
2918 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
2919 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
2920 default: return "UNKNOWN";
2925 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
2927 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
2928 struct mach_o_str_command_external raw;
2929 unsigned int nameoff;
2931 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
2932 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
2934 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2935 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
2938 nameoff = bfd_h_get_32 (abfd, raw.str);
2940 cmd->name_offset = command->offset + nameoff;
2941 cmd->name_len = command->len - nameoff;
2942 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
2943 if (cmd->name_str == NULL)
2945 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
2946 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
2952 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
2954 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
2955 struct mach_o_dylib_command_external raw;
2956 unsigned int nameoff;
2958 switch (command->type)
2960 case BFD_MACH_O_LC_LOAD_DYLIB:
2961 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2962 case BFD_MACH_O_LC_ID_DYLIB:
2963 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2964 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
2971 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2972 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
2975 nameoff = bfd_h_get_32 (abfd, raw.name);
2976 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
2977 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
2978 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
2980 cmd->name_offset = command->offset + nameoff;
2981 cmd->name_len = command->len - nameoff;
2982 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
2983 if (cmd->name_str == NULL)
2985 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
2986 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
2992 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
2993 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
2995 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2997 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3002 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3004 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3005 bfd_mach_o_thread_command *cmd = &command->command.thread;
3006 unsigned int offset;
3007 unsigned int nflavours;
3010 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3011 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3013 /* Count the number of threads. */
3016 while (offset != command->len)
3018 struct mach_o_thread_command_external raw;
3020 if (offset >= command->len)
3023 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3024 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3027 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3031 /* Allocate threads. */
3032 cmd->flavours = bfd_alloc
3033 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3034 if (cmd->flavours == NULL)
3036 cmd->nflavours = nflavours;
3040 while (offset != command->len)
3042 struct mach_o_thread_command_external raw;
3044 if (offset >= command->len)
3047 if (nflavours >= cmd->nflavours)
3050 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3051 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3054 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3055 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3056 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3057 offset += cmd->flavours[nflavours].size + sizeof (raw);
3061 for (i = 0; i < nflavours; i++)
3064 unsigned int snamelen;
3066 const char *flavourstr;
3067 const char *prefix = "LC_THREAD";
3070 switch (mdata->header.cputype)
3072 case BFD_MACH_O_CPU_TYPE_POWERPC:
3073 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3074 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3076 case BFD_MACH_O_CPU_TYPE_I386:
3077 case BFD_MACH_O_CPU_TYPE_X86_64:
3078 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3081 flavourstr = "UNKNOWN_ARCHITECTURE";
3085 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3086 sname = bfd_alloc (abfd, snamelen);
3092 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3093 if (bfd_get_section_by_name (abfd, sname) == NULL)
3098 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3102 bfdsec->size = cmd->flavours[i].size;
3103 bfdsec->filepos = cmd->flavours[i].offset;
3104 bfdsec->alignment_power = 0x0;
3106 cmd->section = bfdsec;
3113 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3115 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3116 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3118 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3121 struct mach_o_dysymtab_command_external raw;
3123 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3124 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3127 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3128 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3129 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3130 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3131 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3132 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3133 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3134 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3135 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3136 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3137 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3138 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3139 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3140 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3141 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3142 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3143 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3144 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3147 if (cmd->nmodtab != 0)
3150 int wide = bfd_mach_o_wide_p (abfd);
3151 unsigned int module_len = wide ? 56 : 52;
3154 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3155 if (cmd->dylib_module == NULL)
3158 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3161 for (i = 0; i < cmd->nmodtab; i++)
3163 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3165 unsigned char buf[56];
3167 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3170 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3171 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3172 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3173 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3174 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3175 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3176 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3177 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3178 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3179 v = bfd_h_get_32 (abfd, buf +36);
3180 module->iinit = v & 0xffff;
3181 module->iterm = (v >> 16) & 0xffff;
3182 v = bfd_h_get_32 (abfd, buf + 40);
3183 module->ninit = v & 0xffff;
3184 module->nterm = (v >> 16) & 0xffff;
3187 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3188 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3192 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3193 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3202 cmd->dylib_toc = bfd_alloc
3203 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3204 if (cmd->dylib_toc == NULL)
3207 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3210 for (i = 0; i < cmd->ntoc; i++)
3212 struct mach_o_dylib_table_of_contents_external raw;
3213 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3215 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3218 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3219 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3223 if (cmd->nindirectsyms != 0)
3227 cmd->indirect_syms = bfd_alloc
3228 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3229 if (cmd->indirect_syms == NULL)
3232 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3235 for (i = 0; i < cmd->nindirectsyms; i++)
3237 unsigned char raw[4];
3238 unsigned int *is = &cmd->indirect_syms[i];
3240 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3243 *is = bfd_h_get_32 (abfd, raw);
3247 if (cmd->nextrefsyms != 0)
3252 cmd->ext_refs = bfd_alloc
3253 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3254 if (cmd->ext_refs == NULL)
3257 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3260 for (i = 0; i < cmd->nextrefsyms; i++)
3262 unsigned char raw[4];
3263 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3265 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3268 /* Fields isym and flags are written as bit-fields, thus we need
3269 a specific processing for endianness. */
3270 v = bfd_h_get_32 (abfd, raw);
3271 if (bfd_big_endian (abfd))
3273 ref->isym = (v >> 8) & 0xffffff;
3274 ref->flags = v & 0xff;
3278 ref->isym = v & 0xffffff;
3279 ref->flags = (v >> 24) & 0xff;
3284 if (mdata->dysymtab)
3286 mdata->dysymtab = cmd;
3292 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3294 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3295 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3296 struct mach_o_symtab_command_external raw;
3298 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3300 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3301 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3304 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3305 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3306 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3307 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3308 symtab->symbols = NULL;
3309 symtab->strtab = NULL;
3311 if (symtab->nsyms != 0)
3312 abfd->flags |= HAS_SYMS;
3316 mdata->symtab = symtab;
3321 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3323 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3325 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3327 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3328 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3335 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3337 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3338 struct mach_o_linkedit_data_command_external raw;
3340 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3341 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3344 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3345 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3350 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3352 bfd_mach_o_str_command *cmd = &command->command.str;
3353 struct mach_o_str_command_external raw;
3356 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3357 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3360 off = bfd_get_32 (abfd, raw.str);
3361 cmd->stroff = command->offset + off;
3362 cmd->str_len = command->len - off;
3363 cmd->str = bfd_alloc (abfd, cmd->str_len);
3364 if (cmd->str == NULL)
3366 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3367 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3373 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3375 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3376 struct mach_o_dyld_info_command_external raw;
3378 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3379 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3382 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3383 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3384 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3385 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3386 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3387 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3388 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3389 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3390 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3391 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3396 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3398 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3399 struct mach_o_version_min_command_external raw;
3402 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3403 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3406 ver = bfd_get_32 (abfd, raw.version);
3407 cmd->rel = ver >> 16;
3408 cmd->maj = ver >> 8;
3410 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3415 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3417 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3418 struct mach_o_encryption_info_command_external raw;
3420 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3421 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3424 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3425 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3426 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3431 bfd_mach_o_read_segment (bfd *abfd,
3432 bfd_mach_o_load_command *command,
3435 bfd_mach_o_segment_command *seg = &command->command.segment;
3440 struct mach_o_segment_command_64_external raw;
3442 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3444 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3445 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3448 memcpy (seg->segname, raw.segname, 16);
3449 seg->segname[16] = '\0';
3451 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3452 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3453 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3454 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3455 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3456 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3457 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3458 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3462 struct mach_o_segment_command_32_external raw;
3464 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3466 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3467 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3470 memcpy (seg->segname, raw.segname, 16);
3471 seg->segname[16] = '\0';
3473 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3474 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3475 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3476 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3477 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3478 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3479 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3480 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3482 seg->sect_head = NULL;
3483 seg->sect_tail = NULL;
3485 for (i = 0; i < seg->nsects; i++)
3491 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3492 + (i * BFD_MACH_O_SECTION_64_SIZE);
3494 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3495 + (i * BFD_MACH_O_SECTION_SIZE);
3497 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3501 bfd_mach_o_append_section_to_segment (seg, sec);
3508 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3510 return bfd_mach_o_read_segment (abfd, command, 0);
3514 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3516 return bfd_mach_o_read_segment (abfd, command, 1);
3520 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3522 struct mach_o_load_command_external raw;
3525 /* Read command type and length. */
3526 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3527 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3530 cmd = bfd_h_get_32 (abfd, raw.cmd);
3531 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3532 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3533 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3535 switch (command->type)
3537 case BFD_MACH_O_LC_SEGMENT:
3538 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3541 case BFD_MACH_O_LC_SEGMENT_64:
3542 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3545 case BFD_MACH_O_LC_SYMTAB:
3546 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3549 case BFD_MACH_O_LC_SYMSEG:
3551 case BFD_MACH_O_LC_THREAD:
3552 case BFD_MACH_O_LC_UNIXTHREAD:
3553 if (bfd_mach_o_read_thread (abfd, command) != 0)
3556 case BFD_MACH_O_LC_LOAD_DYLINKER:
3557 case BFD_MACH_O_LC_ID_DYLINKER:
3558 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3561 case BFD_MACH_O_LC_LOAD_DYLIB:
3562 case BFD_MACH_O_LC_ID_DYLIB:
3563 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3564 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3565 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3566 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3569 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3570 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3573 case BFD_MACH_O_LC_LOADFVMLIB:
3574 case BFD_MACH_O_LC_IDFVMLIB:
3575 case BFD_MACH_O_LC_IDENT:
3576 case BFD_MACH_O_LC_FVMFILE:
3577 case BFD_MACH_O_LC_PREPAGE:
3578 case BFD_MACH_O_LC_ROUTINES:
3579 case BFD_MACH_O_LC_ROUTINES_64:
3581 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3582 case BFD_MACH_O_LC_SUB_UMBRELLA:
3583 case BFD_MACH_O_LC_SUB_LIBRARY:
3584 case BFD_MACH_O_LC_SUB_CLIENT:
3585 case BFD_MACH_O_LC_RPATH:
3586 if (bfd_mach_o_read_str (abfd, command) != 0)
3589 case BFD_MACH_O_LC_DYSYMTAB:
3590 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3593 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3594 case BFD_MACH_O_LC_PREBIND_CKSUM:
3596 case BFD_MACH_O_LC_UUID:
3597 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3600 case BFD_MACH_O_LC_CODE_SIGNATURE:
3601 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3602 case BFD_MACH_O_LC_FUNCTION_STARTS:
3603 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3606 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3607 if (!bfd_mach_o_read_encryption_info (abfd, command))
3610 case BFD_MACH_O_LC_DYLD_INFO:
3611 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3614 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3615 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3616 if (!bfd_mach_o_read_version_min (abfd, command))
3620 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3621 abfd, (unsigned long) command->type);
3629 bfd_mach_o_flatten_sections (bfd *abfd)
3631 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3635 /* Count total number of sections. */
3638 for (i = 0; i < mdata->header.ncmds; i++)
3640 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3641 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3643 bfd_mach_o_segment_command *seg;
3645 seg = &mdata->commands[i].command.segment;
3646 mdata->nsects += seg->nsects;
3650 /* Allocate sections array. */
3651 mdata->sections = bfd_alloc (abfd,
3652 mdata->nsects * sizeof (bfd_mach_o_section *));
3654 /* Fill the array. */
3657 for (i = 0; i < mdata->header.ncmds; i++)
3659 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3660 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3662 bfd_mach_o_segment_command *seg;
3663 bfd_mach_o_section *sec;
3665 seg = &mdata->commands[i].command.segment;
3666 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3668 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3669 mdata->sections[csect++] = sec;
3675 bfd_mach_o_scan_start_address (bfd *abfd)
3677 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3678 bfd_mach_o_thread_command *cmd = NULL;
3681 for (i = 0; i < mdata->header.ncmds; i++)
3682 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3683 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3685 cmd = &mdata->commands[i].command.thread;
3692 /* FIXME: create a subtarget hook ? */
3693 for (i = 0; i < cmd->nflavours; i++)
3695 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
3696 && (cmd->flavours[i].flavour
3697 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
3699 unsigned char buf[4];
3701 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
3702 || bfd_bread (buf, 4, abfd) != 4)
3705 abfd->start_address = bfd_h_get_32 (abfd, buf);
3707 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
3708 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
3710 unsigned char buf[4];
3712 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3713 || bfd_bread (buf, 4, abfd) != 4)
3716 abfd->start_address = bfd_h_get_32 (abfd, buf);
3718 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
3719 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
3721 unsigned char buf[8];
3723 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3724 || bfd_bread (buf, 8, abfd) != 8)
3727 abfd->start_address = bfd_h_get_64 (abfd, buf);
3729 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
3730 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
3732 unsigned char buf[8];
3734 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
3735 || bfd_bread (buf, 8, abfd) != 8)
3738 abfd->start_address = bfd_h_get_64 (abfd, buf);
3746 bfd_mach_o_set_arch_mach (bfd *abfd,
3747 enum bfd_architecture arch,
3748 unsigned long machine)
3750 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
3752 /* If this isn't the right architecture for this backend, and this
3753 isn't the generic backend, fail. */
3754 if (arch != bed->arch
3755 && arch != bfd_arch_unknown
3756 && bed->arch != bfd_arch_unknown)
3759 return bfd_default_set_arch_mach (abfd, arch, machine);
3763 bfd_mach_o_scan (bfd *abfd,
3764 bfd_mach_o_header *header,
3765 bfd_mach_o_data_struct *mdata)
3768 enum bfd_architecture cputype;
3769 unsigned long cpusubtype;
3770 unsigned int hdrsize;
3772 hdrsize = mach_o_wide_p (header) ?
3773 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3775 mdata->header = *header;
3777 abfd->flags = abfd->flags & BFD_IN_MEMORY;
3778 switch (header->filetype)
3780 case BFD_MACH_O_MH_OBJECT:
3781 abfd->flags |= HAS_RELOC;
3783 case BFD_MACH_O_MH_EXECUTE:
3784 abfd->flags |= EXEC_P;
3786 case BFD_MACH_O_MH_DYLIB:
3787 case BFD_MACH_O_MH_BUNDLE:
3788 abfd->flags |= DYNAMIC;
3792 abfd->tdata.mach_o_data = mdata;
3794 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
3795 &cputype, &cpusubtype);
3796 if (cputype == bfd_arch_unknown)
3798 (*_bfd_error_handler)
3799 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3800 header->cputype, header->cpusubtype);
3804 bfd_set_arch_mach (abfd, cputype, cpusubtype);
3806 if (header->ncmds != 0)
3808 mdata->commands = bfd_alloc
3809 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
3810 if (mdata->commands == NULL)
3813 for (i = 0; i < header->ncmds; i++)
3815 bfd_mach_o_load_command *cur = &mdata->commands[i];
3818 cur->offset = hdrsize;
3821 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
3822 cur->offset = prev->offset + prev->len;
3825 if (bfd_mach_o_read_command (abfd, cur) < 0)
3830 if (bfd_mach_o_scan_start_address (abfd) < 0)
3833 bfd_mach_o_flatten_sections (abfd);
3838 bfd_mach_o_mkobject_init (bfd *abfd)
3840 bfd_mach_o_data_struct *mdata = NULL;
3842 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
3845 abfd->tdata.mach_o_data = mdata;
3847 mdata->header.magic = 0;
3848 mdata->header.cputype = 0;
3849 mdata->header.cpusubtype = 0;
3850 mdata->header.filetype = 0;
3851 mdata->header.ncmds = 0;
3852 mdata->header.sizeofcmds = 0;
3853 mdata->header.flags = 0;
3854 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
3855 mdata->commands = NULL;
3857 mdata->sections = NULL;
3858 mdata->dyn_reloc_cache = NULL;
3864 bfd_mach_o_gen_mkobject (bfd *abfd)
3866 bfd_mach_o_data_struct *mdata;
3868 if (!bfd_mach_o_mkobject_init (abfd))
3871 mdata = bfd_mach_o_get_data (abfd);
3872 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
3873 mdata->header.cputype = 0;
3874 mdata->header.cpusubtype = 0;
3875 mdata->header.byteorder = abfd->xvec->byteorder;
3876 mdata->header.version = 1;
3882 bfd_mach_o_header_p (bfd *abfd,
3883 bfd_mach_o_filetype filetype,
3884 bfd_mach_o_cpu_type cputype)
3886 struct bfd_preserve preserve;
3887 bfd_mach_o_header header;
3889 preserve.marker = NULL;
3890 if (!bfd_mach_o_read_header (abfd, &header))
3893 if (! (header.byteorder == BFD_ENDIAN_BIG
3894 || header.byteorder == BFD_ENDIAN_LITTLE))
3896 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
3897 (unsigned long) header.byteorder);
3901 if (! ((header.byteorder == BFD_ENDIAN_BIG
3902 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
3903 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
3904 || (header.byteorder == BFD_ENDIAN_LITTLE
3905 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
3906 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
3909 /* Check cputype and filetype.
3910 In case of wildcard, do not accept magics that are handled by existing
3914 if (header.cputype != cputype)
3919 if (header.filetype != filetype)
3924 switch (header.filetype)
3926 case BFD_MACH_O_MH_CORE:
3927 /* Handled by core_p */
3934 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
3935 if (preserve.marker == NULL
3936 || !bfd_preserve_save (abfd, &preserve))
3939 if (!bfd_mach_o_scan (abfd, &header,
3940 (bfd_mach_o_data_struct *) preserve.marker))
3943 bfd_preserve_finish (abfd, &preserve);
3947 bfd_set_error (bfd_error_wrong_format);
3950 if (preserve.marker != NULL)
3951 bfd_preserve_restore (abfd, &preserve);
3955 static const bfd_target *
3956 bfd_mach_o_gen_object_p (bfd *abfd)
3958 return bfd_mach_o_header_p (abfd, 0, 0);
3961 static const bfd_target *
3962 bfd_mach_o_gen_core_p (bfd *abfd)
3964 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
3967 typedef struct mach_o_fat_archentry
3969 unsigned long cputype;
3970 unsigned long cpusubtype;
3971 unsigned long offset;
3973 unsigned long align;
3974 } mach_o_fat_archentry;
3976 typedef struct mach_o_fat_data_struct
3978 unsigned long magic;
3979 unsigned long nfat_arch;
3980 mach_o_fat_archentry *archentries;
3981 } mach_o_fat_data_struct;
3984 bfd_mach_o_archive_p (bfd *abfd)
3986 mach_o_fat_data_struct *adata = NULL;
3987 struct mach_o_fat_header_external hdr;
3990 if (bfd_seek (abfd, 0, SEEK_SET) != 0
3991 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
3994 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
3998 adata->magic = bfd_getb32 (hdr.magic);
3999 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4000 if (adata->magic != 0xcafebabe)
4002 /* Avoid matching Java bytecode files, which have the same magic number.
4003 In the Java bytecode file format this field contains the JVM version,
4004 which starts at 43.0. */
4005 if (adata->nfat_arch > 30)
4008 adata->archentries =
4009 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4010 if (adata->archentries == NULL)
4013 for (i = 0; i < adata->nfat_arch; i++)
4015 struct mach_o_fat_arch_external arch;
4016 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4018 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4019 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4020 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4021 adata->archentries[i].size = bfd_getb32 (arch.size);
4022 adata->archentries[i].align = bfd_getb32 (arch.align);
4025 abfd->tdata.mach_o_fat_data = adata;
4030 bfd_release (abfd, adata);
4031 bfd_set_error (bfd_error_wrong_format);
4036 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4038 mach_o_fat_data_struct *adata;
4039 mach_o_fat_archentry *entry = NULL;
4042 enum bfd_architecture arch_type;
4043 unsigned long arch_subtype;
4045 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4046 BFD_ASSERT (adata != NULL);
4048 /* Find index of previous entry. */
4050 i = 0; /* Start at first one. */
4053 for (i = 0; i < adata->nfat_arch; i++)
4055 if (adata->archentries[i].offset == prev->origin)
4059 if (i == adata->nfat_arch)
4062 bfd_set_error (bfd_error_bad_value);
4065 i++; /* Get next entry. */
4068 if (i >= adata->nfat_arch)
4070 bfd_set_error (bfd_error_no_more_archived_files);
4074 entry = &adata->archentries[i];
4075 nbfd = _bfd_new_bfd_contained_in (archive);
4079 nbfd->origin = entry->offset;
4081 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4082 &arch_type, &arch_subtype);
4084 /* Create the member filename. Use ARCH_NAME. */
4085 nbfd->filename = bfd_printable_arch_mach (arch_type, arch_subtype);
4086 nbfd->iostream = NULL;
4087 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4092 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4093 If ABFD is a fat image containing a member that corresponds to FORMAT
4094 and ARCH, returns it.
4095 In other case, returns NULL.
4096 This function allows transparent uses of fat images. */
4098 bfd_mach_o_fat_extract (bfd *abfd,
4100 const bfd_arch_info_type *arch)
4103 mach_o_fat_data_struct *adata;
4106 if (bfd_check_format (abfd, format))
4108 if (bfd_get_arch_info (abfd) == arch)
4112 if (!bfd_check_format (abfd, bfd_archive)
4113 || abfd->xvec != &mach_o_fat_vec)
4116 /* This is a Mach-O fat image. */
4117 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4118 BFD_ASSERT (adata != NULL);
4120 for (i = 0; i < adata->nfat_arch; i++)
4122 struct mach_o_fat_archentry *e = &adata->archentries[i];
4123 enum bfd_architecture cpu_type;
4124 unsigned long cpu_subtype;
4126 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4127 &cpu_type, &cpu_subtype);
4128 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4131 /* The architecture is found. */
4132 res = _bfd_new_bfd_contained_in (abfd);
4136 res->origin = e->offset;
4138 res->filename = bfd_printable_arch_mach (cpu_type, cpu_subtype);
4139 res->iostream = NULL;
4141 if (bfd_check_format (res, format))
4143 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4154 bfd_mach_o_lookup_command (bfd *abfd,
4155 bfd_mach_o_load_command_type type,
4156 bfd_mach_o_load_command **mcommand)
4158 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4159 bfd_mach_o_load_command *ncmd = NULL;
4160 unsigned int i, num;
4162 BFD_ASSERT (md != NULL);
4163 BFD_ASSERT (mcommand != NULL);
4166 for (i = 0; i < md->header.ncmds; i++)
4168 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4170 if (cmd->type != type)
4183 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4187 case BFD_MACH_O_CPU_TYPE_MC680x0:
4189 case BFD_MACH_O_CPU_TYPE_MC88000:
4191 case BFD_MACH_O_CPU_TYPE_POWERPC:
4193 case BFD_MACH_O_CPU_TYPE_I386:
4195 case BFD_MACH_O_CPU_TYPE_SPARC:
4197 case BFD_MACH_O_CPU_TYPE_I860:
4199 case BFD_MACH_O_CPU_TYPE_HPPA:
4200 return 0xc0000000 - 0x04000000;
4206 /* The following two tables should be kept, as far as possible, in order of
4207 most frequently used entries to optimize their use from gas. */
4209 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4211 { "regular", BFD_MACH_O_S_REGULAR},
4212 { "coalesced", BFD_MACH_O_S_COALESCED},
4213 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4214 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4215 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4216 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4217 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4218 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4219 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4220 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4221 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4222 { "interposing", BFD_MACH_O_S_INTERPOSING},
4223 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4224 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4225 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4226 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4227 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4231 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4233 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4234 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4235 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4236 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4237 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4238 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4239 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4240 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4241 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4242 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4243 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4247 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4250 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4252 const bfd_mach_o_xlat_name *x;
4253 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4255 for (x = bfd_mach_o_section_type_name; x->name; x++)
4256 if (strcmp (x->name, name) == 0)
4258 /* We found it... does the target support it? */
4259 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4260 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4261 return x->val; /* OK. */
4263 break; /* Not supported. */
4265 /* Maximum section ID = 0xff. */
4269 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4272 bfd_mach_o_get_section_attribute_from_name (const char *name)
4274 const bfd_mach_o_xlat_name *x;
4276 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4277 if (strcmp (x->name, name) == 0)
4279 return (unsigned int)-1;
4283 bfd_mach_o_core_fetch_environment (bfd *abfd,
4284 unsigned char **rbuf,
4287 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4288 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4291 for (i = 0; i < mdata->header.ncmds; i++)
4293 bfd_mach_o_load_command *cur = &mdata->commands[i];
4294 bfd_mach_o_segment_command *seg = NULL;
4296 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4299 seg = &cur->command.segment;
4301 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4303 unsigned long start = seg->fileoff;
4304 unsigned long end = seg->fileoff + seg->filesize;
4305 unsigned char *buf = bfd_malloc (1024);
4306 unsigned long size = 1024;
4310 bfd_size_type nread = 0;
4311 unsigned long offset;
4312 int found_nonnull = 0;
4314 if (size > (end - start))
4315 size = (end - start);
4317 buf = bfd_realloc_or_free (buf, size);
4321 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4327 nread = bfd_bread (buf, size, abfd);
4335 for (offset = 4; offset <= size; offset += 4)
4339 val = *((unsigned long *) (buf + size - offset));
4340 if (! found_nonnull)
4345 else if (val == 0x0)
4347 unsigned long bottom;
4350 bottom = seg->fileoff + seg->filesize - offset;
4351 top = seg->fileoff + seg->filesize - 4;
4352 *rbuf = bfd_malloc (top - bottom);
4353 *rlen = top - bottom;
4355 memcpy (*rbuf, buf + size - *rlen, *rlen);
4361 if (size == (end - start))
4375 bfd_mach_o_core_file_failing_command (bfd *abfd)
4377 unsigned char *buf = NULL;
4378 unsigned int len = 0;
4381 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4385 return (char *) buf;
4389 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4394 static bfd_mach_o_uuid_command *
4395 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4397 bfd_mach_o_load_command *uuid_cmd;
4398 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4401 return &uuid_cmd->command.uuid;
4404 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4407 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4409 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4412 BFD_ASSERT (uuid_cmd);
4414 if (!bfd_check_format (abfd, bfd_object))
4417 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4418 || bfd_mach_o_get_data (abfd) == NULL
4419 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4422 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4423 if (dsym_uuid_cmd == NULL)
4426 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4427 sizeof (uuid_cmd->uuid)) != 0)
4433 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4434 The caller is responsible for closing the returned BFD object and
4435 its my_archive if the returned BFD is in a fat dSYM. */
4438 bfd_mach_o_find_dsym (const char *dsym_filename,
4439 const bfd_mach_o_uuid_command *uuid_cmd,
4440 const bfd_arch_info_type *arch)
4442 bfd *base_dsym_bfd, *dsym_bfd;
4444 BFD_ASSERT (uuid_cmd);
4446 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4447 if (base_dsym_bfd == NULL)
4450 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4451 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4454 bfd_close (dsym_bfd);
4455 if (base_dsym_bfd != dsym_bfd)
4456 bfd_close (base_dsym_bfd);
4461 /* Return a BFD created from a dSYM file for ABFD.
4462 The caller is responsible for closing the returned BFD object, its
4463 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4466 bfd_mach_o_follow_dsym (bfd *abfd)
4468 char *dsym_filename;
4469 bfd_mach_o_uuid_command *uuid_cmd;
4470 bfd *dsym_bfd, *base_bfd = abfd;
4471 const char *base_basename;
4473 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4476 if (abfd->my_archive)
4477 base_bfd = abfd->my_archive;
4478 /* BFD may have been opened from a stream. */
4479 if (base_bfd->filename == NULL)
4481 bfd_set_error (bfd_error_invalid_operation);
4484 base_basename = lbasename (base_bfd->filename);
4486 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4487 if (uuid_cmd == NULL)
4490 /* TODO: We assume the DWARF file has the same as the binary's.
4491 It seems apple's GDB checks all files in the dSYM bundle directory.
4492 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4494 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4495 + strlen (dsym_subdir) + 1
4496 + strlen (base_basename) + 1);
4497 sprintf (dsym_filename, "%s%s/%s",
4498 base_bfd->filename, dsym_subdir, base_basename);
4500 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4501 bfd_get_arch_info (abfd));
4502 if (dsym_bfd == NULL)
4503 free (dsym_filename);
4509 bfd_mach_o_find_nearest_line (bfd *abfd,
4513 const char **filename_ptr,
4514 const char **functionname_ptr,
4515 unsigned int *line_ptr)
4517 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4520 switch (mdata->header.filetype)
4522 case BFD_MACH_O_MH_OBJECT:
4524 case BFD_MACH_O_MH_EXECUTE:
4525 case BFD_MACH_O_MH_DYLIB:
4526 case BFD_MACH_O_MH_BUNDLE:
4527 case BFD_MACH_O_MH_KEXT_BUNDLE:
4528 if (mdata->dwarf2_find_line_info == NULL)
4530 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4531 /* When we couldn't find dSYM for this binary, we look for
4532 the debug information in the binary itself. In this way,
4533 we won't try finding separated dSYM again because
4534 mdata->dwarf2_find_line_info will be filled. */
4535 if (! mdata->dsym_bfd)
4537 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4538 dwarf_debug_sections, symbols,
4539 &mdata->dwarf2_find_line_info))
4546 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4547 section, symbols, offset,
4548 filename_ptr, functionname_ptr,
4550 &mdata->dwarf2_find_line_info))
4556 bfd_mach_o_close_and_cleanup (bfd *abfd)
4558 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4559 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4561 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4562 bfd_mach_o_free_cached_info (abfd);
4563 if (mdata->dsym_bfd != NULL)
4565 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4566 char *dsym_filename = (char *)(fat_bfd
4568 : mdata->dsym_bfd->filename);
4569 bfd_close (mdata->dsym_bfd);
4570 mdata->dsym_bfd = NULL;
4572 bfd_close (fat_bfd);
4573 free (dsym_filename);
4577 return _bfd_generic_close_and_cleanup (abfd);
4580 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4582 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4584 free (mdata->dyn_reloc_cache);
4585 mdata->dyn_reloc_cache = NULL;
4586 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4588 free (asect->relocation);
4589 asect->relocation = NULL;
4595 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4596 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4598 #define bfd_mach_o_swap_reloc_in NULL
4599 #define bfd_mach_o_swap_reloc_out NULL
4600 #define bfd_mach_o_print_thread NULL
4601 #define bfd_mach_o_tgt_seg_table NULL
4602 #define bfd_mach_o_section_type_valid_for_tgt NULL
4604 #define TARGET_NAME mach_o_be_vec
4605 #define TARGET_STRING "mach-o-be"
4606 #define TARGET_ARCHITECTURE bfd_arch_unknown
4607 #define TARGET_BIG_ENDIAN 1
4608 #define TARGET_ARCHIVE 0
4609 #define TARGET_PRIORITY 1
4610 #include "mach-o-target.c"
4613 #undef TARGET_STRING
4614 #undef TARGET_ARCHITECTURE
4615 #undef TARGET_BIG_ENDIAN
4616 #undef TARGET_ARCHIVE
4617 #undef TARGET_PRIORITY
4619 #define TARGET_NAME mach_o_le_vec
4620 #define TARGET_STRING "mach-o-le"
4621 #define TARGET_ARCHITECTURE bfd_arch_unknown
4622 #define TARGET_BIG_ENDIAN 0
4623 #define TARGET_ARCHIVE 0
4624 #define TARGET_PRIORITY 1
4626 #include "mach-o-target.c"
4629 #undef TARGET_STRING
4630 #undef TARGET_ARCHITECTURE
4631 #undef TARGET_BIG_ENDIAN
4632 #undef TARGET_ARCHIVE
4633 #undef TARGET_PRIORITY
4635 /* Not yet handled: creating an archive. */
4636 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4639 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4640 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4641 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4642 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4643 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4644 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4645 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4646 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4647 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4648 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4650 #define TARGET_NAME mach_o_fat_vec
4651 #define TARGET_STRING "mach-o-fat"
4652 #define TARGET_ARCHITECTURE bfd_arch_unknown
4653 #define TARGET_BIG_ENDIAN 1
4654 #define TARGET_ARCHIVE 1
4655 #define TARGET_PRIORITY 0
4657 #include "mach-o-target.c"
4660 #undef TARGET_STRING
4661 #undef TARGET_ARCHITECTURE
4662 #undef TARGET_BIG_ENDIAN
4663 #undef TARGET_ARCHIVE
4664 #undef TARGET_PRIORITY