1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "aout/stab_gnu.h"
27 #include "mach-o/reloc.h"
28 #include "mach-o/external.h"
33 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
34 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
35 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
37 #define FILE_ALIGN(off, algn) \
38 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
41 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
);
44 bfd_mach_o_version (bfd
*abfd
)
46 bfd_mach_o_data_struct
*mdata
= NULL
;
48 BFD_ASSERT (bfd_mach_o_valid (abfd
));
49 mdata
= bfd_mach_o_get_data (abfd
);
51 return mdata
->header
.version
;
55 bfd_mach_o_valid (bfd
*abfd
)
57 if (abfd
== NULL
|| abfd
->xvec
== NULL
)
60 if (abfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
63 if (bfd_mach_o_get_data (abfd
) == NULL
)
68 static INLINE bfd_boolean
69 mach_o_wide_p (bfd_mach_o_header
*header
)
71 switch (header
->version
)
83 static INLINE bfd_boolean
84 bfd_mach_o_wide_p (bfd
*abfd
)
86 return mach_o_wide_p (&bfd_mach_o_get_data (abfd
)->header
);
89 /* Tables to translate well known Mach-O segment/section names to bfd
90 names. Use of canonical names (such as .text or .debug_frame) is required
94 static const mach_o_section_name_xlat text_section_names_xlat
[] =
97 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
98 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
, 0},
99 { ".const", "__const",
100 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
101 BFD_MACH_O_S_ATTR_NONE
, 0},
102 { ".static_const", "__static_const",
103 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
104 BFD_MACH_O_S_ATTR_NONE
, 0},
105 { ".cstring", "__cstring",
106 SEC_READONLY
| SEC_DATA
| SEC_LOAD
| SEC_MERGE
| SEC_STRINGS
,
107 BFD_MACH_O_S_CSTRING_LITERALS
,
108 BFD_MACH_O_S_ATTR_NONE
, 0},
109 { ".literal4", "__literal4",
110 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_4BYTE_LITERALS
,
111 BFD_MACH_O_S_ATTR_NONE
, 2},
112 { ".literal8", "__literal8",
113 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_8BYTE_LITERALS
,
114 BFD_MACH_O_S_ATTR_NONE
, 3},
115 { ".literal16", "__literal16",
116 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_16BYTE_LITERALS
,
117 BFD_MACH_O_S_ATTR_NONE
, 4},
118 { ".constructor", "__constructor",
119 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
120 BFD_MACH_O_S_ATTR_NONE
, 0},
121 { ".destructor", "__destructor",
122 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
123 BFD_MACH_O_S_ATTR_NONE
, 0},
124 { ".eh_frame", "__eh_frame",
125 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_COALESCED
,
126 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
127 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
128 | BFD_MACH_O_S_ATTR_NO_TOC
, 2},
129 { NULL
, NULL
, 0, 0, 0, 0}
132 /* __DATA Segment. */
133 static const mach_o_section_name_xlat data_section_names_xlat
[] =
136 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
137 BFD_MACH_O_S_ATTR_NONE
, 0},
139 SEC_NO_FLAGS
, BFD_MACH_O_S_ZEROFILL
,
140 BFD_MACH_O_S_ATTR_NONE
, 0},
141 { ".const_data", "__const",
142 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
143 BFD_MACH_O_S_ATTR_NONE
, 0},
144 { ".static_data", "__static_data",
145 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
146 BFD_MACH_O_S_ATTR_NONE
, 0},
147 { ".mod_init_func", "__mod_init_func",
148 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
,
149 BFD_MACH_O_S_ATTR_NONE
, 2},
150 { ".mod_term_func", "__mod_term_func",
151 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
,
152 BFD_MACH_O_S_ATTR_NONE
, 2},
154 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
155 BFD_MACH_O_S_ATTR_NONE
, 0},
156 { ".cfstring", "__cfstring",
157 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
158 BFD_MACH_O_S_ATTR_NONE
, 2},
159 { NULL
, NULL
, 0, 0, 0, 0}
162 /* __DWARF Segment. */
163 static const mach_o_section_name_xlat dwarf_section_names_xlat
[] =
165 { ".debug_frame", "__debug_frame",
166 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
167 BFD_MACH_O_S_ATTR_DEBUG
, 0},
168 { ".debug_info", "__debug_info",
169 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
170 BFD_MACH_O_S_ATTR_DEBUG
, 0},
171 { ".debug_abbrev", "__debug_abbrev",
172 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
173 BFD_MACH_O_S_ATTR_DEBUG
, 0},
174 { ".debug_aranges", "__debug_aranges",
175 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
176 BFD_MACH_O_S_ATTR_DEBUG
, 0},
177 { ".debug_macinfo", "__debug_macinfo",
178 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
179 BFD_MACH_O_S_ATTR_DEBUG
, 0},
180 { ".debug_line", "__debug_line",
181 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
182 BFD_MACH_O_S_ATTR_DEBUG
, 0},
183 { ".debug_loc", "__debug_loc",
184 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
185 BFD_MACH_O_S_ATTR_DEBUG
, 0},
186 { ".debug_pubnames", "__debug_pubnames",
187 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
188 BFD_MACH_O_S_ATTR_DEBUG
, 0},
189 { ".debug_pubtypes", "__debug_pubtypes",
190 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
191 BFD_MACH_O_S_ATTR_DEBUG
, 0},
192 { ".debug_str", "__debug_str",
193 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
194 BFD_MACH_O_S_ATTR_DEBUG
, 0},
195 { ".debug_ranges", "__debug_ranges",
196 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
197 BFD_MACH_O_S_ATTR_DEBUG
, 0},
198 { ".debug_macro", "__debug_macro",
199 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
200 BFD_MACH_O_S_ATTR_DEBUG
, 0},
201 { ".debug_gdb_scripts", "__debug_gdb_scri",
202 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
203 BFD_MACH_O_S_ATTR_DEBUG
, 0},
204 { NULL
, NULL
, 0, 0, 0, 0}
207 /* __OBJC Segment. */
208 static const mach_o_section_name_xlat objc_section_names_xlat
[] =
210 { ".objc_class", "__class",
211 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
212 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
213 { ".objc_meta_class", "__meta_class",
214 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
215 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
216 { ".objc_cat_cls_meth", "__cat_cls_meth",
217 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
218 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
219 { ".objc_cat_inst_meth", "__cat_inst_meth",
220 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
221 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
222 { ".objc_protocol", "__protocol",
223 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
224 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
225 { ".objc_string_object", "__string_object",
226 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
227 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
228 { ".objc_cls_meth", "__cls_meth",
229 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
230 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
231 { ".objc_inst_meth", "__inst_meth",
232 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
233 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
234 { ".objc_cls_refs", "__cls_refs",
235 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
236 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
237 { ".objc_message_refs", "__message_refs",
238 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
239 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
240 { ".objc_symbols", "__symbols",
241 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
242 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
243 { ".objc_category", "__category",
244 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
245 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
246 { ".objc_class_vars", "__class_vars",
247 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
248 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
249 { ".objc_instance_vars", "__instance_vars",
250 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
251 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
252 { ".objc_module_info", "__module_info",
253 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
254 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
255 { ".objc_selector_strs", "__selector_strs",
256 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_CSTRING_LITERALS
,
257 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
258 { ".objc_image_info", "__image_info",
259 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
260 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
261 { ".objc_selector_fixup", "__sel_fixup",
262 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
263 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
265 { ".objc1_class_ext", "__class_ext",
266 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
267 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
268 { ".objc1_property_list", "__property",
269 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
270 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
271 { ".objc1_protocol_ext", "__protocol_ext",
272 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
273 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
274 { NULL
, NULL
, 0, 0, 0, 0}
277 static const mach_o_segment_name_xlat segsec_names_xlat
[] =
279 { "__TEXT", text_section_names_xlat
},
280 { "__DATA", data_section_names_xlat
},
281 { "__DWARF", dwarf_section_names_xlat
},
282 { "__OBJC", objc_section_names_xlat
},
286 static const char dsym_subdir
[] = ".dSYM/Contents/Resources/DWARF";
288 /* For both cases bfd-name => mach-o name and vice versa, the specific target
289 is checked before the generic. This allows a target (e.g. ppc for cstring)
290 to override the generic definition with a more specific one. */
292 /* Fetch the translation from a Mach-O section designation (segment, section)
293 as a bfd short name, if one exists. Otherwise return NULL.
295 Allow the segment and section names to be unterminated 16 byte arrays. */
297 const mach_o_section_name_xlat
*
298 bfd_mach_o_section_data_for_mach_sect (bfd
*abfd
, const char *segname
,
299 const char *sectname
)
301 const struct mach_o_segment_name_xlat
*seg
;
302 const mach_o_section_name_xlat
*sec
;
303 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
305 /* First try any target-specific translations defined... */
306 if (bed
->segsec_names_xlat
)
307 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
308 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
309 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
310 if (strncmp (sec
->mach_o_name
, sectname
,
311 BFD_MACH_O_SECTNAME_SIZE
) == 0)
314 /* ... and then the Mach-O generic ones. */
315 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
316 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
317 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
318 if (strncmp (sec
->mach_o_name
, sectname
,
319 BFD_MACH_O_SECTNAME_SIZE
) == 0)
325 /* If the bfd_name for this section is a 'canonical' form for which we
326 know the Mach-O data, return the segment name and the data for the
327 Mach-O equivalent. Otherwise return NULL. */
329 const mach_o_section_name_xlat
*
330 bfd_mach_o_section_data_for_bfd_name (bfd
*abfd
, const char *bfd_name
,
331 const char **segname
)
333 const struct mach_o_segment_name_xlat
*seg
;
334 const mach_o_section_name_xlat
*sec
;
335 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
338 if (bfd_name
[0] != '.')
341 /* First try any target-specific translations defined... */
342 if (bed
->segsec_names_xlat
)
343 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
344 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
345 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
347 *segname
= seg
->segname
;
351 /* ... and then the Mach-O generic ones. */
352 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
353 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
354 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
356 *segname
= seg
->segname
;
363 /* Convert Mach-O section name to BFD.
365 Try to use standard/canonical names, for which we have tables including
366 default flag settings - which are returned. Otherwise forge a new name
367 in the form "<segmentname>.<sectionname>" this will be prefixed with
368 LC_SEGMENT. if the segment name does not begin with an underscore.
370 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
371 terminated if the name length is exactly 16 bytes - but must be if the name
372 length is less than 16 characters). */
375 bfd_mach_o_convert_section_name_to_bfd (bfd
*abfd
, const char *segname
,
376 const char *secname
, const char **name
,
379 const mach_o_section_name_xlat
*xlat
;
382 const char *pfx
= "";
385 *flags
= SEC_NO_FLAGS
;
387 /* First search for a canonical name...
388 xlat will be non-null if there is an entry for segname, secname. */
389 xlat
= bfd_mach_o_section_data_for_mach_sect (abfd
, segname
, secname
);
392 len
= strlen (xlat
->bfd_name
);
393 res
= bfd_alloc (abfd
, len
+1);
396 memcpy (res
, xlat
->bfd_name
, len
+1);
398 *flags
= xlat
->bfd_flags
;
402 /* ... else we make up a bfd name from the segment concatenated with the
405 len
= 16 + 1 + 16 + 1;
407 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
408 with an underscore. */
409 if (segname
[0] != '_')
411 static const char seg_pfx
[] = "LC_SEGMENT.";
414 len
+= sizeof (seg_pfx
) - 1;
417 res
= bfd_alloc (abfd
, len
);
420 snprintf (res
, len
, "%s%.16s.%.16s", pfx
, segname
, secname
);
424 /* Convert a bfd section name to a Mach-O segment + section name.
426 If the name is a canonical one for which we have a Darwin match
427 return the translation table - which contains defaults for flags,
428 type, attribute and default alignment data.
430 Otherwise, expand the bfd_name (assumed to be in the form
431 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
433 static const mach_o_section_name_xlat
*
434 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
436 bfd_mach_o_section
*section
)
438 const mach_o_section_name_xlat
*xlat
;
439 const char *name
= bfd_get_section_name (abfd
, sect
);
446 memset (section
->segname
, 0, BFD_MACH_O_SEGNAME_SIZE
+ 1);
447 memset (section
->sectname
, 0, BFD_MACH_O_SECTNAME_SIZE
+ 1);
449 /* See if is a canonical name ... */
450 xlat
= bfd_mach_o_section_data_for_bfd_name (abfd
, name
, &segname
);
453 strcpy (section
->segname
, segname
);
454 strcpy (section
->sectname
, xlat
->mach_o_name
);
458 /* .. else we convert our constructed one back to Mach-O.
459 Strip LC_SEGMENT. prefix, if present. */
460 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
464 dot
= strchr (name
, '.');
467 /* Try to split name into segment and section names. */
468 if (dot
&& dot
!= name
)
471 seclen
= len
- (dot
+ 1 - name
);
473 if (seglen
<= BFD_MACH_O_SEGNAME_SIZE
474 && seclen
<= BFD_MACH_O_SECTNAME_SIZE
)
476 memcpy (section
->segname
, name
, seglen
);
477 section
->segname
[seglen
] = 0;
478 memcpy (section
->sectname
, dot
+ 1, seclen
);
479 section
->sectname
[seclen
] = 0;
484 /* The segment and section names are both missing - don't make them
486 if (dot
&& dot
== name
)
489 /* Just duplicate the name into both segment and section. */
492 memcpy (section
->segname
, name
, len
);
493 section
->segname
[len
] = 0;
494 memcpy (section
->sectname
, name
, len
);
495 section
->sectname
[len
] = 0;
499 /* Return the size of an entry for section SEC.
500 Must be called only for symbol pointer section and symbol stubs
504 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
506 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
508 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
509 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
510 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
511 case BFD_MACH_O_S_SYMBOL_STUBS
:
512 return sec
->reserved2
;
519 /* Return the number of indirect symbols for a section.
520 Must be called only for symbol pointer section and symbol stubs
524 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
528 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
532 return sec
->size
/ elsz
;
535 /* Append command CMD to ABFD. Note that header.ncmds is not updated. */
538 bfd_mach_o_append_command (bfd
*abfd
, bfd_mach_o_load_command
*cmd
)
540 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
542 if (mdata
->last_command
!= NULL
)
543 mdata
->last_command
->next
= cmd
;
545 mdata
->first_command
= cmd
;
546 mdata
->last_command
= cmd
;
550 /* Copy any private info we understand from the input symbol
551 to the output symbol. */
554 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
556 bfd
*obfd ATTRIBUTE_UNUSED
,
559 bfd_mach_o_asymbol
*os
, *is
;
561 os
= (bfd_mach_o_asymbol
*)osymbol
;
562 is
= (bfd_mach_o_asymbol
*)isymbol
;
563 os
->n_type
= is
->n_type
;
564 os
->n_sect
= is
->n_sect
;
565 os
->n_desc
= is
->n_desc
;
566 os
->symbol
.udata
.i
= is
->symbol
.udata
.i
;
571 /* Copy any private info we understand from the input section
572 to the output section. */
575 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd
, asection
*isection
,
576 bfd
*obfd
, asection
*osection
)
578 bfd_mach_o_section
*os
= bfd_mach_o_get_mach_o_section (osection
);
579 bfd_mach_o_section
*is
= bfd_mach_o_get_mach_o_section (isection
);
581 if (ibfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
582 || obfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
585 BFD_ASSERT (is
!= NULL
&& os
!= NULL
);
587 os
->flags
= is
->flags
;
588 os
->reserved1
= is
->reserved1
;
589 os
->reserved2
= is
->reserved2
;
590 os
->reserved3
= is
->reserved3
;
595 /* Copy any private info we understand from the input bfd
596 to the output bfd. */
599 bfd_mach_o_bfd_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
601 bfd_mach_o_data_struct
*imdata
;
602 bfd_mach_o_data_struct
*omdata
;
603 bfd_mach_o_load_command
*icmd
;
605 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
606 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
609 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
610 BFD_ASSERT (bfd_mach_o_valid (obfd
));
612 imdata
= bfd_mach_o_get_data (ibfd
);
613 omdata
= bfd_mach_o_get_data (obfd
);
615 /* Copy header flags. */
616 omdata
->header
.flags
= imdata
->header
.flags
;
619 for (icmd
= imdata
->first_command
; icmd
!= NULL
; icmd
= icmd
->next
)
621 bfd_mach_o_load_command
*ocmd
;
625 case BFD_MACH_O_LC_LOAD_DYLIB
:
626 case BFD_MACH_O_LC_LOAD_DYLINKER
:
627 case BFD_MACH_O_LC_DYLD_INFO
:
628 /* Command is copied. */
629 ocmd
= bfd_alloc (obfd
, sizeof (bfd_mach_o_load_command
));
633 /* Copy common fields. */
634 ocmd
->type
= icmd
->type
;
635 ocmd
->type_required
= icmd
->type_required
;
637 ocmd
->len
= icmd
->len
;
641 /* Command is not copied. */
648 case BFD_MACH_O_LC_LOAD_DYLIB
:
650 bfd_mach_o_dylib_command
*idy
= &icmd
->command
.dylib
;
651 bfd_mach_o_dylib_command
*ody
= &ocmd
->command
.dylib
;
653 ody
->name_offset
= idy
->name_offset
;
654 ody
->timestamp
= idy
->timestamp
;
655 ody
->current_version
= idy
->current_version
;
656 ody
->compatibility_version
= idy
->compatibility_version
;
657 ody
->name_str
= idy
->name_str
;
661 case BFD_MACH_O_LC_LOAD_DYLINKER
:
663 bfd_mach_o_dylinker_command
*idy
= &icmd
->command
.dylinker
;
664 bfd_mach_o_dylinker_command
*ody
= &ocmd
->command
.dylinker
;
666 ody
->name_offset
= idy
->name_offset
;
667 ody
->name_str
= idy
->name_str
;
671 case BFD_MACH_O_LC_DYLD_INFO
:
673 bfd_mach_o_dyld_info_command
*idy
= &icmd
->command
.dyld_info
;
674 bfd_mach_o_dyld_info_command
*ody
= &ocmd
->command
.dyld_info
;
676 if (bfd_mach_o_read_dyld_content (ibfd
, idy
))
678 ody
->rebase_size
= idy
->rebase_size
;
679 ody
->rebase_content
= idy
->rebase_content
;
681 ody
->bind_size
= idy
->bind_size
;
682 ody
->bind_content
= idy
->bind_content
;
684 ody
->weak_bind_size
= idy
->weak_bind_size
;
685 ody
->weak_bind_content
= idy
->weak_bind_content
;
687 ody
->lazy_bind_size
= idy
->lazy_bind_size
;
688 ody
->lazy_bind_content
= idy
->lazy_bind_content
;
690 ody
->export_size
= idy
->export_size
;
691 ody
->export_content
= idy
->export_content
;
697 /* That command should be handled. */
701 /* Insert command. */
702 bfd_mach_o_append_command (obfd
, ocmd
);
708 /* This allows us to set up to 32 bits of flags (unless we invent some
709 fiendish scheme to subdivide). For now, we'll just set the file flags
710 without error checking - just overwrite. */
713 bfd_mach_o_bfd_set_private_flags (bfd
*abfd
, flagword flags
)
715 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
720 mdata
->header
.flags
= flags
;
724 /* Count the total number of symbols. */
727 bfd_mach_o_count_symbols (bfd
*abfd
)
729 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
731 if (mdata
->symtab
== NULL
)
733 return mdata
->symtab
->nsyms
;
737 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
739 long nsyms
= bfd_mach_o_count_symbols (abfd
);
741 return ((nsyms
+ 1) * sizeof (asymbol
*));
745 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
747 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
748 long nsyms
= bfd_mach_o_count_symbols (abfd
);
749 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
757 /* Do not try to read symbols if there are none. */
762 if (!bfd_mach_o_read_symtab_symbols (abfd
))
764 (*_bfd_error_handler
)
765 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
769 BFD_ASSERT (sym
->symbols
!= NULL
);
771 for (j
= 0; j
< sym
->nsyms
; j
++)
772 alocation
[j
] = &sym
->symbols
[j
].symbol
;
779 /* Create synthetic symbols for indirect symbols. */
782 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
783 long symcount ATTRIBUTE_UNUSED
,
784 asymbol
**syms ATTRIBUTE_UNUSED
,
785 long dynsymcount ATTRIBUTE_UNUSED
,
786 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
789 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
790 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
791 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
793 unsigned long count
, i
, j
, n
;
800 /* Stop now if no symbols or no indirect symbols. */
801 if (dysymtab
== NULL
|| symtab
== NULL
|| symtab
->symbols
== NULL
)
804 if (dysymtab
->nindirectsyms
== 0)
807 /* We need to allocate a bfd symbol for every indirect symbol and to
808 allocate the memory for its name. */
809 count
= dysymtab
->nindirectsyms
;
810 size
= count
* sizeof (asymbol
) + 1;
812 for (j
= 0; j
< count
; j
++)
814 unsigned int isym
= dysymtab
->indirect_syms
[j
];
816 /* Some indirect symbols are anonymous. */
817 if (isym
< symtab
->nsyms
&& symtab
->symbols
[isym
].symbol
.name
)
818 size
+= strlen (symtab
->symbols
[isym
].symbol
.name
) + sizeof ("$stub");
821 s
= *ret
= (asymbol
*) bfd_malloc (size
);
824 names
= (char *) (s
+ count
);
829 for (i
= 0; i
< mdata
->nsects
; i
++)
831 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
832 unsigned int first
, last
;
836 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
838 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
839 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
840 case BFD_MACH_O_S_SYMBOL_STUBS
:
841 /* Only these sections have indirect symbols. */
842 first
= sec
->reserved1
;
843 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
845 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
846 for (j
= first
; j
< last
; j
++)
848 unsigned int isym
= dysymtab
->indirect_syms
[j
];
850 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
851 s
->section
= sec
->bfdsection
;
852 s
->value
= addr
- sec
->addr
;
855 if (isym
< symtab
->nsyms
856 && symtab
->symbols
[isym
].symbol
.name
)
858 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
863 memcpy (names
, sym
, len
);
865 memcpy (names
, "$stub", sizeof ("$stub"));
866 names
+= sizeof ("$stub");
885 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
889 bfd_symbol_info (symbol
, ret
);
893 bfd_mach_o_print_symbol (bfd
*abfd
,
896 bfd_print_symbol_type how
)
898 FILE *file
= (FILE *) afile
;
900 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
904 case bfd_print_symbol_name
:
905 fprintf (file
, "%s", symbol
->name
);
908 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
909 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
910 name
= bfd_get_stab_name (asym
->n_type
);
912 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
914 case BFD_MACH_O_N_UNDF
:
915 if (symbol
->value
== 0)
920 case BFD_MACH_O_N_ABS
:
923 case BFD_MACH_O_N_INDR
:
926 case BFD_MACH_O_N_PBUD
:
929 case BFD_MACH_O_N_SECT
:
938 fprintf (file
, " %02x %-6s %02x %04x",
939 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
940 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
941 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
942 fprintf (file
, " [%s]", symbol
->section
->name
);
943 fprintf (file
, " %s", symbol
->name
);
948 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
949 bfd_mach_o_cpu_subtype msubtype
,
950 enum bfd_architecture
*type
,
951 unsigned long *subtype
)
953 *subtype
= bfd_arch_unknown
;
957 case BFD_MACH_O_CPU_TYPE_VAX
:
958 *type
= bfd_arch_vax
;
960 case BFD_MACH_O_CPU_TYPE_MC680x0
:
961 *type
= bfd_arch_m68k
;
963 case BFD_MACH_O_CPU_TYPE_I386
:
964 *type
= bfd_arch_i386
;
965 *subtype
= bfd_mach_i386_i386
;
967 case BFD_MACH_O_CPU_TYPE_X86_64
:
968 *type
= bfd_arch_i386
;
969 *subtype
= bfd_mach_x86_64
;
971 case BFD_MACH_O_CPU_TYPE_MIPS
:
972 *type
= bfd_arch_mips
;
974 case BFD_MACH_O_CPU_TYPE_MC98000
:
975 *type
= bfd_arch_m98k
;
977 case BFD_MACH_O_CPU_TYPE_HPPA
:
978 *type
= bfd_arch_hppa
;
980 case BFD_MACH_O_CPU_TYPE_ARM
:
981 *type
= bfd_arch_arm
;
984 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
985 *subtype
= bfd_mach_arm_4T
;
987 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
988 *subtype
= bfd_mach_arm_4T
; /* Best fit ? */
990 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
991 *subtype
= bfd_mach_arm_5TE
;
993 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
994 *subtype
= bfd_mach_arm_XScale
;
996 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
997 *subtype
= bfd_mach_arm_5TE
; /* Best fit ? */
999 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
1004 case BFD_MACH_O_CPU_TYPE_MC88000
:
1005 *type
= bfd_arch_m88k
;
1007 case BFD_MACH_O_CPU_TYPE_SPARC
:
1008 *type
= bfd_arch_sparc
;
1009 *subtype
= bfd_mach_sparc
;
1011 case BFD_MACH_O_CPU_TYPE_I860
:
1012 *type
= bfd_arch_i860
;
1014 case BFD_MACH_O_CPU_TYPE_ALPHA
:
1015 *type
= bfd_arch_alpha
;
1017 case BFD_MACH_O_CPU_TYPE_POWERPC
:
1018 *type
= bfd_arch_powerpc
;
1019 *subtype
= bfd_mach_ppc
;
1021 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
1022 *type
= bfd_arch_powerpc
;
1023 *subtype
= bfd_mach_ppc64
;
1025 case BFD_MACH_O_CPU_TYPE_ARM64
:
1026 *type
= bfd_arch_aarch64
;
1027 *subtype
= bfd_mach_aarch64
;
1030 *type
= bfd_arch_unknown
;
1035 /* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4. Return the
1036 number of bytes written or -1 in case of error. */
1039 bfd_mach_o_pad4 (bfd
*abfd
, unsigned int len
)
1043 char pad
[4] = {0,0,0,0};
1044 unsigned int padlen
= 4 - (len
% 4);
1046 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1055 /* Likewise, but for a command. */
1058 bfd_mach_o_pad_command (bfd
*abfd
, unsigned int len
)
1060 unsigned int align
= bfd_mach_o_wide_p (abfd
) ? 8 : 4;
1062 if (len
% align
!= 0)
1065 unsigned int padlen
= align
- (len
% align
);
1067 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1077 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1079 struct mach_o_header_external raw
;
1082 size
= mach_o_wide_p (header
) ?
1083 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1085 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
1086 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
1087 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
1088 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
1089 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
1090 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
1091 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
1093 if (mach_o_wide_p (header
))
1094 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
1096 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1097 || bfd_bwrite (&raw
, size
, abfd
) != size
)
1104 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1106 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
1108 struct mach_o_thread_command_external raw
;
1109 unsigned int offset
;
1111 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
1112 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
1114 offset
= BFD_MACH_O_LC_SIZE
;
1115 for (i
= 0; i
< cmd
->nflavours
; i
++)
1117 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
1118 BFD_ASSERT (cmd
->flavours
[i
].offset
==
1119 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
1121 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
1122 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
1124 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
1125 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1128 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
1135 bfd_mach_o_write_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1137 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
1138 struct mach_o_str_command_external raw
;
1139 unsigned int namelen
;
1141 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.str
);
1143 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1144 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1147 namelen
= strlen (cmd
->name_str
) + 1;
1148 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1151 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1158 bfd_mach_o_write_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1160 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
1161 struct mach_o_dylib_command_external raw
;
1162 unsigned int namelen
;
1164 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.name
);
1165 bfd_h_put_32 (abfd
, cmd
->timestamp
, raw
.timestamp
);
1166 bfd_h_put_32 (abfd
, cmd
->current_version
, raw
.current_version
);
1167 bfd_h_put_32 (abfd
, cmd
->compatibility_version
, raw
.compatibility_version
);
1169 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1170 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1173 namelen
= strlen (cmd
->name_str
) + 1;
1174 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1177 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1184 bfd_mach_o_write_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1186 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
1187 struct mach_o_entry_point_command_external raw
;
1189 bfd_h_put_64 (abfd
, cmd
->entryoff
, raw
.entryoff
);
1190 bfd_h_put_64 (abfd
, cmd
->stacksize
, raw
.stacksize
);
1192 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1193 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1200 bfd_mach_o_write_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1202 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
1203 struct mach_o_dyld_info_command_external raw
;
1205 bfd_h_put_32 (abfd
, cmd
->rebase_off
, raw
.rebase_off
);
1206 bfd_h_put_32 (abfd
, cmd
->rebase_size
, raw
.rebase_size
);
1207 bfd_h_put_32 (abfd
, cmd
->bind_off
, raw
.bind_off
);
1208 bfd_h_put_32 (abfd
, cmd
->bind_size
, raw
.bind_size
);
1209 bfd_h_put_32 (abfd
, cmd
->weak_bind_off
, raw
.weak_bind_off
);
1210 bfd_h_put_32 (abfd
, cmd
->weak_bind_size
, raw
.weak_bind_size
);
1211 bfd_h_put_32 (abfd
, cmd
->lazy_bind_off
, raw
.lazy_bind_off
);
1212 bfd_h_put_32 (abfd
, cmd
->lazy_bind_size
, raw
.lazy_bind_size
);
1213 bfd_h_put_32 (abfd
, cmd
->export_off
, raw
.export_off
);
1214 bfd_h_put_32 (abfd
, cmd
->export_size
, raw
.export_size
);
1216 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1217 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1220 if (cmd
->rebase_size
!= 0)
1221 if (bfd_seek (abfd
, cmd
->rebase_off
, SEEK_SET
) != 0
1222 || (bfd_bwrite (cmd
->rebase_content
, cmd
->rebase_size
, abfd
) !=
1226 if (cmd
->bind_size
!= 0)
1227 if (bfd_seek (abfd
, cmd
->bind_off
, SEEK_SET
) != 0
1228 || (bfd_bwrite (cmd
->bind_content
, cmd
->bind_size
, abfd
) !=
1232 if (cmd
->weak_bind_size
!= 0)
1233 if (bfd_seek (abfd
, cmd
->weak_bind_off
, SEEK_SET
) != 0
1234 || (bfd_bwrite (cmd
->weak_bind_content
, cmd
->weak_bind_size
, abfd
) !=
1235 cmd
->weak_bind_size
))
1238 if (cmd
->lazy_bind_size
!= 0)
1239 if (bfd_seek (abfd
, cmd
->lazy_bind_off
, SEEK_SET
) != 0
1240 || (bfd_bwrite (cmd
->lazy_bind_content
, cmd
->lazy_bind_size
, abfd
) !=
1241 cmd
->lazy_bind_size
))
1244 if (cmd
->export_size
!= 0)
1245 if (bfd_seek (abfd
, cmd
->export_off
, SEEK_SET
) != 0
1246 || (bfd_bwrite (cmd
->export_content
, cmd
->export_size
, abfd
) !=
1254 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
1257 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1260 /* In addition to the need to byte-swap the symbol number, the bit positions
1261 of the fields in the relocation information vary per target endian-ness. */
1264 bfd_mach_o_swap_in_non_scattered_reloc (bfd
*abfd
, bfd_mach_o_reloc_info
*rel
,
1265 unsigned char *fields
)
1267 unsigned char info
= fields
[3];
1269 if (bfd_big_endian (abfd
))
1271 rel
->r_value
= (fields
[0] << 16) | (fields
[1] << 8) | fields
[2];
1272 rel
->r_type
= (info
>> BFD_MACH_O_BE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1273 rel
->r_pcrel
= (info
& BFD_MACH_O_BE_PCREL
) ? 1 : 0;
1274 rel
->r_length
= (info
>> BFD_MACH_O_BE_LENGTH_SHIFT
)
1275 & BFD_MACH_O_LENGTH_MASK
;
1276 rel
->r_extern
= (info
& BFD_MACH_O_BE_EXTERN
) ? 1 : 0;
1280 rel
->r_value
= (fields
[2] << 16) | (fields
[1] << 8) | fields
[0];
1281 rel
->r_type
= (info
>> BFD_MACH_O_LE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1282 rel
->r_pcrel
= (info
& BFD_MACH_O_LE_PCREL
) ? 1 : 0;
1283 rel
->r_length
= (info
>> BFD_MACH_O_LE_LENGTH_SHIFT
)
1284 & BFD_MACH_O_LENGTH_MASK
;
1285 rel
->r_extern
= (info
& BFD_MACH_O_LE_EXTERN
) ? 1 : 0;
1290 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
1291 struct mach_o_reloc_info_external
*raw
,
1292 arelent
*res
, asymbol
**syms
)
1294 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1295 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1296 bfd_mach_o_reloc_info reloc
;
1300 addr
= bfd_get_32 (abfd
, raw
->r_address
);
1301 res
->sym_ptr_ptr
= NULL
;
1304 if (addr
& BFD_MACH_O_SR_SCATTERED
)
1307 bfd_vma symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
1309 /* Scattered relocation, can't be extern. */
1310 reloc
.r_scattered
= 1;
1313 /* Extract section and offset from r_value (symnum). */
1314 reloc
.r_value
= symnum
;
1315 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1316 end of the data for the section (e.g. in a calculation of section
1317 data length). At present, the symbol will end up associated with
1318 the following section or, if it falls within alignment padding, as
1319 null - which will assert later. */
1320 for (j
= 0; j
< mdata
->nsects
; j
++)
1322 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
1323 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
1325 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
1326 res
->addend
= symnum
- sect
->addr
;
1331 /* Extract the info and address fields from r_address. */
1332 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
1333 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
1334 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
1335 reloc
.r_address
= BFD_MACH_O_GET_SR_TYPE (addr
);
1336 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
1342 /* Non-scattered relocation. */
1343 reloc
.r_scattered
= 0;
1345 /* The value and info fields have to be extracted dependent on target
1347 bfd_mach_o_swap_in_non_scattered_reloc (abfd
, &reloc
, raw
->r_symbolnum
);
1348 num
= reloc
.r_value
;
1352 /* An external symbol number. */
1355 else if (num
== 0x00ffffff || num
== 0)
1357 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1358 is generic code, we don't know wether this is really a PAIR.
1359 This value is almost certainly not a valid section number, hence
1360 this specific case to avoid an assertion failure.
1361 Target specific swap_reloc_in routine should adjust that. */
1362 sym
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1366 /* PR 17512: file: 006-2964-0.004. */
1367 if (num
>= mdata
->nsects
)
1370 /* A section number. */
1371 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1372 /* For a symbol defined in section S, the addend (stored in the
1373 binary) contains the address of the section. To comply with
1374 bfd convention, subtract the section address.
1375 Use the address from the header, so that the user can modify
1376 the vma of the section. */
1377 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1379 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1380 in the lower 16bits of the address value. So we have to find the
1381 'symbol' from the preceding reloc. We do this even though the
1382 section symbol is probably not needed here, because NULL symbol
1383 values cause an assert in generic BFD code. This must be done in
1384 the PPC swap_reloc_in routine. */
1385 res
->sym_ptr_ptr
= sym
;
1387 /* The 'address' is just r_address.
1388 ??? maybe this should be masked with 0xffffff for safety. */
1389 res
->address
= addr
;
1390 reloc
.r_address
= addr
;
1393 /* We have set up a reloc with all the information present, so the swapper
1394 can modify address, value and addend fields, if necessary, to convey
1395 information in the generic BFD reloc that is mach-o specific. */
1397 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
1403 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1404 unsigned long count
,
1405 arelent
*res
, asymbol
**syms
)
1408 struct mach_o_reloc_info_external
*native_relocs
;
1409 bfd_size_type native_size
;
1411 /* Allocate and read relocs. */
1412 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1414 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1415 if (native_relocs
== NULL
)
1418 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1419 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1422 for (i
= 0; i
< count
; i
++)
1424 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
1428 free (native_relocs
);
1431 free (native_relocs
);
1436 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1437 arelent
**rels
, asymbol
**syms
)
1439 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1443 if (asect
->reloc_count
== 0)
1446 /* No need to go further if we don't know how to read relocs. */
1447 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1450 if (asect
->relocation
== NULL
)
1452 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1456 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1457 asect
->reloc_count
, res
, syms
) < 0)
1462 asect
->relocation
= res
;
1465 res
= asect
->relocation
;
1466 for (i
= 0; i
< asect
->reloc_count
; i
++)
1474 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1476 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1478 if (mdata
->dysymtab
== NULL
)
1480 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1481 * sizeof (arelent
*);
1485 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1486 struct bfd_symbol
**syms
)
1488 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1489 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1490 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1494 if (dysymtab
== NULL
)
1496 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1499 /* No need to go further if we don't know how to read relocs. */
1500 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1503 if (mdata
->dyn_reloc_cache
== NULL
)
1505 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1506 * sizeof (arelent
));
1510 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1511 dysymtab
->nextrel
, res
, syms
) < 0)
1517 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1519 res
+ dysymtab
->nextrel
, syms
) < 0)
1525 mdata
->dyn_reloc_cache
= res
;
1528 res
= mdata
->dyn_reloc_cache
;
1529 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1535 /* In addition to the need to byte-swap the symbol number, the bit positions
1536 of the fields in the relocation information vary per target endian-ness. */
1539 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1540 bfd_mach_o_reloc_info
*rel
)
1542 unsigned char info
= 0;
1544 BFD_ASSERT (rel
->r_type
<= 15);
1545 BFD_ASSERT (rel
->r_length
<= 3);
1547 if (bfd_big_endian (abfd
))
1549 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1550 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1551 fields
[2] = rel
->r_value
& 0xff;
1552 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1553 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1554 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1555 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1559 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1560 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1561 fields
[0] = rel
->r_value
& 0xff;
1562 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1563 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1564 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1565 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1571 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1576 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1578 sec
= section
->bfdsection
;
1579 if (sec
->reloc_count
== 0)
1582 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1585 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1588 /* Convert and write. */
1589 entries
= section
->bfdsection
->orelocation
;
1590 for (i
= 0; i
< section
->nreloc
; i
++)
1592 arelent
*rel
= entries
[i
];
1593 struct mach_o_reloc_info_external raw
;
1594 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1596 /* Convert relocation to an intermediate representation. */
1597 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1600 /* Lower the relocation info. */
1601 if (pinfo
->r_scattered
)
1605 v
= BFD_MACH_O_SR_SCATTERED
1606 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1607 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1608 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1609 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1610 /* Note: scattered relocs have field in reverse order... */
1611 bfd_put_32 (abfd
, v
, raw
.r_address
);
1612 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1616 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1617 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1621 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1622 != BFD_MACH_O_RELENT_SIZE
)
1629 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1631 struct mach_o_section_32_external raw
;
1633 memcpy (raw
.sectname
, section
->sectname
, 16);
1634 memcpy (raw
.segname
, section
->segname
, 16);
1635 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1636 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1637 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1638 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1639 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1640 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1641 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1642 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1643 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1645 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1646 != BFD_MACH_O_SECTION_SIZE
)
1653 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1655 struct mach_o_section_64_external raw
;
1657 memcpy (raw
.sectname
, section
->sectname
, 16);
1658 memcpy (raw
.segname
, section
->segname
, 16);
1659 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1660 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1661 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1662 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1663 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1664 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1665 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1666 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1667 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1668 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1670 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1671 != BFD_MACH_O_SECTION_64_SIZE
)
1678 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1680 struct mach_o_segment_command_32_external raw
;
1681 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1682 bfd_mach_o_section
*sec
;
1684 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1686 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1687 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1690 memcpy (raw
.segname
, seg
->segname
, 16);
1691 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1692 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1693 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1694 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1695 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1696 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1697 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1698 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1700 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1701 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1704 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1705 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1712 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1714 struct mach_o_segment_command_64_external raw
;
1715 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1716 bfd_mach_o_section
*sec
;
1718 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1720 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1721 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1724 memcpy (raw
.segname
, seg
->segname
, 16);
1725 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1726 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1727 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1728 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1729 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1730 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1731 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1732 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1734 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1735 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1738 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1739 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1746 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1748 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1750 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1751 struct bfd_strtab_hash
*strtab
;
1752 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1755 /* Write the symbols first. */
1756 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1759 strtab
= _bfd_stringtab_init ();
1764 /* Although we don't strictly need to do this, for compatibility with
1765 Darwin system tools, actually output an empty string for the index
1767 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1769 for (i
= 0; i
< sym
->nsyms
; i
++)
1771 bfd_size_type str_index
;
1772 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1774 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1775 /* An index of 0 always means the empty string. */
1779 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1781 if (str_index
== (bfd_size_type
) -1)
1787 struct mach_o_nlist_64_external raw
;
1789 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1790 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1791 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1792 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1793 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1796 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1801 struct mach_o_nlist_external raw
;
1803 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1804 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1805 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1806 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1807 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1810 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1814 sym
->strsize
= _bfd_stringtab_size (strtab
);
1815 sym
->stroff
= mdata
->filelen
;
1816 mdata
->filelen
+= sym
->strsize
;
1818 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
1821 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1823 _bfd_stringtab_free (strtab
);
1825 /* Pad string table. */
1826 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
1829 mdata
->filelen
+= padlen
;
1830 sym
->strsize
+= padlen
;
1835 _bfd_stringtab_free (strtab
);
1840 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1842 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1843 struct mach_o_symtab_command_external raw
;
1845 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1848 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1849 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1850 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1851 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1853 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1854 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1860 /* Count the number of indirect symbols in the image.
1861 Requires that the sections are in their final order. */
1864 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1867 unsigned int nisyms
= 0;
1869 for (i
= 0; i
< mdata
->nsects
; ++i
)
1871 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1873 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1875 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1876 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1877 case BFD_MACH_O_S_SYMBOL_STUBS
:
1878 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
1887 /* Create the dysymtab. */
1890 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
1892 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1895 We are not going to try and fill these in yet and, moreover, we are
1896 going to bail if they are already set. */
1897 if (cmd
->nmodtab
!= 0
1899 || cmd
->nextrefsyms
!= 0)
1901 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
1902 " implemented for dysymtab commands."));
1908 if (bfd_get_symcount (abfd
) > 0)
1910 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1913 /* Count the number of each kind of symbol. */
1914 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1916 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1917 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
1921 cmd
->iextdefsym
= i
;
1922 for (; i
< bfd_get_symcount (abfd
); ++i
)
1924 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1925 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
1928 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
1929 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
1930 cmd
->nundefsym
= bfd_get_symcount (abfd
)
1937 cmd
->iextdefsym
= 0;
1938 cmd
->nextdefsym
= 0;
1943 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
1944 if (cmd
->nindirectsyms
> 0)
1949 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
1950 cmd
->indirectsymoff
= mdata
->filelen
;
1951 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
1953 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
1954 if (cmd
->indirect_syms
== NULL
)
1958 for (i
= 0; i
< mdata
->nsects
; ++i
)
1960 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1962 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1964 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1965 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1966 case BFD_MACH_O_S_SYMBOL_STUBS
:
1969 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
1971 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
1972 if (isyms
== NULL
|| num
== 0)
1974 /* Record the starting index in the reserved1 field. */
1976 for (j
= 0; j
< num
; j
++, n
++)
1978 if (isyms
[j
] == NULL
)
1979 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
1980 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
1981 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
1982 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
1983 | BFD_MACH_O_INDIRECT_SYM_ABS
;
1985 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
1998 /* Write a dysymtab command.
1999 TODO: Possibly coalesce writes of smaller objects. */
2002 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2004 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2006 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2008 if (cmd
->nmodtab
!= 0)
2012 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2015 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2017 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2021 iinit
= module
->iinit
& 0xffff;
2022 iinit
|= ((module
->iterm
& 0xffff) << 16);
2024 ninit
= module
->ninit
& 0xffff;
2025 ninit
|= ((module
->nterm
& 0xffff) << 16);
2027 if (bfd_mach_o_wide_p (abfd
))
2029 struct mach_o_dylib_module_64_external w
;
2031 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2032 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2033 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2034 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2035 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2036 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2037 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2038 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2039 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2040 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2041 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2042 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2043 &w
.objc_module_info_addr
);
2044 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2045 &w
.objc_module_info_size
);
2047 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2052 struct mach_o_dylib_module_external n
;
2054 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2055 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2056 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2057 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2058 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2059 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2060 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2061 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2062 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2063 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2064 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2065 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2066 &n
.objc_module_info_addr
);
2067 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2068 &n
.objc_module_info_size
);
2070 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2080 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2083 for (i
= 0; i
< cmd
->ntoc
; i
++)
2085 struct mach_o_dylib_table_of_contents_external raw
;
2086 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2088 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2089 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2091 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2096 if (cmd
->nindirectsyms
> 0)
2100 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2103 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2105 unsigned char raw
[4];
2107 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2108 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2113 if (cmd
->nextrefsyms
!= 0)
2117 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2120 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2123 unsigned char raw
[4];
2124 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2126 /* Fields isym and flags are written as bit-fields, thus we need
2127 a specific processing for endianness. */
2129 if (bfd_big_endian (abfd
))
2131 v
= ((ref
->isym
& 0xffffff) << 8);
2132 v
|= ref
->flags
& 0xff;
2136 v
= ref
->isym
& 0xffffff;
2137 v
|= ((ref
->flags
& 0xff) << 24);
2140 bfd_h_put_32 (abfd
, v
, raw
);
2141 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2147 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2151 struct mach_o_dysymtab_command_external raw
;
2153 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2154 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2155 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2156 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2157 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2158 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2159 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2160 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2161 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2162 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2163 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2164 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2165 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2166 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2167 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2168 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2169 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2170 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2172 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2180 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2182 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2184 /* Just leave debug symbols where they are (pretend they are local, and
2185 then they will just be sorted on position). */
2186 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2189 /* Local (we should never see an undefined local AFAICT). */
2190 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2193 /* Common symbols look like undefined externs. */
2194 if (mtyp
== BFD_MACH_O_N_UNDF
)
2197 /* A defined non-local, non-debug symbol. */
2202 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2204 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2205 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2206 unsigned int soa
, sob
;
2208 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2209 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2216 /* If it's local or stab, just preserve the input order. */
2219 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2221 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2224 /* This is probably an error. */
2228 /* The second sort key is name. */
2229 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2232 /* Process the symbols.
2234 This should be OK for single-module files - but it is not likely to work
2235 for multi-module shared libraries.
2237 (a) If the application has not filled in the relevant mach-o fields, make
2240 (b) Order them, like this:
2243 ( ii) external defined
2245 (iii) external undefined/common
2252 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2255 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2257 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2260 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2262 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2264 /* We use this value, which is out-of-range as a symbol index, to signal
2265 that the mach-o-specific data are not filled in and need to be created
2266 from the bfd values. It is much preferable for the application to do
2267 this, since more meaningful diagnostics can be made that way. */
2269 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2271 /* No symbol information has been set - therefore determine
2272 it from the bfd symbol flags/info. */
2273 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2274 s
->n_type
= BFD_MACH_O_N_ABS
;
2275 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2277 s
->n_type
= BFD_MACH_O_N_UNDF
;
2278 if (s
->symbol
.flags
& BSF_WEAK
)
2279 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2280 /* mach-o automatically makes undefined symbols extern. */
2281 s
->n_type
|= BFD_MACH_O_N_EXT
;
2282 s
->symbol
.flags
|= BSF_GLOBAL
;
2284 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2286 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2287 s
->symbol
.flags
|= BSF_GLOBAL
;
2290 s
->n_type
= BFD_MACH_O_N_SECT
;
2292 if (s
->symbol
.flags
& BSF_GLOBAL
)
2293 s
->n_type
|= BFD_MACH_O_N_EXT
;
2296 /* Put the section index in, where required. */
2297 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2298 && s
->symbol
.section
!= bfd_und_section_ptr
2299 && s
->symbol
.section
!= bfd_com_section_ptr
)
2300 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2301 && s
->symbol
.name
== NULL
))
2302 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2304 /* Number to preserve order for local and debug syms. */
2305 s
->symbol
.udata
.i
= i
;
2308 /* Sort the symbols. */
2309 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2310 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2312 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2314 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2315 s
->symbol
.udata
.i
= i
; /* renumber. */
2321 /* We build a flat table of sections, which can be re-ordered if necessary.
2322 Fill in the section number and other mach-o-specific data. */
2325 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2328 unsigned target_index
;
2331 nsect
= bfd_count_sections (abfd
);
2333 /* Don't do it if it's already set - assume the application knows what it's
2335 if (mdata
->nsects
== nsect
2336 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2339 mdata
->nsects
= nsect
;
2340 mdata
->sections
= bfd_alloc (abfd
,
2341 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2342 if (mdata
->sections
== NULL
)
2345 /* We need to check that this can be done... */
2347 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%d)"
2348 " maximum is 255,\n"), nsect
);
2350 /* Create Mach-O sections.
2351 Section type, attribute and align should have been set when the
2352 section was created - either read in or specified. */
2354 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2356 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
2357 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2359 mdata
->sections
[target_index
] = msect
;
2361 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
2362 msect
->size
= bfd_get_section_size (sec
);
2364 /* Use the largest alignment set, in case it was bumped after the
2365 section was created. */
2366 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2369 sec
->target_index
= ++target_index
;
2376 bfd_mach_o_write_contents (bfd
*abfd
)
2378 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2379 bfd_mach_o_load_command
*cmd
;
2380 bfd_mach_o_symtab_command
*symtab
= NULL
;
2381 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2382 bfd_mach_o_segment_command
*linkedit
= NULL
;
2384 /* Make the commands, if not already present. */
2385 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2387 abfd
->output_has_begun
= TRUE
;
2389 /* Write the header. */
2390 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2393 /* First pass: allocate the linkedit segment. */
2394 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2397 case BFD_MACH_O_LC_SEGMENT_64
:
2398 case BFD_MACH_O_LC_SEGMENT
:
2399 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2400 linkedit
= &cmd
->command
.segment
;
2402 case BFD_MACH_O_LC_SYMTAB
:
2403 symtab
= &cmd
->command
.symtab
;
2405 case BFD_MACH_O_LC_DYSYMTAB
:
2406 dysymtab
= &cmd
->command
.dysymtab
;
2408 case BFD_MACH_O_LC_DYLD_INFO
:
2410 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2412 if (di
->rebase_size
!= 0)
2414 di
->rebase_off
= mdata
->filelen
;
2415 mdata
->filelen
+= di
->rebase_size
;
2417 if (di
->bind_size
!= 0)
2419 di
->bind_off
= mdata
->filelen
;
2420 mdata
->filelen
+= di
->bind_size
;
2422 if (di
->weak_bind_size
!= 0)
2424 di
->weak_bind_off
= mdata
->filelen
;
2425 mdata
->filelen
+= di
->weak_bind_size
;
2427 if (di
->lazy_bind_size
!= 0)
2429 di
->lazy_bind_off
= mdata
->filelen
;
2430 mdata
->filelen
+= di
->lazy_bind_size
;
2432 if (di
->export_size
!= 0)
2434 di
->export_off
= mdata
->filelen
;
2435 mdata
->filelen
+= di
->export_size
;
2439 case BFD_MACH_O_LC_LOAD_DYLIB
:
2440 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2441 case BFD_MACH_O_LC_MAIN
:
2442 /* Nothing to do. */
2445 (*_bfd_error_handler
)
2446 (_("unable to allocate data for load command 0x%lx"),
2447 (unsigned long) cmd
->type
);
2451 /* Specially handle symtab and dysymtab. */
2453 /* Pre-allocate the symbol table (but not the string table). The reason
2454 is that the dysymtab is after the symbol table but before the string
2455 table (required by the native strip tool). */
2458 unsigned int symlen
;
2459 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2461 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2463 /* Align for symbols. */
2464 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2465 symtab
->symoff
= mdata
->filelen
;
2467 symtab
->nsyms
= bfd_get_symcount (abfd
);
2468 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2471 /* Build the dysymtab. */
2472 if (dysymtab
!= NULL
)
2473 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2476 /* Write symtab and strtab. */
2478 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2481 /* Adjust linkedit size. */
2482 if (linkedit
!= NULL
)
2484 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2486 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2487 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2488 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2490 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2491 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2492 | BFD_MACH_O_PROT_EXECUTE
;
2495 /* Second pass: write commands. */
2496 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2498 struct mach_o_load_command_external raw
;
2499 unsigned long typeflag
;
2501 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2503 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2504 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2506 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2507 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2512 case BFD_MACH_O_LC_SEGMENT
:
2513 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2516 case BFD_MACH_O_LC_SEGMENT_64
:
2517 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2520 case BFD_MACH_O_LC_SYMTAB
:
2521 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2524 case BFD_MACH_O_LC_DYSYMTAB
:
2525 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2528 case BFD_MACH_O_LC_THREAD
:
2529 case BFD_MACH_O_LC_UNIXTHREAD
:
2530 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2533 case BFD_MACH_O_LC_LOAD_DYLIB
:
2534 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2537 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2538 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2541 case BFD_MACH_O_LC_MAIN
:
2542 if (!bfd_mach_o_write_main (abfd
, cmd
))
2545 case BFD_MACH_O_LC_DYLD_INFO
:
2546 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2550 (*_bfd_error_handler
)
2551 (_("unable to write unknown load command 0x%lx"),
2552 (unsigned long) cmd
->type
);
2561 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2562 bfd_mach_o_section
*s
)
2564 if (seg
->sect_head
== NULL
)
2567 seg
->sect_tail
->next
= s
;
2571 /* Create section Mach-O flags from BFD flags. */
2574 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2578 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2580 /* Create default flags. */
2581 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2582 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2583 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2584 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2585 | BFD_MACH_O_S_REGULAR
;
2586 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2587 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2588 else if (bfd_flags
& SEC_DEBUGGING
)
2589 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2591 s
->flags
= BFD_MACH_O_S_REGULAR
;
2595 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2597 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2601 seg
->fileoff
= mdata
->filelen
;
2602 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2603 | BFD_MACH_O_PROT_EXECUTE
;
2604 seg
->maxprot
= seg
->initprot
;
2606 /* Append sections to the segment.
2608 This is a little tedious, we have to honor the need to account zerofill
2609 sections after all the rest. This forces us to do the calculation of
2610 total vmsize in three passes so that any alignment increments are
2611 properly accounted. */
2612 for (i
= 0; i
< mdata
->nsects
; ++i
)
2614 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2615 asection
*sec
= s
->bfdsection
;
2617 /* Although we account for zerofill section sizes in vm order, they are
2618 placed in the file in source sequence. */
2619 bfd_mach_o_append_section_to_segment (seg
, s
);
2622 /* Zerofill sections have zero file size & offset, the only content
2623 written to the file is the symbols. */
2624 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2625 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2626 == BFD_MACH_O_S_GB_ZEROFILL
))
2629 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2630 sections, even those with zero size. */
2633 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2634 seg
->vmsize
+= s
->size
;
2636 /* MH_OBJECT files have unaligned content. */
2639 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2640 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2642 seg
->filesize
+= s
->size
;
2644 /* The system tools write even zero-sized sections with an offset
2645 field set to the current file position. */
2646 s
->offset
= mdata
->filelen
;
2649 sec
->filepos
= s
->offset
;
2650 mdata
->filelen
+= s
->size
;
2653 /* Now pass through again, for zerofill, only now we just update the
2654 vmsize, and then for zerofill_GB. */
2655 for (j
= 0; j
< 2; j
++)
2660 stype
= BFD_MACH_O_S_ZEROFILL
;
2662 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2664 for (i
= 0; i
< mdata
->nsects
; ++i
)
2666 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2668 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2673 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2674 seg
->vmsize
+= s
->size
;
2679 /* Allocate space for the relocations. */
2680 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2682 for (i
= 0; i
< mdata
->nsects
; ++i
)
2684 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2685 asection
*sec
= ms
->bfdsection
;
2687 ms
->nreloc
= sec
->reloc_count
;
2688 if (ms
->nreloc
== 0)
2690 /* Clear nreloc and reloff if there is no relocs. */
2694 sec
->rel_filepos
= mdata
->filelen
;
2695 ms
->reloff
= sec
->rel_filepos
;
2696 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2703 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2705 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2707 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2709 bfd_mach_o_section
*s
;
2713 seg
->fileoff
= mdata
->filelen
;
2718 /* Append sections to the segment. We assume they are properly ordered
2719 by vma (but we check that). */
2721 for (i
= 0; i
< mdata
->nsects
; ++i
)
2723 s
= mdata
->sections
[i
];
2725 /* Consider only sections for this segment. */
2726 if (strcmp (seg
->segname
, s
->segname
) != 0)
2729 bfd_mach_o_append_section_to_segment (seg
, s
);
2731 BFD_ASSERT (s
->addr
>= vma
);
2732 vma
= s
->addr
+ s
->size
;
2735 /* Set segment file offset: make it page aligned. */
2736 vma
= seg
->sect_head
->addr
;
2737 seg
->vmaddr
= vma
& ~pagemask
;
2738 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2739 mdata
->filelen
+= pagemask
+ 1;
2740 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2741 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2743 /* Set section file offset. */
2744 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2746 asection
*sec
= s
->bfdsection
;
2747 flagword flags
= bfd_get_section_flags (abfd
, sec
);
2749 /* Adjust segment size. */
2750 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2751 seg
->vmsize
+= s
->size
;
2753 /* File offset and length. */
2754 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2756 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
2757 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2758 != BFD_MACH_O_S_GB_ZEROFILL
))
2760 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2762 s
->offset
= mdata
->filelen
;
2763 s
->bfdsection
->filepos
= s
->offset
;
2765 seg
->filesize
+= s
->size
;
2766 mdata
->filelen
+= s
->size
;
2771 s
->bfdsection
->filepos
= 0;
2774 /* Set protection. */
2775 if (flags
& SEC_LOAD
)
2777 if (flags
& SEC_CODE
)
2778 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
2779 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
2780 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
2783 /* Relocs shouldn't appear in non-object files. */
2784 if (s
->bfdsection
->reloc_count
!= 0)
2789 if (seg
->initprot
!= 0)
2790 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2791 | BFD_MACH_O_PROT_EXECUTE
;
2795 /* Round segment size (and file size). */
2796 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
2797 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
2798 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
2803 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2804 fields in header. */
2807 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
2809 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2810 unsigned int hdrlen
;
2812 bfd_mach_o_load_command
*cmd
;
2815 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2816 align
= wide
? 8 - 1 : 4 - 1;
2818 mdata
->header
.ncmds
= 0;
2820 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
2822 mdata
->header
.ncmds
++;
2823 cmd
->offset
= offset
;
2827 case BFD_MACH_O_LC_SEGMENT_64
:
2828 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2829 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
2831 case BFD_MACH_O_LC_SEGMENT
:
2832 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2833 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
2835 case BFD_MACH_O_LC_SYMTAB
:
2836 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2837 + BFD_MACH_O_LC_SIZE
;
2839 case BFD_MACH_O_LC_DYSYMTAB
:
2840 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2841 + BFD_MACH_O_LC_SIZE
;
2843 case BFD_MACH_O_LC_LOAD_DYLIB
:
2844 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
2845 + BFD_MACH_O_LC_SIZE
;
2846 cmd
->command
.dylib
.name_offset
= cmd
->len
;
2847 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
2848 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2850 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2851 cmd
->len
= sizeof (struct mach_o_str_command_external
)
2852 + BFD_MACH_O_LC_SIZE
;
2853 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
2854 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
2855 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2857 case BFD_MACH_O_LC_MAIN
:
2858 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
2859 + BFD_MACH_O_LC_SIZE
;
2861 case BFD_MACH_O_LC_DYLD_INFO
:
2862 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
2863 + BFD_MACH_O_LC_SIZE
;
2866 (*_bfd_error_handler
)
2867 (_("unable to layout unknown load command 0x%lx"),
2868 (unsigned long) cmd
->type
);
2872 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
2875 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
2876 mdata
->filelen
= offset
;
2879 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2883 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
2884 bfd_mach_o_load_command
*cmd
,
2885 const char *segname
, unsigned int nbr_sect
)
2887 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2888 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2890 /* Init segment command. */
2891 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
2892 cmd
->type_required
= FALSE
;
2894 strcpy (seg
->segname
, segname
);
2895 seg
->nsects
= nbr_sect
;
2905 seg
->sect_head
= NULL
;
2906 seg
->sect_tail
= NULL
;
2909 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2910 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2911 and copy functionality. */
2914 bfd_mach_o_build_commands (bfd
*abfd
)
2916 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2917 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2918 unsigned int nbr_segcmd
= 0;
2919 bfd_mach_o_load_command
*commands
;
2920 unsigned int nbr_commands
;
2921 int symtab_idx
= -1;
2922 int dysymtab_idx
= -1;
2926 /* Return now if already built. */
2927 if (mdata
->header
.ncmds
!= 0)
2930 /* Fill in the file type, if not already set. */
2931 if (mdata
->header
.filetype
== 0)
2933 if (abfd
->flags
& EXEC_P
)
2934 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2935 else if (abfd
->flags
& DYNAMIC
)
2936 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2938 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2941 /* If hasn't already been done, flatten sections list, and sort
2942 if/when required. Must be done before the symbol table is adjusted,
2943 since that depends on properly numbered sections. */
2944 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2945 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2948 /* Order the symbol table, fill-in/check mach-o specific fields and
2949 partition out any indirect symbols. */
2950 if (!bfd_mach_o_mangle_symbols (abfd
))
2953 /* Segment commands. */
2954 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
2956 /* Only one segment for all the sections. But the segment is
2957 optional if there is no sections. */
2958 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
2962 bfd_mach_o_section
*prev_sect
= NULL
;
2964 /* One pagezero segment and one linkedit segment. */
2967 /* Create one segment for associated segment name in sections.
2968 Assume that sections with the same segment name are consecutive. */
2969 for (i
= 0; i
< mdata
->nsects
; i
++)
2971 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
2973 if (prev_sect
== NULL
2974 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
2977 prev_sect
= this_sect
;
2982 nbr_commands
= nbr_segcmd
;
2984 /* One command for the symbol table (only if there are symbols. */
2985 if (bfd_get_symcount (abfd
) > 0)
2986 symtab_idx
= nbr_commands
++;
2989 This is a rather crude test for whether we should build a dysymtab. */
2990 if (bfd_mach_o_should_emit_dysymtab ()
2991 && bfd_get_symcount (abfd
))
2993 /* If there should be a case where a dysymtab could be emitted without
2994 a symtab (seems improbable), this would need amending. */
2995 dysymtab_idx
= nbr_commands
++;
2998 /* Add an entry point command. */
2999 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3000 && bfd_get_start_address (abfd
) != 0)
3001 main_idx
= nbr_commands
++;
3003 /* Well, we must have a header, at least. */
3004 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3006 /* A bit unusual, but no content is valid;
3007 as -n empty.s -o empty.o */
3008 if (nbr_commands
== 0)
3010 /* Layout commands (well none...) and set headers command fields. */
3011 bfd_mach_o_layout_commands (mdata
);
3015 /* Create commands for segments (and symtabs), prepend them. */
3016 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3017 if (commands
== NULL
)
3019 for (i
= 0; i
< nbr_commands
- 1; i
++)
3020 commands
[i
].next
= &commands
[i
+ 1];
3021 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3022 if (mdata
->first_command
== NULL
)
3023 mdata
->last_command
= &commands
[nbr_commands
- 1];
3024 mdata
->first_command
= &commands
[0];
3026 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3028 /* For object file, there is only one segment. */
3029 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3031 else if (nbr_segcmd
!= 0)
3033 bfd_mach_o_load_command
*cmd
;
3035 BFD_ASSERT (nbr_segcmd
>= 2);
3039 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3041 /* Segments from sections. */
3043 for (i
= 0; i
< mdata
->nsects
;)
3045 const char *segname
= mdata
->sections
[i
]->segname
;
3046 unsigned int nbr_sect
= 1;
3048 /* Count number of sections for this segment. */
3049 for (i
++; i
< mdata
->nsects
; i
++)
3050 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3055 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3060 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3063 if (symtab_idx
>= 0)
3065 /* Init symtab command. */
3066 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3068 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3069 cmd
->type_required
= FALSE
;
3072 /* If required, setup symtab command, see comment above about the quality
3074 if (dysymtab_idx
>= 0)
3076 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3078 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3079 cmd
->type_required
= FALSE
;
3082 /* Create the main command. */
3085 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3087 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3088 cmd
->type_required
= TRUE
;
3090 cmd
->command
.main
.entryoff
= 0;
3091 cmd
->command
.main
.stacksize
= 0;
3094 /* Layout commands. */
3095 bfd_mach_o_layout_commands (mdata
);
3097 /* So, now we have sized the commands and the filelen set to that.
3098 Now we can build the segment command and set the section file offsets. */
3099 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3101 for (i
= 0; i
< nbr_segcmd
; i
++)
3102 if (!bfd_mach_o_build_obj_seg_command
3103 (abfd
, &commands
[i
].command
.segment
))
3110 /* Skip pagezero and linkedit segments. */
3111 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3113 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3115 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3118 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3119 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3122 /* Set the size of __PAGEZERO. */
3123 commands
[0].command
.segment
.vmsize
=
3124 commands
[1].command
.segment
.vmaddr
;
3126 /* Set the vma and fileoff of __LINKEDIT. */
3127 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3128 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3130 /* Set entry point (once segments have been laid out). */
3132 commands
[main_idx
].command
.main
.entryoff
=
3133 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3139 /* Set the contents of a section. */
3142 bfd_mach_o_set_section_contents (bfd
*abfd
,
3144 const void * location
,
3146 bfd_size_type count
)
3150 /* Trying to write the first section contents will trigger the creation of
3151 the load commands if they are not already present. */
3152 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3158 pos
= section
->filepos
+ offset
;
3159 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3160 || bfd_bwrite (location
, count
, abfd
) != count
)
3167 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3168 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3173 /* Make an empty symbol. This is required only because
3174 bfd_make_section_anyway wants to create a symbol for the section. */
3177 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3179 asymbol
*new_symbol
;
3181 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3182 if (new_symbol
== NULL
)
3184 new_symbol
->the_bfd
= abfd
;
3185 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3190 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
3192 struct mach_o_header_external raw
;
3194 bfd_vma (*get32
) (const void *) = NULL
;
3196 /* Just read the magic number. */
3197 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3198 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3201 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3203 header
->byteorder
= BFD_ENDIAN_BIG
;
3204 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3205 header
->version
= 1;
3208 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3210 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3211 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3212 header
->version
= 1;
3215 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3217 header
->byteorder
= BFD_ENDIAN_BIG
;
3218 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3219 header
->version
= 2;
3222 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3224 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3225 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3226 header
->version
= 2;
3231 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3235 /* Once the size of the header is known, read the full header. */
3236 size
= mach_o_wide_p (header
) ?
3237 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3239 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3240 || bfd_bread (&raw
, size
, abfd
) != size
)
3243 header
->cputype
= (*get32
) (raw
.cputype
);
3244 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3245 header
->filetype
= (*get32
) (raw
.filetype
);
3246 header
->ncmds
= (*get32
) (raw
.ncmds
);
3247 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3248 header
->flags
= (*get32
) (raw
.flags
);
3250 if (mach_o_wide_p (header
))
3251 header
->reserved
= (*get32
) (raw
.reserved
);
3253 header
->reserved
= 0;
3259 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3261 bfd_mach_o_section
*s
;
3262 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
3264 s
= bfd_mach_o_get_mach_o_section (sec
);
3268 static const mach_o_section_name_xlat
* xlat
;
3270 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3273 sec
->used_by_bfd
= s
;
3274 s
->bfdsection
= sec
;
3276 /* Create the Darwin seg/sect name pair from the bfd name.
3277 If this is a canonical name for which a specific paiting exists
3278 there will also be defined flags, type, attribute and alignment
3280 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3283 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3284 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3286 (void) bfd_set_section_alignment (abfd
, sec
, s
->align
);
3287 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
3288 if (bfd_flags
== SEC_NO_FLAGS
)
3289 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
3292 /* Create default flags. */
3293 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3296 return _bfd_generic_new_section_hook (abfd
, sec
);
3300 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
3304 bfd_mach_o_section
*section
;
3306 flags
= bfd_get_section_flags (abfd
, sec
);
3307 section
= bfd_mach_o_get_mach_o_section (sec
);
3309 /* TODO: see if we should use the xlat system for doing this by
3310 preference and fall back to this for unknown sections. */
3312 if (flags
== SEC_NO_FLAGS
)
3314 /* Try to guess flags. */
3315 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3316 flags
= SEC_DEBUGGING
;
3320 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3321 != BFD_MACH_O_S_ZEROFILL
)
3324 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3326 if (prot
& BFD_MACH_O_PROT_WRITE
)
3328 else if (prot
& BFD_MACH_O_PROT_READ
)
3329 flags
|= SEC_READONLY
;
3335 if ((flags
& SEC_DEBUGGING
) == 0)
3339 if (section
->offset
!= 0)
3340 flags
|= SEC_HAS_CONTENTS
;
3341 if (section
->nreloc
!= 0)
3344 bfd_set_section_flags (abfd
, sec
, flags
);
3346 sec
->vma
= section
->addr
;
3347 sec
->lma
= section
->addr
;
3348 sec
->size
= section
->size
;
3349 sec
->filepos
= section
->offset
;
3350 sec
->alignment_power
= section
->align
;
3351 sec
->segment_mark
= 0;
3352 sec
->reloc_count
= section
->nreloc
;
3353 sec
->rel_filepos
= section
->reloff
;
3357 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3358 const unsigned char *segname
,
3359 const unsigned char *sectname
)
3364 bfd_mach_o_convert_section_name_to_bfd
3365 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3369 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3373 bfd_mach_o_read_section_32 (bfd
*abfd
,
3374 unsigned int offset
,
3377 struct mach_o_section_32_external raw
;
3379 bfd_mach_o_section
*section
;
3381 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3382 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3383 != BFD_MACH_O_SECTION_SIZE
))
3386 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3390 section
= bfd_mach_o_get_mach_o_section (sec
);
3391 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3392 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3393 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3394 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3395 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3396 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3397 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3398 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3399 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3400 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3401 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3402 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3403 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3404 section
->reserved3
= 0;
3406 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3412 bfd_mach_o_read_section_64 (bfd
*abfd
,
3413 unsigned int offset
,
3416 struct mach_o_section_64_external raw
;
3418 bfd_mach_o_section
*section
;
3420 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3421 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3422 != BFD_MACH_O_SECTION_64_SIZE
))
3425 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3429 section
= bfd_mach_o_get_mach_o_section (sec
);
3430 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3431 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3432 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3433 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3434 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3435 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3436 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3437 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3438 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3439 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3440 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3441 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3442 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3443 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3445 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3451 bfd_mach_o_read_section (bfd
*abfd
,
3452 unsigned int offset
,
3457 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
3459 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
3463 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3464 bfd_mach_o_symtab_command
*sym
,
3465 bfd_mach_o_asymbol
*s
,
3468 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3469 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3470 unsigned int symwidth
=
3471 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3472 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3473 struct mach_o_nlist_64_external raw
;
3474 unsigned char type
= -1;
3475 unsigned char section
= -1;
3477 symvalue value
= -1;
3478 unsigned long stroff
= -1;
3479 unsigned int symtype
= -1;
3481 BFD_ASSERT (sym
->strtab
!= NULL
);
3483 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3484 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3486 (*_bfd_error_handler
)
3487 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3488 symwidth
, (unsigned long) symoff
);
3492 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3493 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3494 symtype
= type
& BFD_MACH_O_N_TYPE
;
3495 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3496 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3498 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3500 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3502 if (stroff
>= sym
->strsize
)
3504 (*_bfd_error_handler
)
3505 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3506 (unsigned long) stroff
,
3507 (unsigned long) sym
->strsize
);
3511 s
->symbol
.the_bfd
= abfd
;
3512 s
->symbol
.name
= sym
->strtab
+ stroff
;
3513 s
->symbol
.value
= value
;
3514 s
->symbol
.flags
= 0x0;
3515 s
->symbol
.udata
.i
= i
;
3517 s
->n_sect
= section
;
3520 if (type
& BFD_MACH_O_N_STAB
)
3522 s
->symbol
.flags
|= BSF_DEBUGGING
;
3523 s
->symbol
.section
= bfd_und_section_ptr
;
3535 if ((section
> 0) && (section
<= mdata
->nsects
))
3537 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3539 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3546 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3547 s
->symbol
.flags
|= BSF_GLOBAL
;
3549 s
->symbol
.flags
|= BSF_LOCAL
;
3553 case BFD_MACH_O_N_UNDF
:
3554 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3555 && s
->symbol
.value
!= 0)
3557 /* A common symbol. */
3558 s
->symbol
.section
= bfd_com_section_ptr
;
3559 s
->symbol
.flags
= BSF_NO_FLAGS
;
3563 s
->symbol
.section
= bfd_und_section_ptr
;
3564 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3565 s
->symbol
.flags
|= BSF_WEAK
;
3568 case BFD_MACH_O_N_PBUD
:
3569 s
->symbol
.section
= bfd_und_section_ptr
;
3571 case BFD_MACH_O_N_ABS
:
3572 s
->symbol
.section
= bfd_abs_section_ptr
;
3574 case BFD_MACH_O_N_SECT
:
3575 if ((section
> 0) && (section
<= mdata
->nsects
))
3577 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3579 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3583 /* Mach-O uses 0 to mean "no section"; not an error. */
3586 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3587 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3588 s
->symbol
.name
, section
, mdata
->nsects
);
3590 s
->symbol
.section
= bfd_und_section_ptr
;
3593 case BFD_MACH_O_N_INDR
:
3594 /* FIXME: we don't follow the BFD convention as this indirect symbol
3595 won't be followed by the referenced one. This looks harmless
3596 unless we start using the linker. */
3597 s
->symbol
.flags
|= BSF_INDIRECT
;
3598 s
->symbol
.section
= bfd_ind_section_ptr
;
3599 s
->symbol
.value
= 0;
3602 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3603 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3604 s
->symbol
.name
, symtype
);
3605 s
->symbol
.section
= bfd_und_section_ptr
;
3614 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3616 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3617 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3619 /* Fail if there is no symtab. */
3623 /* Success if already loaded. */
3627 if (abfd
->flags
& BFD_IN_MEMORY
)
3629 struct bfd_in_memory
*b
;
3631 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3633 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3635 bfd_set_error (bfd_error_file_truncated
);
3638 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3642 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
3643 if (sym
->strtab
== NULL
)
3646 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
3647 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
3649 bfd_set_error (bfd_error_file_truncated
);
3658 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3660 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3661 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3664 if (sym
== NULL
|| sym
->symbols
)
3665 /* Return now if there are no symbols or if already loaded. */
3668 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
3670 if (sym
->symbols
== NULL
)
3672 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3676 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3678 sym
->symbols
= NULL
;
3682 for (i
= 0; i
< sym
->nsyms
; i
++)
3684 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3686 sym
->symbols
= NULL
;
3695 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3697 switch ((int) flavour
)
3699 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3700 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3701 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3702 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3703 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3704 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3705 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3706 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3707 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3708 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3709 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3710 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3711 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3712 default: return "UNKNOWN";
3717 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3719 switch ((int) flavour
)
3721 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3722 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3723 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3724 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3725 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3726 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3727 default: return "UNKNOWN";
3732 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3734 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
3735 struct mach_o_str_command_external raw
;
3736 unsigned int nameoff
;
3737 unsigned int namelen
;
3739 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3740 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3743 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
3745 cmd
->name_offset
= nameoff
;
3746 namelen
= command
->len
- nameoff
;
3747 nameoff
+= command
->offset
;
3748 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3749 if (cmd
->name_str
== NULL
)
3751 if (bfd_seek (abfd
, nameoff
, SEEK_SET
) != 0
3752 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3758 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3760 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3761 struct mach_o_dylib_command_external raw
;
3762 unsigned int nameoff
;
3763 unsigned int namelen
;
3765 switch (command
->type
)
3767 case BFD_MACH_O_LC_LOAD_DYLIB
:
3768 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
3769 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3770 case BFD_MACH_O_LC_ID_DYLIB
:
3771 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3772 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3779 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3780 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3783 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3784 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3785 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3786 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3788 cmd
->name_offset
= command
->offset
+ nameoff
;
3789 namelen
= command
->len
- nameoff
;
3790 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3791 if (cmd
->name_str
== NULL
)
3793 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3794 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3800 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
3801 bfd_mach_o_load_command
*command
)
3803 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
3804 struct mach_o_prebound_dylib_command_external raw
;
3805 unsigned int nameoff
;
3806 unsigned int modoff
;
3807 unsigned int str_len
;
3810 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3811 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3814 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3815 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
3816 if (nameoff
> command
->len
|| modoff
> command
->len
)
3819 str_len
= command
->len
- sizeof (raw
);
3820 str
= bfd_alloc (abfd
, str_len
);
3823 if (bfd_bread (str
, str_len
, abfd
) != str_len
)
3826 cmd
->name_offset
= command
->offset
+ nameoff
;
3827 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
3828 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
3830 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3831 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3836 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
3837 bfd_mach_o_load_command
*command
)
3839 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
3840 struct mach_o_prebind_cksum_command_external raw
;
3842 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3843 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3846 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
3851 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
3852 bfd_mach_o_load_command
*command
)
3854 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
3855 struct mach_o_twolevel_hints_command_external raw
;
3857 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3858 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3861 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
3862 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
3867 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3869 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
3870 struct mach_o_fvmlib_command_external raw
;
3871 unsigned int nameoff
;
3872 unsigned int namelen
;
3874 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3875 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3878 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3879 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3880 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3882 fvm
->name_offset
= command
->offset
+ nameoff
;
3883 namelen
= command
->len
- nameoff
;
3884 fvm
->name_str
= bfd_alloc (abfd
, namelen
);
3885 if (fvm
->name_str
== NULL
)
3887 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3888 || bfd_bread (fvm
->name_str
, namelen
, abfd
) != namelen
)
3894 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3896 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3897 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3898 unsigned int offset
;
3899 unsigned int nflavours
;
3902 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3903 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3905 /* Count the number of threads. */
3908 while (offset
!= command
->len
)
3910 struct mach_o_thread_command_external raw
;
3912 if (offset
>= command
->len
)
3915 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3916 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3919 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3923 /* Allocate threads. */
3924 cmd
->flavours
= bfd_alloc
3925 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3926 if (cmd
->flavours
== NULL
)
3928 cmd
->nflavours
= nflavours
;
3932 while (offset
!= command
->len
)
3934 struct mach_o_thread_command_external raw
;
3936 if (offset
>= command
->len
)
3939 if (nflavours
>= cmd
->nflavours
)
3942 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3943 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3946 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3947 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3948 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3949 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3953 for (i
= 0; i
< nflavours
; i
++)
3956 unsigned int snamelen
;
3958 const char *flavourstr
;
3959 const char *prefix
= "LC_THREAD";
3962 switch (mdata
->header
.cputype
)
3964 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3965 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
3967 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
3969 case BFD_MACH_O_CPU_TYPE_I386
:
3970 case BFD_MACH_O_CPU_TYPE_X86_64
:
3972 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
3975 flavourstr
= "UNKNOWN_ARCHITECTURE";
3979 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
3980 sname
= bfd_alloc (abfd
, snamelen
);
3986 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
3987 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
3992 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
3996 bfdsec
->size
= cmd
->flavours
[i
].size
;
3997 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
3998 bfdsec
->alignment_power
= 0x0;
4000 cmd
->section
= bfdsec
;
4007 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4009 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4010 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4012 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4015 struct mach_o_dysymtab_command_external raw
;
4017 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4018 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4021 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4022 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4023 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4024 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4025 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4026 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4027 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4028 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4029 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4030 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4031 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4032 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4033 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4034 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4035 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4036 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4037 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4038 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4041 if (cmd
->nmodtab
!= 0)
4044 int wide
= bfd_mach_o_wide_p (abfd
);
4045 unsigned int module_len
= wide
? 56 : 52;
4048 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
4049 if (cmd
->dylib_module
== NULL
)
4052 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4055 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4057 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4059 unsigned char buf
[56];
4061 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4064 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4065 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4066 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4067 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4068 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4069 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4070 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4071 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4072 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4073 v
= bfd_h_get_32 (abfd
, buf
+36);
4074 module
->iinit
= v
& 0xffff;
4075 module
->iterm
= (v
>> 16) & 0xffff;
4076 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4077 module
->ninit
= v
& 0xffff;
4078 module
->nterm
= (v
>> 16) & 0xffff;
4081 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4082 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4086 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4087 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4096 cmd
->dylib_toc
= bfd_alloc
4097 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
4098 if (cmd
->dylib_toc
== NULL
)
4101 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4104 for (i
= 0; i
< cmd
->ntoc
; i
++)
4106 struct mach_o_dylib_table_of_contents_external raw
;
4107 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4109 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4112 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4113 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4117 if (cmd
->nindirectsyms
!= 0)
4121 cmd
->indirect_syms
= bfd_alloc
4122 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
4123 if (cmd
->indirect_syms
== NULL
)
4126 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4129 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4131 unsigned char raw
[4];
4132 unsigned int *is
= &cmd
->indirect_syms
[i
];
4134 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4137 *is
= bfd_h_get_32 (abfd
, raw
);
4141 if (cmd
->nextrefsyms
!= 0)
4146 cmd
->ext_refs
= bfd_alloc
4147 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
4148 if (cmd
->ext_refs
== NULL
)
4151 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4154 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4156 unsigned char raw
[4];
4157 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4159 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4162 /* Fields isym and flags are written as bit-fields, thus we need
4163 a specific processing for endianness. */
4164 v
= bfd_h_get_32 (abfd
, raw
);
4165 if (bfd_big_endian (abfd
))
4167 ref
->isym
= (v
>> 8) & 0xffffff;
4168 ref
->flags
= v
& 0xff;
4172 ref
->isym
= v
& 0xffffff;
4173 ref
->flags
= (v
>> 24) & 0xff;
4178 if (mdata
->dysymtab
)
4180 mdata
->dysymtab
= cmd
;
4186 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4188 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4189 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4190 struct mach_o_symtab_command_external raw
;
4192 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4194 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4195 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4198 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4199 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4200 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4201 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4202 symtab
->symbols
= NULL
;
4203 symtab
->strtab
= NULL
;
4205 if (symtab
->nsyms
!= 0)
4206 abfd
->flags
|= HAS_SYMS
;
4210 mdata
->symtab
= symtab
;
4215 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4217 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4219 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4221 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4222 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4229 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4231 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4232 struct mach_o_linkedit_data_command_external raw
;
4234 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4235 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4238 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4239 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4244 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4246 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4247 struct mach_o_str_command_external raw
;
4250 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4251 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4254 off
= bfd_get_32 (abfd
, raw
.str
);
4255 cmd
->stroff
= command
->offset
+ off
;
4256 cmd
->str_len
= command
->len
- off
;
4257 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
4258 if (cmd
->str
== NULL
)
4260 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
4261 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
4266 static unsigned char *
4267 bfd_mach_o_alloc_and_read (bfd
*abfd
, unsigned int off
, unsigned int size
)
4271 buf
= bfd_alloc (abfd
, size
);
4274 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4275 || bfd_bread (buf
, size
, abfd
) != size
)
4281 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4283 /* Read rebase content. */
4284 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4286 cmd
->rebase_content
=
4287 bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4288 if (cmd
->rebase_content
== NULL
)
4292 /* Read bind content. */
4293 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4296 bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4297 if (cmd
->bind_content
== NULL
)
4301 /* Read weak bind content. */
4302 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4304 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4305 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4306 if (cmd
->weak_bind_content
== NULL
)
4310 /* Read lazy bind content. */
4311 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4313 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4314 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4315 if (cmd
->lazy_bind_content
== NULL
)
4319 /* Read export content. */
4320 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4322 cmd
->export_content
= bfd_mach_o_alloc_and_read
4323 (abfd
, cmd
->export_off
, cmd
->export_size
);
4324 if (cmd
->export_content
== NULL
)
4332 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4334 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4335 struct mach_o_dyld_info_command_external raw
;
4337 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4338 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4341 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4342 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4343 cmd
->rebase_content
= NULL
;
4344 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4345 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4346 cmd
->bind_content
= NULL
;
4347 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4348 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4349 cmd
->weak_bind_content
= NULL
;
4350 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4351 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4352 cmd
->lazy_bind_content
= NULL
;
4353 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4354 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4355 cmd
->export_content
= NULL
;
4360 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4362 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4363 struct mach_o_version_min_command_external raw
;
4366 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4367 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4370 ver
= bfd_get_32 (abfd
, raw
.version
);
4371 cmd
->rel
= ver
>> 16;
4372 cmd
->maj
= ver
>> 8;
4374 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
4379 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4381 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4382 struct mach_o_encryption_info_command_external raw
;
4384 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4385 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4388 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4389 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4390 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4395 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4397 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4398 struct mach_o_entry_point_command_external raw
;
4400 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4401 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4404 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4405 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4410 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4412 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4413 struct mach_o_source_version_command_external raw
;
4416 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4417 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4420 ver
= bfd_get_64 (abfd
, raw
.version
);
4421 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4422 generates warnings) in case of the host doesn't support 64 bit
4424 cmd
->e
= ver
& 0x3ff;
4426 cmd
->d
= ver
& 0x3ff;
4428 cmd
->c
= ver
& 0x3ff;
4430 cmd
->b
= ver
& 0x3ff;
4432 cmd
->a
= ver
& 0xffffff;
4437 bfd_mach_o_read_segment (bfd
*abfd
,
4438 bfd_mach_o_load_command
*command
,
4441 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4446 struct mach_o_segment_command_64_external raw
;
4448 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4450 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4451 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4454 memcpy (seg
->segname
, raw
.segname
, 16);
4455 seg
->segname
[16] = '\0';
4457 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4458 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4459 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4460 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4461 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4462 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4463 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4464 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4468 struct mach_o_segment_command_32_external raw
;
4470 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4472 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4473 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4476 memcpy (seg
->segname
, raw
.segname
, 16);
4477 seg
->segname
[16] = '\0';
4479 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4480 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4481 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4482 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4483 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4484 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4485 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4486 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4488 seg
->sect_head
= NULL
;
4489 seg
->sect_tail
= NULL
;
4491 for (i
= 0; i
< seg
->nsects
; i
++)
4497 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
4498 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
4500 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
4501 + (i
* BFD_MACH_O_SECTION_SIZE
);
4503 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
4507 bfd_mach_o_append_section_to_segment
4508 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4515 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4517 return bfd_mach_o_read_segment (abfd
, command
, 0);
4521 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4523 return bfd_mach_o_read_segment (abfd
, command
, 1);
4527 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4529 struct mach_o_load_command_external raw
;
4532 /* Read command type and length. */
4533 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
4534 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4537 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4538 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4539 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4540 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4542 switch (command
->type
)
4544 case BFD_MACH_O_LC_SEGMENT
:
4545 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4548 case BFD_MACH_O_LC_SEGMENT_64
:
4549 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4552 case BFD_MACH_O_LC_SYMTAB
:
4553 if (!bfd_mach_o_read_symtab (abfd
, command
))
4556 case BFD_MACH_O_LC_SYMSEG
:
4558 case BFD_MACH_O_LC_THREAD
:
4559 case BFD_MACH_O_LC_UNIXTHREAD
:
4560 if (!bfd_mach_o_read_thread (abfd
, command
))
4563 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4564 case BFD_MACH_O_LC_ID_DYLINKER
:
4565 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4566 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4569 case BFD_MACH_O_LC_LOAD_DYLIB
:
4570 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4571 case BFD_MACH_O_LC_ID_DYLIB
:
4572 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4573 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4574 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4575 if (!bfd_mach_o_read_dylib (abfd
, command
))
4578 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4579 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4582 case BFD_MACH_O_LC_LOADFVMLIB
:
4583 case BFD_MACH_O_LC_IDFVMLIB
:
4584 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4587 case BFD_MACH_O_LC_IDENT
:
4588 case BFD_MACH_O_LC_FVMFILE
:
4589 case BFD_MACH_O_LC_PREPAGE
:
4590 case BFD_MACH_O_LC_ROUTINES
:
4591 case BFD_MACH_O_LC_ROUTINES_64
:
4593 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4594 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4595 case BFD_MACH_O_LC_SUB_LIBRARY
:
4596 case BFD_MACH_O_LC_SUB_CLIENT
:
4597 case BFD_MACH_O_LC_RPATH
:
4598 if (!bfd_mach_o_read_str (abfd
, command
))
4601 case BFD_MACH_O_LC_DYSYMTAB
:
4602 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4605 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4606 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4609 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4610 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4613 case BFD_MACH_O_LC_UUID
:
4614 if (!bfd_mach_o_read_uuid (abfd
, command
))
4617 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4618 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4619 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4620 case BFD_MACH_O_LC_DATA_IN_CODE
:
4621 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4622 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4625 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4626 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4629 case BFD_MACH_O_LC_DYLD_INFO
:
4630 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
4633 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4634 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4635 if (!bfd_mach_o_read_version_min (abfd
, command
))
4638 case BFD_MACH_O_LC_MAIN
:
4639 if (!bfd_mach_o_read_main (abfd
, command
))
4642 case BFD_MACH_O_LC_SOURCE_VERSION
:
4643 if (!bfd_mach_o_read_source_version (abfd
, command
))
4647 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
4648 abfd
, (unsigned long) command
->type
);
4656 bfd_mach_o_flatten_sections (bfd
*abfd
)
4658 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4659 bfd_mach_o_load_command
*cmd
;
4662 /* Count total number of sections. */
4665 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4667 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4668 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4670 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4672 mdata
->nsects
+= seg
->nsects
;
4676 /* Allocate sections array. */
4677 mdata
->sections
= bfd_alloc (abfd
,
4678 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
4680 /* Fill the array. */
4683 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4685 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4686 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4688 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4689 bfd_mach_o_section
*sec
;
4691 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
4693 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
4694 mdata
->sections
[csect
++] = sec
;
4700 bfd_mach_o_scan_start_address (bfd
*abfd
)
4702 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4703 bfd_mach_o_thread_command
*thr
= NULL
;
4704 bfd_mach_o_load_command
*cmd
;
4707 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4708 if (cmd
->type
== BFD_MACH_O_LC_THREAD
4709 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
4711 thr
= &cmd
->command
.thread
;
4714 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
4716 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
4717 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
4721 abfd
->start_address
= main_cmd
->entryoff
4722 + (text_sect
->addr
- text_sect
->offset
);
4727 /* An object file has no start address, so do not fail if not found. */
4731 /* FIXME: create a subtarget hook ? */
4732 for (i
= 0; i
< thr
->nflavours
; i
++)
4734 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
4735 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
4737 unsigned char buf
[4];
4739 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
4740 || bfd_bread (buf
, 4, abfd
) != 4)
4743 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4745 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
4746 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
4748 unsigned char buf
[4];
4750 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4751 || bfd_bread (buf
, 4, abfd
) != 4)
4754 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4756 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
4757 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
4759 unsigned char buf
[8];
4761 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4762 || bfd_bread (buf
, 8, abfd
) != 8)
4765 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4767 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
4768 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
4770 unsigned char buf
[8];
4772 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
4773 || bfd_bread (buf
, 8, abfd
) != 8)
4776 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4784 bfd_mach_o_set_arch_mach (bfd
*abfd
,
4785 enum bfd_architecture arch
,
4786 unsigned long machine
)
4788 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4790 /* If this isn't the right architecture for this backend, and this
4791 isn't the generic backend, fail. */
4792 if (arch
!= bed
->arch
4793 && arch
!= bfd_arch_unknown
4794 && bed
->arch
!= bfd_arch_unknown
)
4797 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4801 bfd_mach_o_scan (bfd
*abfd
,
4802 bfd_mach_o_header
*header
,
4803 bfd_mach_o_data_struct
*mdata
)
4806 enum bfd_architecture cputype
;
4807 unsigned long cpusubtype
;
4808 unsigned int hdrsize
;
4810 hdrsize
= mach_o_wide_p (header
) ?
4811 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
4813 mdata
->header
= *header
;
4815 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
4816 switch (header
->filetype
)
4818 case BFD_MACH_O_MH_OBJECT
:
4819 abfd
->flags
|= HAS_RELOC
;
4821 case BFD_MACH_O_MH_EXECUTE
:
4822 abfd
->flags
|= EXEC_P
;
4824 case BFD_MACH_O_MH_DYLIB
:
4825 case BFD_MACH_O_MH_BUNDLE
:
4826 abfd
->flags
|= DYNAMIC
;
4830 abfd
->tdata
.mach_o_data
= mdata
;
4832 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
4833 &cputype
, &cpusubtype
);
4834 if (cputype
== bfd_arch_unknown
)
4836 (*_bfd_error_handler
)
4837 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4838 header
->cputype
, header
->cpusubtype
);
4842 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
4844 if (header
->ncmds
!= 0)
4846 bfd_mach_o_load_command
*cmd
;
4848 mdata
->first_command
= NULL
;
4849 mdata
->last_command
= NULL
;
4850 cmd
= bfd_alloc (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
4854 for (i
= 0; i
< header
->ncmds
; i
++)
4856 bfd_mach_o_load_command
*cur
= &cmd
[i
];
4858 bfd_mach_o_append_command (abfd
, cur
);
4861 cur
->offset
= hdrsize
;
4864 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
4865 cur
->offset
= prev
->offset
+ prev
->len
;
4868 if (!bfd_mach_o_read_command (abfd
, cur
))
4873 /* Sections should be flatten before scanning start address. */
4874 bfd_mach_o_flatten_sections (abfd
);
4875 if (!bfd_mach_o_scan_start_address (abfd
))
4882 bfd_mach_o_mkobject_init (bfd
*abfd
)
4884 bfd_mach_o_data_struct
*mdata
= NULL
;
4886 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
4889 abfd
->tdata
.mach_o_data
= mdata
;
4891 mdata
->header
.magic
= 0;
4892 mdata
->header
.cputype
= 0;
4893 mdata
->header
.cpusubtype
= 0;
4894 mdata
->header
.filetype
= 0;
4895 mdata
->header
.ncmds
= 0;
4896 mdata
->header
.sizeofcmds
= 0;
4897 mdata
->header
.flags
= 0;
4898 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
4899 mdata
->first_command
= NULL
;
4900 mdata
->last_command
= NULL
;
4902 mdata
->sections
= NULL
;
4903 mdata
->dyn_reloc_cache
= NULL
;
4909 bfd_mach_o_gen_mkobject (bfd
*abfd
)
4911 bfd_mach_o_data_struct
*mdata
;
4913 if (!bfd_mach_o_mkobject_init (abfd
))
4916 mdata
= bfd_mach_o_get_data (abfd
);
4917 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
4918 mdata
->header
.cputype
= 0;
4919 mdata
->header
.cpusubtype
= 0;
4920 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
4921 mdata
->header
.version
= 1;
4927 bfd_mach_o_header_p (bfd
*abfd
,
4928 bfd_mach_o_filetype filetype
,
4929 bfd_mach_o_cpu_type cputype
)
4931 bfd_mach_o_header header
;
4932 bfd_mach_o_data_struct
*mdata
;
4934 if (!bfd_mach_o_read_header (abfd
, &header
))
4937 if (! (header
.byteorder
== BFD_ENDIAN_BIG
4938 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
4940 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
4941 (unsigned long) header
.byteorder
);
4945 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
4946 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
4947 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
4948 || (header
.byteorder
== BFD_ENDIAN_LITTLE
4949 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
4950 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
4953 /* Check cputype and filetype.
4954 In case of wildcard, do not accept magics that are handled by existing
4958 if (header
.cputype
!= cputype
)
4964 /* Do not recognize 64 architectures if not configured for 64bit targets.
4965 This could happen only for generic targets. */
4966 if (mach_o_wide_p (&header
))
4973 if (header
.filetype
!= filetype
)
4978 switch (header
.filetype
)
4980 case BFD_MACH_O_MH_CORE
:
4981 /* Handled by core_p */
4988 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
4992 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
4998 bfd_set_error (bfd_error_wrong_format
);
5004 static const bfd_target
*
5005 bfd_mach_o_gen_object_p (bfd
*abfd
)
5007 return bfd_mach_o_header_p (abfd
, 0, 0);
5010 static const bfd_target
*
5011 bfd_mach_o_gen_core_p (bfd
*abfd
)
5013 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
5016 /* Return the base address of ABFD, ie the address at which the image is
5017 mapped. The possible initial pagezero is ignored. */
5020 bfd_mach_o_get_base_address (bfd
*abfd
)
5022 bfd_mach_o_data_struct
*mdata
;
5023 bfd_mach_o_load_command
*cmd
;
5025 /* Check for Mach-O. */
5026 if (!bfd_mach_o_valid (abfd
))
5028 mdata
= bfd_mach_o_get_data (abfd
);
5030 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5032 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5033 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5035 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5037 if (segcmd
->initprot
!= 0)
5038 return segcmd
->vmaddr
;
5044 typedef struct mach_o_fat_archentry
5046 unsigned long cputype
;
5047 unsigned long cpusubtype
;
5048 unsigned long offset
;
5050 unsigned long align
;
5051 } mach_o_fat_archentry
;
5053 typedef struct mach_o_fat_data_struct
5055 unsigned long magic
;
5056 unsigned long nfat_arch
;
5057 mach_o_fat_archentry
*archentries
;
5058 } mach_o_fat_data_struct
;
5061 bfd_mach_o_archive_p (bfd
*abfd
)
5063 mach_o_fat_data_struct
*adata
= NULL
;
5064 struct mach_o_fat_header_external hdr
;
5067 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5068 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5071 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5075 adata
->magic
= bfd_getb32 (hdr
.magic
);
5076 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5077 if (adata
->magic
!= 0xcafebabe)
5079 /* Avoid matching Java bytecode files, which have the same magic number.
5080 In the Java bytecode file format this field contains the JVM version,
5081 which starts at 43.0. */
5082 if (adata
->nfat_arch
> 30)
5085 adata
->archentries
=
5086 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
5087 if (adata
->archentries
== NULL
)
5090 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5092 struct mach_o_fat_arch_external arch
;
5093 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5095 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5096 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5097 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5098 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5099 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5102 abfd
->tdata
.mach_o_fat_data
= adata
;
5107 bfd_release (abfd
, adata
);
5108 bfd_set_error (bfd_error_wrong_format
);
5112 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5113 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5114 Set arelt_data and origin fields too. */
5117 bfd_mach_o_fat_member_init (bfd
*abfd
,
5118 enum bfd_architecture arch_type
,
5119 unsigned long arch_subtype
,
5120 mach_o_fat_archentry
*entry
)
5122 struct areltdata
*areltdata
;
5123 /* Create the member filename. Use ARCH_NAME. */
5124 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5128 /* Use the architecture name if known. */
5129 abfd
->filename
= xstrdup (ap
->printable_name
);
5133 /* Forge a uniq id. */
5134 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5135 char *name
= xmalloc (namelen
);
5136 snprintf (name
, namelen
, "0x%lx-0x%lx",
5137 entry
->cputype
, entry
->cpusubtype
);
5138 abfd
->filename
= name
;
5141 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5142 areltdata
->parsed_size
= entry
->size
;
5143 abfd
->arelt_data
= areltdata
;
5144 abfd
->iostream
= NULL
;
5145 abfd
->origin
= entry
->offset
;
5149 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5151 mach_o_fat_data_struct
*adata
;
5152 mach_o_fat_archentry
*entry
= NULL
;
5155 enum bfd_architecture arch_type
;
5156 unsigned long arch_subtype
;
5158 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5159 BFD_ASSERT (adata
!= NULL
);
5161 /* Find index of previous entry. */
5164 /* Start at first one. */
5169 /* Find index of PREV. */
5170 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5172 if (adata
->archentries
[i
].offset
== prev
->origin
)
5176 if (i
== adata
->nfat_arch
)
5179 bfd_set_error (bfd_error_bad_value
);
5183 /* Get next entry. */
5187 if (i
>= adata
->nfat_arch
)
5189 bfd_set_error (bfd_error_no_more_archived_files
);
5193 entry
= &adata
->archentries
[i
];
5194 nbfd
= _bfd_new_bfd_contained_in (archive
);
5198 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5199 &arch_type
, &arch_subtype
);
5201 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
5203 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5208 /* Analogous to stat call. */
5211 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5213 if (abfd
->arelt_data
== NULL
)
5215 bfd_set_error (bfd_error_invalid_operation
);
5222 buf
->st_mode
= 0644;
5223 buf
->st_size
= arelt_size (abfd
);
5228 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5229 If ABFD is a fat image containing a member that corresponds to FORMAT
5230 and ARCH, returns it.
5231 In other case, returns NULL.
5232 This function allows transparent uses of fat images. */
5235 bfd_mach_o_fat_extract (bfd
*abfd
,
5237 const bfd_arch_info_type
*arch
)
5240 mach_o_fat_data_struct
*adata
;
5243 if (bfd_check_format (abfd
, format
))
5245 if (bfd_get_arch_info (abfd
) == arch
)
5249 if (!bfd_check_format (abfd
, bfd_archive
)
5250 || abfd
->xvec
!= &mach_o_fat_vec
)
5253 /* This is a Mach-O fat image. */
5254 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5255 BFD_ASSERT (adata
!= NULL
);
5257 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5259 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5260 enum bfd_architecture cpu_type
;
5261 unsigned long cpu_subtype
;
5263 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5264 &cpu_type
, &cpu_subtype
);
5265 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5268 /* The architecture is found. */
5269 res
= _bfd_new_bfd_contained_in (abfd
);
5273 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
5275 if (bfd_check_format (res
, format
))
5277 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5288 bfd_mach_o_lookup_command (bfd
*abfd
,
5289 bfd_mach_o_load_command_type type
,
5290 bfd_mach_o_load_command
**mcommand
)
5292 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5293 struct bfd_mach_o_load_command
*cmd
;
5296 BFD_ASSERT (mdata
!= NULL
);
5297 BFD_ASSERT (mcommand
!= NULL
);
5300 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5302 if (cmd
->type
!= type
)
5314 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5318 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5320 case BFD_MACH_O_CPU_TYPE_MC88000
:
5322 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5324 case BFD_MACH_O_CPU_TYPE_I386
:
5326 case BFD_MACH_O_CPU_TYPE_SPARC
:
5328 case BFD_MACH_O_CPU_TYPE_I860
:
5330 case BFD_MACH_O_CPU_TYPE_HPPA
:
5331 return 0xc0000000 - 0x04000000;
5337 /* The following two tables should be kept, as far as possible, in order of
5338 most frequently used entries to optimize their use from gas. */
5340 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5342 { "regular", BFD_MACH_O_S_REGULAR
},
5343 { "coalesced", BFD_MACH_O_S_COALESCED
},
5344 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5345 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5346 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5347 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5348 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5349 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5350 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5351 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5352 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5353 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5354 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5355 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5356 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5357 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5358 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5362 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5364 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5365 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5366 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5367 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5368 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5369 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5370 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5371 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5372 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5373 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5374 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5378 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5381 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5383 const bfd_mach_o_xlat_name
*x
;
5384 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5386 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5387 if (strcmp (x
->name
, name
) == 0)
5389 /* We found it... does the target support it? */
5390 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5391 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5392 return x
->val
; /* OK. */
5394 break; /* Not supported. */
5396 /* Maximum section ID = 0xff. */
5400 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5403 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5405 const bfd_mach_o_xlat_name
*x
;
5407 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5408 if (strcmp (x
->name
, name
) == 0)
5410 return (unsigned int)-1;
5414 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5415 unsigned char **rbuf
,
5418 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5419 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5420 bfd_mach_o_load_command
*cmd
;
5422 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5424 bfd_mach_o_segment_command
*seg
;
5426 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5429 seg
= &cmd
->command
.segment
;
5431 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5433 unsigned long start
= seg
->fileoff
;
5434 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5435 unsigned char *buf
= bfd_malloc (1024);
5436 unsigned long size
= 1024;
5440 bfd_size_type nread
= 0;
5441 unsigned long offset
;
5442 int found_nonnull
= 0;
5444 if (size
> (end
- start
))
5445 size
= (end
- start
);
5447 buf
= bfd_realloc_or_free (buf
, size
);
5451 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5457 nread
= bfd_bread (buf
, size
, abfd
);
5465 for (offset
= 4; offset
<= size
; offset
+= 4)
5469 val
= *((unsigned long *) (buf
+ size
- offset
));
5470 if (! found_nonnull
)
5475 else if (val
== 0x0)
5477 unsigned long bottom
;
5480 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5481 top
= seg
->fileoff
+ seg
->filesize
- 4;
5482 *rbuf
= bfd_malloc (top
- bottom
);
5483 *rlen
= top
- bottom
;
5485 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5491 if (size
== (end
- start
))
5505 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5507 unsigned char *buf
= NULL
;
5508 unsigned int len
= 0;
5511 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5515 return (char *) buf
;
5519 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5524 static bfd_mach_o_uuid_command
*
5525 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5527 bfd_mach_o_load_command
*uuid_cmd
;
5528 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5531 return &uuid_cmd
->command
.uuid
;
5534 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5537 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5539 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5542 BFD_ASSERT (uuid_cmd
);
5544 if (!bfd_check_format (abfd
, bfd_object
))
5547 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5548 || bfd_mach_o_get_data (abfd
) == NULL
5549 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5552 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5553 if (dsym_uuid_cmd
== NULL
)
5556 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5557 sizeof (uuid_cmd
->uuid
)) != 0)
5563 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5564 The caller is responsible for closing the returned BFD object and
5565 its my_archive if the returned BFD is in a fat dSYM. */
5568 bfd_mach_o_find_dsym (const char *dsym_filename
,
5569 const bfd_mach_o_uuid_command
*uuid_cmd
,
5570 const bfd_arch_info_type
*arch
)
5572 bfd
*base_dsym_bfd
, *dsym_bfd
;
5574 BFD_ASSERT (uuid_cmd
);
5576 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
5577 if (base_dsym_bfd
== NULL
)
5580 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
5581 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
5584 bfd_close (dsym_bfd
);
5585 if (base_dsym_bfd
!= dsym_bfd
)
5586 bfd_close (base_dsym_bfd
);
5591 /* Return a BFD created from a dSYM file for ABFD.
5592 The caller is responsible for closing the returned BFD object, its
5593 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5596 bfd_mach_o_follow_dsym (bfd
*abfd
)
5598 char *dsym_filename
;
5599 bfd_mach_o_uuid_command
*uuid_cmd
;
5600 bfd
*dsym_bfd
, *base_bfd
= abfd
;
5601 const char *base_basename
;
5603 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
5606 if (abfd
->my_archive
)
5607 base_bfd
= abfd
->my_archive
;
5608 /* BFD may have been opened from a stream. */
5609 if (base_bfd
->filename
== NULL
)
5611 bfd_set_error (bfd_error_invalid_operation
);
5614 base_basename
= lbasename (base_bfd
->filename
);
5616 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5617 if (uuid_cmd
== NULL
)
5620 /* TODO: We assume the DWARF file has the same as the binary's.
5621 It seems apple's GDB checks all files in the dSYM bundle directory.
5622 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5624 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
5625 + strlen (dsym_subdir
) + 1
5626 + strlen (base_basename
) + 1);
5627 sprintf (dsym_filename
, "%s%s/%s",
5628 base_bfd
->filename
, dsym_subdir
, base_basename
);
5630 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
5631 bfd_get_arch_info (abfd
));
5632 if (dsym_bfd
== NULL
)
5633 free (dsym_filename
);
5639 bfd_mach_o_find_nearest_line (bfd
*abfd
,
5643 const char **filename_ptr
,
5644 const char **functionname_ptr
,
5645 unsigned int *line_ptr
,
5646 unsigned int *discriminator_ptr
)
5648 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5651 switch (mdata
->header
.filetype
)
5653 case BFD_MACH_O_MH_OBJECT
:
5655 case BFD_MACH_O_MH_EXECUTE
:
5656 case BFD_MACH_O_MH_DYLIB
:
5657 case BFD_MACH_O_MH_BUNDLE
:
5658 case BFD_MACH_O_MH_KEXT_BUNDLE
:
5659 if (mdata
->dwarf2_find_line_info
== NULL
)
5661 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
5662 /* When we couldn't find dSYM for this binary, we look for
5663 the debug information in the binary itself. In this way,
5664 we won't try finding separated dSYM again because
5665 mdata->dwarf2_find_line_info will be filled. */
5666 if (! mdata
->dsym_bfd
)
5668 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
5669 dwarf_debug_sections
, symbols
,
5670 &mdata
->dwarf2_find_line_info
,
5678 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
5679 filename_ptr
, functionname_ptr
,
5680 line_ptr
, discriminator_ptr
,
5681 dwarf_debug_sections
, 0,
5682 &mdata
->dwarf2_find_line_info
);
5686 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
5688 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5689 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
5691 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
5692 bfd_mach_o_free_cached_info (abfd
);
5693 if (mdata
->dsym_bfd
!= NULL
)
5695 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
5696 char *dsym_filename
= (char *)(fat_bfd
5698 : mdata
->dsym_bfd
->filename
);
5699 bfd_close (mdata
->dsym_bfd
);
5700 mdata
->dsym_bfd
= NULL
;
5702 bfd_close (fat_bfd
);
5703 free (dsym_filename
);
5707 if (bfd_get_format (abfd
) == bfd_archive
5708 && abfd
->xvec
== &mach_o_fat_vec
)
5710 return _bfd_generic_close_and_cleanup (abfd
);
5713 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
5715 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5717 free (mdata
->dyn_reloc_cache
);
5718 mdata
->dyn_reloc_cache
= NULL
;
5719 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
5721 free (asect
->relocation
);
5722 asect
->relocation
= NULL
;
5728 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5729 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5731 #define bfd_mach_o_swap_reloc_in NULL
5732 #define bfd_mach_o_swap_reloc_out NULL
5733 #define bfd_mach_o_print_thread NULL
5734 #define bfd_mach_o_tgt_seg_table NULL
5735 #define bfd_mach_o_section_type_valid_for_tgt NULL
5737 #define TARGET_NAME mach_o_be_vec
5738 #define TARGET_STRING "mach-o-be"
5739 #define TARGET_ARCHITECTURE bfd_arch_unknown
5740 #define TARGET_PAGESIZE 1
5741 #define TARGET_BIG_ENDIAN 1
5742 #define TARGET_ARCHIVE 0
5743 #define TARGET_PRIORITY 1
5744 #include "mach-o-target.c"
5747 #undef TARGET_STRING
5748 #undef TARGET_ARCHITECTURE
5749 #undef TARGET_PAGESIZE
5750 #undef TARGET_BIG_ENDIAN
5751 #undef TARGET_ARCHIVE
5752 #undef TARGET_PRIORITY
5754 #define TARGET_NAME mach_o_le_vec
5755 #define TARGET_STRING "mach-o-le"
5756 #define TARGET_ARCHITECTURE bfd_arch_unknown
5757 #define TARGET_PAGESIZE 1
5758 #define TARGET_BIG_ENDIAN 0
5759 #define TARGET_ARCHIVE 0
5760 #define TARGET_PRIORITY 1
5762 #include "mach-o-target.c"
5765 #undef TARGET_STRING
5766 #undef TARGET_ARCHITECTURE
5767 #undef TARGET_PAGESIZE
5768 #undef TARGET_BIG_ENDIAN
5769 #undef TARGET_ARCHIVE
5770 #undef TARGET_PRIORITY
5772 /* Not yet handled: creating an archive. */
5773 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5776 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5777 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5778 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5779 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5780 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5781 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5782 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5783 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5784 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5785 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5787 #define TARGET_NAME mach_o_fat_vec
5788 #define TARGET_STRING "mach-o-fat"
5789 #define TARGET_ARCHITECTURE bfd_arch_unknown
5790 #define TARGET_PAGESIZE 1
5791 #define TARGET_BIG_ENDIAN 1
5792 #define TARGET_ARCHIVE 1
5793 #define TARGET_PRIORITY 0
5795 #include "mach-o-target.c"
5798 #undef TARGET_STRING
5799 #undef TARGET_ARCHITECTURE
5800 #undef TARGET_PAGESIZE
5801 #undef TARGET_BIG_ENDIAN
5802 #undef TARGET_ARCHIVE
5803 #undef TARGET_PRIORITY