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
,
537 bfd
*obfd ATTRIBUTE_UNUSED
,
540 bfd_mach_o_asymbol
*os
, *is
;
541 os
= (bfd_mach_o_asymbol
*)osymbol
;
542 is
= (bfd_mach_o_asymbol
*)isymbol
;
543 os
->n_type
= is
->n_type
;
544 os
->n_sect
= is
->n_sect
;
545 os
->n_desc
= is
->n_desc
;
546 os
->symbol
.udata
.i
= is
->symbol
.udata
.i
;
550 /* Copy any private info we understand from the input section
551 to the output section. */
554 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
556 bfd
*obfd ATTRIBUTE_UNUSED
,
559 if (osection
->used_by_bfd
== NULL
)
560 osection
->used_by_bfd
= isection
->used_by_bfd
;
562 if (isection
->used_by_bfd
!= NULL
)
563 memcpy (osection
->used_by_bfd
, isection
->used_by_bfd
,
564 sizeof (bfd_mach_o_section
));
566 if (osection
->used_by_bfd
!= NULL
)
567 ((bfd_mach_o_section
*)osection
->used_by_bfd
)->bfdsection
= osection
;
572 /* Copy any private info we understand from the input bfd
573 to the output bfd. */
576 bfd_mach_o_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
578 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
579 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
582 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
583 BFD_ASSERT (bfd_mach_o_valid (obfd
));
585 /* FIXME: copy commands. */
590 /* This allows us to set up to 32 bits of flags (unless we invent some
591 fiendish scheme to subdivide). For now, we'll just set the file flags
592 without error checking - just overwrite. */
595 bfd_mach_o_bfd_set_private_flags (bfd
*abfd
, flagword flags
)
597 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
602 mdata
->header
.flags
= flags
;
606 /* Count the total number of symbols. */
609 bfd_mach_o_count_symbols (bfd
*abfd
)
611 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
613 if (mdata
->symtab
== NULL
)
615 return mdata
->symtab
->nsyms
;
619 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
621 long nsyms
= bfd_mach_o_count_symbols (abfd
);
623 return ((nsyms
+ 1) * sizeof (asymbol
*));
627 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
629 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
630 long nsyms
= bfd_mach_o_count_symbols (abfd
);
631 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
639 /* Do not try to read symbols if there are none. */
644 if (!bfd_mach_o_read_symtab_symbols (abfd
))
646 (*_bfd_error_handler
)
647 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
651 BFD_ASSERT (sym
->symbols
!= NULL
);
653 for (j
= 0; j
< sym
->nsyms
; j
++)
654 alocation
[j
] = &sym
->symbols
[j
].symbol
;
661 /* Create synthetic symbols for indirect symbols. */
664 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
665 long symcount ATTRIBUTE_UNUSED
,
666 asymbol
**syms ATTRIBUTE_UNUSED
,
667 long dynsymcount ATTRIBUTE_UNUSED
,
668 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
671 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
672 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
673 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
675 unsigned long count
, i
, j
, n
;
682 /* Stop now if no symbols or no indirect symbols. */
683 if (dysymtab
== NULL
|| symtab
== NULL
|| symtab
->symbols
== NULL
)
686 if (dysymtab
->nindirectsyms
== 0)
689 /* We need to allocate a bfd symbol for every indirect symbol and to
690 allocate the memory for its name. */
691 count
= dysymtab
->nindirectsyms
;
692 size
= count
* sizeof (asymbol
) + 1;
694 for (j
= 0; j
< count
; j
++)
696 unsigned int isym
= dysymtab
->indirect_syms
[j
];
698 /* Some indirect symbols are anonymous. */
699 if (isym
< symtab
->nsyms
&& symtab
->symbols
[isym
].symbol
.name
)
700 size
+= strlen (symtab
->symbols
[isym
].symbol
.name
) + sizeof ("$stub");
703 s
= *ret
= (asymbol
*) bfd_malloc (size
);
706 names
= (char *) (s
+ count
);
711 for (i
= 0; i
< mdata
->nsects
; i
++)
713 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
714 unsigned int first
, last
;
718 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
720 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
721 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
722 case BFD_MACH_O_S_SYMBOL_STUBS
:
723 /* Only these sections have indirect symbols. */
724 first
= sec
->reserved1
;
725 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
727 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
728 for (j
= first
; j
< last
; j
++)
730 unsigned int isym
= dysymtab
->indirect_syms
[j
];
732 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
733 s
->section
= sec
->bfdsection
;
734 s
->value
= addr
- sec
->addr
;
737 if (isym
< symtab
->nsyms
738 && symtab
->symbols
[isym
].symbol
.name
)
740 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
745 memcpy (names
, sym
, len
);
747 memcpy (names
, "$stub", sizeof ("$stub"));
748 names
+= sizeof ("$stub");
767 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
771 bfd_symbol_info (symbol
, ret
);
775 bfd_mach_o_print_symbol (bfd
*abfd
,
778 bfd_print_symbol_type how
)
780 FILE *file
= (FILE *) afile
;
782 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
786 case bfd_print_symbol_name
:
787 fprintf (file
, "%s", symbol
->name
);
790 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
791 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
792 name
= bfd_get_stab_name (asym
->n_type
);
794 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
796 case BFD_MACH_O_N_UNDF
:
797 if (symbol
->value
== 0)
802 case BFD_MACH_O_N_ABS
:
805 case BFD_MACH_O_N_INDR
:
808 case BFD_MACH_O_N_PBUD
:
811 case BFD_MACH_O_N_SECT
:
820 fprintf (file
, " %02x %-6s %02x %04x",
821 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
822 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
823 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
824 fprintf (file
, " [%s]", symbol
->section
->name
);
825 fprintf (file
, " %s", symbol
->name
);
830 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
831 bfd_mach_o_cpu_subtype msubtype
,
832 enum bfd_architecture
*type
,
833 unsigned long *subtype
)
835 *subtype
= bfd_arch_unknown
;
839 case BFD_MACH_O_CPU_TYPE_VAX
:
840 *type
= bfd_arch_vax
;
842 case BFD_MACH_O_CPU_TYPE_MC680x0
:
843 *type
= bfd_arch_m68k
;
845 case BFD_MACH_O_CPU_TYPE_I386
:
846 *type
= bfd_arch_i386
;
847 *subtype
= bfd_mach_i386_i386
;
849 case BFD_MACH_O_CPU_TYPE_X86_64
:
850 *type
= bfd_arch_i386
;
851 *subtype
= bfd_mach_x86_64
;
853 case BFD_MACH_O_CPU_TYPE_MIPS
:
854 *type
= bfd_arch_mips
;
856 case BFD_MACH_O_CPU_TYPE_MC98000
:
857 *type
= bfd_arch_m98k
;
859 case BFD_MACH_O_CPU_TYPE_HPPA
:
860 *type
= bfd_arch_hppa
;
862 case BFD_MACH_O_CPU_TYPE_ARM
:
863 *type
= bfd_arch_arm
;
866 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
867 *subtype
= bfd_mach_arm_4T
;
869 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
870 *subtype
= bfd_mach_arm_4T
; /* Best fit ? */
872 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
873 *subtype
= bfd_mach_arm_5TE
;
875 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
876 *subtype
= bfd_mach_arm_XScale
;
878 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
879 *subtype
= bfd_mach_arm_5TE
; /* Best fit ? */
881 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
886 case BFD_MACH_O_CPU_TYPE_MC88000
:
887 *type
= bfd_arch_m88k
;
889 case BFD_MACH_O_CPU_TYPE_SPARC
:
890 *type
= bfd_arch_sparc
;
891 *subtype
= bfd_mach_sparc
;
893 case BFD_MACH_O_CPU_TYPE_I860
:
894 *type
= bfd_arch_i860
;
896 case BFD_MACH_O_CPU_TYPE_ALPHA
:
897 *type
= bfd_arch_alpha
;
899 case BFD_MACH_O_CPU_TYPE_POWERPC
:
900 *type
= bfd_arch_powerpc
;
901 *subtype
= bfd_mach_ppc
;
903 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
904 *type
= bfd_arch_powerpc
;
905 *subtype
= bfd_mach_ppc64
;
908 *type
= bfd_arch_unknown
;
914 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
916 struct mach_o_header_external raw
;
919 size
= mach_o_wide_p (header
) ?
920 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
922 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
923 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
924 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
925 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
926 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
927 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
928 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
930 if (mach_o_wide_p (header
))
931 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
933 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
934 || bfd_bwrite (&raw
, size
, abfd
) != size
)
941 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
943 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
945 struct mach_o_thread_command_external raw
;
948 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
949 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
952 for (i
= 0; i
< cmd
->nflavours
; i
++)
954 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
955 BFD_ASSERT (cmd
->flavours
[i
].offset
==
956 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
958 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
959 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
961 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
962 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
965 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
972 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
975 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
979 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
980 struct mach_o_reloc_info_external
*raw
,
981 arelent
*res
, asymbol
**syms
)
983 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
984 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
985 bfd_mach_o_reloc_info reloc
;
990 addr
= bfd_get_32 (abfd
, raw
->r_address
);
991 symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
993 if (addr
& BFD_MACH_O_SR_SCATTERED
)
997 /* Scattered relocation.
998 Extract section and offset from r_value. */
999 res
->sym_ptr_ptr
= NULL
;
1001 for (j
= 0; j
< mdata
->nsects
; j
++)
1003 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
1004 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
1006 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
1007 res
->addend
= symnum
- sect
->addr
;
1011 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
1012 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
1013 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
1014 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
1015 reloc
.r_scattered
= 1;
1019 unsigned int num
= BFD_MACH_O_GET_R_SYMBOLNUM (symnum
);
1021 res
->address
= addr
;
1022 if (symnum
& BFD_MACH_O_R_EXTERN
)
1029 BFD_ASSERT (num
!= 0);
1030 BFD_ASSERT (num
<= mdata
->nsects
);
1031 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1032 /* For a symbol defined in section S, the addend (stored in the
1033 binary) contains the address of the section. To comply with
1034 bfd conventio, substract the section address.
1035 Use the address from the header, so that the user can modify
1036 the vma of the section. */
1037 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1040 res
->sym_ptr_ptr
= sym
;
1041 reloc
.r_type
= BFD_MACH_O_GET_R_TYPE (symnum
);
1042 reloc
.r_length
= BFD_MACH_O_GET_R_LENGTH (symnum
);
1043 reloc
.r_pcrel
= (symnum
& BFD_MACH_O_R_PCREL
) ? 1 : 0;
1044 reloc
.r_scattered
= 0;
1047 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
1053 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1054 unsigned long count
,
1055 arelent
*res
, asymbol
**syms
)
1058 struct mach_o_reloc_info_external
*native_relocs
;
1059 bfd_size_type native_size
;
1061 /* Allocate and read relocs. */
1062 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1064 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1065 if (native_relocs
== NULL
)
1068 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1069 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1072 for (i
= 0; i
< count
; i
++)
1074 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
1078 free (native_relocs
);
1081 free (native_relocs
);
1086 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1087 arelent
**rels
, asymbol
**syms
)
1089 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1093 if (asect
->reloc_count
== 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 (asect
->relocation
== NULL
)
1102 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1106 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1107 asect
->reloc_count
, res
, syms
) < 0)
1112 asect
->relocation
= res
;
1115 res
= asect
->relocation
;
1116 for (i
= 0; i
< asect
->reloc_count
; i
++)
1124 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1126 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1128 if (mdata
->dysymtab
== NULL
)
1130 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1131 * sizeof (arelent
*);
1135 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1136 struct bfd_symbol
**syms
)
1138 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1139 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1140 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1144 if (dysymtab
== NULL
)
1146 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1149 /* No need to go further if we don't know how to read relocs. */
1150 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1153 if (mdata
->dyn_reloc_cache
== NULL
)
1155 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1156 * sizeof (arelent
));
1160 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1161 dysymtab
->nextrel
, res
, syms
) < 0)
1167 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1169 res
+ dysymtab
->nextrel
, syms
) < 0)
1175 mdata
->dyn_reloc_cache
= res
;
1178 res
= mdata
->dyn_reloc_cache
;
1179 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1186 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1188 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1192 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1194 sec
= section
->bfdsection
;
1195 if (sec
->reloc_count
== 0)
1198 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1201 /* Allocate relocation room. */
1202 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, 2);
1203 section
->nreloc
= sec
->reloc_count
;
1204 sec
->rel_filepos
= mdata
->filelen
;
1205 section
->reloff
= sec
->rel_filepos
;
1206 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
1208 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1211 /* Convert and write. */
1212 entries
= section
->bfdsection
->orelocation
;
1213 for (i
= 0; i
< section
->nreloc
; i
++)
1215 arelent
*rel
= entries
[i
];
1216 struct mach_o_reloc_info_external raw
;
1217 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1219 /* Convert relocation to an intermediate representation. */
1220 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1223 /* Lower the relocation info. */
1224 if (pinfo
->r_scattered
)
1228 v
= BFD_MACH_O_SR_SCATTERED
1229 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1230 | BFD_MACH_O_SET_SR_LENGTH(pinfo
->r_length
)
1231 | BFD_MACH_O_SET_SR_TYPE(pinfo
->r_type
)
1232 | BFD_MACH_O_SET_SR_ADDRESS(pinfo
->r_address
);
1233 /* Note: scattered relocs have field in reverse order... */
1234 bfd_put_32 (abfd
, v
, raw
.r_address
);
1235 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1241 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1242 v
= BFD_MACH_O_SET_R_SYMBOLNUM (pinfo
->r_value
)
1243 | (pinfo
->r_pcrel
? BFD_MACH_O_R_PCREL
: 0)
1244 | BFD_MACH_O_SET_R_LENGTH (pinfo
->r_length
)
1245 | (pinfo
->r_extern
? BFD_MACH_O_R_EXTERN
: 0)
1246 | BFD_MACH_O_SET_R_TYPE (pinfo
->r_type
);
1247 bfd_put_32 (abfd
, v
, raw
.r_symbolnum
);
1250 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1251 != BFD_MACH_O_RELENT_SIZE
)
1258 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1260 struct mach_o_section_32_external raw
;
1262 memcpy (raw
.sectname
, section
->sectname
, 16);
1263 memcpy (raw
.segname
, section
->segname
, 16);
1264 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1265 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1266 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1267 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1268 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1269 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1270 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1271 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1272 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1274 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1275 != BFD_MACH_O_SECTION_SIZE
)
1282 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1284 struct mach_o_section_64_external raw
;
1286 memcpy (raw
.sectname
, section
->sectname
, 16);
1287 memcpy (raw
.segname
, section
->segname
, 16);
1288 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1289 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1290 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1291 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1292 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1293 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1294 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1295 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1296 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1297 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1299 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1300 != BFD_MACH_O_SECTION_64_SIZE
)
1307 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1309 struct mach_o_segment_command_32_external raw
;
1310 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1311 bfd_mach_o_section
*sec
;
1313 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1315 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1316 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1319 memcpy (raw
.segname
, seg
->segname
, 16);
1320 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1321 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1322 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1323 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1324 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1325 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1326 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1327 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1329 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1330 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1333 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1334 if (bfd_mach_o_write_section_32 (abfd
, sec
))
1341 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1343 struct mach_o_segment_command_64_external raw
;
1344 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1345 bfd_mach_o_section
*sec
;
1347 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1349 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1350 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1353 memcpy (raw
.segname
, seg
->segname
, 16);
1354 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1355 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1356 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1357 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1358 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1359 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1360 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1361 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1363 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1364 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1367 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1368 if (bfd_mach_o_write_section_64 (abfd
, sec
))
1375 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1377 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1378 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1380 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1381 unsigned int symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1382 struct bfd_strtab_hash
*strtab
;
1383 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1385 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1387 /* Write the symbols first. */
1388 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, wide
? 3 : 2);
1389 sym
->symoff
= mdata
->filelen
;
1390 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1393 sym
->nsyms
= bfd_get_symcount (abfd
);
1394 mdata
->filelen
+= sym
->nsyms
* symlen
;
1396 strtab
= _bfd_stringtab_init ();
1401 /* Although we don't strictly need to do this, for compatibility with
1402 Darwin system tools, actually output an empty string for the index
1404 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1406 for (i
= 0; i
< sym
->nsyms
; i
++)
1408 bfd_size_type str_index
;
1409 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1411 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1412 /* An index of 0 always means the empty string. */
1416 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1418 if (str_index
== (bfd_size_type
) -1)
1424 struct mach_o_nlist_64_external raw
;
1426 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1427 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1428 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1429 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1430 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1433 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1438 struct mach_o_nlist_external raw
;
1440 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1441 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1442 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1443 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1444 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1447 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1451 sym
->strsize
= _bfd_stringtab_size (strtab
);
1452 sym
->stroff
= mdata
->filelen
;
1453 mdata
->filelen
+= sym
->strsize
;
1455 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1457 _bfd_stringtab_free (strtab
);
1461 struct mach_o_symtab_command_external raw
;
1463 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1464 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1465 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1466 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1468 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1469 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1476 _bfd_stringtab_free (strtab
);
1480 /* Write a dysymtab command.
1481 TODO: Possibly coalesce writes of smaller objects. */
1484 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1486 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
1488 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
1490 if (cmd
->nmodtab
!= 0)
1494 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
1497 for (i
= 0; i
< cmd
->nmodtab
; i
++)
1499 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
1503 iinit
= module
->iinit
& 0xffff;
1504 iinit
|= ((module
->iterm
& 0xffff) << 16);
1506 ninit
= module
->ninit
& 0xffff;
1507 ninit
|= ((module
->nterm
& 0xffff) << 16);
1509 if (bfd_mach_o_wide_p (abfd
))
1511 struct mach_o_dylib_module_64_external w
;
1513 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
1514 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
1515 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
1516 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
1517 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
1518 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
1519 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
1520 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
1521 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
1522 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
1523 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
1524 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
1525 &w
.objc_module_info_addr
);
1526 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
1527 &w
.objc_module_info_size
);
1529 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
1534 struct mach_o_dylib_module_external n
;
1536 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
1537 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
1538 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
1539 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
1540 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
1541 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
1542 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
1543 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
1544 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
1545 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
1546 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
1547 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
1548 &n
.objc_module_info_addr
);
1549 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
1550 &n
.objc_module_info_size
);
1552 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
1562 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
1565 for (i
= 0; i
< cmd
->ntoc
; i
++)
1567 struct mach_o_dylib_table_of_contents_external raw
;
1568 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
1570 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
1571 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
1573 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1578 if (cmd
->nindirectsyms
> 0)
1582 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
1585 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
1587 unsigned char raw
[4];
1589 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
1590 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1595 if (cmd
->nextrefsyms
!= 0)
1599 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
1602 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
1605 unsigned char raw
[4];
1606 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
1608 /* Fields isym and flags are written as bit-fields, thus we need
1609 a specific processing for endianness. */
1611 if (bfd_big_endian (abfd
))
1613 v
= ((ref
->isym
& 0xffffff) << 8);
1614 v
|= ref
->flags
& 0xff;
1618 v
= ref
->isym
& 0xffffff;
1619 v
|= ((ref
->flags
& 0xff) << 24);
1622 bfd_h_put_32 (abfd
, v
, raw
);
1623 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1629 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
1633 struct mach_o_dysymtab_command_external raw
;
1635 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
1636 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
1637 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
1638 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
1639 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
1640 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
1641 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
1642 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
1643 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
1644 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
1645 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
1646 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
1647 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
1648 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
1649 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
1650 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
1651 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
1652 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
1654 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1662 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
1664 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
1666 /* Just leave debug symbols where they are (pretend they are local, and
1667 then they will just be sorted on position). */
1668 if (s
->n_type
& BFD_MACH_O_N_STAB
)
1671 /* Local (we should never see an undefined local AFAICT). */
1672 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
1675 /* Common symbols look like undefined externs. */
1676 if (mtyp
== BFD_MACH_O_N_UNDF
)
1679 /* A defined non-local, non-debug symbol. */
1684 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
1686 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
1687 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
1688 unsigned int soa
, sob
;
1690 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
1691 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
1698 /* If it's local or stab, just preserve the input order. */
1701 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
1703 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
1706 /* This is probably an error. */
1710 /* The second sort key is name. */
1711 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
1714 /* Process the symbols.
1716 This should be OK for single-module files - but it is not likely to work
1717 for multi-module shared libraries.
1719 (a) If the application has not filled in the relevant mach-o fields, make
1722 (b) Order them, like this:
1725 ( ii) external defined
1727 (iii) external undefined/common
1734 bfd_mach_o_mangle_symbols (bfd
*abfd
)
1737 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1739 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
1742 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
1744 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1746 /* We use this value, which is out-of-range as a symbol index, to signal
1747 that the mach-o-specific data are not filled in and need to be created
1748 from the bfd values. It is much preferable for the application to do
1749 this, since more meaningful diagnostics can be made that way. */
1751 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
1753 /* No symbol information has been set - therefore determine
1754 it from the bfd symbol flags/info. */
1755 if (s
->symbol
.section
== bfd_abs_section_ptr
)
1756 s
->n_type
= BFD_MACH_O_N_ABS
;
1757 else if (s
->symbol
.section
== bfd_und_section_ptr
)
1759 s
->n_type
= BFD_MACH_O_N_UNDF
;
1760 if (s
->symbol
.flags
& BSF_WEAK
)
1761 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
1762 /* mach-o automatically makes undefined symbols extern. */
1763 s
->n_type
|= BFD_MACH_O_N_EXT
;
1764 s
->symbol
.flags
|= BSF_GLOBAL
;
1766 else if (s
->symbol
.section
== bfd_com_section_ptr
)
1768 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
1769 s
->symbol
.flags
|= BSF_GLOBAL
;
1772 s
->n_type
= BFD_MACH_O_N_SECT
;
1774 if (s
->symbol
.flags
& BSF_GLOBAL
)
1775 s
->n_type
|= BFD_MACH_O_N_EXT
;
1778 /* Put the section index in, where required. */
1779 if ((s
->symbol
.section
!= bfd_abs_section_ptr
1780 && s
->symbol
.section
!= bfd_und_section_ptr
1781 && s
->symbol
.section
!= bfd_com_section_ptr
)
1782 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
1783 && s
->symbol
.name
== NULL
))
1784 s
->n_sect
= s
->symbol
.section
->target_index
;
1786 /* Number to preserve order for local and debug syms. */
1787 s
->symbol
.udata
.i
= i
;
1790 /* Sort the symbols. */
1791 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
1792 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
1794 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1796 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1797 s
->symbol
.udata
.i
= i
; /* renumber. */
1803 /* We build a flat table of sections, which can be re-ordered if necessary.
1804 Fill in the section number and other mach-o-specific data. */
1807 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1810 unsigned target_index
;
1813 nsect
= bfd_count_sections (abfd
);
1815 /* Don't do it if it's already set - assume the application knows what it's
1817 if (mdata
->nsects
== nsect
1818 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
1821 mdata
->nsects
= nsect
;
1822 mdata
->sections
= bfd_alloc (abfd
,
1823 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
1824 if (mdata
->sections
== NULL
)
1827 /* We need to check that this can be done... */
1829 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%d)"
1830 " maximum is 255,\n"), nsect
);
1832 /* Create Mach-O sections.
1833 Section type, attribute and align should have been set when the
1834 section was created - either read in or specified. */
1836 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1838 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
1839 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
1841 mdata
->sections
[target_index
] = msect
;
1843 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
1844 msect
->size
= bfd_get_section_size (sec
);
1846 /* Use the largest alignment set, in case it was bumped after the
1847 section was created. */
1848 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
1851 sec
->target_index
= ++target_index
;
1858 bfd_mach_o_write_contents (bfd
*abfd
)
1861 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1863 /* Make the commands, if not already present. */
1864 if (mdata
->header
.ncmds
== 0)
1865 if (!bfd_mach_o_build_commands (abfd
))
1868 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
1871 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
1873 struct mach_o_load_command_external raw
;
1874 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
1875 unsigned long typeflag
;
1877 typeflag
= cur
->type
| (cur
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
1879 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
1880 bfd_h_put_32 (abfd
, cur
->len
, raw
.cmdsize
);
1882 if (bfd_seek (abfd
, cur
->offset
, SEEK_SET
) != 0
1883 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
1888 case BFD_MACH_O_LC_SEGMENT
:
1889 if (bfd_mach_o_write_segment_32 (abfd
, cur
) != 0)
1892 case BFD_MACH_O_LC_SEGMENT_64
:
1893 if (bfd_mach_o_write_segment_64 (abfd
, cur
) != 0)
1896 case BFD_MACH_O_LC_SYMTAB
:
1897 if (!bfd_mach_o_write_symtab (abfd
, cur
))
1900 case BFD_MACH_O_LC_DYSYMTAB
:
1901 if (!bfd_mach_o_write_dysymtab (abfd
, cur
))
1904 case BFD_MACH_O_LC_SYMSEG
:
1906 case BFD_MACH_O_LC_THREAD
:
1907 case BFD_MACH_O_LC_UNIXTHREAD
:
1908 if (bfd_mach_o_write_thread (abfd
, cur
) != 0)
1911 case BFD_MACH_O_LC_LOADFVMLIB
:
1912 case BFD_MACH_O_LC_IDFVMLIB
:
1913 case BFD_MACH_O_LC_IDENT
:
1914 case BFD_MACH_O_LC_FVMFILE
:
1915 case BFD_MACH_O_LC_PREPAGE
:
1916 case BFD_MACH_O_LC_LOAD_DYLIB
:
1917 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
1918 case BFD_MACH_O_LC_ID_DYLIB
:
1919 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
1920 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
1921 case BFD_MACH_O_LC_LOAD_DYLINKER
:
1922 case BFD_MACH_O_LC_ID_DYLINKER
:
1923 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
1924 case BFD_MACH_O_LC_ROUTINES
:
1925 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
1928 (*_bfd_error_handler
) (_("unable to write unknown load command 0x%lx"),
1929 (unsigned long) cur
->type
);
1938 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
1941 bfd_mach_o_section
*s
= (bfd_mach_o_section
*)sec
->used_by_bfd
;
1942 if (seg
->sect_head
== NULL
)
1945 seg
->sect_tail
->next
= s
;
1949 /* Create section Mach-O flags from BFD flags. */
1952 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
1955 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
1957 /* Create default flags. */
1958 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1959 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1960 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1961 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1962 | BFD_MACH_O_S_REGULAR
;
1963 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1964 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1965 else if (bfd_flags
& SEC_DEBUGGING
)
1966 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1968 s
->flags
= BFD_MACH_O_S_REGULAR
;
1971 /* Count the number of sections in the list for the segment named.
1973 The special case of NULL or "" for the segment name is valid for
1974 an MH_OBJECT file and means 'all sections available'.
1976 Requires that the sections table in mdata be filled in.
1978 Returns the number of sections (0 is valid).
1979 Any number > 255 signals an invalid section count, although we will,
1980 perhaps, allow the file to be written (in line with Darwin tools up
1983 A section count of (unsigned long) -1 signals a definite error. */
1985 static unsigned long
1986 bfd_mach_o_count_sections_for_seg (const char *segment
,
1987 bfd_mach_o_data_struct
*mdata
)
1990 if (mdata
== NULL
|| mdata
->sections
== NULL
)
1991 return (unsigned long) -1;
1993 /* The MH_OBJECT case, all sections are considered; Although nsects is
1994 is an unsigned long, the maximum valid section count is 255 and this
1995 will have been checked already by mangle_sections. */
1996 if (segment
== NULL
|| segment
[0] == '\0')
1997 return mdata
->nsects
;
1999 /* Count the number of sections we see in this segment. */
2001 for (i
= 0; i
< mdata
->nsects
; ++i
)
2003 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2004 if (strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
2011 bfd_mach_o_build_seg_command (const char *segment
,
2012 bfd_mach_o_data_struct
*mdata
,
2013 bfd_mach_o_segment_command
*seg
)
2016 int is_mho
= (segment
== NULL
|| segment
[0] == '\0');
2018 /* Fill segment command. */
2020 memset (seg
->segname
, 0, sizeof (seg
->segname
));
2022 strncpy (seg
->segname
, segment
, sizeof (seg
->segname
));
2024 /* TODO: fix this up for non-MH_OBJECT cases. */
2027 seg
->fileoff
= mdata
->filelen
;
2029 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2030 | BFD_MACH_O_PROT_EXECUTE
;
2031 seg
->initprot
= seg
->maxprot
;
2033 seg
->sect_head
= NULL
;
2034 seg
->sect_tail
= NULL
;
2036 /* Append sections to the segment. */
2038 for (i
= 0; i
< mdata
->nsects
; ++i
)
2040 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2041 asection
*sec
= s
->bfdsection
;
2043 /* If we're not making an MH_OBJECT, check whether this section is from
2044 our segment, and skip if not. Otherwise, just add all sections. */
2046 && strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) != 0)
2049 bfd_mach_o_append_section_to_segment (seg
, sec
);
2055 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2056 s
->offset
= mdata
->filelen
;
2059 sec
->filepos
= s
->offset
;
2061 mdata
->filelen
+= s
->size
;
2064 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
2065 seg
->vmsize
= seg
->filesize
;
2071 bfd_mach_o_build_dysymtab_command (bfd
*abfd
,
2072 bfd_mach_o_data_struct
*mdata
,
2073 bfd_mach_o_load_command
*cmd
)
2075 bfd_mach_o_dysymtab_command
*dsym
= &cmd
->command
.dysymtab
;
2078 We are not going to try and fill these in yet and, moreover, we are
2079 going to bail if they are already set. */
2080 if (dsym
->nmodtab
!= 0
2082 || dsym
->nextrefsyms
!= 0)
2084 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
2085 " implemented for dysymtab commands."));
2089 dsym
->ilocalsym
= 0;
2091 if (bfd_get_symcount (abfd
) > 0)
2093 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2096 /* Count the number of each kind of symbol. */
2097 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2099 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2100 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
2103 dsym
->nlocalsym
= i
;
2104 dsym
->iextdefsym
= i
;
2105 for (; i
< bfd_get_symcount (abfd
); ++i
)
2107 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2108 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
2111 dsym
->nextdefsym
= i
- dsym
->nlocalsym
;
2112 dsym
->iundefsym
= dsym
->nextdefsym
+ dsym
->iextdefsym
;
2113 dsym
->nundefsym
= bfd_get_symcount (abfd
)
2119 dsym
->nlocalsym
= 0;
2120 dsym
->iextdefsym
= 0;
2121 dsym
->nextdefsym
= 0;
2122 dsym
->iundefsym
= 0;
2123 dsym
->nundefsym
= 0;
2126 if (dsym
->nindirectsyms
> 0)
2130 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2131 dsym
->indirectsymoff
= mdata
->filelen
;
2132 mdata
->filelen
+= dsym
->nindirectsyms
* 4;
2134 dsym
->indirect_syms
= bfd_zalloc (abfd
, dsym
->nindirectsyms
* 4);
2135 if (dsym
->indirect_syms
== NULL
)
2138 /* So fill in the indices. */
2139 for (i
= 0; i
< dsym
->nindirectsyms
; ++i
)
2141 /* TODO: fill in the table. */
2148 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2149 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2150 and copy functionality. */
2153 bfd_mach_o_build_commands (bfd
*abfd
)
2155 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2156 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2157 int segcmd_idx
= -1;
2158 int symtab_idx
= -1;
2159 int dysymtab_idx
= -1;
2160 unsigned long base_offset
= 0;
2162 /* Return now if commands are already present. */
2163 if (mdata
->header
.ncmds
)
2166 /* Fill in the file type, if not already set. */
2168 if (mdata
->header
.filetype
== 0)
2170 if (abfd
->flags
& EXEC_P
)
2171 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2172 else if (abfd
->flags
& DYNAMIC
)
2173 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2175 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2178 /* If hasn't already been done, flatten sections list, and sort
2179 if/when required. Must be done before the symbol table is adjusted,
2180 since that depends on properly numbered sections. */
2181 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2182 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2185 /* Order the symbol table, fill-in/check mach-o specific fields and
2186 partition out any indirect symbols. */
2187 if (!bfd_mach_o_mangle_symbols (abfd
))
2190 /* Very simple command set (only really applicable to MH_OBJECTs):
2191 All the commands are optional - present only when there is suitable data.
2192 (i.e. it is valid to have an empty file)
2194 a command (segment) to contain all the sections,
2195 command for the symbol table,
2196 a command for the dysymtab.
2198 ??? maybe we should assert that this is an MH_OBJECT? */
2200 if (mdata
->nsects
> 0)
2203 mdata
->header
.ncmds
= 1;
2206 if (bfd_get_symcount (abfd
) > 0)
2208 mdata
->header
.ncmds
++;
2209 symtab_idx
= segcmd_idx
+ 1; /* 0 if the seg command is absent. */
2213 This is a rather crude test for whether we should build a dysymtab. */
2214 if (bfd_mach_o_should_emit_dysymtab ()
2215 && bfd_get_symcount (abfd
))
2217 mdata
->header
.ncmds
++;
2218 /* If there should be a case where a dysymtab could be emitted without
2219 a symtab (seems improbable), this would need amending. */
2220 dysymtab_idx
= symtab_idx
+ 1;
2224 base_offset
= BFD_MACH_O_HEADER_64_SIZE
;
2226 base_offset
= BFD_MACH_O_HEADER_SIZE
;
2228 /* Well, we must have a header, at least. */
2229 mdata
->filelen
= base_offset
;
2231 /* A bit unusual, but no content is valid;
2232 as -n empty.s -o empty.o */
2233 if (mdata
->header
.ncmds
== 0)
2236 mdata
->commands
= bfd_zalloc (abfd
, mdata
->header
.ncmds
2237 * sizeof (bfd_mach_o_load_command
));
2238 if (mdata
->commands
== NULL
)
2241 if (segcmd_idx
>= 0)
2243 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[segcmd_idx
];
2244 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2246 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2247 seg
->nsects
= bfd_mach_o_count_sections_for_seg (NULL
, mdata
);
2248 if (seg
->nsects
== (unsigned long) -1)
2251 /* Init segment command. */
2252 cmd
->offset
= base_offset
;
2255 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
2256 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2257 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
2261 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
2262 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2263 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
2266 cmd
->type_required
= FALSE
;
2267 mdata
->header
.sizeofcmds
= cmd
->len
;
2268 mdata
->filelen
+= cmd
->len
;
2271 if (symtab_idx
>= 0)
2273 /* Init symtab command. */
2274 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[symtab_idx
];
2276 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
2277 cmd
->offset
= base_offset
;
2278 if (segcmd_idx
>= 0)
2279 cmd
->offset
+= mdata
->commands
[segcmd_idx
].len
;
2281 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2282 + BFD_MACH_O_LC_SIZE
;
2283 cmd
->type_required
= FALSE
;
2284 mdata
->header
.sizeofcmds
+= cmd
->len
;
2285 mdata
->filelen
+= cmd
->len
;
2288 /* If required, setup symtab command, see comment above about the quality
2290 if (dysymtab_idx
>= 0)
2292 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[dysymtab_idx
];
2294 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
2295 if (symtab_idx
>= 0)
2296 cmd
->offset
= mdata
->commands
[symtab_idx
].offset
2297 + mdata
->commands
[symtab_idx
].len
;
2298 else if (segcmd_idx
>= 0)
2299 cmd
->offset
= mdata
->commands
[segcmd_idx
].offset
2300 + mdata
->commands
[segcmd_idx
].len
;
2302 cmd
->offset
= base_offset
;
2304 cmd
->type_required
= FALSE
;
2305 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2306 + BFD_MACH_O_LC_SIZE
;
2308 mdata
->header
.sizeofcmds
+= cmd
->len
;
2309 mdata
->filelen
+= cmd
->len
;
2312 /* So, now we have sized the commands and the filelen set to that.
2313 Now we can build the segment command and set the section file offsets. */
2315 && ! bfd_mach_o_build_seg_command
2316 (NULL
, mdata
, &mdata
->commands
[segcmd_idx
].command
.segment
))
2319 /* If we're doing a dysymtab, cmd points to its load command. */
2320 if (dysymtab_idx
>= 0
2321 && ! bfd_mach_o_build_dysymtab_command (abfd
, mdata
,
2322 &mdata
->commands
[dysymtab_idx
]))
2325 /* The symtab command is filled in when the symtab is written. */
2329 /* Set the contents of a section. */
2332 bfd_mach_o_set_section_contents (bfd
*abfd
,
2334 const void * location
,
2336 bfd_size_type count
)
2340 /* Trying to write the first section contents will trigger the creation of
2341 the load commands if they are not already present. */
2342 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
2348 pos
= section
->filepos
+ offset
;
2349 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2350 || bfd_bwrite (location
, count
, abfd
) != count
)
2357 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
2358 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2363 /* Make an empty symbol. This is required only because
2364 bfd_make_section_anyway wants to create a symbol for the section. */
2367 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
2369 asymbol
*new_symbol
;
2371 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
2372 if (new_symbol
== NULL
)
2374 new_symbol
->the_bfd
= abfd
;
2375 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
2380 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
2382 struct mach_o_header_external raw
;
2384 bfd_vma (*get32
) (const void *) = NULL
;
2386 /* Just read the magic number. */
2387 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2388 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
2391 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2393 header
->byteorder
= BFD_ENDIAN_BIG
;
2394 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2395 header
->version
= 1;
2398 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2400 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2401 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2402 header
->version
= 1;
2405 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2407 header
->byteorder
= BFD_ENDIAN_BIG
;
2408 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2409 header
->version
= 2;
2412 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2414 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2415 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2416 header
->version
= 2;
2421 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
2425 /* Once the size of the header is known, read the full header. */
2426 size
= mach_o_wide_p (header
) ?
2427 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2429 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2430 || bfd_bread (&raw
, size
, abfd
) != size
)
2433 header
->cputype
= (*get32
) (raw
.cputype
);
2434 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
2435 header
->filetype
= (*get32
) (raw
.filetype
);
2436 header
->ncmds
= (*get32
) (raw
.ncmds
);
2437 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
2438 header
->flags
= (*get32
) (raw
.flags
);
2440 if (mach_o_wide_p (header
))
2441 header
->reserved
= (*get32
) (raw
.reserved
);
2447 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
2449 bfd_mach_o_section
*s
;
2450 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
2452 s
= bfd_mach_o_get_mach_o_section (sec
);
2456 static const mach_o_section_name_xlat
* xlat
;
2458 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
2461 sec
->used_by_bfd
= s
;
2462 s
->bfdsection
= sec
;
2464 /* Create the Darwin seg/sect name pair from the bfd name.
2465 If this is a canonical name for which a specific paiting exists
2466 there will also be defined flags, type, attribute and alignment
2468 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
2471 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
2472 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
2474 bfd_set_section_alignment (abfd
, sec
, s
->align
);
2475 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2476 if (bfd_flags
== SEC_NO_FLAGS
)
2477 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
2480 /* Create default flags. */
2481 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
2484 return _bfd_generic_new_section_hook (abfd
, sec
);
2488 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
2492 bfd_mach_o_section
*section
;
2494 flags
= bfd_get_section_flags (abfd
, sec
);
2495 section
= bfd_mach_o_get_mach_o_section (sec
);
2497 /* TODO: see if we should use the xlat system for doing this by
2498 preference and fall back to this for unknown sections. */
2500 if (flags
== SEC_NO_FLAGS
)
2502 /* Try to guess flags. */
2503 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
2504 flags
= SEC_DEBUGGING
;
2508 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2509 != BFD_MACH_O_S_ZEROFILL
)
2512 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
2514 if (prot
& BFD_MACH_O_PROT_WRITE
)
2516 else if (prot
& BFD_MACH_O_PROT_READ
)
2517 flags
|= SEC_READONLY
;
2523 if ((flags
& SEC_DEBUGGING
) == 0)
2527 if (section
->offset
!= 0)
2528 flags
|= SEC_HAS_CONTENTS
;
2529 if (section
->nreloc
!= 0)
2532 bfd_set_section_flags (abfd
, sec
, flags
);
2534 sec
->vma
= section
->addr
;
2535 sec
->lma
= section
->addr
;
2536 sec
->size
= section
->size
;
2537 sec
->filepos
= section
->offset
;
2538 sec
->alignment_power
= section
->align
;
2539 sec
->segment_mark
= 0;
2540 sec
->reloc_count
= section
->nreloc
;
2541 sec
->rel_filepos
= section
->reloff
;
2545 bfd_mach_o_make_bfd_section (bfd
*abfd
,
2546 const unsigned char *segname
,
2547 const unsigned char *sectname
)
2552 bfd_mach_o_convert_section_name_to_bfd
2553 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
2557 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
2561 bfd_mach_o_read_section_32 (bfd
*abfd
,
2562 unsigned int offset
,
2565 struct mach_o_section_32_external raw
;
2567 bfd_mach_o_section
*section
;
2569 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2570 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
2571 != BFD_MACH_O_SECTION_SIZE
))
2574 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2578 section
= bfd_mach_o_get_mach_o_section (sec
);
2579 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2580 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2581 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2582 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2583 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
2584 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
2585 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2586 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2587 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2588 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2589 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2590 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2591 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2592 section
->reserved3
= 0;
2594 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2600 bfd_mach_o_read_section_64 (bfd
*abfd
,
2601 unsigned int offset
,
2604 struct mach_o_section_64_external raw
;
2606 bfd_mach_o_section
*section
;
2608 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2609 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
2610 != BFD_MACH_O_SECTION_64_SIZE
))
2613 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2617 section
= bfd_mach_o_get_mach_o_section (sec
);
2618 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2619 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2620 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2621 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2622 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
2623 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
2624 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2625 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2626 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2627 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2628 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2629 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2630 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2631 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
2633 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2639 bfd_mach_o_read_section (bfd
*abfd
,
2640 unsigned int offset
,
2645 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
2647 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
2651 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
2652 bfd_mach_o_symtab_command
*sym
,
2653 bfd_mach_o_asymbol
*s
,
2656 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2657 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
2658 unsigned int symwidth
=
2659 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2660 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
2661 struct mach_o_nlist_64_external raw
;
2662 unsigned char type
= -1;
2663 unsigned char section
= -1;
2665 symvalue value
= -1;
2666 unsigned long stroff
= -1;
2667 unsigned int symtype
= -1;
2669 BFD_ASSERT (sym
->strtab
!= NULL
);
2671 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
2672 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
2674 (*_bfd_error_handler
)
2675 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2676 symwidth
, (unsigned long) symoff
);
2680 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
2681 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
2682 symtype
= type
& BFD_MACH_O_N_TYPE
;
2683 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
2684 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
2686 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
2688 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
2690 if (stroff
>= sym
->strsize
)
2692 (*_bfd_error_handler
)
2693 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2694 (unsigned long) stroff
,
2695 (unsigned long) sym
->strsize
);
2699 s
->symbol
.the_bfd
= abfd
;
2700 s
->symbol
.name
= sym
->strtab
+ stroff
;
2701 s
->symbol
.value
= value
;
2702 s
->symbol
.flags
= 0x0;
2703 s
->symbol
.udata
.i
= i
;
2705 s
->n_sect
= section
;
2708 if (type
& BFD_MACH_O_N_STAB
)
2710 s
->symbol
.flags
|= BSF_DEBUGGING
;
2711 s
->symbol
.section
= bfd_und_section_ptr
;
2723 if ((section
> 0) && (section
<= mdata
->nsects
))
2725 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2727 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2734 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
2735 s
->symbol
.flags
|= BSF_GLOBAL
;
2737 s
->symbol
.flags
|= BSF_LOCAL
;
2741 case BFD_MACH_O_N_UNDF
:
2742 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
2743 && s
->symbol
.value
!= 0)
2745 /* A common symbol. */
2746 s
->symbol
.section
= bfd_com_section_ptr
;
2747 s
->symbol
.flags
= BSF_NO_FLAGS
;
2751 s
->symbol
.section
= bfd_und_section_ptr
;
2752 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
2753 s
->symbol
.flags
|= BSF_WEAK
;
2756 case BFD_MACH_O_N_PBUD
:
2757 s
->symbol
.section
= bfd_und_section_ptr
;
2759 case BFD_MACH_O_N_ABS
:
2760 s
->symbol
.section
= bfd_abs_section_ptr
;
2762 case BFD_MACH_O_N_SECT
:
2763 if ((section
> 0) && (section
<= mdata
->nsects
))
2765 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2767 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2771 /* Mach-O uses 0 to mean "no section"; not an error. */
2774 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2775 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2776 s
->symbol
.name
, section
, mdata
->nsects
);
2778 s
->symbol
.section
= bfd_und_section_ptr
;
2781 case BFD_MACH_O_N_INDR
:
2782 /* FIXME: we don't follow the BFD convention as this indirect symbol
2783 won't be followed by the referenced one. This looks harmless
2784 unless we start using the linker. */
2785 s
->symbol
.flags
|= BSF_INDIRECT
;
2786 s
->symbol
.section
= bfd_ind_section_ptr
;
2787 s
->symbol
.value
= 0;
2790 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2791 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2792 s
->symbol
.name
, symtype
);
2793 s
->symbol
.section
= bfd_und_section_ptr
;
2802 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
2804 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2805 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2807 /* Fail if there is no symtab. */
2811 /* Success if already loaded. */
2815 if (abfd
->flags
& BFD_IN_MEMORY
)
2817 struct bfd_in_memory
*b
;
2819 b
= (struct bfd_in_memory
*) abfd
->iostream
;
2821 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
2823 bfd_set_error (bfd_error_file_truncated
);
2826 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
2830 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
2831 if (sym
->strtab
== NULL
)
2834 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
2835 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
2837 bfd_set_error (bfd_error_file_truncated
);
2846 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
2848 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2849 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2852 if (sym
== NULL
|| sym
->symbols
)
2854 /* Return now if there are no symbols or if already loaded. */
2858 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
2860 if (sym
->symbols
== NULL
)
2862 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2866 if (!bfd_mach_o_read_symtab_strtab (abfd
))
2869 for (i
= 0; i
< sym
->nsyms
; i
++)
2871 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
2879 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2881 switch ((int) flavour
)
2883 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2884 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2885 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2886 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2887 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2888 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2889 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2890 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2891 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2892 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2893 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2894 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2895 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2896 default: return "UNKNOWN";
2901 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2903 switch ((int) flavour
)
2905 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2906 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2907 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2908 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2909 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2910 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2911 default: return "UNKNOWN";
2916 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2918 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2919 struct mach_o_str_command_external raw
;
2920 unsigned int nameoff
;
2922 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
2923 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
2925 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2926 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2929 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
2931 cmd
->name_offset
= command
->offset
+ nameoff
;
2932 cmd
->name_len
= command
->len
- nameoff
;
2933 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2934 if (cmd
->name_str
== NULL
)
2936 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2937 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2943 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2945 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
2946 struct mach_o_dylib_command_external raw
;
2947 unsigned int nameoff
;
2949 switch (command
->type
)
2951 case BFD_MACH_O_LC_LOAD_DYLIB
:
2952 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2953 case BFD_MACH_O_LC_ID_DYLIB
:
2954 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2955 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
2962 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2963 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2966 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
2967 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
2968 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
2969 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
2971 cmd
->name_offset
= command
->offset
+ nameoff
;
2972 cmd
->name_len
= command
->len
- nameoff
;
2973 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2974 if (cmd
->name_str
== NULL
)
2976 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2977 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2983 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
2984 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
2986 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2988 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
2993 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2995 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
2996 struct mach_o_fvmlib_command_external raw
;
2997 unsigned int nameoff
;
2999 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3000 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3003 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3004 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3005 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3007 fvm
->name_offset
= command
->offset
+ nameoff
;
3008 fvm
->name_len
= command
->len
- nameoff
;
3009 fvm
->name_str
= bfd_alloc (abfd
, fvm
->name_len
);
3010 if (fvm
->name_str
== NULL
)
3012 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3013 || bfd_bread (fvm
->name_str
, fvm
->name_len
, abfd
) != fvm
->name_len
)
3019 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3021 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3022 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3023 unsigned int offset
;
3024 unsigned int nflavours
;
3027 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3028 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3030 /* Count the number of threads. */
3033 while (offset
!= command
->len
)
3035 struct mach_o_thread_command_external raw
;
3037 if (offset
>= command
->len
)
3040 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3041 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3044 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3048 /* Allocate threads. */
3049 cmd
->flavours
= bfd_alloc
3050 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3051 if (cmd
->flavours
== NULL
)
3053 cmd
->nflavours
= nflavours
;
3057 while (offset
!= command
->len
)
3059 struct mach_o_thread_command_external raw
;
3061 if (offset
>= command
->len
)
3064 if (nflavours
>= cmd
->nflavours
)
3067 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3068 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3071 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3072 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3073 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3074 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3078 for (i
= 0; i
< nflavours
; i
++)
3081 unsigned int snamelen
;
3083 const char *flavourstr
;
3084 const char *prefix
= "LC_THREAD";
3087 switch (mdata
->header
.cputype
)
3089 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3090 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
3091 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
3093 case BFD_MACH_O_CPU_TYPE_I386
:
3094 case BFD_MACH_O_CPU_TYPE_X86_64
:
3095 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
3098 flavourstr
= "UNKNOWN_ARCHITECTURE";
3102 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
3103 sname
= bfd_alloc (abfd
, snamelen
);
3109 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
3110 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
3115 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
3119 bfdsec
->size
= cmd
->flavours
[i
].size
;
3120 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
3121 bfdsec
->alignment_power
= 0x0;
3123 cmd
->section
= bfdsec
;
3130 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3132 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
3133 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3135 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
3138 struct mach_o_dysymtab_command_external raw
;
3140 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3141 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3144 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
3145 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
3146 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
3147 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
3148 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
3149 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
3150 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
3151 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
3152 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
3153 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
3154 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
3155 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
3156 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
3157 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
3158 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
3159 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
3160 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
3161 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
3164 if (cmd
->nmodtab
!= 0)
3167 int wide
= bfd_mach_o_wide_p (abfd
);
3168 unsigned int module_len
= wide
? 56 : 52;
3171 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
3172 if (cmd
->dylib_module
== NULL
)
3175 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
3178 for (i
= 0; i
< cmd
->nmodtab
; i
++)
3180 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
3182 unsigned char buf
[56];
3184 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
3187 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
3188 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
3189 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
3190 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
3191 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
3192 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
3193 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
3194 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
3195 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
3196 v
= bfd_h_get_32 (abfd
, buf
+36);
3197 module
->iinit
= v
& 0xffff;
3198 module
->iterm
= (v
>> 16) & 0xffff;
3199 v
= bfd_h_get_32 (abfd
, buf
+ 40);
3200 module
->ninit
= v
& 0xffff;
3201 module
->nterm
= (v
>> 16) & 0xffff;
3204 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
3205 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
3209 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
3210 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
3219 cmd
->dylib_toc
= bfd_alloc
3220 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
3221 if (cmd
->dylib_toc
== NULL
)
3224 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
3227 for (i
= 0; i
< cmd
->ntoc
; i
++)
3229 struct mach_o_dylib_table_of_contents_external raw
;
3230 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
3232 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3235 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
3236 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
3240 if (cmd
->nindirectsyms
!= 0)
3244 cmd
->indirect_syms
= bfd_alloc
3245 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
3246 if (cmd
->indirect_syms
== NULL
)
3249 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
3252 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
3254 unsigned char raw
[4];
3255 unsigned int *is
= &cmd
->indirect_syms
[i
];
3257 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3260 *is
= bfd_h_get_32 (abfd
, raw
);
3264 if (cmd
->nextrefsyms
!= 0)
3269 cmd
->ext_refs
= bfd_alloc
3270 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
3271 if (cmd
->ext_refs
== NULL
)
3274 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
3277 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
3279 unsigned char raw
[4];
3280 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
3282 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3285 /* Fields isym and flags are written as bit-fields, thus we need
3286 a specific processing for endianness. */
3287 v
= bfd_h_get_32 (abfd
, raw
);
3288 if (bfd_big_endian (abfd
))
3290 ref
->isym
= (v
>> 8) & 0xffffff;
3291 ref
->flags
= v
& 0xff;
3295 ref
->isym
= v
& 0xffffff;
3296 ref
->flags
= (v
>> 24) & 0xff;
3301 if (mdata
->dysymtab
)
3303 mdata
->dysymtab
= cmd
;
3309 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3311 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
3312 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3313 struct mach_o_symtab_command_external raw
;
3315 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
3317 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3318 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3321 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
3322 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
3323 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
3324 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
3325 symtab
->symbols
= NULL
;
3326 symtab
->strtab
= NULL
;
3328 if (symtab
->nsyms
!= 0)
3329 abfd
->flags
|= HAS_SYMS
;
3333 mdata
->symtab
= symtab
;
3338 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3340 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
3342 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
3344 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3345 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
3352 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3354 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
3355 struct mach_o_linkedit_data_command_external raw
;
3357 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3358 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3361 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
3362 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
3367 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3369 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
3370 struct mach_o_str_command_external raw
;
3373 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3374 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3377 off
= bfd_get_32 (abfd
, raw
.str
);
3378 cmd
->stroff
= command
->offset
+ off
;
3379 cmd
->str_len
= command
->len
- off
;
3380 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
3381 if (cmd
->str
== NULL
)
3383 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
3384 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
3390 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3392 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
3393 struct mach_o_dyld_info_command_external raw
;
3395 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3396 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3399 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
3400 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
3401 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
3402 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
3403 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
3404 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
3405 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
3406 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
3407 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
3408 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
3413 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3415 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
3416 struct mach_o_version_min_command_external raw
;
3419 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3420 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3423 ver
= bfd_get_32 (abfd
, raw
.version
);
3424 cmd
->rel
= ver
>> 16;
3425 cmd
->maj
= ver
>> 8;
3427 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
3432 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3434 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
3435 struct mach_o_encryption_info_command_external raw
;
3437 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3438 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3441 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
3442 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
3443 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
3448 bfd_mach_o_read_segment (bfd
*abfd
,
3449 bfd_mach_o_load_command
*command
,
3452 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
3457 struct mach_o_segment_command_64_external raw
;
3459 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
3461 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3462 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3465 memcpy (seg
->segname
, raw
.segname
, 16);
3466 seg
->segname
[16] = '\0';
3468 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
3469 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
3470 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
3471 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
3472 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3473 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3474 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3475 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3479 struct mach_o_segment_command_32_external raw
;
3481 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
3483 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3484 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3487 memcpy (seg
->segname
, raw
.segname
, 16);
3488 seg
->segname
[16] = '\0';
3490 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
3491 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
3492 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
3493 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
3494 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3495 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3496 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3497 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3499 seg
->sect_head
= NULL
;
3500 seg
->sect_tail
= NULL
;
3502 for (i
= 0; i
< seg
->nsects
; i
++)
3508 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
3509 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
3511 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
3512 + (i
* BFD_MACH_O_SECTION_SIZE
);
3514 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
3518 bfd_mach_o_append_section_to_segment (seg
, sec
);
3525 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3527 return bfd_mach_o_read_segment (abfd
, command
, 0);
3531 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3533 return bfd_mach_o_read_segment (abfd
, command
, 1);
3537 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3539 struct mach_o_load_command_external raw
;
3542 /* Read command type and length. */
3543 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
3544 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
3547 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
3548 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
3549 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
3550 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
3552 switch (command
->type
)
3554 case BFD_MACH_O_LC_SEGMENT
:
3555 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
3558 case BFD_MACH_O_LC_SEGMENT_64
:
3559 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
3562 case BFD_MACH_O_LC_SYMTAB
:
3563 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
3566 case BFD_MACH_O_LC_SYMSEG
:
3568 case BFD_MACH_O_LC_THREAD
:
3569 case BFD_MACH_O_LC_UNIXTHREAD
:
3570 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
3573 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3574 case BFD_MACH_O_LC_ID_DYLINKER
:
3575 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
3578 case BFD_MACH_O_LC_LOAD_DYLIB
:
3579 case BFD_MACH_O_LC_ID_DYLIB
:
3580 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3581 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3582 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3583 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
3586 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
3587 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
3590 case BFD_MACH_O_LC_LOADFVMLIB
:
3591 case BFD_MACH_O_LC_IDFVMLIB
:
3592 if (bfd_mach_o_read_fvmlib (abfd
, command
) != 0)
3595 case BFD_MACH_O_LC_IDENT
:
3596 case BFD_MACH_O_LC_FVMFILE
:
3597 case BFD_MACH_O_LC_PREPAGE
:
3598 case BFD_MACH_O_LC_ROUTINES
:
3599 case BFD_MACH_O_LC_ROUTINES_64
:
3601 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
3602 case BFD_MACH_O_LC_SUB_UMBRELLA
:
3603 case BFD_MACH_O_LC_SUB_LIBRARY
:
3604 case BFD_MACH_O_LC_SUB_CLIENT
:
3605 case BFD_MACH_O_LC_RPATH
:
3606 if (bfd_mach_o_read_str (abfd
, command
) != 0)
3609 case BFD_MACH_O_LC_DYSYMTAB
:
3610 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
3613 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
3614 case BFD_MACH_O_LC_PREBIND_CKSUM
:
3616 case BFD_MACH_O_LC_UUID
:
3617 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
3620 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3621 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3622 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3623 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
3626 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
3627 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
3630 case BFD_MACH_O_LC_DYLD_INFO
:
3631 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
3634 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
3635 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
3636 if (!bfd_mach_o_read_version_min (abfd
, command
))
3640 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
3641 abfd
, (unsigned long) command
->type
);
3649 bfd_mach_o_flatten_sections (bfd
*abfd
)
3651 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3655 /* Count total number of sections. */
3658 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3660 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3661 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3663 bfd_mach_o_segment_command
*seg
;
3665 seg
= &mdata
->commands
[i
].command
.segment
;
3666 mdata
->nsects
+= seg
->nsects
;
3670 /* Allocate sections array. */
3671 mdata
->sections
= bfd_alloc (abfd
,
3672 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
3674 /* Fill the array. */
3677 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3679 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3680 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3682 bfd_mach_o_segment_command
*seg
;
3683 bfd_mach_o_section
*sec
;
3685 seg
= &mdata
->commands
[i
].command
.segment
;
3686 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
3688 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3689 mdata
->sections
[csect
++] = sec
;
3695 bfd_mach_o_scan_start_address (bfd
*abfd
)
3697 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3698 bfd_mach_o_thread_command
*cmd
= NULL
;
3701 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3702 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
3703 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
3705 cmd
= &mdata
->commands
[i
].command
.thread
;
3712 /* FIXME: create a subtarget hook ? */
3713 for (i
= 0; i
< cmd
->nflavours
; i
++)
3715 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
3716 && (cmd
->flavours
[i
].flavour
3717 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
3719 unsigned char buf
[4];
3721 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
3722 || bfd_bread (buf
, 4, abfd
) != 4)
3725 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3727 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
3728 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
3730 unsigned char buf
[4];
3732 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3733 || bfd_bread (buf
, 4, abfd
) != 4)
3736 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3738 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
3739 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
3741 unsigned char buf
[8];
3743 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3744 || bfd_bread (buf
, 8, abfd
) != 8)
3747 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3749 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
3750 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
3752 unsigned char buf
[8];
3754 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
3755 || bfd_bread (buf
, 8, abfd
) != 8)
3758 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3766 bfd_mach_o_set_arch_mach (bfd
*abfd
,
3767 enum bfd_architecture arch
,
3768 unsigned long machine
)
3770 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
3772 /* If this isn't the right architecture for this backend, and this
3773 isn't the generic backend, fail. */
3774 if (arch
!= bed
->arch
3775 && arch
!= bfd_arch_unknown
3776 && bed
->arch
!= bfd_arch_unknown
)
3779 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3783 bfd_mach_o_scan (bfd
*abfd
,
3784 bfd_mach_o_header
*header
,
3785 bfd_mach_o_data_struct
*mdata
)
3788 enum bfd_architecture cputype
;
3789 unsigned long cpusubtype
;
3790 unsigned int hdrsize
;
3792 hdrsize
= mach_o_wide_p (header
) ?
3793 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3795 mdata
->header
= *header
;
3797 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
3798 switch (header
->filetype
)
3800 case BFD_MACH_O_MH_OBJECT
:
3801 abfd
->flags
|= HAS_RELOC
;
3803 case BFD_MACH_O_MH_EXECUTE
:
3804 abfd
->flags
|= EXEC_P
;
3806 case BFD_MACH_O_MH_DYLIB
:
3807 case BFD_MACH_O_MH_BUNDLE
:
3808 abfd
->flags
|= DYNAMIC
;
3812 abfd
->tdata
.mach_o_data
= mdata
;
3814 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
3815 &cputype
, &cpusubtype
);
3816 if (cputype
== bfd_arch_unknown
)
3818 (*_bfd_error_handler
)
3819 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3820 header
->cputype
, header
->cpusubtype
);
3824 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
3826 if (header
->ncmds
!= 0)
3828 mdata
->commands
= bfd_alloc
3829 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
3830 if (mdata
->commands
== NULL
)
3833 for (i
= 0; i
< header
->ncmds
; i
++)
3835 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
3838 cur
->offset
= hdrsize
;
3841 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
3842 cur
->offset
= prev
->offset
+ prev
->len
;
3845 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
3850 if (bfd_mach_o_scan_start_address (abfd
) < 0)
3853 bfd_mach_o_flatten_sections (abfd
);
3858 bfd_mach_o_mkobject_init (bfd
*abfd
)
3860 bfd_mach_o_data_struct
*mdata
= NULL
;
3862 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3865 abfd
->tdata
.mach_o_data
= mdata
;
3867 mdata
->header
.magic
= 0;
3868 mdata
->header
.cputype
= 0;
3869 mdata
->header
.cpusubtype
= 0;
3870 mdata
->header
.filetype
= 0;
3871 mdata
->header
.ncmds
= 0;
3872 mdata
->header
.sizeofcmds
= 0;
3873 mdata
->header
.flags
= 0;
3874 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
3875 mdata
->commands
= NULL
;
3877 mdata
->sections
= NULL
;
3878 mdata
->dyn_reloc_cache
= NULL
;
3884 bfd_mach_o_gen_mkobject (bfd
*abfd
)
3886 bfd_mach_o_data_struct
*mdata
;
3888 if (!bfd_mach_o_mkobject_init (abfd
))
3891 mdata
= bfd_mach_o_get_data (abfd
);
3892 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
3893 mdata
->header
.cputype
= 0;
3894 mdata
->header
.cpusubtype
= 0;
3895 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
3896 mdata
->header
.version
= 1;
3902 bfd_mach_o_header_p (bfd
*abfd
,
3903 bfd_mach_o_filetype filetype
,
3904 bfd_mach_o_cpu_type cputype
)
3906 struct bfd_preserve preserve
;
3907 bfd_mach_o_header header
;
3909 preserve
.marker
= NULL
;
3910 if (!bfd_mach_o_read_header (abfd
, &header
))
3913 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3914 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3916 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3917 (unsigned long) header
.byteorder
);
3921 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3922 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3923 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3924 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3925 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3926 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3929 /* Check cputype and filetype.
3930 In case of wildcard, do not accept magics that are handled by existing
3934 if (header
.cputype
!= cputype
)
3940 if (header
.filetype
!= filetype
)
3945 switch (header
.filetype
)
3947 case BFD_MACH_O_MH_CORE
:
3948 /* Handled by core_p */
3955 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3956 if (preserve
.marker
== NULL
3957 || !bfd_preserve_save (abfd
, &preserve
))
3960 if (!bfd_mach_o_scan (abfd
, &header
,
3961 (bfd_mach_o_data_struct
*) preserve
.marker
))
3964 bfd_preserve_finish (abfd
, &preserve
);
3968 bfd_set_error (bfd_error_wrong_format
);
3971 if (preserve
.marker
!= NULL
)
3972 bfd_preserve_restore (abfd
, &preserve
);
3976 static const bfd_target
*
3977 bfd_mach_o_gen_object_p (bfd
*abfd
)
3979 return bfd_mach_o_header_p (abfd
, 0, 0);
3982 static const bfd_target
*
3983 bfd_mach_o_gen_core_p (bfd
*abfd
)
3985 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
3988 typedef struct mach_o_fat_archentry
3990 unsigned long cputype
;
3991 unsigned long cpusubtype
;
3992 unsigned long offset
;
3994 unsigned long align
;
3995 } mach_o_fat_archentry
;
3997 typedef struct mach_o_fat_data_struct
3999 unsigned long magic
;
4000 unsigned long nfat_arch
;
4001 mach_o_fat_archentry
*archentries
;
4002 } mach_o_fat_data_struct
;
4005 bfd_mach_o_archive_p (bfd
*abfd
)
4007 mach_o_fat_data_struct
*adata
= NULL
;
4008 struct mach_o_fat_header_external hdr
;
4011 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
4012 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
4015 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
4019 adata
->magic
= bfd_getb32 (hdr
.magic
);
4020 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
4021 if (adata
->magic
!= 0xcafebabe)
4023 /* Avoid matching Java bytecode files, which have the same magic number.
4024 In the Java bytecode file format this field contains the JVM version,
4025 which starts at 43.0. */
4026 if (adata
->nfat_arch
> 30)
4029 adata
->archentries
=
4030 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
4031 if (adata
->archentries
== NULL
)
4034 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4036 struct mach_o_fat_arch_external arch
;
4037 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
4039 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
4040 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
4041 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
4042 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
4043 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
4046 abfd
->tdata
.mach_o_fat_data
= adata
;
4051 bfd_release (abfd
, adata
);
4052 bfd_set_error (bfd_error_wrong_format
);
4056 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4057 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4058 Set arelt_data and origin fields too. */
4061 bfd_mach_o_fat_member_init (bfd
*abfd
,
4062 enum bfd_architecture arch_type
,
4063 unsigned long arch_subtype
,
4064 mach_o_fat_archentry
*entry
)
4066 struct areltdata
*areltdata
;
4067 /* Create the member filename. Use ARCH_NAME. */
4068 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
4072 /* Use the architecture name if known. */
4073 abfd
->filename
= ap
->printable_name
;
4077 /* Forge a uniq id. */
4078 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
4079 char *name
= bfd_alloc (abfd
, namelen
);
4080 snprintf (name
, namelen
, "0x%lx-0x%lx",
4081 entry
->cputype
, entry
->cpusubtype
);
4082 abfd
->filename
= name
;
4085 areltdata
= bfd_zalloc (abfd
, sizeof (struct areltdata
));
4086 areltdata
->parsed_size
= entry
->size
;
4087 abfd
->arelt_data
= areltdata
;
4088 abfd
->iostream
= NULL
;
4089 abfd
->origin
= entry
->offset
;
4093 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
4095 mach_o_fat_data_struct
*adata
;
4096 mach_o_fat_archentry
*entry
= NULL
;
4099 enum bfd_architecture arch_type
;
4100 unsigned long arch_subtype
;
4102 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
4103 BFD_ASSERT (adata
!= NULL
);
4105 /* Find index of previous entry. */
4108 /* Start at first one. */
4113 /* Find index of PREV. */
4114 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4116 if (adata
->archentries
[i
].offset
== prev
->origin
)
4120 if (i
== adata
->nfat_arch
)
4123 bfd_set_error (bfd_error_bad_value
);
4127 /* Get next entry. */
4131 if (i
>= adata
->nfat_arch
)
4133 bfd_set_error (bfd_error_no_more_archived_files
);
4137 entry
= &adata
->archentries
[i
];
4138 nbfd
= _bfd_new_bfd_contained_in (archive
);
4142 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
4143 &arch_type
, &arch_subtype
);
4145 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
4147 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
4152 /* Analogous to stat call. */
4155 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
4157 if (abfd
->arelt_data
== NULL
)
4159 bfd_set_error (bfd_error_invalid_operation
);
4166 buf
->st_mode
= 0644;
4167 buf
->st_size
= arelt_size (abfd
);
4172 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4173 If ABFD is a fat image containing a member that corresponds to FORMAT
4174 and ARCH, returns it.
4175 In other case, returns NULL.
4176 This function allows transparent uses of fat images. */
4179 bfd_mach_o_fat_extract (bfd
*abfd
,
4181 const bfd_arch_info_type
*arch
)
4184 mach_o_fat_data_struct
*adata
;
4187 if (bfd_check_format (abfd
, format
))
4189 if (bfd_get_arch_info (abfd
) == arch
)
4193 if (!bfd_check_format (abfd
, bfd_archive
)
4194 || abfd
->xvec
!= &mach_o_fat_vec
)
4197 /* This is a Mach-O fat image. */
4198 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
4199 BFD_ASSERT (adata
!= NULL
);
4201 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4203 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
4204 enum bfd_architecture cpu_type
;
4205 unsigned long cpu_subtype
;
4207 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
4208 &cpu_type
, &cpu_subtype
);
4209 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
4212 /* The architecture is found. */
4213 res
= _bfd_new_bfd_contained_in (abfd
);
4217 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
4219 if (bfd_check_format (res
, format
))
4221 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
4232 bfd_mach_o_lookup_command (bfd
*abfd
,
4233 bfd_mach_o_load_command_type type
,
4234 bfd_mach_o_load_command
**mcommand
)
4236 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
4237 bfd_mach_o_load_command
*ncmd
= NULL
;
4238 unsigned int i
, num
;
4240 BFD_ASSERT (md
!= NULL
);
4241 BFD_ASSERT (mcommand
!= NULL
);
4244 for (i
= 0; i
< md
->header
.ncmds
; i
++)
4246 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
4248 if (cmd
->type
!= type
)
4261 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
4265 case BFD_MACH_O_CPU_TYPE_MC680x0
:
4267 case BFD_MACH_O_CPU_TYPE_MC88000
:
4269 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4271 case BFD_MACH_O_CPU_TYPE_I386
:
4273 case BFD_MACH_O_CPU_TYPE_SPARC
:
4275 case BFD_MACH_O_CPU_TYPE_I860
:
4277 case BFD_MACH_O_CPU_TYPE_HPPA
:
4278 return 0xc0000000 - 0x04000000;
4284 /* The following two tables should be kept, as far as possible, in order of
4285 most frequently used entries to optimize their use from gas. */
4287 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
4289 { "regular", BFD_MACH_O_S_REGULAR
},
4290 { "coalesced", BFD_MACH_O_S_COALESCED
},
4291 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
4292 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
4293 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
4294 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
4295 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
4296 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
4297 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
4298 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
4299 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
4300 { "interposing", BFD_MACH_O_S_INTERPOSING
},
4301 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
4302 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
4303 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
4304 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
4305 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
4309 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
4311 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
4312 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
4313 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
4314 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
4315 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
4316 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
4317 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
4318 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
4319 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
4320 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4321 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4325 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4328 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
4330 const bfd_mach_o_xlat_name
*x
;
4331 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4333 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
4334 if (strcmp (x
->name
, name
) == 0)
4336 /* We found it... does the target support it? */
4337 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
4338 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
4339 return x
->val
; /* OK. */
4341 break; /* Not supported. */
4343 /* Maximum section ID = 0xff. */
4347 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4350 bfd_mach_o_get_section_attribute_from_name (const char *name
)
4352 const bfd_mach_o_xlat_name
*x
;
4354 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
4355 if (strcmp (x
->name
, name
) == 0)
4357 return (unsigned int)-1;
4361 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4362 unsigned char **rbuf
,
4365 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4366 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4369 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4371 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4372 bfd_mach_o_segment_command
*seg
= NULL
;
4374 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4377 seg
= &cur
->command
.segment
;
4379 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4381 unsigned long start
= seg
->fileoff
;
4382 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4383 unsigned char *buf
= bfd_malloc (1024);
4384 unsigned long size
= 1024;
4388 bfd_size_type nread
= 0;
4389 unsigned long offset
;
4390 int found_nonnull
= 0;
4392 if (size
> (end
- start
))
4393 size
= (end
- start
);
4395 buf
= bfd_realloc_or_free (buf
, size
);
4399 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4405 nread
= bfd_bread (buf
, size
, abfd
);
4413 for (offset
= 4; offset
<= size
; offset
+= 4)
4417 val
= *((unsigned long *) (buf
+ size
- offset
));
4418 if (! found_nonnull
)
4423 else if (val
== 0x0)
4425 unsigned long bottom
;
4428 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4429 top
= seg
->fileoff
+ seg
->filesize
- 4;
4430 *rbuf
= bfd_malloc (top
- bottom
);
4431 *rlen
= top
- bottom
;
4433 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4439 if (size
== (end
- start
))
4453 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4455 unsigned char *buf
= NULL
;
4456 unsigned int len
= 0;
4459 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4463 return (char *) buf
;
4467 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4472 static bfd_mach_o_uuid_command
*
4473 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
4475 bfd_mach_o_load_command
*uuid_cmd
;
4476 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
4479 return &uuid_cmd
->command
.uuid
;
4482 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4485 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
4487 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
4490 BFD_ASSERT (uuid_cmd
);
4492 if (!bfd_check_format (abfd
, bfd_object
))
4495 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
4496 || bfd_mach_o_get_data (abfd
) == NULL
4497 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
4500 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4501 if (dsym_uuid_cmd
== NULL
)
4504 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
4505 sizeof (uuid_cmd
->uuid
)) != 0)
4511 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4512 The caller is responsible for closing the returned BFD object and
4513 its my_archive if the returned BFD is in a fat dSYM. */
4516 bfd_mach_o_find_dsym (const char *dsym_filename
,
4517 const bfd_mach_o_uuid_command
*uuid_cmd
,
4518 const bfd_arch_info_type
*arch
)
4520 bfd
*base_dsym_bfd
, *dsym_bfd
;
4522 BFD_ASSERT (uuid_cmd
);
4524 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
4525 if (base_dsym_bfd
== NULL
)
4528 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
4529 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
4532 bfd_close (dsym_bfd
);
4533 if (base_dsym_bfd
!= dsym_bfd
)
4534 bfd_close (base_dsym_bfd
);
4539 /* Return a BFD created from a dSYM file for ABFD.
4540 The caller is responsible for closing the returned BFD object, its
4541 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4544 bfd_mach_o_follow_dsym (bfd
*abfd
)
4546 char *dsym_filename
;
4547 bfd_mach_o_uuid_command
*uuid_cmd
;
4548 bfd
*dsym_bfd
, *base_bfd
= abfd
;
4549 const char *base_basename
;
4551 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
4554 if (abfd
->my_archive
)
4555 base_bfd
= abfd
->my_archive
;
4556 /* BFD may have been opened from a stream. */
4557 if (base_bfd
->filename
== NULL
)
4559 bfd_set_error (bfd_error_invalid_operation
);
4562 base_basename
= lbasename (base_bfd
->filename
);
4564 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4565 if (uuid_cmd
== NULL
)
4568 /* TODO: We assume the DWARF file has the same as the binary's.
4569 It seems apple's GDB checks all files in the dSYM bundle directory.
4570 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4572 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
4573 + strlen (dsym_subdir
) + 1
4574 + strlen (base_basename
) + 1);
4575 sprintf (dsym_filename
, "%s%s/%s",
4576 base_bfd
->filename
, dsym_subdir
, base_basename
);
4578 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
4579 bfd_get_arch_info (abfd
));
4580 if (dsym_bfd
== NULL
)
4581 free (dsym_filename
);
4587 bfd_mach_o_find_nearest_line (bfd
*abfd
,
4591 const char **filename_ptr
,
4592 const char **functionname_ptr
,
4593 unsigned int *line_ptr
)
4595 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4598 switch (mdata
->header
.filetype
)
4600 case BFD_MACH_O_MH_OBJECT
:
4602 case BFD_MACH_O_MH_EXECUTE
:
4603 case BFD_MACH_O_MH_DYLIB
:
4604 case BFD_MACH_O_MH_BUNDLE
:
4605 case BFD_MACH_O_MH_KEXT_BUNDLE
:
4606 if (mdata
->dwarf2_find_line_info
== NULL
)
4608 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
4609 /* When we couldn't find dSYM for this binary, we look for
4610 the debug information in the binary itself. In this way,
4611 we won't try finding separated dSYM again because
4612 mdata->dwarf2_find_line_info will be filled. */
4613 if (! mdata
->dsym_bfd
)
4615 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
4616 dwarf_debug_sections
, symbols
,
4617 &mdata
->dwarf2_find_line_info
))
4624 if (_bfd_dwarf2_find_nearest_line (abfd
, dwarf_debug_sections
,
4625 section
, symbols
, offset
,
4626 filename_ptr
, functionname_ptr
,
4628 &mdata
->dwarf2_find_line_info
))
4634 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
4636 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4637 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
4639 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
4640 bfd_mach_o_free_cached_info (abfd
);
4641 if (mdata
->dsym_bfd
!= NULL
)
4643 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
4644 char *dsym_filename
= (char *)(fat_bfd
4646 : mdata
->dsym_bfd
->filename
);
4647 bfd_close (mdata
->dsym_bfd
);
4648 mdata
->dsym_bfd
= NULL
;
4650 bfd_close (fat_bfd
);
4651 free (dsym_filename
);
4655 return _bfd_generic_close_and_cleanup (abfd
);
4658 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
4660 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4662 free (mdata
->dyn_reloc_cache
);
4663 mdata
->dyn_reloc_cache
= NULL
;
4664 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
4666 free (asect
->relocation
);
4667 asect
->relocation
= NULL
;
4673 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4674 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4676 #define bfd_mach_o_swap_reloc_in NULL
4677 #define bfd_mach_o_swap_reloc_out NULL
4678 #define bfd_mach_o_print_thread NULL
4679 #define bfd_mach_o_tgt_seg_table NULL
4680 #define bfd_mach_o_section_type_valid_for_tgt NULL
4682 #define TARGET_NAME mach_o_be_vec
4683 #define TARGET_STRING "mach-o-be"
4684 #define TARGET_ARCHITECTURE bfd_arch_unknown
4685 #define TARGET_BIG_ENDIAN 1
4686 #define TARGET_ARCHIVE 0
4687 #define TARGET_PRIORITY 1
4688 #include "mach-o-target.c"
4691 #undef TARGET_STRING
4692 #undef TARGET_ARCHITECTURE
4693 #undef TARGET_BIG_ENDIAN
4694 #undef TARGET_ARCHIVE
4695 #undef TARGET_PRIORITY
4697 #define TARGET_NAME mach_o_le_vec
4698 #define TARGET_STRING "mach-o-le"
4699 #define TARGET_ARCHITECTURE bfd_arch_unknown
4700 #define TARGET_BIG_ENDIAN 0
4701 #define TARGET_ARCHIVE 0
4702 #define TARGET_PRIORITY 1
4704 #include "mach-o-target.c"
4707 #undef TARGET_STRING
4708 #undef TARGET_ARCHITECTURE
4709 #undef TARGET_BIG_ENDIAN
4710 #undef TARGET_ARCHIVE
4711 #undef TARGET_PRIORITY
4713 /* Not yet handled: creating an archive. */
4714 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4717 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4718 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4719 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4720 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4721 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4722 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4723 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4724 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4725 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
4726 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4728 #define TARGET_NAME mach_o_fat_vec
4729 #define TARGET_STRING "mach-o-fat"
4730 #define TARGET_ARCHITECTURE bfd_arch_unknown
4731 #define TARGET_BIG_ENDIAN 1
4732 #define TARGET_ARCHIVE 1
4733 #define TARGET_PRIORITY 0
4735 #include "mach-o-target.c"
4738 #undef TARGET_STRING
4739 #undef TARGET_ARCHITECTURE
4740 #undef TARGET_BIG_ENDIAN
4741 #undef TARGET_ARCHIVE
4742 #undef TARGET_PRIORITY