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
)
1191 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1193 sec
= section
->bfdsection
;
1194 if (sec
->reloc_count
== 0)
1197 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1200 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1203 /* Convert and write. */
1204 entries
= section
->bfdsection
->orelocation
;
1205 for (i
= 0; i
< section
->nreloc
; i
++)
1207 arelent
*rel
= entries
[i
];
1208 struct mach_o_reloc_info_external raw
;
1209 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1211 /* Convert relocation to an intermediate representation. */
1212 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1215 /* Lower the relocation info. */
1216 if (pinfo
->r_scattered
)
1220 v
= BFD_MACH_O_SR_SCATTERED
1221 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1222 | BFD_MACH_O_SET_SR_LENGTH(pinfo
->r_length
)
1223 | BFD_MACH_O_SET_SR_TYPE(pinfo
->r_type
)
1224 | BFD_MACH_O_SET_SR_ADDRESS(pinfo
->r_address
);
1225 /* Note: scattered relocs have field in reverse order... */
1226 bfd_put_32 (abfd
, v
, raw
.r_address
);
1227 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1233 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1234 v
= BFD_MACH_O_SET_R_SYMBOLNUM (pinfo
->r_value
)
1235 | (pinfo
->r_pcrel
? BFD_MACH_O_R_PCREL
: 0)
1236 | BFD_MACH_O_SET_R_LENGTH (pinfo
->r_length
)
1237 | (pinfo
->r_extern
? BFD_MACH_O_R_EXTERN
: 0)
1238 | BFD_MACH_O_SET_R_TYPE (pinfo
->r_type
);
1239 bfd_put_32 (abfd
, v
, raw
.r_symbolnum
);
1242 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1243 != BFD_MACH_O_RELENT_SIZE
)
1250 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1252 struct mach_o_section_32_external raw
;
1254 memcpy (raw
.sectname
, section
->sectname
, 16);
1255 memcpy (raw
.segname
, section
->segname
, 16);
1256 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1257 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1258 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1259 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1260 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1261 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1262 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1263 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1264 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1266 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1267 != BFD_MACH_O_SECTION_SIZE
)
1274 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1276 struct mach_o_section_64_external raw
;
1278 memcpy (raw
.sectname
, section
->sectname
, 16);
1279 memcpy (raw
.segname
, section
->segname
, 16);
1280 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1281 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1282 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1283 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1284 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1285 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1286 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1287 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1288 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1289 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1291 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1292 != BFD_MACH_O_SECTION_64_SIZE
)
1299 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1301 struct mach_o_segment_command_32_external raw
;
1302 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1303 bfd_mach_o_section
*sec
;
1305 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1307 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1308 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1311 memcpy (raw
.segname
, seg
->segname
, 16);
1312 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1313 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1314 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1315 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1316 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1317 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1318 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1319 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1321 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1322 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1325 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1326 if (bfd_mach_o_write_section_32 (abfd
, sec
))
1333 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1335 struct mach_o_segment_command_64_external raw
;
1336 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1337 bfd_mach_o_section
*sec
;
1339 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1341 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1342 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1345 memcpy (raw
.segname
, seg
->segname
, 16);
1346 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1347 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1348 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1349 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1350 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1351 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1352 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1353 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1355 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1356 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1359 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1360 if (bfd_mach_o_write_section_64 (abfd
, sec
))
1367 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1369 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1370 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1372 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1373 unsigned int symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1374 struct bfd_strtab_hash
*strtab
;
1375 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1377 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1379 /* Write the symbols first. */
1380 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, wide
? 3 : 2);
1381 sym
->symoff
= mdata
->filelen
;
1382 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1385 sym
->nsyms
= bfd_get_symcount (abfd
);
1386 mdata
->filelen
+= sym
->nsyms
* symlen
;
1388 strtab
= _bfd_stringtab_init ();
1393 /* Although we don't strictly need to do this, for compatibility with
1394 Darwin system tools, actually output an empty string for the index
1396 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1398 for (i
= 0; i
< sym
->nsyms
; i
++)
1400 bfd_size_type str_index
;
1401 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1403 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1404 /* An index of 0 always means the empty string. */
1408 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1410 if (str_index
== (bfd_size_type
) -1)
1416 struct mach_o_nlist_64_external raw
;
1418 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1419 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1420 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1421 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1422 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1425 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1430 struct mach_o_nlist_external raw
;
1432 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1433 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1434 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1435 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1436 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1439 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1443 sym
->strsize
= _bfd_stringtab_size (strtab
);
1444 sym
->stroff
= mdata
->filelen
;
1445 mdata
->filelen
+= sym
->strsize
;
1447 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1449 _bfd_stringtab_free (strtab
);
1453 struct mach_o_symtab_command_external raw
;
1455 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1456 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1457 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1458 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1460 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1461 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1468 _bfd_stringtab_free (strtab
);
1472 /* Write a dysymtab command.
1473 TODO: Possibly coalesce writes of smaller objects. */
1476 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1478 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
1480 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
1482 if (cmd
->nmodtab
!= 0)
1486 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
1489 for (i
= 0; i
< cmd
->nmodtab
; i
++)
1491 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
1495 iinit
= module
->iinit
& 0xffff;
1496 iinit
|= ((module
->iterm
& 0xffff) << 16);
1498 ninit
= module
->ninit
& 0xffff;
1499 ninit
|= ((module
->nterm
& 0xffff) << 16);
1501 if (bfd_mach_o_wide_p (abfd
))
1503 struct mach_o_dylib_module_64_external w
;
1505 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
1506 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
1507 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
1508 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
1509 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
1510 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
1511 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
1512 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
1513 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
1514 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
1515 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
1516 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
1517 &w
.objc_module_info_addr
);
1518 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
1519 &w
.objc_module_info_size
);
1521 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
1526 struct mach_o_dylib_module_external n
;
1528 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
1529 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
1530 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
1531 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
1532 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
1533 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
1534 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
1535 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
1536 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
1537 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
1538 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
1539 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
1540 &n
.objc_module_info_addr
);
1541 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
1542 &n
.objc_module_info_size
);
1544 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
1554 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
1557 for (i
= 0; i
< cmd
->ntoc
; i
++)
1559 struct mach_o_dylib_table_of_contents_external raw
;
1560 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
1562 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
1563 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
1565 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1570 if (cmd
->nindirectsyms
> 0)
1574 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
1577 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
1579 unsigned char raw
[4];
1581 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
1582 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1587 if (cmd
->nextrefsyms
!= 0)
1591 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
1594 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
1597 unsigned char raw
[4];
1598 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
1600 /* Fields isym and flags are written as bit-fields, thus we need
1601 a specific processing for endianness. */
1603 if (bfd_big_endian (abfd
))
1605 v
= ((ref
->isym
& 0xffffff) << 8);
1606 v
|= ref
->flags
& 0xff;
1610 v
= ref
->isym
& 0xffffff;
1611 v
|= ((ref
->flags
& 0xff) << 24);
1614 bfd_h_put_32 (abfd
, v
, raw
);
1615 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1621 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
1625 struct mach_o_dysymtab_command_external raw
;
1627 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
1628 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
1629 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
1630 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
1631 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
1632 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
1633 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
1634 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
1635 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
1636 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
1637 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
1638 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
1639 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
1640 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
1641 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
1642 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
1643 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
1644 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
1646 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1654 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
1656 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
1658 /* Just leave debug symbols where they are (pretend they are local, and
1659 then they will just be sorted on position). */
1660 if (s
->n_type
& BFD_MACH_O_N_STAB
)
1663 /* Local (we should never see an undefined local AFAICT). */
1664 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
1667 /* Common symbols look like undefined externs. */
1668 if (mtyp
== BFD_MACH_O_N_UNDF
)
1671 /* A defined non-local, non-debug symbol. */
1676 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
1678 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
1679 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
1680 unsigned int soa
, sob
;
1682 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
1683 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
1690 /* If it's local or stab, just preserve the input order. */
1693 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
1695 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
1698 /* This is probably an error. */
1702 /* The second sort key is name. */
1703 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
1706 /* Process the symbols.
1708 This should be OK for single-module files - but it is not likely to work
1709 for multi-module shared libraries.
1711 (a) If the application has not filled in the relevant mach-o fields, make
1714 (b) Order them, like this:
1717 ( ii) external defined
1719 (iii) external undefined/common
1726 bfd_mach_o_mangle_symbols (bfd
*abfd
)
1729 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1731 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
1734 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
1736 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1738 /* We use this value, which is out-of-range as a symbol index, to signal
1739 that the mach-o-specific data are not filled in and need to be created
1740 from the bfd values. It is much preferable for the application to do
1741 this, since more meaningful diagnostics can be made that way. */
1743 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
1745 /* No symbol information has been set - therefore determine
1746 it from the bfd symbol flags/info. */
1747 if (s
->symbol
.section
== bfd_abs_section_ptr
)
1748 s
->n_type
= BFD_MACH_O_N_ABS
;
1749 else if (s
->symbol
.section
== bfd_und_section_ptr
)
1751 s
->n_type
= BFD_MACH_O_N_UNDF
;
1752 if (s
->symbol
.flags
& BSF_WEAK
)
1753 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
1754 /* mach-o automatically makes undefined symbols extern. */
1755 s
->n_type
|= BFD_MACH_O_N_EXT
;
1756 s
->symbol
.flags
|= BSF_GLOBAL
;
1758 else if (s
->symbol
.section
== bfd_com_section_ptr
)
1760 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
1761 s
->symbol
.flags
|= BSF_GLOBAL
;
1764 s
->n_type
= BFD_MACH_O_N_SECT
;
1766 if (s
->symbol
.flags
& BSF_GLOBAL
)
1767 s
->n_type
|= BFD_MACH_O_N_EXT
;
1770 /* Put the section index in, where required. */
1771 if ((s
->symbol
.section
!= bfd_abs_section_ptr
1772 && s
->symbol
.section
!= bfd_und_section_ptr
1773 && s
->symbol
.section
!= bfd_com_section_ptr
)
1774 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
1775 && s
->symbol
.name
== NULL
))
1776 s
->n_sect
= s
->symbol
.section
->target_index
;
1778 /* Number to preserve order for local and debug syms. */
1779 s
->symbol
.udata
.i
= i
;
1782 /* Sort the symbols. */
1783 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
1784 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
1786 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1788 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1789 s
->symbol
.udata
.i
= i
; /* renumber. */
1795 /* We build a flat table of sections, which can be re-ordered if necessary.
1796 Fill in the section number and other mach-o-specific data. */
1799 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1802 unsigned target_index
;
1805 nsect
= bfd_count_sections (abfd
);
1807 /* Don't do it if it's already set - assume the application knows what it's
1809 if (mdata
->nsects
== nsect
1810 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
1813 mdata
->nsects
= nsect
;
1814 mdata
->sections
= bfd_alloc (abfd
,
1815 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
1816 if (mdata
->sections
== NULL
)
1819 /* We need to check that this can be done... */
1821 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%d)"
1822 " maximum is 255,\n"), nsect
);
1824 /* Create Mach-O sections.
1825 Section type, attribute and align should have been set when the
1826 section was created - either read in or specified. */
1828 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1830 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
1831 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
1833 mdata
->sections
[target_index
] = msect
;
1835 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
1836 msect
->size
= bfd_get_section_size (sec
);
1838 /* Use the largest alignment set, in case it was bumped after the
1839 section was created. */
1840 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
1843 sec
->target_index
= ++target_index
;
1850 bfd_mach_o_write_contents (bfd
*abfd
)
1853 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1855 /* Make the commands, if not already present. */
1856 if (mdata
->header
.ncmds
== 0)
1857 if (!bfd_mach_o_build_commands (abfd
))
1860 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
1863 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
1865 struct mach_o_load_command_external raw
;
1866 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
1867 unsigned long typeflag
;
1869 typeflag
= cur
->type
| (cur
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
1871 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
1872 bfd_h_put_32 (abfd
, cur
->len
, raw
.cmdsize
);
1874 if (bfd_seek (abfd
, cur
->offset
, SEEK_SET
) != 0
1875 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
1880 case BFD_MACH_O_LC_SEGMENT
:
1881 if (bfd_mach_o_write_segment_32 (abfd
, cur
) != 0)
1884 case BFD_MACH_O_LC_SEGMENT_64
:
1885 if (bfd_mach_o_write_segment_64 (abfd
, cur
) != 0)
1888 case BFD_MACH_O_LC_SYMTAB
:
1889 if (!bfd_mach_o_write_symtab (abfd
, cur
))
1892 case BFD_MACH_O_LC_DYSYMTAB
:
1893 if (!bfd_mach_o_write_dysymtab (abfd
, cur
))
1896 case BFD_MACH_O_LC_SYMSEG
:
1898 case BFD_MACH_O_LC_THREAD
:
1899 case BFD_MACH_O_LC_UNIXTHREAD
:
1900 if (bfd_mach_o_write_thread (abfd
, cur
) != 0)
1903 case BFD_MACH_O_LC_LOADFVMLIB
:
1904 case BFD_MACH_O_LC_IDFVMLIB
:
1905 case BFD_MACH_O_LC_IDENT
:
1906 case BFD_MACH_O_LC_FVMFILE
:
1907 case BFD_MACH_O_LC_PREPAGE
:
1908 case BFD_MACH_O_LC_LOAD_DYLIB
:
1909 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
1910 case BFD_MACH_O_LC_ID_DYLIB
:
1911 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
1912 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
1913 case BFD_MACH_O_LC_LOAD_DYLINKER
:
1914 case BFD_MACH_O_LC_ID_DYLINKER
:
1915 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
1916 case BFD_MACH_O_LC_ROUTINES
:
1917 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
1920 (*_bfd_error_handler
) (_("unable to write unknown load command 0x%lx"),
1921 (unsigned long) cur
->type
);
1930 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
1933 bfd_mach_o_section
*s
= (bfd_mach_o_section
*)sec
->used_by_bfd
;
1934 if (seg
->sect_head
== NULL
)
1937 seg
->sect_tail
->next
= s
;
1941 /* Create section Mach-O flags from BFD flags. */
1944 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
1947 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
1949 /* Create default flags. */
1950 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1951 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1952 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1953 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1954 | BFD_MACH_O_S_REGULAR
;
1955 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1956 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1957 else if (bfd_flags
& SEC_DEBUGGING
)
1958 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1960 s
->flags
= BFD_MACH_O_S_REGULAR
;
1963 /* Count the number of sections in the list for the segment named.
1965 The special case of NULL or "" for the segment name is valid for
1966 an MH_OBJECT file and means 'all sections available'.
1968 Requires that the sections table in mdata be filled in.
1970 Returns the number of sections (0 is valid).
1971 Any number > 255 signals an invalid section count, although we will,
1972 perhaps, allow the file to be written (in line with Darwin tools up
1975 A section count of (unsigned long) -1 signals a definite error. */
1977 static unsigned long
1978 bfd_mach_o_count_sections_for_seg (const char *segment
,
1979 bfd_mach_o_data_struct
*mdata
)
1982 if (mdata
== NULL
|| mdata
->sections
== NULL
)
1983 return (unsigned long) -1;
1985 /* The MH_OBJECT case, all sections are considered; Although nsects is
1986 is an unsigned long, the maximum valid section count is 255 and this
1987 will have been checked already by mangle_sections. */
1988 if (segment
== NULL
|| segment
[0] == '\0')
1989 return mdata
->nsects
;
1991 /* Count the number of sections we see in this segment. */
1993 for (i
= 0; i
< mdata
->nsects
; ++i
)
1995 bfd_mach_o_section
*s
= mdata
->sections
[i
];
1996 if (strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
2003 bfd_mach_o_build_seg_command (const char *segment
,
2004 bfd_mach_o_data_struct
*mdata
,
2005 bfd_mach_o_segment_command
*seg
)
2008 int is_mho
= (segment
== NULL
|| segment
[0] == '\0');
2010 /* Fill segment command. */
2012 memset (seg
->segname
, 0, sizeof (seg
->segname
));
2014 strncpy (seg
->segname
, segment
, sizeof (seg
->segname
));
2016 /* TODO: fix this up for non-MH_OBJECT cases. */
2020 seg
->fileoff
= mdata
->filelen
;
2022 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2023 | BFD_MACH_O_PROT_EXECUTE
;
2024 seg
->initprot
= seg
->maxprot
;
2026 seg
->sect_head
= NULL
;
2027 seg
->sect_tail
= NULL
;
2029 /* Append sections to the segment. */
2031 for (i
= 0; i
< mdata
->nsects
; ++i
)
2033 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2034 asection
*sec
= s
->bfdsection
;
2036 /* If we're not making an MH_OBJECT, check whether this section is from
2037 our segment, and skip if not. Otherwise, just add all sections. */
2039 && strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) != 0)
2042 bfd_mach_o_append_section_to_segment (seg
, sec
);
2047 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2048 seg
->vmsize
+= s
->size
;
2051 /* Zerofill sections have zero file size & offset,
2052 and are not written. */
2053 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2054 || (s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2055 == BFD_MACH_O_S_GB_ZEROFILL
)
2060 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2061 s
->offset
= mdata
->filelen
;
2064 sec
->filepos
= s
->offset
;
2066 mdata
->filelen
+= s
->size
;
2069 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
2070 seg
->filesize
= FILE_ALIGN(seg
->filesize
, 2);
2072 /* Allocate relocation room. */
2073 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, 2);
2075 for (i
= 0; i
< mdata
->nsects
; ++i
)
2077 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2078 asection
*sec
= ms
->bfdsection
;
2080 if ((ms
->nreloc
= sec
->reloc_count
) == 0)
2085 sec
->rel_filepos
= mdata
->filelen
;
2086 ms
->reloff
= sec
->rel_filepos
;
2087 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2093 /* Count the number of indirect symbols in the image.
2094 Requires that the sections are in their final order. */
2097 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2100 unsigned int nisyms
= 0;
2102 for (i
= 0; i
< mdata
->nsects
; ++i
)
2104 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2106 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2108 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2109 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2110 case BFD_MACH_O_S_SYMBOL_STUBS
:
2111 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2121 bfd_mach_o_build_dysymtab_command (bfd
*abfd
,
2122 bfd_mach_o_data_struct
*mdata
,
2123 bfd_mach_o_load_command
*cmd
)
2125 bfd_mach_o_dysymtab_command
*dsym
= &cmd
->command
.dysymtab
;
2128 We are not going to try and fill these in yet and, moreover, we are
2129 going to bail if they are already set. */
2130 if (dsym
->nmodtab
!= 0
2132 || dsym
->nextrefsyms
!= 0)
2134 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
2135 " implemented for dysymtab commands."));
2139 dsym
->ilocalsym
= 0;
2141 if (bfd_get_symcount (abfd
) > 0)
2143 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2146 /* Count the number of each kind of symbol. */
2147 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2149 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2150 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
2153 dsym
->nlocalsym
= i
;
2154 dsym
->iextdefsym
= i
;
2155 for (; i
< bfd_get_symcount (abfd
); ++i
)
2157 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2158 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
2161 dsym
->nextdefsym
= i
- dsym
->nlocalsym
;
2162 dsym
->iundefsym
= dsym
->nextdefsym
+ dsym
->iextdefsym
;
2163 dsym
->nundefsym
= bfd_get_symcount (abfd
)
2169 dsym
->nlocalsym
= 0;
2170 dsym
->iextdefsym
= 0;
2171 dsym
->nextdefsym
= 0;
2172 dsym
->iundefsym
= 0;
2173 dsym
->nundefsym
= 0;
2176 dsym
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
2177 if (dsym
->nindirectsyms
> 0)
2182 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2183 dsym
->indirectsymoff
= mdata
->filelen
;
2184 mdata
->filelen
+= dsym
->nindirectsyms
* 4;
2186 dsym
->indirect_syms
= bfd_zalloc (abfd
, dsym
->nindirectsyms
* 4);
2187 if (dsym
->indirect_syms
== NULL
)
2191 for (i
= 0; i
< mdata
->nsects
; ++i
)
2193 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2195 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2197 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2198 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2199 case BFD_MACH_O_S_SYMBOL_STUBS
:
2202 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2204 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2205 if (isyms
== NULL
|| num
== 0)
2207 /* Record the starting index in the reserved1 field. */
2209 for (j
= 0; j
< num
; j
++, n
++)
2211 if (isyms
[j
] == NULL
)
2212 dsym
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2214 dsym
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2227 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2228 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2229 and copy functionality. */
2232 bfd_mach_o_build_commands (bfd
*abfd
)
2234 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2235 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2236 int segcmd_idx
= -1;
2237 int symtab_idx
= -1;
2238 int dysymtab_idx
= -1;
2239 unsigned long base_offset
= 0;
2241 /* Return now if commands are already present. */
2242 if (mdata
->header
.ncmds
)
2245 /* Fill in the file type, if not already set. */
2247 if (mdata
->header
.filetype
== 0)
2249 if (abfd
->flags
& EXEC_P
)
2250 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2251 else if (abfd
->flags
& DYNAMIC
)
2252 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2254 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2257 /* If hasn't already been done, flatten sections list, and sort
2258 if/when required. Must be done before the symbol table is adjusted,
2259 since that depends on properly numbered sections. */
2260 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2261 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2264 /* Order the symbol table, fill-in/check mach-o specific fields and
2265 partition out any indirect symbols. */
2266 if (!bfd_mach_o_mangle_symbols (abfd
))
2269 /* Very simple command set (only really applicable to MH_OBJECTs):
2270 All the commands are optional - present only when there is suitable data.
2271 (i.e. it is valid to have an empty file)
2273 a command (segment) to contain all the sections,
2274 command for the symbol table,
2275 a command for the dysymtab.
2277 ??? maybe we should assert that this is an MH_OBJECT? */
2279 if (mdata
->nsects
> 0)
2282 mdata
->header
.ncmds
= 1;
2285 if (bfd_get_symcount (abfd
) > 0)
2287 mdata
->header
.ncmds
++;
2288 symtab_idx
= segcmd_idx
+ 1; /* 0 if the seg command is absent. */
2292 This is a rather crude test for whether we should build a dysymtab. */
2293 if (bfd_mach_o_should_emit_dysymtab ()
2294 && bfd_get_symcount (abfd
))
2296 mdata
->header
.ncmds
++;
2297 /* If there should be a case where a dysymtab could be emitted without
2298 a symtab (seems improbable), this would need amending. */
2299 dysymtab_idx
= symtab_idx
+ 1;
2303 base_offset
= BFD_MACH_O_HEADER_64_SIZE
;
2305 base_offset
= BFD_MACH_O_HEADER_SIZE
;
2307 /* Well, we must have a header, at least. */
2308 mdata
->filelen
= base_offset
;
2310 /* A bit unusual, but no content is valid;
2311 as -n empty.s -o empty.o */
2312 if (mdata
->header
.ncmds
== 0)
2315 mdata
->commands
= bfd_zalloc (abfd
, mdata
->header
.ncmds
2316 * sizeof (bfd_mach_o_load_command
));
2317 if (mdata
->commands
== NULL
)
2320 if (segcmd_idx
>= 0)
2322 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[segcmd_idx
];
2323 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2325 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2326 seg
->nsects
= bfd_mach_o_count_sections_for_seg (NULL
, mdata
);
2327 if (seg
->nsects
== (unsigned long) -1)
2330 /* Init segment command. */
2331 cmd
->offset
= base_offset
;
2334 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
2335 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2336 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
2340 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
2341 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2342 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
2345 cmd
->type_required
= FALSE
;
2346 mdata
->header
.sizeofcmds
= cmd
->len
;
2347 mdata
->filelen
+= cmd
->len
;
2350 if (symtab_idx
>= 0)
2352 /* Init symtab command. */
2353 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[symtab_idx
];
2355 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
2356 cmd
->offset
= base_offset
;
2357 if (segcmd_idx
>= 0)
2358 cmd
->offset
+= mdata
->commands
[segcmd_idx
].len
;
2360 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2361 + BFD_MACH_O_LC_SIZE
;
2362 cmd
->type_required
= FALSE
;
2363 mdata
->header
.sizeofcmds
+= cmd
->len
;
2364 mdata
->filelen
+= cmd
->len
;
2367 /* If required, setup symtab command, see comment above about the quality
2369 if (dysymtab_idx
>= 0)
2371 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[dysymtab_idx
];
2373 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
2374 if (symtab_idx
>= 0)
2375 cmd
->offset
= mdata
->commands
[symtab_idx
].offset
2376 + mdata
->commands
[symtab_idx
].len
;
2377 else if (segcmd_idx
>= 0)
2378 cmd
->offset
= mdata
->commands
[segcmd_idx
].offset
2379 + mdata
->commands
[segcmd_idx
].len
;
2381 cmd
->offset
= base_offset
;
2383 cmd
->type_required
= FALSE
;
2384 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2385 + BFD_MACH_O_LC_SIZE
;
2387 mdata
->header
.sizeofcmds
+= cmd
->len
;
2388 mdata
->filelen
+= cmd
->len
;
2391 /* So, now we have sized the commands and the filelen set to that.
2392 Now we can build the segment command and set the section file offsets. */
2394 && ! bfd_mach_o_build_seg_command
2395 (NULL
, mdata
, &mdata
->commands
[segcmd_idx
].command
.segment
))
2398 /* If we're doing a dysymtab, cmd points to its load command. */
2399 if (dysymtab_idx
>= 0
2400 && ! bfd_mach_o_build_dysymtab_command (abfd
, mdata
,
2401 &mdata
->commands
[dysymtab_idx
]))
2404 /* The symtab command is filled in when the symtab is written. */
2408 /* Set the contents of a section. */
2411 bfd_mach_o_set_section_contents (bfd
*abfd
,
2413 const void * location
,
2415 bfd_size_type count
)
2419 /* Trying to write the first section contents will trigger the creation of
2420 the load commands if they are not already present. */
2421 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
2427 pos
= section
->filepos
+ offset
;
2428 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2429 || bfd_bwrite (location
, count
, abfd
) != count
)
2436 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
2437 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2442 /* Make an empty symbol. This is required only because
2443 bfd_make_section_anyway wants to create a symbol for the section. */
2446 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
2448 asymbol
*new_symbol
;
2450 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
2451 if (new_symbol
== NULL
)
2453 new_symbol
->the_bfd
= abfd
;
2454 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
2459 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
2461 struct mach_o_header_external raw
;
2463 bfd_vma (*get32
) (const void *) = NULL
;
2465 /* Just read the magic number. */
2466 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2467 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
2470 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2472 header
->byteorder
= BFD_ENDIAN_BIG
;
2473 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2474 header
->version
= 1;
2477 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2479 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2480 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2481 header
->version
= 1;
2484 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2486 header
->byteorder
= BFD_ENDIAN_BIG
;
2487 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2488 header
->version
= 2;
2491 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2493 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2494 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2495 header
->version
= 2;
2500 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
2504 /* Once the size of the header is known, read the full header. */
2505 size
= mach_o_wide_p (header
) ?
2506 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2508 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2509 || bfd_bread (&raw
, size
, abfd
) != size
)
2512 header
->cputype
= (*get32
) (raw
.cputype
);
2513 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
2514 header
->filetype
= (*get32
) (raw
.filetype
);
2515 header
->ncmds
= (*get32
) (raw
.ncmds
);
2516 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
2517 header
->flags
= (*get32
) (raw
.flags
);
2519 if (mach_o_wide_p (header
))
2520 header
->reserved
= (*get32
) (raw
.reserved
);
2526 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
2528 bfd_mach_o_section
*s
;
2529 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
2531 s
= bfd_mach_o_get_mach_o_section (sec
);
2535 static const mach_o_section_name_xlat
* xlat
;
2537 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
2540 sec
->used_by_bfd
= s
;
2541 s
->bfdsection
= sec
;
2543 /* Create the Darwin seg/sect name pair from the bfd name.
2544 If this is a canonical name for which a specific paiting exists
2545 there will also be defined flags, type, attribute and alignment
2547 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
2550 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
2551 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
2553 bfd_set_section_alignment (abfd
, sec
, s
->align
);
2554 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2555 if (bfd_flags
== SEC_NO_FLAGS
)
2556 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
2559 /* Create default flags. */
2560 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
2563 return _bfd_generic_new_section_hook (abfd
, sec
);
2567 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
2571 bfd_mach_o_section
*section
;
2573 flags
= bfd_get_section_flags (abfd
, sec
);
2574 section
= bfd_mach_o_get_mach_o_section (sec
);
2576 /* TODO: see if we should use the xlat system for doing this by
2577 preference and fall back to this for unknown sections. */
2579 if (flags
== SEC_NO_FLAGS
)
2581 /* Try to guess flags. */
2582 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
2583 flags
= SEC_DEBUGGING
;
2587 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2588 != BFD_MACH_O_S_ZEROFILL
)
2591 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
2593 if (prot
& BFD_MACH_O_PROT_WRITE
)
2595 else if (prot
& BFD_MACH_O_PROT_READ
)
2596 flags
|= SEC_READONLY
;
2602 if ((flags
& SEC_DEBUGGING
) == 0)
2606 if (section
->offset
!= 0)
2607 flags
|= SEC_HAS_CONTENTS
;
2608 if (section
->nreloc
!= 0)
2611 bfd_set_section_flags (abfd
, sec
, flags
);
2613 sec
->vma
= section
->addr
;
2614 sec
->lma
= section
->addr
;
2615 sec
->size
= section
->size
;
2616 sec
->filepos
= section
->offset
;
2617 sec
->alignment_power
= section
->align
;
2618 sec
->segment_mark
= 0;
2619 sec
->reloc_count
= section
->nreloc
;
2620 sec
->rel_filepos
= section
->reloff
;
2624 bfd_mach_o_make_bfd_section (bfd
*abfd
,
2625 const unsigned char *segname
,
2626 const unsigned char *sectname
)
2631 bfd_mach_o_convert_section_name_to_bfd
2632 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
2636 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
2640 bfd_mach_o_read_section_32 (bfd
*abfd
,
2641 unsigned int offset
,
2644 struct mach_o_section_32_external raw
;
2646 bfd_mach_o_section
*section
;
2648 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2649 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
2650 != BFD_MACH_O_SECTION_SIZE
))
2653 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2657 section
= bfd_mach_o_get_mach_o_section (sec
);
2658 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2659 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2660 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2661 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2662 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
2663 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
2664 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2665 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2666 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2667 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2668 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2669 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2670 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2671 section
->reserved3
= 0;
2673 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2679 bfd_mach_o_read_section_64 (bfd
*abfd
,
2680 unsigned int offset
,
2683 struct mach_o_section_64_external raw
;
2685 bfd_mach_o_section
*section
;
2687 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2688 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
2689 != BFD_MACH_O_SECTION_64_SIZE
))
2692 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2696 section
= bfd_mach_o_get_mach_o_section (sec
);
2697 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2698 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2699 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2700 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2701 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
2702 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
2703 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2704 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2705 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2706 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2707 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2708 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2709 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2710 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
2712 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2718 bfd_mach_o_read_section (bfd
*abfd
,
2719 unsigned int offset
,
2724 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
2726 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
2730 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
2731 bfd_mach_o_symtab_command
*sym
,
2732 bfd_mach_o_asymbol
*s
,
2735 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2736 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
2737 unsigned int symwidth
=
2738 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2739 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
2740 struct mach_o_nlist_64_external raw
;
2741 unsigned char type
= -1;
2742 unsigned char section
= -1;
2744 symvalue value
= -1;
2745 unsigned long stroff
= -1;
2746 unsigned int symtype
= -1;
2748 BFD_ASSERT (sym
->strtab
!= NULL
);
2750 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
2751 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
2753 (*_bfd_error_handler
)
2754 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2755 symwidth
, (unsigned long) symoff
);
2759 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
2760 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
2761 symtype
= type
& BFD_MACH_O_N_TYPE
;
2762 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
2763 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
2765 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
2767 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
2769 if (stroff
>= sym
->strsize
)
2771 (*_bfd_error_handler
)
2772 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2773 (unsigned long) stroff
,
2774 (unsigned long) sym
->strsize
);
2778 s
->symbol
.the_bfd
= abfd
;
2779 s
->symbol
.name
= sym
->strtab
+ stroff
;
2780 s
->symbol
.value
= value
;
2781 s
->symbol
.flags
= 0x0;
2782 s
->symbol
.udata
.i
= i
;
2784 s
->n_sect
= section
;
2787 if (type
& BFD_MACH_O_N_STAB
)
2789 s
->symbol
.flags
|= BSF_DEBUGGING
;
2790 s
->symbol
.section
= bfd_und_section_ptr
;
2802 if ((section
> 0) && (section
<= mdata
->nsects
))
2804 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2806 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2813 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
2814 s
->symbol
.flags
|= BSF_GLOBAL
;
2816 s
->symbol
.flags
|= BSF_LOCAL
;
2820 case BFD_MACH_O_N_UNDF
:
2821 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
2822 && s
->symbol
.value
!= 0)
2824 /* A common symbol. */
2825 s
->symbol
.section
= bfd_com_section_ptr
;
2826 s
->symbol
.flags
= BSF_NO_FLAGS
;
2830 s
->symbol
.section
= bfd_und_section_ptr
;
2831 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
2832 s
->symbol
.flags
|= BSF_WEAK
;
2835 case BFD_MACH_O_N_PBUD
:
2836 s
->symbol
.section
= bfd_und_section_ptr
;
2838 case BFD_MACH_O_N_ABS
:
2839 s
->symbol
.section
= bfd_abs_section_ptr
;
2841 case BFD_MACH_O_N_SECT
:
2842 if ((section
> 0) && (section
<= mdata
->nsects
))
2844 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2846 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2850 /* Mach-O uses 0 to mean "no section"; not an error. */
2853 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2854 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2855 s
->symbol
.name
, section
, mdata
->nsects
);
2857 s
->symbol
.section
= bfd_und_section_ptr
;
2860 case BFD_MACH_O_N_INDR
:
2861 /* FIXME: we don't follow the BFD convention as this indirect symbol
2862 won't be followed by the referenced one. This looks harmless
2863 unless we start using the linker. */
2864 s
->symbol
.flags
|= BSF_INDIRECT
;
2865 s
->symbol
.section
= bfd_ind_section_ptr
;
2866 s
->symbol
.value
= 0;
2869 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2870 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2871 s
->symbol
.name
, symtype
);
2872 s
->symbol
.section
= bfd_und_section_ptr
;
2881 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
2883 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2884 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2886 /* Fail if there is no symtab. */
2890 /* Success if already loaded. */
2894 if (abfd
->flags
& BFD_IN_MEMORY
)
2896 struct bfd_in_memory
*b
;
2898 b
= (struct bfd_in_memory
*) abfd
->iostream
;
2900 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
2902 bfd_set_error (bfd_error_file_truncated
);
2905 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
2909 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
2910 if (sym
->strtab
== NULL
)
2913 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
2914 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
2916 bfd_set_error (bfd_error_file_truncated
);
2925 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
2927 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2928 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2931 if (sym
== NULL
|| sym
->symbols
)
2933 /* Return now if there are no symbols or if already loaded. */
2937 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
2939 if (sym
->symbols
== NULL
)
2941 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2945 if (!bfd_mach_o_read_symtab_strtab (abfd
))
2948 for (i
= 0; i
< sym
->nsyms
; i
++)
2950 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
2958 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2960 switch ((int) flavour
)
2962 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2963 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2964 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2965 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2966 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2967 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2968 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2969 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2970 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2971 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2972 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2973 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2974 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2975 default: return "UNKNOWN";
2980 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2982 switch ((int) flavour
)
2984 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2985 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2986 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2987 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2988 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2989 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2990 default: return "UNKNOWN";
2995 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2997 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2998 struct mach_o_str_command_external raw
;
2999 unsigned int nameoff
;
3001 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
3002 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
3004 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3005 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3008 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
3010 cmd
->name_offset
= command
->offset
+ nameoff
;
3011 cmd
->name_len
= command
->len
- nameoff
;
3012 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
3013 if (cmd
->name_str
== NULL
)
3015 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3016 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
3022 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3024 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3025 struct mach_o_dylib_command_external raw
;
3026 unsigned int nameoff
;
3028 switch (command
->type
)
3030 case BFD_MACH_O_LC_LOAD_DYLIB
:
3031 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3032 case BFD_MACH_O_LC_ID_DYLIB
:
3033 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3034 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3041 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3042 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3045 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3046 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3047 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3048 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3050 cmd
->name_offset
= command
->offset
+ nameoff
;
3051 cmd
->name_len
= command
->len
- nameoff
;
3052 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
3053 if (cmd
->name_str
== NULL
)
3055 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3056 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
3062 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
3063 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
3065 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3067 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
3072 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3074 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
3075 struct mach_o_fvmlib_command_external raw
;
3076 unsigned int nameoff
;
3078 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3079 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3082 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3083 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3084 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3086 fvm
->name_offset
= command
->offset
+ nameoff
;
3087 fvm
->name_len
= command
->len
- nameoff
;
3088 fvm
->name_str
= bfd_alloc (abfd
, fvm
->name_len
);
3089 if (fvm
->name_str
== NULL
)
3091 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3092 || bfd_bread (fvm
->name_str
, fvm
->name_len
, abfd
) != fvm
->name_len
)
3098 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3100 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3101 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3102 unsigned int offset
;
3103 unsigned int nflavours
;
3106 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3107 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3109 /* Count the number of threads. */
3112 while (offset
!= command
->len
)
3114 struct mach_o_thread_command_external raw
;
3116 if (offset
>= command
->len
)
3119 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3120 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3123 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3127 /* Allocate threads. */
3128 cmd
->flavours
= bfd_alloc
3129 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3130 if (cmd
->flavours
== NULL
)
3132 cmd
->nflavours
= nflavours
;
3136 while (offset
!= command
->len
)
3138 struct mach_o_thread_command_external raw
;
3140 if (offset
>= command
->len
)
3143 if (nflavours
>= cmd
->nflavours
)
3146 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3147 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3150 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3151 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3152 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3153 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3157 for (i
= 0; i
< nflavours
; i
++)
3160 unsigned int snamelen
;
3162 const char *flavourstr
;
3163 const char *prefix
= "LC_THREAD";
3166 switch (mdata
->header
.cputype
)
3168 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3169 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
3170 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
3172 case BFD_MACH_O_CPU_TYPE_I386
:
3173 case BFD_MACH_O_CPU_TYPE_X86_64
:
3174 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
3177 flavourstr
= "UNKNOWN_ARCHITECTURE";
3181 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
3182 sname
= bfd_alloc (abfd
, snamelen
);
3188 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
3189 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
3194 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
3198 bfdsec
->size
= cmd
->flavours
[i
].size
;
3199 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
3200 bfdsec
->alignment_power
= 0x0;
3202 cmd
->section
= bfdsec
;
3209 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3211 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
3212 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3214 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
3217 struct mach_o_dysymtab_command_external raw
;
3219 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3220 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3223 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
3224 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
3225 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
3226 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
3227 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
3228 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
3229 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
3230 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
3231 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
3232 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
3233 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
3234 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
3235 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
3236 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
3237 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
3238 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
3239 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
3240 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
3243 if (cmd
->nmodtab
!= 0)
3246 int wide
= bfd_mach_o_wide_p (abfd
);
3247 unsigned int module_len
= wide
? 56 : 52;
3250 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
3251 if (cmd
->dylib_module
== NULL
)
3254 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
3257 for (i
= 0; i
< cmd
->nmodtab
; i
++)
3259 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
3261 unsigned char buf
[56];
3263 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
3266 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
3267 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
3268 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
3269 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
3270 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
3271 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
3272 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
3273 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
3274 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
3275 v
= bfd_h_get_32 (abfd
, buf
+36);
3276 module
->iinit
= v
& 0xffff;
3277 module
->iterm
= (v
>> 16) & 0xffff;
3278 v
= bfd_h_get_32 (abfd
, buf
+ 40);
3279 module
->ninit
= v
& 0xffff;
3280 module
->nterm
= (v
>> 16) & 0xffff;
3283 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
3284 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
3288 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
3289 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
3298 cmd
->dylib_toc
= bfd_alloc
3299 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
3300 if (cmd
->dylib_toc
== NULL
)
3303 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
3306 for (i
= 0; i
< cmd
->ntoc
; i
++)
3308 struct mach_o_dylib_table_of_contents_external raw
;
3309 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
3311 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3314 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
3315 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
3319 if (cmd
->nindirectsyms
!= 0)
3323 cmd
->indirect_syms
= bfd_alloc
3324 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
3325 if (cmd
->indirect_syms
== NULL
)
3328 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
3331 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
3333 unsigned char raw
[4];
3334 unsigned int *is
= &cmd
->indirect_syms
[i
];
3336 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3339 *is
= bfd_h_get_32 (abfd
, raw
);
3343 if (cmd
->nextrefsyms
!= 0)
3348 cmd
->ext_refs
= bfd_alloc
3349 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
3350 if (cmd
->ext_refs
== NULL
)
3353 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
3356 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
3358 unsigned char raw
[4];
3359 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
3361 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3364 /* Fields isym and flags are written as bit-fields, thus we need
3365 a specific processing for endianness. */
3366 v
= bfd_h_get_32 (abfd
, raw
);
3367 if (bfd_big_endian (abfd
))
3369 ref
->isym
= (v
>> 8) & 0xffffff;
3370 ref
->flags
= v
& 0xff;
3374 ref
->isym
= v
& 0xffffff;
3375 ref
->flags
= (v
>> 24) & 0xff;
3380 if (mdata
->dysymtab
)
3382 mdata
->dysymtab
= cmd
;
3388 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3390 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
3391 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3392 struct mach_o_symtab_command_external raw
;
3394 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
3396 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3397 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3400 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
3401 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
3402 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
3403 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
3404 symtab
->symbols
= NULL
;
3405 symtab
->strtab
= NULL
;
3407 if (symtab
->nsyms
!= 0)
3408 abfd
->flags
|= HAS_SYMS
;
3412 mdata
->symtab
= symtab
;
3417 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3419 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
3421 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
3423 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3424 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
3431 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3433 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
3434 struct mach_o_linkedit_data_command_external raw
;
3436 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3437 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3440 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
3441 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
3446 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3448 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
3449 struct mach_o_str_command_external raw
;
3452 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3453 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3456 off
= bfd_get_32 (abfd
, raw
.str
);
3457 cmd
->stroff
= command
->offset
+ off
;
3458 cmd
->str_len
= command
->len
- off
;
3459 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
3460 if (cmd
->str
== NULL
)
3462 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
3463 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
3469 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3471 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
3472 struct mach_o_dyld_info_command_external raw
;
3474 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3475 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3478 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
3479 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
3480 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
3481 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
3482 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
3483 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
3484 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
3485 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
3486 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
3487 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
3492 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3494 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
3495 struct mach_o_version_min_command_external raw
;
3498 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3499 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3502 ver
= bfd_get_32 (abfd
, raw
.version
);
3503 cmd
->rel
= ver
>> 16;
3504 cmd
->maj
= ver
>> 8;
3506 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
3511 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3513 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
3514 struct mach_o_encryption_info_command_external raw
;
3516 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3517 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3520 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
3521 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
3522 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
3527 bfd_mach_o_read_segment (bfd
*abfd
,
3528 bfd_mach_o_load_command
*command
,
3531 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
3536 struct mach_o_segment_command_64_external raw
;
3538 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
3540 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3541 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3544 memcpy (seg
->segname
, raw
.segname
, 16);
3545 seg
->segname
[16] = '\0';
3547 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
3548 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
3549 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
3550 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
3551 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3552 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3553 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3554 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3558 struct mach_o_segment_command_32_external raw
;
3560 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
3562 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3563 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3566 memcpy (seg
->segname
, raw
.segname
, 16);
3567 seg
->segname
[16] = '\0';
3569 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
3570 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
3571 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
3572 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
3573 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3574 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3575 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3576 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3578 seg
->sect_head
= NULL
;
3579 seg
->sect_tail
= NULL
;
3581 for (i
= 0; i
< seg
->nsects
; i
++)
3587 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
3588 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
3590 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
3591 + (i
* BFD_MACH_O_SECTION_SIZE
);
3593 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
3597 bfd_mach_o_append_section_to_segment (seg
, sec
);
3604 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3606 return bfd_mach_o_read_segment (abfd
, command
, 0);
3610 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3612 return bfd_mach_o_read_segment (abfd
, command
, 1);
3616 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3618 struct mach_o_load_command_external raw
;
3621 /* Read command type and length. */
3622 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
3623 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
3626 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
3627 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
3628 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
3629 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
3631 switch (command
->type
)
3633 case BFD_MACH_O_LC_SEGMENT
:
3634 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
3637 case BFD_MACH_O_LC_SEGMENT_64
:
3638 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
3641 case BFD_MACH_O_LC_SYMTAB
:
3642 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
3645 case BFD_MACH_O_LC_SYMSEG
:
3647 case BFD_MACH_O_LC_THREAD
:
3648 case BFD_MACH_O_LC_UNIXTHREAD
:
3649 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
3652 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3653 case BFD_MACH_O_LC_ID_DYLINKER
:
3654 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
3657 case BFD_MACH_O_LC_LOAD_DYLIB
:
3658 case BFD_MACH_O_LC_ID_DYLIB
:
3659 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3660 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3661 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3662 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
3665 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
3666 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
3669 case BFD_MACH_O_LC_LOADFVMLIB
:
3670 case BFD_MACH_O_LC_IDFVMLIB
:
3671 if (bfd_mach_o_read_fvmlib (abfd
, command
) != 0)
3674 case BFD_MACH_O_LC_IDENT
:
3675 case BFD_MACH_O_LC_FVMFILE
:
3676 case BFD_MACH_O_LC_PREPAGE
:
3677 case BFD_MACH_O_LC_ROUTINES
:
3678 case BFD_MACH_O_LC_ROUTINES_64
:
3680 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
3681 case BFD_MACH_O_LC_SUB_UMBRELLA
:
3682 case BFD_MACH_O_LC_SUB_LIBRARY
:
3683 case BFD_MACH_O_LC_SUB_CLIENT
:
3684 case BFD_MACH_O_LC_RPATH
:
3685 if (bfd_mach_o_read_str (abfd
, command
) != 0)
3688 case BFD_MACH_O_LC_DYSYMTAB
:
3689 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
3692 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
3693 case BFD_MACH_O_LC_PREBIND_CKSUM
:
3695 case BFD_MACH_O_LC_UUID
:
3696 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
3699 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3700 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3701 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3702 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
3705 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
3706 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
3709 case BFD_MACH_O_LC_DYLD_INFO
:
3710 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
3713 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
3714 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
3715 if (!bfd_mach_o_read_version_min (abfd
, command
))
3719 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
3720 abfd
, (unsigned long) command
->type
);
3728 bfd_mach_o_flatten_sections (bfd
*abfd
)
3730 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3734 /* Count total number of sections. */
3737 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3739 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3740 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3742 bfd_mach_o_segment_command
*seg
;
3744 seg
= &mdata
->commands
[i
].command
.segment
;
3745 mdata
->nsects
+= seg
->nsects
;
3749 /* Allocate sections array. */
3750 mdata
->sections
= bfd_alloc (abfd
,
3751 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
3753 /* Fill the array. */
3756 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3758 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3759 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3761 bfd_mach_o_segment_command
*seg
;
3762 bfd_mach_o_section
*sec
;
3764 seg
= &mdata
->commands
[i
].command
.segment
;
3765 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
3767 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3768 mdata
->sections
[csect
++] = sec
;
3774 bfd_mach_o_scan_start_address (bfd
*abfd
)
3776 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3777 bfd_mach_o_thread_command
*cmd
= NULL
;
3780 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3781 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
3782 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
3784 cmd
= &mdata
->commands
[i
].command
.thread
;
3791 /* FIXME: create a subtarget hook ? */
3792 for (i
= 0; i
< cmd
->nflavours
; i
++)
3794 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
3795 && (cmd
->flavours
[i
].flavour
3796 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
3798 unsigned char buf
[4];
3800 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, 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
)
3807 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
3809 unsigned char buf
[4];
3811 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3812 || bfd_bread (buf
, 4, abfd
) != 4)
3815 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3817 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
3818 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
3820 unsigned char buf
[8];
3822 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3823 || bfd_bread (buf
, 8, abfd
) != 8)
3826 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3828 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
3829 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
3831 unsigned char buf
[8];
3833 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
3834 || bfd_bread (buf
, 8, abfd
) != 8)
3837 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3845 bfd_mach_o_set_arch_mach (bfd
*abfd
,
3846 enum bfd_architecture arch
,
3847 unsigned long machine
)
3849 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
3851 /* If this isn't the right architecture for this backend, and this
3852 isn't the generic backend, fail. */
3853 if (arch
!= bed
->arch
3854 && arch
!= bfd_arch_unknown
3855 && bed
->arch
!= bfd_arch_unknown
)
3858 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3862 bfd_mach_o_scan (bfd
*abfd
,
3863 bfd_mach_o_header
*header
,
3864 bfd_mach_o_data_struct
*mdata
)
3867 enum bfd_architecture cputype
;
3868 unsigned long cpusubtype
;
3869 unsigned int hdrsize
;
3871 hdrsize
= mach_o_wide_p (header
) ?
3872 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3874 mdata
->header
= *header
;
3876 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
3877 switch (header
->filetype
)
3879 case BFD_MACH_O_MH_OBJECT
:
3880 abfd
->flags
|= HAS_RELOC
;
3882 case BFD_MACH_O_MH_EXECUTE
:
3883 abfd
->flags
|= EXEC_P
;
3885 case BFD_MACH_O_MH_DYLIB
:
3886 case BFD_MACH_O_MH_BUNDLE
:
3887 abfd
->flags
|= DYNAMIC
;
3891 abfd
->tdata
.mach_o_data
= mdata
;
3893 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
3894 &cputype
, &cpusubtype
);
3895 if (cputype
== bfd_arch_unknown
)
3897 (*_bfd_error_handler
)
3898 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3899 header
->cputype
, header
->cpusubtype
);
3903 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
3905 if (header
->ncmds
!= 0)
3907 mdata
->commands
= bfd_alloc
3908 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
3909 if (mdata
->commands
== NULL
)
3912 for (i
= 0; i
< header
->ncmds
; i
++)
3914 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
3917 cur
->offset
= hdrsize
;
3920 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
3921 cur
->offset
= prev
->offset
+ prev
->len
;
3924 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
3929 if (bfd_mach_o_scan_start_address (abfd
) < 0)
3932 bfd_mach_o_flatten_sections (abfd
);
3937 bfd_mach_o_mkobject_init (bfd
*abfd
)
3939 bfd_mach_o_data_struct
*mdata
= NULL
;
3941 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3944 abfd
->tdata
.mach_o_data
= mdata
;
3946 mdata
->header
.magic
= 0;
3947 mdata
->header
.cputype
= 0;
3948 mdata
->header
.cpusubtype
= 0;
3949 mdata
->header
.filetype
= 0;
3950 mdata
->header
.ncmds
= 0;
3951 mdata
->header
.sizeofcmds
= 0;
3952 mdata
->header
.flags
= 0;
3953 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
3954 mdata
->commands
= NULL
;
3956 mdata
->sections
= NULL
;
3957 mdata
->dyn_reloc_cache
= NULL
;
3963 bfd_mach_o_gen_mkobject (bfd
*abfd
)
3965 bfd_mach_o_data_struct
*mdata
;
3967 if (!bfd_mach_o_mkobject_init (abfd
))
3970 mdata
= bfd_mach_o_get_data (abfd
);
3971 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
3972 mdata
->header
.cputype
= 0;
3973 mdata
->header
.cpusubtype
= 0;
3974 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
3975 mdata
->header
.version
= 1;
3981 bfd_mach_o_header_p (bfd
*abfd
,
3982 bfd_mach_o_filetype filetype
,
3983 bfd_mach_o_cpu_type cputype
)
3985 struct bfd_preserve preserve
;
3986 bfd_mach_o_header header
;
3988 preserve
.marker
= NULL
;
3989 if (!bfd_mach_o_read_header (abfd
, &header
))
3992 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3993 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3995 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3996 (unsigned long) header
.byteorder
);
4000 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
4001 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
4002 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
4003 || (header
.byteorder
== BFD_ENDIAN_LITTLE
4004 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
4005 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
4008 /* Check cputype and filetype.
4009 In case of wildcard, do not accept magics that are handled by existing
4013 if (header
.cputype
!= cputype
)
4019 if (header
.filetype
!= filetype
)
4024 switch (header
.filetype
)
4026 case BFD_MACH_O_MH_CORE
:
4027 /* Handled by core_p */
4034 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
4035 if (preserve
.marker
== NULL
4036 || !bfd_preserve_save (abfd
, &preserve
))
4039 if (!bfd_mach_o_scan (abfd
, &header
,
4040 (bfd_mach_o_data_struct
*) preserve
.marker
))
4043 bfd_preserve_finish (abfd
, &preserve
);
4047 bfd_set_error (bfd_error_wrong_format
);
4050 if (preserve
.marker
!= NULL
)
4051 bfd_preserve_restore (abfd
, &preserve
);
4055 static const bfd_target
*
4056 bfd_mach_o_gen_object_p (bfd
*abfd
)
4058 return bfd_mach_o_header_p (abfd
, 0, 0);
4061 static const bfd_target
*
4062 bfd_mach_o_gen_core_p (bfd
*abfd
)
4064 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
4067 typedef struct mach_o_fat_archentry
4069 unsigned long cputype
;
4070 unsigned long cpusubtype
;
4071 unsigned long offset
;
4073 unsigned long align
;
4074 } mach_o_fat_archentry
;
4076 typedef struct mach_o_fat_data_struct
4078 unsigned long magic
;
4079 unsigned long nfat_arch
;
4080 mach_o_fat_archentry
*archentries
;
4081 } mach_o_fat_data_struct
;
4084 bfd_mach_o_archive_p (bfd
*abfd
)
4086 mach_o_fat_data_struct
*adata
= NULL
;
4087 struct mach_o_fat_header_external hdr
;
4090 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
4091 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
4094 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
4098 adata
->magic
= bfd_getb32 (hdr
.magic
);
4099 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
4100 if (adata
->magic
!= 0xcafebabe)
4102 /* Avoid matching Java bytecode files, which have the same magic number.
4103 In the Java bytecode file format this field contains the JVM version,
4104 which starts at 43.0. */
4105 if (adata
->nfat_arch
> 30)
4108 adata
->archentries
=
4109 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
4110 if (adata
->archentries
== NULL
)
4113 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4115 struct mach_o_fat_arch_external arch
;
4116 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
4118 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
4119 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
4120 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
4121 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
4122 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
4125 abfd
->tdata
.mach_o_fat_data
= adata
;
4130 bfd_release (abfd
, adata
);
4131 bfd_set_error (bfd_error_wrong_format
);
4135 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4136 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4137 Set arelt_data and origin fields too. */
4140 bfd_mach_o_fat_member_init (bfd
*abfd
,
4141 enum bfd_architecture arch_type
,
4142 unsigned long arch_subtype
,
4143 mach_o_fat_archentry
*entry
)
4145 struct areltdata
*areltdata
;
4146 /* Create the member filename. Use ARCH_NAME. */
4147 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
4151 /* Use the architecture name if known. */
4152 abfd
->filename
= ap
->printable_name
;
4156 /* Forge a uniq id. */
4157 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
4158 char *name
= bfd_alloc (abfd
, namelen
);
4159 snprintf (name
, namelen
, "0x%lx-0x%lx",
4160 entry
->cputype
, entry
->cpusubtype
);
4161 abfd
->filename
= name
;
4164 areltdata
= bfd_zalloc (abfd
, sizeof (struct areltdata
));
4165 areltdata
->parsed_size
= entry
->size
;
4166 abfd
->arelt_data
= areltdata
;
4167 abfd
->iostream
= NULL
;
4168 abfd
->origin
= entry
->offset
;
4172 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
4174 mach_o_fat_data_struct
*adata
;
4175 mach_o_fat_archentry
*entry
= NULL
;
4178 enum bfd_architecture arch_type
;
4179 unsigned long arch_subtype
;
4181 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
4182 BFD_ASSERT (adata
!= NULL
);
4184 /* Find index of previous entry. */
4187 /* Start at first one. */
4192 /* Find index of PREV. */
4193 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4195 if (adata
->archentries
[i
].offset
== prev
->origin
)
4199 if (i
== adata
->nfat_arch
)
4202 bfd_set_error (bfd_error_bad_value
);
4206 /* Get next entry. */
4210 if (i
>= adata
->nfat_arch
)
4212 bfd_set_error (bfd_error_no_more_archived_files
);
4216 entry
= &adata
->archentries
[i
];
4217 nbfd
= _bfd_new_bfd_contained_in (archive
);
4221 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
4222 &arch_type
, &arch_subtype
);
4224 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
4226 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
4231 /* Analogous to stat call. */
4234 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
4236 if (abfd
->arelt_data
== NULL
)
4238 bfd_set_error (bfd_error_invalid_operation
);
4245 buf
->st_mode
= 0644;
4246 buf
->st_size
= arelt_size (abfd
);
4251 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4252 If ABFD is a fat image containing a member that corresponds to FORMAT
4253 and ARCH, returns it.
4254 In other case, returns NULL.
4255 This function allows transparent uses of fat images. */
4258 bfd_mach_o_fat_extract (bfd
*abfd
,
4260 const bfd_arch_info_type
*arch
)
4263 mach_o_fat_data_struct
*adata
;
4266 if (bfd_check_format (abfd
, format
))
4268 if (bfd_get_arch_info (abfd
) == arch
)
4272 if (!bfd_check_format (abfd
, bfd_archive
)
4273 || abfd
->xvec
!= &mach_o_fat_vec
)
4276 /* This is a Mach-O fat image. */
4277 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
4278 BFD_ASSERT (adata
!= NULL
);
4280 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4282 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
4283 enum bfd_architecture cpu_type
;
4284 unsigned long cpu_subtype
;
4286 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
4287 &cpu_type
, &cpu_subtype
);
4288 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
4291 /* The architecture is found. */
4292 res
= _bfd_new_bfd_contained_in (abfd
);
4296 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
4298 if (bfd_check_format (res
, format
))
4300 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
4311 bfd_mach_o_lookup_command (bfd
*abfd
,
4312 bfd_mach_o_load_command_type type
,
4313 bfd_mach_o_load_command
**mcommand
)
4315 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
4316 bfd_mach_o_load_command
*ncmd
= NULL
;
4317 unsigned int i
, num
;
4319 BFD_ASSERT (md
!= NULL
);
4320 BFD_ASSERT (mcommand
!= NULL
);
4323 for (i
= 0; i
< md
->header
.ncmds
; i
++)
4325 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
4327 if (cmd
->type
!= type
)
4340 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
4344 case BFD_MACH_O_CPU_TYPE_MC680x0
:
4346 case BFD_MACH_O_CPU_TYPE_MC88000
:
4348 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4350 case BFD_MACH_O_CPU_TYPE_I386
:
4352 case BFD_MACH_O_CPU_TYPE_SPARC
:
4354 case BFD_MACH_O_CPU_TYPE_I860
:
4356 case BFD_MACH_O_CPU_TYPE_HPPA
:
4357 return 0xc0000000 - 0x04000000;
4363 /* The following two tables should be kept, as far as possible, in order of
4364 most frequently used entries to optimize their use from gas. */
4366 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
4368 { "regular", BFD_MACH_O_S_REGULAR
},
4369 { "coalesced", BFD_MACH_O_S_COALESCED
},
4370 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
4371 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
4372 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
4373 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
4374 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
4375 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
4376 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
4377 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
4378 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
4379 { "interposing", BFD_MACH_O_S_INTERPOSING
},
4380 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
4381 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
4382 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
4383 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
4384 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
4388 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
4390 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
4391 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
4392 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
4393 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
4394 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
4395 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
4396 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
4397 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
4398 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
4399 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4400 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4404 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4407 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
4409 const bfd_mach_o_xlat_name
*x
;
4410 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4412 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
4413 if (strcmp (x
->name
, name
) == 0)
4415 /* We found it... does the target support it? */
4416 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
4417 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
4418 return x
->val
; /* OK. */
4420 break; /* Not supported. */
4422 /* Maximum section ID = 0xff. */
4426 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4429 bfd_mach_o_get_section_attribute_from_name (const char *name
)
4431 const bfd_mach_o_xlat_name
*x
;
4433 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
4434 if (strcmp (x
->name
, name
) == 0)
4436 return (unsigned int)-1;
4440 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4441 unsigned char **rbuf
,
4444 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4445 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4448 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4450 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4451 bfd_mach_o_segment_command
*seg
= NULL
;
4453 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4456 seg
= &cur
->command
.segment
;
4458 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4460 unsigned long start
= seg
->fileoff
;
4461 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4462 unsigned char *buf
= bfd_malloc (1024);
4463 unsigned long size
= 1024;
4467 bfd_size_type nread
= 0;
4468 unsigned long offset
;
4469 int found_nonnull
= 0;
4471 if (size
> (end
- start
))
4472 size
= (end
- start
);
4474 buf
= bfd_realloc_or_free (buf
, size
);
4478 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4484 nread
= bfd_bread (buf
, size
, abfd
);
4492 for (offset
= 4; offset
<= size
; offset
+= 4)
4496 val
= *((unsigned long *) (buf
+ size
- offset
));
4497 if (! found_nonnull
)
4502 else if (val
== 0x0)
4504 unsigned long bottom
;
4507 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4508 top
= seg
->fileoff
+ seg
->filesize
- 4;
4509 *rbuf
= bfd_malloc (top
- bottom
);
4510 *rlen
= top
- bottom
;
4512 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4518 if (size
== (end
- start
))
4532 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4534 unsigned char *buf
= NULL
;
4535 unsigned int len
= 0;
4538 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4542 return (char *) buf
;
4546 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4551 static bfd_mach_o_uuid_command
*
4552 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
4554 bfd_mach_o_load_command
*uuid_cmd
;
4555 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
4558 return &uuid_cmd
->command
.uuid
;
4561 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4564 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
4566 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
4569 BFD_ASSERT (uuid_cmd
);
4571 if (!bfd_check_format (abfd
, bfd_object
))
4574 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
4575 || bfd_mach_o_get_data (abfd
) == NULL
4576 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
4579 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4580 if (dsym_uuid_cmd
== NULL
)
4583 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
4584 sizeof (uuid_cmd
->uuid
)) != 0)
4590 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4591 The caller is responsible for closing the returned BFD object and
4592 its my_archive if the returned BFD is in a fat dSYM. */
4595 bfd_mach_o_find_dsym (const char *dsym_filename
,
4596 const bfd_mach_o_uuid_command
*uuid_cmd
,
4597 const bfd_arch_info_type
*arch
)
4599 bfd
*base_dsym_bfd
, *dsym_bfd
;
4601 BFD_ASSERT (uuid_cmd
);
4603 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
4604 if (base_dsym_bfd
== NULL
)
4607 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
4608 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
4611 bfd_close (dsym_bfd
);
4612 if (base_dsym_bfd
!= dsym_bfd
)
4613 bfd_close (base_dsym_bfd
);
4618 /* Return a BFD created from a dSYM file for ABFD.
4619 The caller is responsible for closing the returned BFD object, its
4620 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4623 bfd_mach_o_follow_dsym (bfd
*abfd
)
4625 char *dsym_filename
;
4626 bfd_mach_o_uuid_command
*uuid_cmd
;
4627 bfd
*dsym_bfd
, *base_bfd
= abfd
;
4628 const char *base_basename
;
4630 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
4633 if (abfd
->my_archive
)
4634 base_bfd
= abfd
->my_archive
;
4635 /* BFD may have been opened from a stream. */
4636 if (base_bfd
->filename
== NULL
)
4638 bfd_set_error (bfd_error_invalid_operation
);
4641 base_basename
= lbasename (base_bfd
->filename
);
4643 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4644 if (uuid_cmd
== NULL
)
4647 /* TODO: We assume the DWARF file has the same as the binary's.
4648 It seems apple's GDB checks all files in the dSYM bundle directory.
4649 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4651 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
4652 + strlen (dsym_subdir
) + 1
4653 + strlen (base_basename
) + 1);
4654 sprintf (dsym_filename
, "%s%s/%s",
4655 base_bfd
->filename
, dsym_subdir
, base_basename
);
4657 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
4658 bfd_get_arch_info (abfd
));
4659 if (dsym_bfd
== NULL
)
4660 free (dsym_filename
);
4666 bfd_mach_o_find_nearest_line (bfd
*abfd
,
4670 const char **filename_ptr
,
4671 const char **functionname_ptr
,
4672 unsigned int *line_ptr
)
4674 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4677 switch (mdata
->header
.filetype
)
4679 case BFD_MACH_O_MH_OBJECT
:
4681 case BFD_MACH_O_MH_EXECUTE
:
4682 case BFD_MACH_O_MH_DYLIB
:
4683 case BFD_MACH_O_MH_BUNDLE
:
4684 case BFD_MACH_O_MH_KEXT_BUNDLE
:
4685 if (mdata
->dwarf2_find_line_info
== NULL
)
4687 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
4688 /* When we couldn't find dSYM for this binary, we look for
4689 the debug information in the binary itself. In this way,
4690 we won't try finding separated dSYM again because
4691 mdata->dwarf2_find_line_info will be filled. */
4692 if (! mdata
->dsym_bfd
)
4694 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
4695 dwarf_debug_sections
, symbols
,
4696 &mdata
->dwarf2_find_line_info
))
4703 if (_bfd_dwarf2_find_nearest_line (abfd
, dwarf_debug_sections
,
4704 section
, symbols
, offset
,
4705 filename_ptr
, functionname_ptr
,
4707 &mdata
->dwarf2_find_line_info
))
4713 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
4715 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4716 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
4718 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
4719 bfd_mach_o_free_cached_info (abfd
);
4720 if (mdata
->dsym_bfd
!= NULL
)
4722 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
4723 char *dsym_filename
= (char *)(fat_bfd
4725 : mdata
->dsym_bfd
->filename
);
4726 bfd_close (mdata
->dsym_bfd
);
4727 mdata
->dsym_bfd
= NULL
;
4729 bfd_close (fat_bfd
);
4730 free (dsym_filename
);
4734 return _bfd_generic_close_and_cleanup (abfd
);
4737 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
4739 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4741 free (mdata
->dyn_reloc_cache
);
4742 mdata
->dyn_reloc_cache
= NULL
;
4743 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
4745 free (asect
->relocation
);
4746 asect
->relocation
= NULL
;
4752 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4753 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4755 #define bfd_mach_o_swap_reloc_in NULL
4756 #define bfd_mach_o_swap_reloc_out NULL
4757 #define bfd_mach_o_print_thread NULL
4758 #define bfd_mach_o_tgt_seg_table NULL
4759 #define bfd_mach_o_section_type_valid_for_tgt NULL
4761 #define TARGET_NAME mach_o_be_vec
4762 #define TARGET_STRING "mach-o-be"
4763 #define TARGET_ARCHITECTURE bfd_arch_unknown
4764 #define TARGET_BIG_ENDIAN 1
4765 #define TARGET_ARCHIVE 0
4766 #define TARGET_PRIORITY 1
4767 #include "mach-o-target.c"
4770 #undef TARGET_STRING
4771 #undef TARGET_ARCHITECTURE
4772 #undef TARGET_BIG_ENDIAN
4773 #undef TARGET_ARCHIVE
4774 #undef TARGET_PRIORITY
4776 #define TARGET_NAME mach_o_le_vec
4777 #define TARGET_STRING "mach-o-le"
4778 #define TARGET_ARCHITECTURE bfd_arch_unknown
4779 #define TARGET_BIG_ENDIAN 0
4780 #define TARGET_ARCHIVE 0
4781 #define TARGET_PRIORITY 1
4783 #include "mach-o-target.c"
4786 #undef TARGET_STRING
4787 #undef TARGET_ARCHITECTURE
4788 #undef TARGET_BIG_ENDIAN
4789 #undef TARGET_ARCHIVE
4790 #undef TARGET_PRIORITY
4792 /* Not yet handled: creating an archive. */
4793 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4796 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4797 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4798 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4799 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4800 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4801 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4802 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4803 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4804 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
4805 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4807 #define TARGET_NAME mach_o_fat_vec
4808 #define TARGET_STRING "mach-o-fat"
4809 #define TARGET_ARCHITECTURE bfd_arch_unknown
4810 #define TARGET_BIG_ENDIAN 1
4811 #define TARGET_ARCHIVE 1
4812 #define TARGET_PRIORITY 0
4814 #include "mach-o-target.c"
4817 #undef TARGET_STRING
4818 #undef TARGET_ARCHITECTURE
4819 #undef TARGET_BIG_ENDIAN
4820 #undef TARGET_ARCHIVE
4821 #undef TARGET_PRIORITY