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. */
2028 seg
->fileoff
= mdata
->filelen
;
2030 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2031 | BFD_MACH_O_PROT_EXECUTE
;
2032 seg
->initprot
= seg
->maxprot
;
2034 seg
->sect_head
= NULL
;
2035 seg
->sect_tail
= NULL
;
2037 /* Append sections to the segment. */
2039 for (i
= 0; i
< mdata
->nsects
; ++i
)
2041 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2042 asection
*sec
= s
->bfdsection
;
2044 /* If we're not making an MH_OBJECT, check whether this section is from
2045 our segment, and skip if not. Otherwise, just add all sections. */
2047 && strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) != 0)
2050 bfd_mach_o_append_section_to_segment (seg
, sec
);
2055 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2056 seg
->vmsize
+= s
->size
;
2059 /* Zerofill sections have zero file size & offset,
2060 and are not written. */
2061 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2062 || (s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2063 == BFD_MACH_O_S_GB_ZEROFILL
)
2068 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2069 s
->offset
= mdata
->filelen
;
2072 sec
->filepos
= s
->offset
;
2074 mdata
->filelen
+= s
->size
;
2077 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
2082 /* Count the number of indirect symbols in the image.
2083 Requires that the sections are in their final order. */
2086 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2089 unsigned int nisyms
= 0;
2091 for (i
= 0; i
< mdata
->nsects
; ++i
)
2093 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2095 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2097 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2098 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2099 case BFD_MACH_O_S_SYMBOL_STUBS
:
2100 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2110 bfd_mach_o_build_dysymtab_command (bfd
*abfd
,
2111 bfd_mach_o_data_struct
*mdata
,
2112 bfd_mach_o_load_command
*cmd
)
2114 bfd_mach_o_dysymtab_command
*dsym
= &cmd
->command
.dysymtab
;
2117 We are not going to try and fill these in yet and, moreover, we are
2118 going to bail if they are already set. */
2119 if (dsym
->nmodtab
!= 0
2121 || dsym
->nextrefsyms
!= 0)
2123 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
2124 " implemented for dysymtab commands."));
2128 dsym
->ilocalsym
= 0;
2130 if (bfd_get_symcount (abfd
) > 0)
2132 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2135 /* Count the number of each kind of symbol. */
2136 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2138 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2139 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
2142 dsym
->nlocalsym
= i
;
2143 dsym
->iextdefsym
= i
;
2144 for (; i
< bfd_get_symcount (abfd
); ++i
)
2146 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2147 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
2150 dsym
->nextdefsym
= i
- dsym
->nlocalsym
;
2151 dsym
->iundefsym
= dsym
->nextdefsym
+ dsym
->iextdefsym
;
2152 dsym
->nundefsym
= bfd_get_symcount (abfd
)
2158 dsym
->nlocalsym
= 0;
2159 dsym
->iextdefsym
= 0;
2160 dsym
->nextdefsym
= 0;
2161 dsym
->iundefsym
= 0;
2162 dsym
->nundefsym
= 0;
2165 dsym
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
2166 if (dsym
->nindirectsyms
> 0)
2171 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2172 dsym
->indirectsymoff
= mdata
->filelen
;
2173 mdata
->filelen
+= dsym
->nindirectsyms
* 4;
2175 dsym
->indirect_syms
= bfd_zalloc (abfd
, dsym
->nindirectsyms
* 4);
2176 if (dsym
->indirect_syms
== NULL
)
2180 for (i
= 0; i
< mdata
->nsects
; ++i
)
2182 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2184 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2186 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2187 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2188 case BFD_MACH_O_S_SYMBOL_STUBS
:
2191 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2193 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2194 if (isyms
== NULL
|| num
== 0)
2196 /* Record the starting index in the reserved1 field. */
2198 for (j
= 0; j
< num
; j
++, n
++)
2200 if (isyms
[j
] == NULL
)
2201 dsym
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2203 dsym
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2216 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2217 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2218 and copy functionality. */
2221 bfd_mach_o_build_commands (bfd
*abfd
)
2223 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2224 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2225 int segcmd_idx
= -1;
2226 int symtab_idx
= -1;
2227 int dysymtab_idx
= -1;
2228 unsigned long base_offset
= 0;
2230 /* Return now if commands are already present. */
2231 if (mdata
->header
.ncmds
)
2234 /* Fill in the file type, if not already set. */
2236 if (mdata
->header
.filetype
== 0)
2238 if (abfd
->flags
& EXEC_P
)
2239 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2240 else if (abfd
->flags
& DYNAMIC
)
2241 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2243 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2246 /* If hasn't already been done, flatten sections list, and sort
2247 if/when required. Must be done before the symbol table is adjusted,
2248 since that depends on properly numbered sections. */
2249 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2250 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2253 /* Order the symbol table, fill-in/check mach-o specific fields and
2254 partition out any indirect symbols. */
2255 if (!bfd_mach_o_mangle_symbols (abfd
))
2258 /* Very simple command set (only really applicable to MH_OBJECTs):
2259 All the commands are optional - present only when there is suitable data.
2260 (i.e. it is valid to have an empty file)
2262 a command (segment) to contain all the sections,
2263 command for the symbol table,
2264 a command for the dysymtab.
2266 ??? maybe we should assert that this is an MH_OBJECT? */
2268 if (mdata
->nsects
> 0)
2271 mdata
->header
.ncmds
= 1;
2274 if (bfd_get_symcount (abfd
) > 0)
2276 mdata
->header
.ncmds
++;
2277 symtab_idx
= segcmd_idx
+ 1; /* 0 if the seg command is absent. */
2281 This is a rather crude test for whether we should build a dysymtab. */
2282 if (bfd_mach_o_should_emit_dysymtab ()
2283 && bfd_get_symcount (abfd
))
2285 mdata
->header
.ncmds
++;
2286 /* If there should be a case where a dysymtab could be emitted without
2287 a symtab (seems improbable), this would need amending. */
2288 dysymtab_idx
= symtab_idx
+ 1;
2292 base_offset
= BFD_MACH_O_HEADER_64_SIZE
;
2294 base_offset
= BFD_MACH_O_HEADER_SIZE
;
2296 /* Well, we must have a header, at least. */
2297 mdata
->filelen
= base_offset
;
2299 /* A bit unusual, but no content is valid;
2300 as -n empty.s -o empty.o */
2301 if (mdata
->header
.ncmds
== 0)
2304 mdata
->commands
= bfd_zalloc (abfd
, mdata
->header
.ncmds
2305 * sizeof (bfd_mach_o_load_command
));
2306 if (mdata
->commands
== NULL
)
2309 if (segcmd_idx
>= 0)
2311 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[segcmd_idx
];
2312 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2314 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2315 seg
->nsects
= bfd_mach_o_count_sections_for_seg (NULL
, mdata
);
2316 if (seg
->nsects
== (unsigned long) -1)
2319 /* Init segment command. */
2320 cmd
->offset
= base_offset
;
2323 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
2324 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2325 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
2329 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
2330 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2331 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
2334 cmd
->type_required
= FALSE
;
2335 mdata
->header
.sizeofcmds
= cmd
->len
;
2336 mdata
->filelen
+= cmd
->len
;
2339 if (symtab_idx
>= 0)
2341 /* Init symtab command. */
2342 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[symtab_idx
];
2344 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
2345 cmd
->offset
= base_offset
;
2346 if (segcmd_idx
>= 0)
2347 cmd
->offset
+= mdata
->commands
[segcmd_idx
].len
;
2349 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2350 + BFD_MACH_O_LC_SIZE
;
2351 cmd
->type_required
= FALSE
;
2352 mdata
->header
.sizeofcmds
+= cmd
->len
;
2353 mdata
->filelen
+= cmd
->len
;
2356 /* If required, setup symtab command, see comment above about the quality
2358 if (dysymtab_idx
>= 0)
2360 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[dysymtab_idx
];
2362 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
2363 if (symtab_idx
>= 0)
2364 cmd
->offset
= mdata
->commands
[symtab_idx
].offset
2365 + mdata
->commands
[symtab_idx
].len
;
2366 else if (segcmd_idx
>= 0)
2367 cmd
->offset
= mdata
->commands
[segcmd_idx
].offset
2368 + mdata
->commands
[segcmd_idx
].len
;
2370 cmd
->offset
= base_offset
;
2372 cmd
->type_required
= FALSE
;
2373 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2374 + BFD_MACH_O_LC_SIZE
;
2376 mdata
->header
.sizeofcmds
+= cmd
->len
;
2377 mdata
->filelen
+= cmd
->len
;
2380 /* So, now we have sized the commands and the filelen set to that.
2381 Now we can build the segment command and set the section file offsets. */
2383 && ! bfd_mach_o_build_seg_command
2384 (NULL
, mdata
, &mdata
->commands
[segcmd_idx
].command
.segment
))
2387 /* If we're doing a dysymtab, cmd points to its load command. */
2388 if (dysymtab_idx
>= 0
2389 && ! bfd_mach_o_build_dysymtab_command (abfd
, mdata
,
2390 &mdata
->commands
[dysymtab_idx
]))
2393 /* The symtab command is filled in when the symtab is written. */
2397 /* Set the contents of a section. */
2400 bfd_mach_o_set_section_contents (bfd
*abfd
,
2402 const void * location
,
2404 bfd_size_type count
)
2408 /* Trying to write the first section contents will trigger the creation of
2409 the load commands if they are not already present. */
2410 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
2416 pos
= section
->filepos
+ offset
;
2417 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2418 || bfd_bwrite (location
, count
, abfd
) != count
)
2425 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
2426 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2431 /* Make an empty symbol. This is required only because
2432 bfd_make_section_anyway wants to create a symbol for the section. */
2435 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
2437 asymbol
*new_symbol
;
2439 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
2440 if (new_symbol
== NULL
)
2442 new_symbol
->the_bfd
= abfd
;
2443 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
2448 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
2450 struct mach_o_header_external raw
;
2452 bfd_vma (*get32
) (const void *) = NULL
;
2454 /* Just read the magic number. */
2455 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2456 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
2459 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2461 header
->byteorder
= BFD_ENDIAN_BIG
;
2462 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2463 header
->version
= 1;
2466 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2468 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2469 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2470 header
->version
= 1;
2473 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2475 header
->byteorder
= BFD_ENDIAN_BIG
;
2476 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2477 header
->version
= 2;
2480 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2482 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2483 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2484 header
->version
= 2;
2489 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
2493 /* Once the size of the header is known, read the full header. */
2494 size
= mach_o_wide_p (header
) ?
2495 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2497 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2498 || bfd_bread (&raw
, size
, abfd
) != size
)
2501 header
->cputype
= (*get32
) (raw
.cputype
);
2502 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
2503 header
->filetype
= (*get32
) (raw
.filetype
);
2504 header
->ncmds
= (*get32
) (raw
.ncmds
);
2505 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
2506 header
->flags
= (*get32
) (raw
.flags
);
2508 if (mach_o_wide_p (header
))
2509 header
->reserved
= (*get32
) (raw
.reserved
);
2515 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
2517 bfd_mach_o_section
*s
;
2518 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
2520 s
= bfd_mach_o_get_mach_o_section (sec
);
2524 static const mach_o_section_name_xlat
* xlat
;
2526 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
2529 sec
->used_by_bfd
= s
;
2530 s
->bfdsection
= sec
;
2532 /* Create the Darwin seg/sect name pair from the bfd name.
2533 If this is a canonical name for which a specific paiting exists
2534 there will also be defined flags, type, attribute and alignment
2536 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
2539 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
2540 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
2542 bfd_set_section_alignment (abfd
, sec
, s
->align
);
2543 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2544 if (bfd_flags
== SEC_NO_FLAGS
)
2545 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
2548 /* Create default flags. */
2549 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
2552 return _bfd_generic_new_section_hook (abfd
, sec
);
2556 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
2560 bfd_mach_o_section
*section
;
2562 flags
= bfd_get_section_flags (abfd
, sec
);
2563 section
= bfd_mach_o_get_mach_o_section (sec
);
2565 /* TODO: see if we should use the xlat system for doing this by
2566 preference and fall back to this for unknown sections. */
2568 if (flags
== SEC_NO_FLAGS
)
2570 /* Try to guess flags. */
2571 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
2572 flags
= SEC_DEBUGGING
;
2576 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2577 != BFD_MACH_O_S_ZEROFILL
)
2580 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
2582 if (prot
& BFD_MACH_O_PROT_WRITE
)
2584 else if (prot
& BFD_MACH_O_PROT_READ
)
2585 flags
|= SEC_READONLY
;
2591 if ((flags
& SEC_DEBUGGING
) == 0)
2595 if (section
->offset
!= 0)
2596 flags
|= SEC_HAS_CONTENTS
;
2597 if (section
->nreloc
!= 0)
2600 bfd_set_section_flags (abfd
, sec
, flags
);
2602 sec
->vma
= section
->addr
;
2603 sec
->lma
= section
->addr
;
2604 sec
->size
= section
->size
;
2605 sec
->filepos
= section
->offset
;
2606 sec
->alignment_power
= section
->align
;
2607 sec
->segment_mark
= 0;
2608 sec
->reloc_count
= section
->nreloc
;
2609 sec
->rel_filepos
= section
->reloff
;
2613 bfd_mach_o_make_bfd_section (bfd
*abfd
,
2614 const unsigned char *segname
,
2615 const unsigned char *sectname
)
2620 bfd_mach_o_convert_section_name_to_bfd
2621 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
2625 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
2629 bfd_mach_o_read_section_32 (bfd
*abfd
,
2630 unsigned int offset
,
2633 struct mach_o_section_32_external raw
;
2635 bfd_mach_o_section
*section
;
2637 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2638 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
2639 != BFD_MACH_O_SECTION_SIZE
))
2642 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2646 section
= bfd_mach_o_get_mach_o_section (sec
);
2647 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2648 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2649 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2650 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2651 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
2652 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
2653 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2654 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2655 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2656 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2657 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2658 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2659 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2660 section
->reserved3
= 0;
2662 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2668 bfd_mach_o_read_section_64 (bfd
*abfd
,
2669 unsigned int offset
,
2672 struct mach_o_section_64_external raw
;
2674 bfd_mach_o_section
*section
;
2676 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2677 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
2678 != BFD_MACH_O_SECTION_64_SIZE
))
2681 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2685 section
= bfd_mach_o_get_mach_o_section (sec
);
2686 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2687 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2688 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2689 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2690 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
2691 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
2692 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2693 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2694 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2695 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2696 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2697 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2698 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2699 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
2701 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2707 bfd_mach_o_read_section (bfd
*abfd
,
2708 unsigned int offset
,
2713 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
2715 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
2719 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
2720 bfd_mach_o_symtab_command
*sym
,
2721 bfd_mach_o_asymbol
*s
,
2724 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2725 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
2726 unsigned int symwidth
=
2727 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2728 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
2729 struct mach_o_nlist_64_external raw
;
2730 unsigned char type
= -1;
2731 unsigned char section
= -1;
2733 symvalue value
= -1;
2734 unsigned long stroff
= -1;
2735 unsigned int symtype
= -1;
2737 BFD_ASSERT (sym
->strtab
!= NULL
);
2739 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
2740 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
2742 (*_bfd_error_handler
)
2743 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2744 symwidth
, (unsigned long) symoff
);
2748 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
2749 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
2750 symtype
= type
& BFD_MACH_O_N_TYPE
;
2751 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
2752 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
2754 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
2756 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
2758 if (stroff
>= sym
->strsize
)
2760 (*_bfd_error_handler
)
2761 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2762 (unsigned long) stroff
,
2763 (unsigned long) sym
->strsize
);
2767 s
->symbol
.the_bfd
= abfd
;
2768 s
->symbol
.name
= sym
->strtab
+ stroff
;
2769 s
->symbol
.value
= value
;
2770 s
->symbol
.flags
= 0x0;
2771 s
->symbol
.udata
.i
= i
;
2773 s
->n_sect
= section
;
2776 if (type
& BFD_MACH_O_N_STAB
)
2778 s
->symbol
.flags
|= BSF_DEBUGGING
;
2779 s
->symbol
.section
= bfd_und_section_ptr
;
2791 if ((section
> 0) && (section
<= mdata
->nsects
))
2793 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2795 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2802 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
2803 s
->symbol
.flags
|= BSF_GLOBAL
;
2805 s
->symbol
.flags
|= BSF_LOCAL
;
2809 case BFD_MACH_O_N_UNDF
:
2810 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
2811 && s
->symbol
.value
!= 0)
2813 /* A common symbol. */
2814 s
->symbol
.section
= bfd_com_section_ptr
;
2815 s
->symbol
.flags
= BSF_NO_FLAGS
;
2819 s
->symbol
.section
= bfd_und_section_ptr
;
2820 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
2821 s
->symbol
.flags
|= BSF_WEAK
;
2824 case BFD_MACH_O_N_PBUD
:
2825 s
->symbol
.section
= bfd_und_section_ptr
;
2827 case BFD_MACH_O_N_ABS
:
2828 s
->symbol
.section
= bfd_abs_section_ptr
;
2830 case BFD_MACH_O_N_SECT
:
2831 if ((section
> 0) && (section
<= mdata
->nsects
))
2833 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2835 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2839 /* Mach-O uses 0 to mean "no section"; not an error. */
2842 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2843 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2844 s
->symbol
.name
, section
, mdata
->nsects
);
2846 s
->symbol
.section
= bfd_und_section_ptr
;
2849 case BFD_MACH_O_N_INDR
:
2850 /* FIXME: we don't follow the BFD convention as this indirect symbol
2851 won't be followed by the referenced one. This looks harmless
2852 unless we start using the linker. */
2853 s
->symbol
.flags
|= BSF_INDIRECT
;
2854 s
->symbol
.section
= bfd_ind_section_ptr
;
2855 s
->symbol
.value
= 0;
2858 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2859 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2860 s
->symbol
.name
, symtype
);
2861 s
->symbol
.section
= bfd_und_section_ptr
;
2870 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
2872 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2873 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2875 /* Fail if there is no symtab. */
2879 /* Success if already loaded. */
2883 if (abfd
->flags
& BFD_IN_MEMORY
)
2885 struct bfd_in_memory
*b
;
2887 b
= (struct bfd_in_memory
*) abfd
->iostream
;
2889 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
2891 bfd_set_error (bfd_error_file_truncated
);
2894 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
2898 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
2899 if (sym
->strtab
== NULL
)
2902 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
2903 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
2905 bfd_set_error (bfd_error_file_truncated
);
2914 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
2916 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2917 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2920 if (sym
== NULL
|| sym
->symbols
)
2922 /* Return now if there are no symbols or if already loaded. */
2926 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
2928 if (sym
->symbols
== NULL
)
2930 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2934 if (!bfd_mach_o_read_symtab_strtab (abfd
))
2937 for (i
= 0; i
< sym
->nsyms
; i
++)
2939 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
2947 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2949 switch ((int) flavour
)
2951 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2952 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2953 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2954 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2955 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2956 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2957 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2958 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2959 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2960 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2961 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2962 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2963 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2964 default: return "UNKNOWN";
2969 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2971 switch ((int) flavour
)
2973 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2974 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2975 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2976 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2977 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2978 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2979 default: return "UNKNOWN";
2984 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2986 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2987 struct mach_o_str_command_external raw
;
2988 unsigned int nameoff
;
2990 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
2991 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
2993 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2994 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2997 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
2999 cmd
->name_offset
= command
->offset
+ nameoff
;
3000 cmd
->name_len
= command
->len
- nameoff
;
3001 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
3002 if (cmd
->name_str
== NULL
)
3004 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3005 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
3011 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3013 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3014 struct mach_o_dylib_command_external raw
;
3015 unsigned int nameoff
;
3017 switch (command
->type
)
3019 case BFD_MACH_O_LC_LOAD_DYLIB
:
3020 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3021 case BFD_MACH_O_LC_ID_DYLIB
:
3022 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3023 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3030 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3031 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3034 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3035 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3036 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3037 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3039 cmd
->name_offset
= command
->offset
+ nameoff
;
3040 cmd
->name_len
= command
->len
- nameoff
;
3041 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
3042 if (cmd
->name_str
== NULL
)
3044 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3045 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
3051 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
3052 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
3054 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3056 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
3061 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3063 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
3064 struct mach_o_fvmlib_command_external raw
;
3065 unsigned int nameoff
;
3067 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3068 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3071 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3072 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3073 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3075 fvm
->name_offset
= command
->offset
+ nameoff
;
3076 fvm
->name_len
= command
->len
- nameoff
;
3077 fvm
->name_str
= bfd_alloc (abfd
, fvm
->name_len
);
3078 if (fvm
->name_str
== NULL
)
3080 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3081 || bfd_bread (fvm
->name_str
, fvm
->name_len
, abfd
) != fvm
->name_len
)
3087 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3089 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3090 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3091 unsigned int offset
;
3092 unsigned int nflavours
;
3095 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3096 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3098 /* Count the number of threads. */
3101 while (offset
!= command
->len
)
3103 struct mach_o_thread_command_external raw
;
3105 if (offset
>= command
->len
)
3108 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3109 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3112 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3116 /* Allocate threads. */
3117 cmd
->flavours
= bfd_alloc
3118 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3119 if (cmd
->flavours
== NULL
)
3121 cmd
->nflavours
= nflavours
;
3125 while (offset
!= command
->len
)
3127 struct mach_o_thread_command_external raw
;
3129 if (offset
>= command
->len
)
3132 if (nflavours
>= cmd
->nflavours
)
3135 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3136 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3139 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3140 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3141 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3142 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3146 for (i
= 0; i
< nflavours
; i
++)
3149 unsigned int snamelen
;
3151 const char *flavourstr
;
3152 const char *prefix
= "LC_THREAD";
3155 switch (mdata
->header
.cputype
)
3157 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3158 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
3159 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
3161 case BFD_MACH_O_CPU_TYPE_I386
:
3162 case BFD_MACH_O_CPU_TYPE_X86_64
:
3163 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
3166 flavourstr
= "UNKNOWN_ARCHITECTURE";
3170 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
3171 sname
= bfd_alloc (abfd
, snamelen
);
3177 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
3178 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
3183 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
3187 bfdsec
->size
= cmd
->flavours
[i
].size
;
3188 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
3189 bfdsec
->alignment_power
= 0x0;
3191 cmd
->section
= bfdsec
;
3198 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3200 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
3201 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3203 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
3206 struct mach_o_dysymtab_command_external raw
;
3208 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3209 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3212 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
3213 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
3214 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
3215 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
3216 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
3217 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
3218 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
3219 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
3220 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
3221 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
3222 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
3223 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
3224 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
3225 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
3226 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
3227 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
3228 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
3229 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
3232 if (cmd
->nmodtab
!= 0)
3235 int wide
= bfd_mach_o_wide_p (abfd
);
3236 unsigned int module_len
= wide
? 56 : 52;
3239 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
3240 if (cmd
->dylib_module
== NULL
)
3243 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
3246 for (i
= 0; i
< cmd
->nmodtab
; i
++)
3248 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
3250 unsigned char buf
[56];
3252 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
3255 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
3256 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
3257 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
3258 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
3259 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
3260 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
3261 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
3262 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
3263 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
3264 v
= bfd_h_get_32 (abfd
, buf
+36);
3265 module
->iinit
= v
& 0xffff;
3266 module
->iterm
= (v
>> 16) & 0xffff;
3267 v
= bfd_h_get_32 (abfd
, buf
+ 40);
3268 module
->ninit
= v
& 0xffff;
3269 module
->nterm
= (v
>> 16) & 0xffff;
3272 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
3273 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
3277 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
3278 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
3287 cmd
->dylib_toc
= bfd_alloc
3288 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
3289 if (cmd
->dylib_toc
== NULL
)
3292 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
3295 for (i
= 0; i
< cmd
->ntoc
; i
++)
3297 struct mach_o_dylib_table_of_contents_external raw
;
3298 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
3300 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3303 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
3304 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
3308 if (cmd
->nindirectsyms
!= 0)
3312 cmd
->indirect_syms
= bfd_alloc
3313 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
3314 if (cmd
->indirect_syms
== NULL
)
3317 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
3320 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
3322 unsigned char raw
[4];
3323 unsigned int *is
= &cmd
->indirect_syms
[i
];
3325 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3328 *is
= bfd_h_get_32 (abfd
, raw
);
3332 if (cmd
->nextrefsyms
!= 0)
3337 cmd
->ext_refs
= bfd_alloc
3338 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
3339 if (cmd
->ext_refs
== NULL
)
3342 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
3345 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
3347 unsigned char raw
[4];
3348 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
3350 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3353 /* Fields isym and flags are written as bit-fields, thus we need
3354 a specific processing for endianness. */
3355 v
= bfd_h_get_32 (abfd
, raw
);
3356 if (bfd_big_endian (abfd
))
3358 ref
->isym
= (v
>> 8) & 0xffffff;
3359 ref
->flags
= v
& 0xff;
3363 ref
->isym
= v
& 0xffffff;
3364 ref
->flags
= (v
>> 24) & 0xff;
3369 if (mdata
->dysymtab
)
3371 mdata
->dysymtab
= cmd
;
3377 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3379 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
3380 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3381 struct mach_o_symtab_command_external raw
;
3383 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
3385 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3386 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3389 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
3390 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
3391 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
3392 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
3393 symtab
->symbols
= NULL
;
3394 symtab
->strtab
= NULL
;
3396 if (symtab
->nsyms
!= 0)
3397 abfd
->flags
|= HAS_SYMS
;
3401 mdata
->symtab
= symtab
;
3406 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3408 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
3410 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
3412 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3413 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
3420 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3422 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
3423 struct mach_o_linkedit_data_command_external raw
;
3425 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3426 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3429 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
3430 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
3435 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3437 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
3438 struct mach_o_str_command_external raw
;
3441 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3442 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3445 off
= bfd_get_32 (abfd
, raw
.str
);
3446 cmd
->stroff
= command
->offset
+ off
;
3447 cmd
->str_len
= command
->len
- off
;
3448 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
3449 if (cmd
->str
== NULL
)
3451 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
3452 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
3458 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3460 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
3461 struct mach_o_dyld_info_command_external raw
;
3463 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3464 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3467 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
3468 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
3469 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
3470 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
3471 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
3472 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
3473 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
3474 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
3475 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
3476 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
3481 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3483 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
3484 struct mach_o_version_min_command_external raw
;
3487 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3488 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3491 ver
= bfd_get_32 (abfd
, raw
.version
);
3492 cmd
->rel
= ver
>> 16;
3493 cmd
->maj
= ver
>> 8;
3495 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
3500 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3502 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
3503 struct mach_o_encryption_info_command_external raw
;
3505 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3506 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3509 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
3510 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
3511 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
3516 bfd_mach_o_read_segment (bfd
*abfd
,
3517 bfd_mach_o_load_command
*command
,
3520 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
3525 struct mach_o_segment_command_64_external raw
;
3527 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
3529 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3530 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3533 memcpy (seg
->segname
, raw
.segname
, 16);
3534 seg
->segname
[16] = '\0';
3536 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
3537 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
3538 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
3539 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
3540 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3541 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3542 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3543 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3547 struct mach_o_segment_command_32_external raw
;
3549 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
3551 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3552 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3555 memcpy (seg
->segname
, raw
.segname
, 16);
3556 seg
->segname
[16] = '\0';
3558 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
3559 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
3560 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
3561 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
3562 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3563 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3564 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3565 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3567 seg
->sect_head
= NULL
;
3568 seg
->sect_tail
= NULL
;
3570 for (i
= 0; i
< seg
->nsects
; i
++)
3576 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
3577 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
3579 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
3580 + (i
* BFD_MACH_O_SECTION_SIZE
);
3582 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
3586 bfd_mach_o_append_section_to_segment (seg
, sec
);
3593 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3595 return bfd_mach_o_read_segment (abfd
, command
, 0);
3599 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3601 return bfd_mach_o_read_segment (abfd
, command
, 1);
3605 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3607 struct mach_o_load_command_external raw
;
3610 /* Read command type and length. */
3611 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
3612 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
3615 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
3616 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
3617 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
3618 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
3620 switch (command
->type
)
3622 case BFD_MACH_O_LC_SEGMENT
:
3623 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
3626 case BFD_MACH_O_LC_SEGMENT_64
:
3627 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
3630 case BFD_MACH_O_LC_SYMTAB
:
3631 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
3634 case BFD_MACH_O_LC_SYMSEG
:
3636 case BFD_MACH_O_LC_THREAD
:
3637 case BFD_MACH_O_LC_UNIXTHREAD
:
3638 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
3641 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3642 case BFD_MACH_O_LC_ID_DYLINKER
:
3643 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
3646 case BFD_MACH_O_LC_LOAD_DYLIB
:
3647 case BFD_MACH_O_LC_ID_DYLIB
:
3648 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3649 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3650 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3651 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
3654 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
3655 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
3658 case BFD_MACH_O_LC_LOADFVMLIB
:
3659 case BFD_MACH_O_LC_IDFVMLIB
:
3660 if (bfd_mach_o_read_fvmlib (abfd
, command
) != 0)
3663 case BFD_MACH_O_LC_IDENT
:
3664 case BFD_MACH_O_LC_FVMFILE
:
3665 case BFD_MACH_O_LC_PREPAGE
:
3666 case BFD_MACH_O_LC_ROUTINES
:
3667 case BFD_MACH_O_LC_ROUTINES_64
:
3669 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
3670 case BFD_MACH_O_LC_SUB_UMBRELLA
:
3671 case BFD_MACH_O_LC_SUB_LIBRARY
:
3672 case BFD_MACH_O_LC_SUB_CLIENT
:
3673 case BFD_MACH_O_LC_RPATH
:
3674 if (bfd_mach_o_read_str (abfd
, command
) != 0)
3677 case BFD_MACH_O_LC_DYSYMTAB
:
3678 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
3681 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
3682 case BFD_MACH_O_LC_PREBIND_CKSUM
:
3684 case BFD_MACH_O_LC_UUID
:
3685 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
3688 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3689 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3690 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3691 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
3694 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
3695 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
3698 case BFD_MACH_O_LC_DYLD_INFO
:
3699 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
3702 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
3703 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
3704 if (!bfd_mach_o_read_version_min (abfd
, command
))
3708 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
3709 abfd
, (unsigned long) command
->type
);
3717 bfd_mach_o_flatten_sections (bfd
*abfd
)
3719 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3723 /* Count total number of sections. */
3726 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3728 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3729 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3731 bfd_mach_o_segment_command
*seg
;
3733 seg
= &mdata
->commands
[i
].command
.segment
;
3734 mdata
->nsects
+= seg
->nsects
;
3738 /* Allocate sections array. */
3739 mdata
->sections
= bfd_alloc (abfd
,
3740 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
3742 /* Fill the array. */
3745 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3747 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3748 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3750 bfd_mach_o_segment_command
*seg
;
3751 bfd_mach_o_section
*sec
;
3753 seg
= &mdata
->commands
[i
].command
.segment
;
3754 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
3756 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3757 mdata
->sections
[csect
++] = sec
;
3763 bfd_mach_o_scan_start_address (bfd
*abfd
)
3765 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3766 bfd_mach_o_thread_command
*cmd
= NULL
;
3769 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3770 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
3771 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
3773 cmd
= &mdata
->commands
[i
].command
.thread
;
3780 /* FIXME: create a subtarget hook ? */
3781 for (i
= 0; i
< cmd
->nflavours
; i
++)
3783 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
3784 && (cmd
->flavours
[i
].flavour
3785 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
3787 unsigned char buf
[4];
3789 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
3790 || bfd_bread (buf
, 4, abfd
) != 4)
3793 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3795 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
3796 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
3798 unsigned char buf
[4];
3800 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3801 || bfd_bread (buf
, 4, abfd
) != 4)
3804 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3806 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
3807 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
3809 unsigned char buf
[8];
3811 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3812 || bfd_bread (buf
, 8, abfd
) != 8)
3815 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3817 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
3818 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
3820 unsigned char buf
[8];
3822 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
3823 || bfd_bread (buf
, 8, abfd
) != 8)
3826 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3834 bfd_mach_o_set_arch_mach (bfd
*abfd
,
3835 enum bfd_architecture arch
,
3836 unsigned long machine
)
3838 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
3840 /* If this isn't the right architecture for this backend, and this
3841 isn't the generic backend, fail. */
3842 if (arch
!= bed
->arch
3843 && arch
!= bfd_arch_unknown
3844 && bed
->arch
!= bfd_arch_unknown
)
3847 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3851 bfd_mach_o_scan (bfd
*abfd
,
3852 bfd_mach_o_header
*header
,
3853 bfd_mach_o_data_struct
*mdata
)
3856 enum bfd_architecture cputype
;
3857 unsigned long cpusubtype
;
3858 unsigned int hdrsize
;
3860 hdrsize
= mach_o_wide_p (header
) ?
3861 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3863 mdata
->header
= *header
;
3865 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
3866 switch (header
->filetype
)
3868 case BFD_MACH_O_MH_OBJECT
:
3869 abfd
->flags
|= HAS_RELOC
;
3871 case BFD_MACH_O_MH_EXECUTE
:
3872 abfd
->flags
|= EXEC_P
;
3874 case BFD_MACH_O_MH_DYLIB
:
3875 case BFD_MACH_O_MH_BUNDLE
:
3876 abfd
->flags
|= DYNAMIC
;
3880 abfd
->tdata
.mach_o_data
= mdata
;
3882 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
3883 &cputype
, &cpusubtype
);
3884 if (cputype
== bfd_arch_unknown
)
3886 (*_bfd_error_handler
)
3887 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3888 header
->cputype
, header
->cpusubtype
);
3892 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
3894 if (header
->ncmds
!= 0)
3896 mdata
->commands
= bfd_alloc
3897 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
3898 if (mdata
->commands
== NULL
)
3901 for (i
= 0; i
< header
->ncmds
; i
++)
3903 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
3906 cur
->offset
= hdrsize
;
3909 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
3910 cur
->offset
= prev
->offset
+ prev
->len
;
3913 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
3918 if (bfd_mach_o_scan_start_address (abfd
) < 0)
3921 bfd_mach_o_flatten_sections (abfd
);
3926 bfd_mach_o_mkobject_init (bfd
*abfd
)
3928 bfd_mach_o_data_struct
*mdata
= NULL
;
3930 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3933 abfd
->tdata
.mach_o_data
= mdata
;
3935 mdata
->header
.magic
= 0;
3936 mdata
->header
.cputype
= 0;
3937 mdata
->header
.cpusubtype
= 0;
3938 mdata
->header
.filetype
= 0;
3939 mdata
->header
.ncmds
= 0;
3940 mdata
->header
.sizeofcmds
= 0;
3941 mdata
->header
.flags
= 0;
3942 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
3943 mdata
->commands
= NULL
;
3945 mdata
->sections
= NULL
;
3946 mdata
->dyn_reloc_cache
= NULL
;
3952 bfd_mach_o_gen_mkobject (bfd
*abfd
)
3954 bfd_mach_o_data_struct
*mdata
;
3956 if (!bfd_mach_o_mkobject_init (abfd
))
3959 mdata
= bfd_mach_o_get_data (abfd
);
3960 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
3961 mdata
->header
.cputype
= 0;
3962 mdata
->header
.cpusubtype
= 0;
3963 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
3964 mdata
->header
.version
= 1;
3970 bfd_mach_o_header_p (bfd
*abfd
,
3971 bfd_mach_o_filetype filetype
,
3972 bfd_mach_o_cpu_type cputype
)
3974 struct bfd_preserve preserve
;
3975 bfd_mach_o_header header
;
3977 preserve
.marker
= NULL
;
3978 if (!bfd_mach_o_read_header (abfd
, &header
))
3981 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3982 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3984 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3985 (unsigned long) header
.byteorder
);
3989 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3990 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3991 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3992 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3993 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3994 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3997 /* Check cputype and filetype.
3998 In case of wildcard, do not accept magics that are handled by existing
4002 if (header
.cputype
!= cputype
)
4008 if (header
.filetype
!= filetype
)
4013 switch (header
.filetype
)
4015 case BFD_MACH_O_MH_CORE
:
4016 /* Handled by core_p */
4023 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
4024 if (preserve
.marker
== NULL
4025 || !bfd_preserve_save (abfd
, &preserve
))
4028 if (!bfd_mach_o_scan (abfd
, &header
,
4029 (bfd_mach_o_data_struct
*) preserve
.marker
))
4032 bfd_preserve_finish (abfd
, &preserve
);
4036 bfd_set_error (bfd_error_wrong_format
);
4039 if (preserve
.marker
!= NULL
)
4040 bfd_preserve_restore (abfd
, &preserve
);
4044 static const bfd_target
*
4045 bfd_mach_o_gen_object_p (bfd
*abfd
)
4047 return bfd_mach_o_header_p (abfd
, 0, 0);
4050 static const bfd_target
*
4051 bfd_mach_o_gen_core_p (bfd
*abfd
)
4053 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
4056 typedef struct mach_o_fat_archentry
4058 unsigned long cputype
;
4059 unsigned long cpusubtype
;
4060 unsigned long offset
;
4062 unsigned long align
;
4063 } mach_o_fat_archentry
;
4065 typedef struct mach_o_fat_data_struct
4067 unsigned long magic
;
4068 unsigned long nfat_arch
;
4069 mach_o_fat_archentry
*archentries
;
4070 } mach_o_fat_data_struct
;
4073 bfd_mach_o_archive_p (bfd
*abfd
)
4075 mach_o_fat_data_struct
*adata
= NULL
;
4076 struct mach_o_fat_header_external hdr
;
4079 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
4080 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
4083 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
4087 adata
->magic
= bfd_getb32 (hdr
.magic
);
4088 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
4089 if (adata
->magic
!= 0xcafebabe)
4091 /* Avoid matching Java bytecode files, which have the same magic number.
4092 In the Java bytecode file format this field contains the JVM version,
4093 which starts at 43.0. */
4094 if (adata
->nfat_arch
> 30)
4097 adata
->archentries
=
4098 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
4099 if (adata
->archentries
== NULL
)
4102 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4104 struct mach_o_fat_arch_external arch
;
4105 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
4107 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
4108 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
4109 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
4110 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
4111 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
4114 abfd
->tdata
.mach_o_fat_data
= adata
;
4119 bfd_release (abfd
, adata
);
4120 bfd_set_error (bfd_error_wrong_format
);
4124 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4125 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4126 Set arelt_data and origin fields too. */
4129 bfd_mach_o_fat_member_init (bfd
*abfd
,
4130 enum bfd_architecture arch_type
,
4131 unsigned long arch_subtype
,
4132 mach_o_fat_archentry
*entry
)
4134 struct areltdata
*areltdata
;
4135 /* Create the member filename. Use ARCH_NAME. */
4136 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
4140 /* Use the architecture name if known. */
4141 abfd
->filename
= ap
->printable_name
;
4145 /* Forge a uniq id. */
4146 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
4147 char *name
= bfd_alloc (abfd
, namelen
);
4148 snprintf (name
, namelen
, "0x%lx-0x%lx",
4149 entry
->cputype
, entry
->cpusubtype
);
4150 abfd
->filename
= name
;
4153 areltdata
= bfd_zalloc (abfd
, sizeof (struct areltdata
));
4154 areltdata
->parsed_size
= entry
->size
;
4155 abfd
->arelt_data
= areltdata
;
4156 abfd
->iostream
= NULL
;
4157 abfd
->origin
= entry
->offset
;
4161 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
4163 mach_o_fat_data_struct
*adata
;
4164 mach_o_fat_archentry
*entry
= NULL
;
4167 enum bfd_architecture arch_type
;
4168 unsigned long arch_subtype
;
4170 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
4171 BFD_ASSERT (adata
!= NULL
);
4173 /* Find index of previous entry. */
4176 /* Start at first one. */
4181 /* Find index of PREV. */
4182 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4184 if (adata
->archentries
[i
].offset
== prev
->origin
)
4188 if (i
== adata
->nfat_arch
)
4191 bfd_set_error (bfd_error_bad_value
);
4195 /* Get next entry. */
4199 if (i
>= adata
->nfat_arch
)
4201 bfd_set_error (bfd_error_no_more_archived_files
);
4205 entry
= &adata
->archentries
[i
];
4206 nbfd
= _bfd_new_bfd_contained_in (archive
);
4210 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
4211 &arch_type
, &arch_subtype
);
4213 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
4215 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
4220 /* Analogous to stat call. */
4223 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
4225 if (abfd
->arelt_data
== NULL
)
4227 bfd_set_error (bfd_error_invalid_operation
);
4234 buf
->st_mode
= 0644;
4235 buf
->st_size
= arelt_size (abfd
);
4240 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4241 If ABFD is a fat image containing a member that corresponds to FORMAT
4242 and ARCH, returns it.
4243 In other case, returns NULL.
4244 This function allows transparent uses of fat images. */
4247 bfd_mach_o_fat_extract (bfd
*abfd
,
4249 const bfd_arch_info_type
*arch
)
4252 mach_o_fat_data_struct
*adata
;
4255 if (bfd_check_format (abfd
, format
))
4257 if (bfd_get_arch_info (abfd
) == arch
)
4261 if (!bfd_check_format (abfd
, bfd_archive
)
4262 || abfd
->xvec
!= &mach_o_fat_vec
)
4265 /* This is a Mach-O fat image. */
4266 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
4267 BFD_ASSERT (adata
!= NULL
);
4269 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4271 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
4272 enum bfd_architecture cpu_type
;
4273 unsigned long cpu_subtype
;
4275 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
4276 &cpu_type
, &cpu_subtype
);
4277 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
4280 /* The architecture is found. */
4281 res
= _bfd_new_bfd_contained_in (abfd
);
4285 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
4287 if (bfd_check_format (res
, format
))
4289 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
4300 bfd_mach_o_lookup_command (bfd
*abfd
,
4301 bfd_mach_o_load_command_type type
,
4302 bfd_mach_o_load_command
**mcommand
)
4304 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
4305 bfd_mach_o_load_command
*ncmd
= NULL
;
4306 unsigned int i
, num
;
4308 BFD_ASSERT (md
!= NULL
);
4309 BFD_ASSERT (mcommand
!= NULL
);
4312 for (i
= 0; i
< md
->header
.ncmds
; i
++)
4314 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
4316 if (cmd
->type
!= type
)
4329 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
4333 case BFD_MACH_O_CPU_TYPE_MC680x0
:
4335 case BFD_MACH_O_CPU_TYPE_MC88000
:
4337 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4339 case BFD_MACH_O_CPU_TYPE_I386
:
4341 case BFD_MACH_O_CPU_TYPE_SPARC
:
4343 case BFD_MACH_O_CPU_TYPE_I860
:
4345 case BFD_MACH_O_CPU_TYPE_HPPA
:
4346 return 0xc0000000 - 0x04000000;
4352 /* The following two tables should be kept, as far as possible, in order of
4353 most frequently used entries to optimize their use from gas. */
4355 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
4357 { "regular", BFD_MACH_O_S_REGULAR
},
4358 { "coalesced", BFD_MACH_O_S_COALESCED
},
4359 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
4360 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
4361 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
4362 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
4363 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
4364 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
4365 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
4366 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
4367 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
4368 { "interposing", BFD_MACH_O_S_INTERPOSING
},
4369 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
4370 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
4371 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
4372 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
4373 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
4377 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
4379 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
4380 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
4381 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
4382 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
4383 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
4384 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
4385 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
4386 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
4387 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
4388 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4389 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4393 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4396 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
4398 const bfd_mach_o_xlat_name
*x
;
4399 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4401 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
4402 if (strcmp (x
->name
, name
) == 0)
4404 /* We found it... does the target support it? */
4405 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
4406 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
4407 return x
->val
; /* OK. */
4409 break; /* Not supported. */
4411 /* Maximum section ID = 0xff. */
4415 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4418 bfd_mach_o_get_section_attribute_from_name (const char *name
)
4420 const bfd_mach_o_xlat_name
*x
;
4422 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
4423 if (strcmp (x
->name
, name
) == 0)
4425 return (unsigned int)-1;
4429 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4430 unsigned char **rbuf
,
4433 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4434 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4437 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4439 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4440 bfd_mach_o_segment_command
*seg
= NULL
;
4442 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4445 seg
= &cur
->command
.segment
;
4447 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4449 unsigned long start
= seg
->fileoff
;
4450 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4451 unsigned char *buf
= bfd_malloc (1024);
4452 unsigned long size
= 1024;
4456 bfd_size_type nread
= 0;
4457 unsigned long offset
;
4458 int found_nonnull
= 0;
4460 if (size
> (end
- start
))
4461 size
= (end
- start
);
4463 buf
= bfd_realloc_or_free (buf
, size
);
4467 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4473 nread
= bfd_bread (buf
, size
, abfd
);
4481 for (offset
= 4; offset
<= size
; offset
+= 4)
4485 val
= *((unsigned long *) (buf
+ size
- offset
));
4486 if (! found_nonnull
)
4491 else if (val
== 0x0)
4493 unsigned long bottom
;
4496 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4497 top
= seg
->fileoff
+ seg
->filesize
- 4;
4498 *rbuf
= bfd_malloc (top
- bottom
);
4499 *rlen
= top
- bottom
;
4501 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4507 if (size
== (end
- start
))
4521 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4523 unsigned char *buf
= NULL
;
4524 unsigned int len
= 0;
4527 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4531 return (char *) buf
;
4535 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4540 static bfd_mach_o_uuid_command
*
4541 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
4543 bfd_mach_o_load_command
*uuid_cmd
;
4544 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
4547 return &uuid_cmd
->command
.uuid
;
4550 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4553 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
4555 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
4558 BFD_ASSERT (uuid_cmd
);
4560 if (!bfd_check_format (abfd
, bfd_object
))
4563 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
4564 || bfd_mach_o_get_data (abfd
) == NULL
4565 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
4568 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4569 if (dsym_uuid_cmd
== NULL
)
4572 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
4573 sizeof (uuid_cmd
->uuid
)) != 0)
4579 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4580 The caller is responsible for closing the returned BFD object and
4581 its my_archive if the returned BFD is in a fat dSYM. */
4584 bfd_mach_o_find_dsym (const char *dsym_filename
,
4585 const bfd_mach_o_uuid_command
*uuid_cmd
,
4586 const bfd_arch_info_type
*arch
)
4588 bfd
*base_dsym_bfd
, *dsym_bfd
;
4590 BFD_ASSERT (uuid_cmd
);
4592 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
4593 if (base_dsym_bfd
== NULL
)
4596 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
4597 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
4600 bfd_close (dsym_bfd
);
4601 if (base_dsym_bfd
!= dsym_bfd
)
4602 bfd_close (base_dsym_bfd
);
4607 /* Return a BFD created from a dSYM file for ABFD.
4608 The caller is responsible for closing the returned BFD object, its
4609 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4612 bfd_mach_o_follow_dsym (bfd
*abfd
)
4614 char *dsym_filename
;
4615 bfd_mach_o_uuid_command
*uuid_cmd
;
4616 bfd
*dsym_bfd
, *base_bfd
= abfd
;
4617 const char *base_basename
;
4619 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
4622 if (abfd
->my_archive
)
4623 base_bfd
= abfd
->my_archive
;
4624 /* BFD may have been opened from a stream. */
4625 if (base_bfd
->filename
== NULL
)
4627 bfd_set_error (bfd_error_invalid_operation
);
4630 base_basename
= lbasename (base_bfd
->filename
);
4632 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4633 if (uuid_cmd
== NULL
)
4636 /* TODO: We assume the DWARF file has the same as the binary's.
4637 It seems apple's GDB checks all files in the dSYM bundle directory.
4638 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4640 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
4641 + strlen (dsym_subdir
) + 1
4642 + strlen (base_basename
) + 1);
4643 sprintf (dsym_filename
, "%s%s/%s",
4644 base_bfd
->filename
, dsym_subdir
, base_basename
);
4646 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
4647 bfd_get_arch_info (abfd
));
4648 if (dsym_bfd
== NULL
)
4649 free (dsym_filename
);
4655 bfd_mach_o_find_nearest_line (bfd
*abfd
,
4659 const char **filename_ptr
,
4660 const char **functionname_ptr
,
4661 unsigned int *line_ptr
)
4663 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4666 switch (mdata
->header
.filetype
)
4668 case BFD_MACH_O_MH_OBJECT
:
4670 case BFD_MACH_O_MH_EXECUTE
:
4671 case BFD_MACH_O_MH_DYLIB
:
4672 case BFD_MACH_O_MH_BUNDLE
:
4673 case BFD_MACH_O_MH_KEXT_BUNDLE
:
4674 if (mdata
->dwarf2_find_line_info
== NULL
)
4676 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
4677 /* When we couldn't find dSYM for this binary, we look for
4678 the debug information in the binary itself. In this way,
4679 we won't try finding separated dSYM again because
4680 mdata->dwarf2_find_line_info will be filled. */
4681 if (! mdata
->dsym_bfd
)
4683 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
4684 dwarf_debug_sections
, symbols
,
4685 &mdata
->dwarf2_find_line_info
))
4692 if (_bfd_dwarf2_find_nearest_line (abfd
, dwarf_debug_sections
,
4693 section
, symbols
, offset
,
4694 filename_ptr
, functionname_ptr
,
4696 &mdata
->dwarf2_find_line_info
))
4702 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
4704 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4705 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
4707 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
4708 bfd_mach_o_free_cached_info (abfd
);
4709 if (mdata
->dsym_bfd
!= NULL
)
4711 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
4712 char *dsym_filename
= (char *)(fat_bfd
4714 : mdata
->dsym_bfd
->filename
);
4715 bfd_close (mdata
->dsym_bfd
);
4716 mdata
->dsym_bfd
= NULL
;
4718 bfd_close (fat_bfd
);
4719 free (dsym_filename
);
4723 return _bfd_generic_close_and_cleanup (abfd
);
4726 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
4728 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4730 free (mdata
->dyn_reloc_cache
);
4731 mdata
->dyn_reloc_cache
= NULL
;
4732 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
4734 free (asect
->relocation
);
4735 asect
->relocation
= NULL
;
4741 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4742 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4744 #define bfd_mach_o_swap_reloc_in NULL
4745 #define bfd_mach_o_swap_reloc_out NULL
4746 #define bfd_mach_o_print_thread NULL
4747 #define bfd_mach_o_tgt_seg_table NULL
4748 #define bfd_mach_o_section_type_valid_for_tgt NULL
4750 #define TARGET_NAME mach_o_be_vec
4751 #define TARGET_STRING "mach-o-be"
4752 #define TARGET_ARCHITECTURE bfd_arch_unknown
4753 #define TARGET_BIG_ENDIAN 1
4754 #define TARGET_ARCHIVE 0
4755 #define TARGET_PRIORITY 1
4756 #include "mach-o-target.c"
4759 #undef TARGET_STRING
4760 #undef TARGET_ARCHITECTURE
4761 #undef TARGET_BIG_ENDIAN
4762 #undef TARGET_ARCHIVE
4763 #undef TARGET_PRIORITY
4765 #define TARGET_NAME mach_o_le_vec
4766 #define TARGET_STRING "mach-o-le"
4767 #define TARGET_ARCHITECTURE bfd_arch_unknown
4768 #define TARGET_BIG_ENDIAN 0
4769 #define TARGET_ARCHIVE 0
4770 #define TARGET_PRIORITY 1
4772 #include "mach-o-target.c"
4775 #undef TARGET_STRING
4776 #undef TARGET_ARCHITECTURE
4777 #undef TARGET_BIG_ENDIAN
4778 #undef TARGET_ARCHIVE
4779 #undef TARGET_PRIORITY
4781 /* Not yet handled: creating an archive. */
4782 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4785 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4786 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4787 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4788 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4789 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4790 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4791 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4792 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4793 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
4794 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4796 #define TARGET_NAME mach_o_fat_vec
4797 #define TARGET_STRING "mach-o-fat"
4798 #define TARGET_ARCHITECTURE bfd_arch_unknown
4799 #define TARGET_BIG_ENDIAN 1
4800 #define TARGET_ARCHIVE 1
4801 #define TARGET_PRIORITY 0
4803 #include "mach-o-target.c"
4806 #undef TARGET_STRING
4807 #undef TARGET_ARCHITECTURE
4808 #undef TARGET_BIG_ENDIAN
4809 #undef TARGET_ARCHIVE
4810 #undef TARGET_PRIORITY