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 /* PR 17512: file: 8396-1185-0.004. */
1353 if (num
>= bfd_get_symcount (abfd
))
1354 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1356 /* An external symbol number. */
1359 else if (num
== 0x00ffffff || num
== 0)
1361 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1362 is generic code, we don't know wether this is really a PAIR.
1363 This value is almost certainly not a valid section number, hence
1364 this specific case to avoid an assertion failure.
1365 Target specific swap_reloc_in routine should adjust that. */
1366 sym
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1370 /* PR 17512: file: 006-2964-0.004. */
1371 if (num
>= mdata
->nsects
)
1374 /* A section number. */
1375 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1376 /* For a symbol defined in section S, the addend (stored in the
1377 binary) contains the address of the section. To comply with
1378 bfd convention, subtract the section address.
1379 Use the address from the header, so that the user can modify
1380 the vma of the section. */
1381 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1383 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1384 in the lower 16bits of the address value. So we have to find the
1385 'symbol' from the preceding reloc. We do this even though the
1386 section symbol is probably not needed here, because NULL symbol
1387 values cause an assert in generic BFD code. This must be done in
1388 the PPC swap_reloc_in routine. */
1389 res
->sym_ptr_ptr
= sym
;
1391 /* The 'address' is just r_address.
1392 ??? maybe this should be masked with 0xffffff for safety. */
1393 res
->address
= addr
;
1394 reloc
.r_address
= addr
;
1397 /* We have set up a reloc with all the information present, so the swapper
1398 can modify address, value and addend fields, if necessary, to convey
1399 information in the generic BFD reloc that is mach-o specific. */
1401 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
1407 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1408 unsigned long count
,
1409 arelent
*res
, asymbol
**syms
)
1412 struct mach_o_reloc_info_external
*native_relocs
;
1413 bfd_size_type native_size
;
1415 /* Allocate and read relocs. */
1416 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1418 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1419 if (native_relocs
== NULL
)
1422 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1423 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1426 for (i
= 0; i
< count
; i
++)
1428 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
1432 free (native_relocs
);
1435 free (native_relocs
);
1440 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1441 arelent
**rels
, asymbol
**syms
)
1443 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1447 if (asect
->reloc_count
== 0)
1450 /* No need to go further if we don't know how to read relocs. */
1451 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1454 if (asect
->relocation
== NULL
)
1456 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1460 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1461 asect
->reloc_count
, res
, syms
) < 0)
1466 asect
->relocation
= res
;
1469 res
= asect
->relocation
;
1470 for (i
= 0; i
< asect
->reloc_count
; i
++)
1478 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1480 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1482 if (mdata
->dysymtab
== NULL
)
1484 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1485 * sizeof (arelent
*);
1489 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1490 struct bfd_symbol
**syms
)
1492 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1493 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1494 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1498 if (dysymtab
== NULL
)
1500 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1503 /* No need to go further if we don't know how to read relocs. */
1504 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1507 if (mdata
->dyn_reloc_cache
== NULL
)
1509 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1510 * sizeof (arelent
));
1514 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1515 dysymtab
->nextrel
, res
, syms
) < 0)
1521 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1523 res
+ dysymtab
->nextrel
, syms
) < 0)
1529 mdata
->dyn_reloc_cache
= res
;
1532 res
= mdata
->dyn_reloc_cache
;
1533 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1539 /* In addition to the need to byte-swap the symbol number, the bit positions
1540 of the fields in the relocation information vary per target endian-ness. */
1543 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1544 bfd_mach_o_reloc_info
*rel
)
1546 unsigned char info
= 0;
1548 BFD_ASSERT (rel
->r_type
<= 15);
1549 BFD_ASSERT (rel
->r_length
<= 3);
1551 if (bfd_big_endian (abfd
))
1553 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1554 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1555 fields
[2] = rel
->r_value
& 0xff;
1556 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1557 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1558 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1559 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1563 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1564 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1565 fields
[0] = rel
->r_value
& 0xff;
1566 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1567 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1568 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1569 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1575 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1580 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1582 sec
= section
->bfdsection
;
1583 if (sec
->reloc_count
== 0)
1586 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1589 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1592 /* Convert and write. */
1593 entries
= section
->bfdsection
->orelocation
;
1594 for (i
= 0; i
< section
->nreloc
; i
++)
1596 arelent
*rel
= entries
[i
];
1597 struct mach_o_reloc_info_external raw
;
1598 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1600 /* Convert relocation to an intermediate representation. */
1601 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1604 /* Lower the relocation info. */
1605 if (pinfo
->r_scattered
)
1609 v
= BFD_MACH_O_SR_SCATTERED
1610 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1611 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1612 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1613 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1614 /* Note: scattered relocs have field in reverse order... */
1615 bfd_put_32 (abfd
, v
, raw
.r_address
);
1616 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1620 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1621 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1625 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1626 != BFD_MACH_O_RELENT_SIZE
)
1633 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1635 struct mach_o_section_32_external raw
;
1637 memcpy (raw
.sectname
, section
->sectname
, 16);
1638 memcpy (raw
.segname
, section
->segname
, 16);
1639 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1640 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1641 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1642 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1643 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1644 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1645 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1646 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1647 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1649 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1650 != BFD_MACH_O_SECTION_SIZE
)
1657 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1659 struct mach_o_section_64_external raw
;
1661 memcpy (raw
.sectname
, section
->sectname
, 16);
1662 memcpy (raw
.segname
, section
->segname
, 16);
1663 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1664 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1665 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1666 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1667 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1668 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1669 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1670 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1671 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1672 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1674 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1675 != BFD_MACH_O_SECTION_64_SIZE
)
1682 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1684 struct mach_o_segment_command_32_external raw
;
1685 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1686 bfd_mach_o_section
*sec
;
1688 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1690 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1691 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1694 memcpy (raw
.segname
, seg
->segname
, 16);
1695 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1696 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1697 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1698 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1699 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1700 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1701 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1702 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1704 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1705 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1708 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1709 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1716 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1718 struct mach_o_segment_command_64_external raw
;
1719 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1720 bfd_mach_o_section
*sec
;
1722 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1724 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1725 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1728 memcpy (raw
.segname
, seg
->segname
, 16);
1729 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1730 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1731 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1732 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1733 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1734 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1735 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1736 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1738 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1739 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1742 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1743 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1750 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1752 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1754 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1755 struct bfd_strtab_hash
*strtab
;
1756 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1759 /* Write the symbols first. */
1760 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1763 strtab
= _bfd_stringtab_init ();
1768 /* Although we don't strictly need to do this, for compatibility with
1769 Darwin system tools, actually output an empty string for the index
1771 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1773 for (i
= 0; i
< sym
->nsyms
; i
++)
1775 bfd_size_type str_index
;
1776 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1778 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1779 /* An index of 0 always means the empty string. */
1783 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1785 if (str_index
== (bfd_size_type
) -1)
1791 struct mach_o_nlist_64_external raw
;
1793 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1794 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1795 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1796 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1797 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1800 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1805 struct mach_o_nlist_external raw
;
1807 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1808 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1809 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1810 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1811 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1814 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1818 sym
->strsize
= _bfd_stringtab_size (strtab
);
1819 sym
->stroff
= mdata
->filelen
;
1820 mdata
->filelen
+= sym
->strsize
;
1822 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
1825 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1827 _bfd_stringtab_free (strtab
);
1829 /* Pad string table. */
1830 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
1833 mdata
->filelen
+= padlen
;
1834 sym
->strsize
+= padlen
;
1839 _bfd_stringtab_free (strtab
);
1844 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1846 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1847 struct mach_o_symtab_command_external raw
;
1849 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1852 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1853 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1854 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1855 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1857 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1858 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1864 /* Count the number of indirect symbols in the image.
1865 Requires that the sections are in their final order. */
1868 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1871 unsigned int nisyms
= 0;
1873 for (i
= 0; i
< mdata
->nsects
; ++i
)
1875 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1877 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1879 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1880 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1881 case BFD_MACH_O_S_SYMBOL_STUBS
:
1882 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
1891 /* Create the dysymtab. */
1894 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
1896 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1899 We are not going to try and fill these in yet and, moreover, we are
1900 going to bail if they are already set. */
1901 if (cmd
->nmodtab
!= 0
1903 || cmd
->nextrefsyms
!= 0)
1905 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
1906 " implemented for dysymtab commands."));
1912 if (bfd_get_symcount (abfd
) > 0)
1914 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1917 /* Count the number of each kind of symbol. */
1918 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1920 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1921 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
1925 cmd
->iextdefsym
= i
;
1926 for (; i
< bfd_get_symcount (abfd
); ++i
)
1928 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1929 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
1932 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
1933 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
1934 cmd
->nundefsym
= bfd_get_symcount (abfd
)
1941 cmd
->iextdefsym
= 0;
1942 cmd
->nextdefsym
= 0;
1947 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
1948 if (cmd
->nindirectsyms
> 0)
1953 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
1954 cmd
->indirectsymoff
= mdata
->filelen
;
1955 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
1957 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
1958 if (cmd
->indirect_syms
== NULL
)
1962 for (i
= 0; i
< mdata
->nsects
; ++i
)
1964 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1966 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1968 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1969 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1970 case BFD_MACH_O_S_SYMBOL_STUBS
:
1973 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
1975 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
1976 if (isyms
== NULL
|| num
== 0)
1978 /* Record the starting index in the reserved1 field. */
1980 for (j
= 0; j
< num
; j
++, n
++)
1982 if (isyms
[j
] == NULL
)
1983 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
1984 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
1985 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
1986 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
1987 | BFD_MACH_O_INDIRECT_SYM_ABS
;
1989 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2002 /* Write a dysymtab command.
2003 TODO: Possibly coalesce writes of smaller objects. */
2006 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2008 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2010 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2012 if (cmd
->nmodtab
!= 0)
2016 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2019 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2021 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2025 iinit
= module
->iinit
& 0xffff;
2026 iinit
|= ((module
->iterm
& 0xffff) << 16);
2028 ninit
= module
->ninit
& 0xffff;
2029 ninit
|= ((module
->nterm
& 0xffff) << 16);
2031 if (bfd_mach_o_wide_p (abfd
))
2033 struct mach_o_dylib_module_64_external w
;
2035 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2036 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2037 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2038 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2039 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2040 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2041 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2042 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2043 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2044 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2045 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2046 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2047 &w
.objc_module_info_addr
);
2048 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2049 &w
.objc_module_info_size
);
2051 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2056 struct mach_o_dylib_module_external n
;
2058 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2059 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2060 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2061 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2062 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2063 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2064 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2065 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2066 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2067 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2068 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2069 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2070 &n
.objc_module_info_addr
);
2071 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2072 &n
.objc_module_info_size
);
2074 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2084 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2087 for (i
= 0; i
< cmd
->ntoc
; i
++)
2089 struct mach_o_dylib_table_of_contents_external raw
;
2090 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2092 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2093 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2095 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2100 if (cmd
->nindirectsyms
> 0)
2104 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2107 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2109 unsigned char raw
[4];
2111 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2112 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2117 if (cmd
->nextrefsyms
!= 0)
2121 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2124 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2127 unsigned char raw
[4];
2128 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2130 /* Fields isym and flags are written as bit-fields, thus we need
2131 a specific processing for endianness. */
2133 if (bfd_big_endian (abfd
))
2135 v
= ((ref
->isym
& 0xffffff) << 8);
2136 v
|= ref
->flags
& 0xff;
2140 v
= ref
->isym
& 0xffffff;
2141 v
|= ((ref
->flags
& 0xff) << 24);
2144 bfd_h_put_32 (abfd
, v
, raw
);
2145 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2151 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2155 struct mach_o_dysymtab_command_external raw
;
2157 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2158 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2159 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2160 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2161 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2162 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2163 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2164 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2165 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2166 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2167 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2168 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2169 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2170 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2171 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2172 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2173 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2174 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2176 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2184 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2186 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2188 /* Just leave debug symbols where they are (pretend they are local, and
2189 then they will just be sorted on position). */
2190 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2193 /* Local (we should never see an undefined local AFAICT). */
2194 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2197 /* Common symbols look like undefined externs. */
2198 if (mtyp
== BFD_MACH_O_N_UNDF
)
2201 /* A defined non-local, non-debug symbol. */
2206 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2208 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2209 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2210 unsigned int soa
, sob
;
2212 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2213 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2220 /* If it's local or stab, just preserve the input order. */
2223 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2225 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2228 /* This is probably an error. */
2232 /* The second sort key is name. */
2233 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2236 /* Process the symbols.
2238 This should be OK for single-module files - but it is not likely to work
2239 for multi-module shared libraries.
2241 (a) If the application has not filled in the relevant mach-o fields, make
2244 (b) Order them, like this:
2247 ( ii) external defined
2249 (iii) external undefined/common
2256 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2259 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2261 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2264 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2266 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2268 /* We use this value, which is out-of-range as a symbol index, to signal
2269 that the mach-o-specific data are not filled in and need to be created
2270 from the bfd values. It is much preferable for the application to do
2271 this, since more meaningful diagnostics can be made that way. */
2273 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2275 /* No symbol information has been set - therefore determine
2276 it from the bfd symbol flags/info. */
2277 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2278 s
->n_type
= BFD_MACH_O_N_ABS
;
2279 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2281 s
->n_type
= BFD_MACH_O_N_UNDF
;
2282 if (s
->symbol
.flags
& BSF_WEAK
)
2283 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2284 /* mach-o automatically makes undefined symbols extern. */
2285 s
->n_type
|= BFD_MACH_O_N_EXT
;
2286 s
->symbol
.flags
|= BSF_GLOBAL
;
2288 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2290 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2291 s
->symbol
.flags
|= BSF_GLOBAL
;
2294 s
->n_type
= BFD_MACH_O_N_SECT
;
2296 if (s
->symbol
.flags
& BSF_GLOBAL
)
2297 s
->n_type
|= BFD_MACH_O_N_EXT
;
2300 /* Put the section index in, where required. */
2301 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2302 && s
->symbol
.section
!= bfd_und_section_ptr
2303 && s
->symbol
.section
!= bfd_com_section_ptr
)
2304 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2305 && s
->symbol
.name
== NULL
))
2306 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2308 /* Number to preserve order for local and debug syms. */
2309 s
->symbol
.udata
.i
= i
;
2312 /* Sort the symbols. */
2313 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2314 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2316 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2318 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2319 s
->symbol
.udata
.i
= i
; /* renumber. */
2325 /* We build a flat table of sections, which can be re-ordered if necessary.
2326 Fill in the section number and other mach-o-specific data. */
2329 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2332 unsigned target_index
;
2335 nsect
= bfd_count_sections (abfd
);
2337 /* Don't do it if it's already set - assume the application knows what it's
2339 if (mdata
->nsects
== nsect
2340 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2343 /* We need to check that this can be done... */
2346 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%u)"
2347 " maximum is 255,\n"), nsect
);
2351 mdata
->nsects
= nsect
;
2352 mdata
->sections
= bfd_alloc (abfd
,
2353 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2354 if (mdata
->sections
== NULL
)
2357 /* Create Mach-O sections.
2358 Section type, attribute and align should have been set when the
2359 section was created - either read in or specified. */
2361 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2363 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
2364 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2366 mdata
->sections
[target_index
] = msect
;
2368 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
2369 msect
->size
= bfd_get_section_size (sec
);
2371 /* Use the largest alignment set, in case it was bumped after the
2372 section was created. */
2373 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2376 sec
->target_index
= ++target_index
;
2383 bfd_mach_o_write_contents (bfd
*abfd
)
2385 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2386 bfd_mach_o_load_command
*cmd
;
2387 bfd_mach_o_symtab_command
*symtab
= NULL
;
2388 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2389 bfd_mach_o_segment_command
*linkedit
= NULL
;
2391 /* Make the commands, if not already present. */
2392 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2394 abfd
->output_has_begun
= TRUE
;
2396 /* Write the header. */
2397 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2400 /* First pass: allocate the linkedit segment. */
2401 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2404 case BFD_MACH_O_LC_SEGMENT_64
:
2405 case BFD_MACH_O_LC_SEGMENT
:
2406 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2407 linkedit
= &cmd
->command
.segment
;
2409 case BFD_MACH_O_LC_SYMTAB
:
2410 symtab
= &cmd
->command
.symtab
;
2412 case BFD_MACH_O_LC_DYSYMTAB
:
2413 dysymtab
= &cmd
->command
.dysymtab
;
2415 case BFD_MACH_O_LC_DYLD_INFO
:
2417 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2419 if (di
->rebase_size
!= 0)
2421 di
->rebase_off
= mdata
->filelen
;
2422 mdata
->filelen
+= di
->rebase_size
;
2424 if (di
->bind_size
!= 0)
2426 di
->bind_off
= mdata
->filelen
;
2427 mdata
->filelen
+= di
->bind_size
;
2429 if (di
->weak_bind_size
!= 0)
2431 di
->weak_bind_off
= mdata
->filelen
;
2432 mdata
->filelen
+= di
->weak_bind_size
;
2434 if (di
->lazy_bind_size
!= 0)
2436 di
->lazy_bind_off
= mdata
->filelen
;
2437 mdata
->filelen
+= di
->lazy_bind_size
;
2439 if (di
->export_size
!= 0)
2441 di
->export_off
= mdata
->filelen
;
2442 mdata
->filelen
+= di
->export_size
;
2446 case BFD_MACH_O_LC_LOAD_DYLIB
:
2447 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2448 case BFD_MACH_O_LC_MAIN
:
2449 /* Nothing to do. */
2452 (*_bfd_error_handler
)
2453 (_("unable to allocate data for load command 0x%lx"),
2454 (unsigned long) cmd
->type
);
2458 /* Specially handle symtab and dysymtab. */
2460 /* Pre-allocate the symbol table (but not the string table). The reason
2461 is that the dysymtab is after the symbol table but before the string
2462 table (required by the native strip tool). */
2465 unsigned int symlen
;
2466 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2468 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2470 /* Align for symbols. */
2471 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2472 symtab
->symoff
= mdata
->filelen
;
2474 symtab
->nsyms
= bfd_get_symcount (abfd
);
2475 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2478 /* Build the dysymtab. */
2479 if (dysymtab
!= NULL
)
2480 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2483 /* Write symtab and strtab. */
2485 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2488 /* Adjust linkedit size. */
2489 if (linkedit
!= NULL
)
2491 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2493 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2494 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2495 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2497 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2498 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2499 | BFD_MACH_O_PROT_EXECUTE
;
2502 /* Second pass: write commands. */
2503 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2505 struct mach_o_load_command_external raw
;
2506 unsigned long typeflag
;
2508 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2510 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2511 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2513 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2514 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2519 case BFD_MACH_O_LC_SEGMENT
:
2520 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2523 case BFD_MACH_O_LC_SEGMENT_64
:
2524 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2527 case BFD_MACH_O_LC_SYMTAB
:
2528 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2531 case BFD_MACH_O_LC_DYSYMTAB
:
2532 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2535 case BFD_MACH_O_LC_THREAD
:
2536 case BFD_MACH_O_LC_UNIXTHREAD
:
2537 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2540 case BFD_MACH_O_LC_LOAD_DYLIB
:
2541 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2544 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2545 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2548 case BFD_MACH_O_LC_MAIN
:
2549 if (!bfd_mach_o_write_main (abfd
, cmd
))
2552 case BFD_MACH_O_LC_DYLD_INFO
:
2553 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2557 (*_bfd_error_handler
)
2558 (_("unable to write unknown load command 0x%lx"),
2559 (unsigned long) cmd
->type
);
2568 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2569 bfd_mach_o_section
*s
)
2571 if (seg
->sect_head
== NULL
)
2574 seg
->sect_tail
->next
= s
;
2578 /* Create section Mach-O flags from BFD flags. */
2581 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2585 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2587 /* Create default flags. */
2588 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2589 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2590 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2591 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2592 | BFD_MACH_O_S_REGULAR
;
2593 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2594 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2595 else if (bfd_flags
& SEC_DEBUGGING
)
2596 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2598 s
->flags
= BFD_MACH_O_S_REGULAR
;
2602 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2604 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2608 seg
->fileoff
= mdata
->filelen
;
2609 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2610 | BFD_MACH_O_PROT_EXECUTE
;
2611 seg
->maxprot
= seg
->initprot
;
2613 /* Append sections to the segment.
2615 This is a little tedious, we have to honor the need to account zerofill
2616 sections after all the rest. This forces us to do the calculation of
2617 total vmsize in three passes so that any alignment increments are
2618 properly accounted. */
2619 for (i
= 0; i
< mdata
->nsects
; ++i
)
2621 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2622 asection
*sec
= s
->bfdsection
;
2624 /* Although we account for zerofill section sizes in vm order, they are
2625 placed in the file in source sequence. */
2626 bfd_mach_o_append_section_to_segment (seg
, s
);
2629 /* Zerofill sections have zero file size & offset, the only content
2630 written to the file is the symbols. */
2631 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2632 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2633 == BFD_MACH_O_S_GB_ZEROFILL
))
2636 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2637 sections, even those with zero size. */
2640 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2641 seg
->vmsize
+= s
->size
;
2643 /* MH_OBJECT files have unaligned content. */
2646 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2647 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2649 seg
->filesize
+= s
->size
;
2651 /* The system tools write even zero-sized sections with an offset
2652 field set to the current file position. */
2653 s
->offset
= mdata
->filelen
;
2656 sec
->filepos
= s
->offset
;
2657 mdata
->filelen
+= s
->size
;
2660 /* Now pass through again, for zerofill, only now we just update the
2661 vmsize, and then for zerofill_GB. */
2662 for (j
= 0; j
< 2; j
++)
2667 stype
= BFD_MACH_O_S_ZEROFILL
;
2669 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2671 for (i
= 0; i
< mdata
->nsects
; ++i
)
2673 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2675 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2680 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2681 seg
->vmsize
+= s
->size
;
2686 /* Allocate space for the relocations. */
2687 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2689 for (i
= 0; i
< mdata
->nsects
; ++i
)
2691 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2692 asection
*sec
= ms
->bfdsection
;
2694 ms
->nreloc
= sec
->reloc_count
;
2695 if (ms
->nreloc
== 0)
2697 /* Clear nreloc and reloff if there is no relocs. */
2701 sec
->rel_filepos
= mdata
->filelen
;
2702 ms
->reloff
= sec
->rel_filepos
;
2703 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2710 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2712 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2714 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2716 bfd_mach_o_section
*s
;
2720 seg
->fileoff
= mdata
->filelen
;
2725 /* Append sections to the segment. We assume they are properly ordered
2726 by vma (but we check that). */
2728 for (i
= 0; i
< mdata
->nsects
; ++i
)
2730 s
= mdata
->sections
[i
];
2732 /* Consider only sections for this segment. */
2733 if (strcmp (seg
->segname
, s
->segname
) != 0)
2736 bfd_mach_o_append_section_to_segment (seg
, s
);
2738 BFD_ASSERT (s
->addr
>= vma
);
2739 vma
= s
->addr
+ s
->size
;
2742 /* Set segment file offset: make it page aligned. */
2743 vma
= seg
->sect_head
->addr
;
2744 seg
->vmaddr
= vma
& ~pagemask
;
2745 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2746 mdata
->filelen
+= pagemask
+ 1;
2747 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2748 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2750 /* Set section file offset. */
2751 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2753 asection
*sec
= s
->bfdsection
;
2754 flagword flags
= bfd_get_section_flags (abfd
, sec
);
2756 /* Adjust segment size. */
2757 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2758 seg
->vmsize
+= s
->size
;
2760 /* File offset and length. */
2761 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2763 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
2764 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2765 != BFD_MACH_O_S_GB_ZEROFILL
))
2767 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2769 s
->offset
= mdata
->filelen
;
2770 s
->bfdsection
->filepos
= s
->offset
;
2772 seg
->filesize
+= s
->size
;
2773 mdata
->filelen
+= s
->size
;
2778 s
->bfdsection
->filepos
= 0;
2781 /* Set protection. */
2782 if (flags
& SEC_LOAD
)
2784 if (flags
& SEC_CODE
)
2785 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
2786 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
2787 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
2790 /* Relocs shouldn't appear in non-object files. */
2791 if (s
->bfdsection
->reloc_count
!= 0)
2796 if (seg
->initprot
!= 0)
2797 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2798 | BFD_MACH_O_PROT_EXECUTE
;
2802 /* Round segment size (and file size). */
2803 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
2804 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
2805 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
2810 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2811 fields in header. */
2814 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
2816 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2817 unsigned int hdrlen
;
2819 bfd_mach_o_load_command
*cmd
;
2822 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2823 align
= wide
? 8 - 1 : 4 - 1;
2825 mdata
->header
.ncmds
= 0;
2827 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
2829 mdata
->header
.ncmds
++;
2830 cmd
->offset
= offset
;
2834 case BFD_MACH_O_LC_SEGMENT_64
:
2835 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2836 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
2838 case BFD_MACH_O_LC_SEGMENT
:
2839 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2840 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
2842 case BFD_MACH_O_LC_SYMTAB
:
2843 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2844 + BFD_MACH_O_LC_SIZE
;
2846 case BFD_MACH_O_LC_DYSYMTAB
:
2847 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2848 + BFD_MACH_O_LC_SIZE
;
2850 case BFD_MACH_O_LC_LOAD_DYLIB
:
2851 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
2852 + BFD_MACH_O_LC_SIZE
;
2853 cmd
->command
.dylib
.name_offset
= cmd
->len
;
2854 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
2855 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2857 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2858 cmd
->len
= sizeof (struct mach_o_str_command_external
)
2859 + BFD_MACH_O_LC_SIZE
;
2860 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
2861 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
2862 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2864 case BFD_MACH_O_LC_MAIN
:
2865 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
2866 + BFD_MACH_O_LC_SIZE
;
2868 case BFD_MACH_O_LC_DYLD_INFO
:
2869 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
2870 + BFD_MACH_O_LC_SIZE
;
2873 (*_bfd_error_handler
)
2874 (_("unable to layout unknown load command 0x%lx"),
2875 (unsigned long) cmd
->type
);
2879 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
2882 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
2883 mdata
->filelen
= offset
;
2886 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2890 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
2891 bfd_mach_o_load_command
*cmd
,
2892 const char *segname
, unsigned int nbr_sect
)
2894 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2895 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2897 /* Init segment command. */
2898 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
2899 cmd
->type_required
= FALSE
;
2901 strcpy (seg
->segname
, segname
);
2902 seg
->nsects
= nbr_sect
;
2912 seg
->sect_head
= NULL
;
2913 seg
->sect_tail
= NULL
;
2916 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2917 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2918 and copy functionality. */
2921 bfd_mach_o_build_commands (bfd
*abfd
)
2923 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2924 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2925 unsigned int nbr_segcmd
= 0;
2926 bfd_mach_o_load_command
*commands
;
2927 unsigned int nbr_commands
;
2928 int symtab_idx
= -1;
2929 int dysymtab_idx
= -1;
2933 /* Return now if already built. */
2934 if (mdata
->header
.ncmds
!= 0)
2937 /* Fill in the file type, if not already set. */
2938 if (mdata
->header
.filetype
== 0)
2940 if (abfd
->flags
& EXEC_P
)
2941 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2942 else if (abfd
->flags
& DYNAMIC
)
2943 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2945 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2948 /* If hasn't already been done, flatten sections list, and sort
2949 if/when required. Must be done before the symbol table is adjusted,
2950 since that depends on properly numbered sections. */
2951 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2952 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2955 /* Order the symbol table, fill-in/check mach-o specific fields and
2956 partition out any indirect symbols. */
2957 if (!bfd_mach_o_mangle_symbols (abfd
))
2960 /* Segment commands. */
2961 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
2963 /* Only one segment for all the sections. But the segment is
2964 optional if there is no sections. */
2965 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
2969 bfd_mach_o_section
*prev_sect
= NULL
;
2971 /* One pagezero segment and one linkedit segment. */
2974 /* Create one segment for associated segment name in sections.
2975 Assume that sections with the same segment name are consecutive. */
2976 for (i
= 0; i
< mdata
->nsects
; i
++)
2978 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
2980 if (prev_sect
== NULL
2981 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
2984 prev_sect
= this_sect
;
2989 nbr_commands
= nbr_segcmd
;
2991 /* One command for the symbol table (only if there are symbols. */
2992 if (bfd_get_symcount (abfd
) > 0)
2993 symtab_idx
= nbr_commands
++;
2996 This is a rather crude test for whether we should build a dysymtab. */
2997 if (bfd_mach_o_should_emit_dysymtab ()
2998 && bfd_get_symcount (abfd
))
3000 /* If there should be a case where a dysymtab could be emitted without
3001 a symtab (seems improbable), this would need amending. */
3002 dysymtab_idx
= nbr_commands
++;
3005 /* Add an entry point command. */
3006 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3007 && bfd_get_start_address (abfd
) != 0)
3008 main_idx
= nbr_commands
++;
3010 /* Well, we must have a header, at least. */
3011 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3013 /* A bit unusual, but no content is valid;
3014 as -n empty.s -o empty.o */
3015 if (nbr_commands
== 0)
3017 /* Layout commands (well none...) and set headers command fields. */
3018 bfd_mach_o_layout_commands (mdata
);
3022 /* Create commands for segments (and symtabs), prepend them. */
3023 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3024 if (commands
== NULL
)
3026 for (i
= 0; i
< nbr_commands
- 1; i
++)
3027 commands
[i
].next
= &commands
[i
+ 1];
3028 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3029 if (mdata
->first_command
== NULL
)
3030 mdata
->last_command
= &commands
[nbr_commands
- 1];
3031 mdata
->first_command
= &commands
[0];
3033 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3035 /* For object file, there is only one segment. */
3036 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3038 else if (nbr_segcmd
!= 0)
3040 bfd_mach_o_load_command
*cmd
;
3042 BFD_ASSERT (nbr_segcmd
>= 2);
3046 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3048 /* Segments from sections. */
3050 for (i
= 0; i
< mdata
->nsects
;)
3052 const char *segname
= mdata
->sections
[i
]->segname
;
3053 unsigned int nbr_sect
= 1;
3055 /* Count number of sections for this segment. */
3056 for (i
++; i
< mdata
->nsects
; i
++)
3057 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3062 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3067 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3070 if (symtab_idx
>= 0)
3072 /* Init symtab command. */
3073 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3075 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3076 cmd
->type_required
= FALSE
;
3079 /* If required, setup symtab command, see comment above about the quality
3081 if (dysymtab_idx
>= 0)
3083 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3085 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3086 cmd
->type_required
= FALSE
;
3089 /* Create the main command. */
3092 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3094 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3095 cmd
->type_required
= TRUE
;
3097 cmd
->command
.main
.entryoff
= 0;
3098 cmd
->command
.main
.stacksize
= 0;
3101 /* Layout commands. */
3102 bfd_mach_o_layout_commands (mdata
);
3104 /* So, now we have sized the commands and the filelen set to that.
3105 Now we can build the segment command and set the section file offsets. */
3106 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3108 for (i
= 0; i
< nbr_segcmd
; i
++)
3109 if (!bfd_mach_o_build_obj_seg_command
3110 (abfd
, &commands
[i
].command
.segment
))
3117 /* Skip pagezero and linkedit segments. */
3118 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3120 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3122 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3125 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3126 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3129 /* Set the size of __PAGEZERO. */
3130 commands
[0].command
.segment
.vmsize
=
3131 commands
[1].command
.segment
.vmaddr
;
3133 /* Set the vma and fileoff of __LINKEDIT. */
3134 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3135 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3137 /* Set entry point (once segments have been laid out). */
3139 commands
[main_idx
].command
.main
.entryoff
=
3140 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3146 /* Set the contents of a section. */
3149 bfd_mach_o_set_section_contents (bfd
*abfd
,
3151 const void * location
,
3153 bfd_size_type count
)
3157 /* Trying to write the first section contents will trigger the creation of
3158 the load commands if they are not already present. */
3159 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3165 pos
= section
->filepos
+ offset
;
3166 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3167 || bfd_bwrite (location
, count
, abfd
) != count
)
3174 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3175 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3180 /* Make an empty symbol. This is required only because
3181 bfd_make_section_anyway wants to create a symbol for the section. */
3184 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3186 asymbol
*new_symbol
;
3188 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3189 if (new_symbol
== NULL
)
3191 new_symbol
->the_bfd
= abfd
;
3192 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3197 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
3199 struct mach_o_header_external raw
;
3201 bfd_vma (*get32
) (const void *) = NULL
;
3203 /* Just read the magic number. */
3204 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3205 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3208 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3210 header
->byteorder
= BFD_ENDIAN_BIG
;
3211 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3212 header
->version
= 1;
3215 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3217 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3218 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3219 header
->version
= 1;
3222 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3224 header
->byteorder
= BFD_ENDIAN_BIG
;
3225 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3226 header
->version
= 2;
3229 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3231 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3232 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3233 header
->version
= 2;
3238 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3242 /* Once the size of the header is known, read the full header. */
3243 size
= mach_o_wide_p (header
) ?
3244 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3246 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3247 || bfd_bread (&raw
, size
, abfd
) != size
)
3250 header
->cputype
= (*get32
) (raw
.cputype
);
3251 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3252 header
->filetype
= (*get32
) (raw
.filetype
);
3253 header
->ncmds
= (*get32
) (raw
.ncmds
);
3254 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3255 header
->flags
= (*get32
) (raw
.flags
);
3257 if (mach_o_wide_p (header
))
3258 header
->reserved
= (*get32
) (raw
.reserved
);
3260 header
->reserved
= 0;
3266 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3268 bfd_mach_o_section
*s
;
3269 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
3271 s
= bfd_mach_o_get_mach_o_section (sec
);
3275 static const mach_o_section_name_xlat
* xlat
;
3277 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3280 sec
->used_by_bfd
= s
;
3281 s
->bfdsection
= sec
;
3283 /* Create the Darwin seg/sect name pair from the bfd name.
3284 If this is a canonical name for which a specific paiting exists
3285 there will also be defined flags, type, attribute and alignment
3287 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3290 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3291 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3293 (void) bfd_set_section_alignment (abfd
, sec
, s
->align
);
3294 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
3295 if (bfd_flags
== SEC_NO_FLAGS
)
3296 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
3299 /* Create default flags. */
3300 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3303 return _bfd_generic_new_section_hook (abfd
, sec
);
3307 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
3311 bfd_mach_o_section
*section
;
3313 flags
= bfd_get_section_flags (abfd
, sec
);
3314 section
= bfd_mach_o_get_mach_o_section (sec
);
3316 /* TODO: see if we should use the xlat system for doing this by
3317 preference and fall back to this for unknown sections. */
3319 if (flags
== SEC_NO_FLAGS
)
3321 /* Try to guess flags. */
3322 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3323 flags
= SEC_DEBUGGING
;
3327 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3328 != BFD_MACH_O_S_ZEROFILL
)
3331 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3333 if (prot
& BFD_MACH_O_PROT_WRITE
)
3335 else if (prot
& BFD_MACH_O_PROT_READ
)
3336 flags
|= SEC_READONLY
;
3342 if ((flags
& SEC_DEBUGGING
) == 0)
3346 if (section
->offset
!= 0)
3347 flags
|= SEC_HAS_CONTENTS
;
3348 if (section
->nreloc
!= 0)
3351 bfd_set_section_flags (abfd
, sec
, flags
);
3353 sec
->vma
= section
->addr
;
3354 sec
->lma
= section
->addr
;
3355 sec
->size
= section
->size
;
3356 sec
->filepos
= section
->offset
;
3357 sec
->alignment_power
= section
->align
;
3358 sec
->segment_mark
= 0;
3359 sec
->reloc_count
= section
->nreloc
;
3360 sec
->rel_filepos
= section
->reloff
;
3364 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3365 const unsigned char *segname
,
3366 const unsigned char *sectname
)
3371 bfd_mach_o_convert_section_name_to_bfd
3372 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3376 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3380 bfd_mach_o_read_section_32 (bfd
*abfd
,
3381 unsigned int offset
,
3384 struct mach_o_section_32_external raw
;
3386 bfd_mach_o_section
*section
;
3388 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3389 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3390 != BFD_MACH_O_SECTION_SIZE
))
3393 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3397 section
= bfd_mach_o_get_mach_o_section (sec
);
3398 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3399 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3400 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3401 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3402 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3403 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3404 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3405 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3406 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3407 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3408 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3409 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3410 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3411 section
->reserved3
= 0;
3413 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3419 bfd_mach_o_read_section_64 (bfd
*abfd
,
3420 unsigned int offset
,
3423 struct mach_o_section_64_external raw
;
3425 bfd_mach_o_section
*section
;
3427 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3428 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3429 != BFD_MACH_O_SECTION_64_SIZE
))
3432 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3436 section
= bfd_mach_o_get_mach_o_section (sec
);
3437 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3438 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3439 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3440 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3441 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3442 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3443 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3444 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3445 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3446 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3447 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3448 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3449 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3450 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3452 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3458 bfd_mach_o_read_section (bfd
*abfd
,
3459 unsigned int offset
,
3464 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
3466 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
3470 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3471 bfd_mach_o_symtab_command
*sym
,
3472 bfd_mach_o_asymbol
*s
,
3475 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3476 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3477 unsigned int symwidth
=
3478 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3479 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3480 struct mach_o_nlist_64_external raw
;
3481 unsigned char type
= -1;
3482 unsigned char section
= -1;
3484 symvalue value
= -1;
3485 unsigned long stroff
= -1;
3486 unsigned int symtype
= -1;
3488 BFD_ASSERT (sym
->strtab
!= NULL
);
3490 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3491 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3493 (*_bfd_error_handler
)
3494 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3495 symwidth
, (unsigned long) symoff
);
3499 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3500 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3501 symtype
= type
& BFD_MACH_O_N_TYPE
;
3502 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3503 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3505 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3507 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3509 if (stroff
>= sym
->strsize
)
3511 (*_bfd_error_handler
)
3512 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3513 (unsigned long) stroff
,
3514 (unsigned long) sym
->strsize
);
3518 s
->symbol
.the_bfd
= abfd
;
3519 s
->symbol
.name
= sym
->strtab
+ stroff
;
3520 s
->symbol
.value
= value
;
3521 s
->symbol
.flags
= 0x0;
3522 s
->symbol
.udata
.i
= i
;
3524 s
->n_sect
= section
;
3527 if (type
& BFD_MACH_O_N_STAB
)
3529 s
->symbol
.flags
|= BSF_DEBUGGING
;
3530 s
->symbol
.section
= bfd_und_section_ptr
;
3542 if ((section
> 0) && (section
<= mdata
->nsects
))
3544 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3546 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3553 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3554 s
->symbol
.flags
|= BSF_GLOBAL
;
3556 s
->symbol
.flags
|= BSF_LOCAL
;
3560 case BFD_MACH_O_N_UNDF
:
3561 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3562 && s
->symbol
.value
!= 0)
3564 /* A common symbol. */
3565 s
->symbol
.section
= bfd_com_section_ptr
;
3566 s
->symbol
.flags
= BSF_NO_FLAGS
;
3570 s
->symbol
.section
= bfd_und_section_ptr
;
3571 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3572 s
->symbol
.flags
|= BSF_WEAK
;
3575 case BFD_MACH_O_N_PBUD
:
3576 s
->symbol
.section
= bfd_und_section_ptr
;
3578 case BFD_MACH_O_N_ABS
:
3579 s
->symbol
.section
= bfd_abs_section_ptr
;
3581 case BFD_MACH_O_N_SECT
:
3582 if ((section
> 0) && (section
<= mdata
->nsects
))
3584 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3586 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3590 /* Mach-O uses 0 to mean "no section"; not an error. */
3593 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3594 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3595 s
->symbol
.name
, section
, mdata
->nsects
);
3597 s
->symbol
.section
= bfd_und_section_ptr
;
3600 case BFD_MACH_O_N_INDR
:
3601 /* FIXME: we don't follow the BFD convention as this indirect symbol
3602 won't be followed by the referenced one. This looks harmless
3603 unless we start using the linker. */
3604 s
->symbol
.flags
|= BSF_INDIRECT
;
3605 s
->symbol
.section
= bfd_ind_section_ptr
;
3606 s
->symbol
.value
= 0;
3609 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3610 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3611 s
->symbol
.name
, symtype
);
3612 s
->symbol
.section
= bfd_und_section_ptr
;
3621 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3623 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3624 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3626 /* Fail if there is no symtab. */
3630 /* Success if already loaded. */
3634 if (abfd
->flags
& BFD_IN_MEMORY
)
3636 struct bfd_in_memory
*b
;
3638 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3640 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3642 bfd_set_error (bfd_error_file_truncated
);
3645 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3649 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
3650 if (sym
->strtab
== NULL
)
3653 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
3654 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
3656 /* PR 17512: file: 10888-1609-0.004. */
3657 bfd_release (abfd
, sym
->strtab
);
3659 bfd_set_error (bfd_error_file_truncated
);
3668 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3670 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3671 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3674 if (sym
== NULL
|| sym
->symbols
)
3675 /* Return now if there are no symbols or if already loaded. */
3678 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
3680 if (sym
->symbols
== NULL
)
3682 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3686 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3688 bfd_release (abfd
, sym
->symbols
);
3689 sym
->symbols
= NULL
;
3693 for (i
= 0; i
< sym
->nsyms
; i
++)
3695 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3697 bfd_release (abfd
, sym
->symbols
);
3698 sym
->symbols
= NULL
;
3707 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3709 switch ((int) flavour
)
3711 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3712 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3713 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3714 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3715 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3716 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3717 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3718 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3719 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3720 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3721 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3722 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3723 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3724 default: return "UNKNOWN";
3729 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3731 switch ((int) flavour
)
3733 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3734 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3735 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3736 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3737 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3738 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3739 default: return "UNKNOWN";
3744 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3746 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
3747 struct mach_o_str_command_external raw
;
3748 unsigned int nameoff
;
3749 unsigned int namelen
;
3751 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3752 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3755 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
3757 cmd
->name_offset
= nameoff
;
3758 namelen
= command
->len
- nameoff
;
3759 nameoff
+= command
->offset
;
3760 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3761 if (cmd
->name_str
== NULL
)
3763 if (bfd_seek (abfd
, nameoff
, SEEK_SET
) != 0
3764 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3770 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3772 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3773 struct mach_o_dylib_command_external raw
;
3774 unsigned int nameoff
;
3775 unsigned int namelen
;
3777 switch (command
->type
)
3779 case BFD_MACH_O_LC_LOAD_DYLIB
:
3780 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
3781 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3782 case BFD_MACH_O_LC_ID_DYLIB
:
3783 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3784 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3791 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3792 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3795 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3796 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3797 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3798 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3800 cmd
->name_offset
= command
->offset
+ nameoff
;
3801 namelen
= command
->len
- nameoff
;
3802 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3803 if (cmd
->name_str
== NULL
)
3805 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3806 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3812 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
3813 bfd_mach_o_load_command
*command
)
3815 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
3816 struct mach_o_prebound_dylib_command_external raw
;
3817 unsigned int nameoff
;
3818 unsigned int modoff
;
3819 unsigned int str_len
;
3822 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3823 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3826 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3827 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
3828 if (nameoff
> command
->len
|| modoff
> command
->len
)
3831 str_len
= command
->len
- sizeof (raw
);
3832 str
= bfd_alloc (abfd
, str_len
);
3835 if (bfd_bread (str
, str_len
, abfd
) != str_len
)
3838 cmd
->name_offset
= command
->offset
+ nameoff
;
3839 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
3840 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
3842 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3843 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3848 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
3849 bfd_mach_o_load_command
*command
)
3851 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
3852 struct mach_o_prebind_cksum_command_external raw
;
3854 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3855 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3858 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
3863 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
3864 bfd_mach_o_load_command
*command
)
3866 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
3867 struct mach_o_twolevel_hints_command_external raw
;
3869 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3870 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3873 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
3874 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
3879 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3881 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
3882 struct mach_o_fvmlib_command_external raw
;
3883 unsigned int nameoff
;
3884 unsigned int namelen
;
3886 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3887 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3890 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3891 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3892 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3894 fvm
->name_offset
= command
->offset
+ nameoff
;
3895 namelen
= command
->len
- nameoff
;
3896 fvm
->name_str
= bfd_alloc (abfd
, namelen
);
3897 if (fvm
->name_str
== NULL
)
3899 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3900 || bfd_bread (fvm
->name_str
, namelen
, abfd
) != namelen
)
3906 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3908 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3909 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3910 unsigned int offset
;
3911 unsigned int nflavours
;
3914 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3915 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3917 /* Count the number of threads. */
3920 while (offset
!= command
->len
)
3922 struct mach_o_thread_command_external raw
;
3924 if (offset
>= command
->len
)
3927 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3928 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3931 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3935 /* Allocate threads. */
3936 cmd
->flavours
= bfd_alloc
3937 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3938 if (cmd
->flavours
== NULL
)
3940 cmd
->nflavours
= nflavours
;
3944 while (offset
!= command
->len
)
3946 struct mach_o_thread_command_external raw
;
3948 if (offset
>= command
->len
)
3951 if (nflavours
>= cmd
->nflavours
)
3954 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3955 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3958 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3959 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3960 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3961 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3965 for (i
= 0; i
< nflavours
; i
++)
3968 unsigned int snamelen
;
3970 const char *flavourstr
;
3971 const char *prefix
= "LC_THREAD";
3974 switch (mdata
->header
.cputype
)
3976 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3977 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
3979 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
3981 case BFD_MACH_O_CPU_TYPE_I386
:
3982 case BFD_MACH_O_CPU_TYPE_X86_64
:
3984 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
3987 flavourstr
= "UNKNOWN_ARCHITECTURE";
3991 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
3992 sname
= bfd_alloc (abfd
, snamelen
);
3998 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
3999 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
4004 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
4008 bfdsec
->size
= cmd
->flavours
[i
].size
;
4009 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
4010 bfdsec
->alignment_power
= 0x0;
4012 cmd
->section
= bfdsec
;
4019 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4021 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4022 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4024 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4027 struct mach_o_dysymtab_command_external raw
;
4029 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4030 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4033 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4034 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4035 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4036 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4037 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4038 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4039 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4040 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4041 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4042 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4043 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4044 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4045 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4046 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4047 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4048 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4049 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4050 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4053 if (cmd
->nmodtab
!= 0)
4056 int wide
= bfd_mach_o_wide_p (abfd
);
4057 unsigned int module_len
= wide
? 56 : 52;
4060 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
4061 if (cmd
->dylib_module
== NULL
)
4064 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4067 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4069 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4071 unsigned char buf
[56];
4073 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4076 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4077 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4078 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4079 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4080 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4081 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4082 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4083 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4084 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4085 v
= bfd_h_get_32 (abfd
, buf
+36);
4086 module
->iinit
= v
& 0xffff;
4087 module
->iterm
= (v
>> 16) & 0xffff;
4088 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4089 module
->ninit
= v
& 0xffff;
4090 module
->nterm
= (v
>> 16) & 0xffff;
4093 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4094 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4098 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4099 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4108 cmd
->dylib_toc
= bfd_alloc
4109 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
4110 if (cmd
->dylib_toc
== NULL
)
4113 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4116 for (i
= 0; i
< cmd
->ntoc
; i
++)
4118 struct mach_o_dylib_table_of_contents_external raw
;
4119 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4121 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4124 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4125 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4129 if (cmd
->nindirectsyms
!= 0)
4133 cmd
->indirect_syms
= bfd_alloc
4134 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
4135 if (cmd
->indirect_syms
== NULL
)
4138 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4141 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4143 unsigned char raw
[4];
4144 unsigned int *is
= &cmd
->indirect_syms
[i
];
4146 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4149 *is
= bfd_h_get_32 (abfd
, raw
);
4153 if (cmd
->nextrefsyms
!= 0)
4158 cmd
->ext_refs
= bfd_alloc
4159 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
4160 if (cmd
->ext_refs
== NULL
)
4163 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4166 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4168 unsigned char raw
[4];
4169 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4171 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4174 /* Fields isym and flags are written as bit-fields, thus we need
4175 a specific processing for endianness. */
4176 v
= bfd_h_get_32 (abfd
, raw
);
4177 if (bfd_big_endian (abfd
))
4179 ref
->isym
= (v
>> 8) & 0xffffff;
4180 ref
->flags
= v
& 0xff;
4184 ref
->isym
= v
& 0xffffff;
4185 ref
->flags
= (v
>> 24) & 0xff;
4190 if (mdata
->dysymtab
)
4192 mdata
->dysymtab
= cmd
;
4198 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4200 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4201 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4202 struct mach_o_symtab_command_external raw
;
4204 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4206 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4207 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4210 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4211 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4212 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4213 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4214 symtab
->symbols
= NULL
;
4215 symtab
->strtab
= NULL
;
4217 if (symtab
->nsyms
!= 0)
4218 abfd
->flags
|= HAS_SYMS
;
4222 mdata
->symtab
= symtab
;
4227 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4229 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4231 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4233 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4234 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4241 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4243 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4244 struct mach_o_linkedit_data_command_external raw
;
4246 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4247 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4250 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4251 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4256 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4258 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4259 struct mach_o_str_command_external raw
;
4262 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4263 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4266 off
= bfd_get_32 (abfd
, raw
.str
);
4267 cmd
->stroff
= command
->offset
+ off
;
4268 cmd
->str_len
= command
->len
- off
;
4269 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
4270 if (cmd
->str
== NULL
)
4272 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
4273 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
4278 static unsigned char *
4279 bfd_mach_o_alloc_and_read (bfd
*abfd
, unsigned int off
, unsigned int size
)
4283 buf
= bfd_alloc (abfd
, size
);
4286 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4287 || bfd_bread (buf
, size
, abfd
) != size
)
4293 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4295 /* Read rebase content. */
4296 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4298 cmd
->rebase_content
=
4299 bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4300 if (cmd
->rebase_content
== NULL
)
4304 /* Read bind content. */
4305 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4308 bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4309 if (cmd
->bind_content
== NULL
)
4313 /* Read weak bind content. */
4314 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4316 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4317 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4318 if (cmd
->weak_bind_content
== NULL
)
4322 /* Read lazy bind content. */
4323 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4325 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4326 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4327 if (cmd
->lazy_bind_content
== NULL
)
4331 /* Read export content. */
4332 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4334 cmd
->export_content
= bfd_mach_o_alloc_and_read
4335 (abfd
, cmd
->export_off
, cmd
->export_size
);
4336 if (cmd
->export_content
== NULL
)
4344 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4346 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4347 struct mach_o_dyld_info_command_external raw
;
4349 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4350 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4353 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4354 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4355 cmd
->rebase_content
= NULL
;
4356 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4357 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4358 cmd
->bind_content
= NULL
;
4359 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4360 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4361 cmd
->weak_bind_content
= NULL
;
4362 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4363 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4364 cmd
->lazy_bind_content
= NULL
;
4365 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4366 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4367 cmd
->export_content
= NULL
;
4372 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4374 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4375 struct mach_o_version_min_command_external raw
;
4378 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4379 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4382 ver
= bfd_get_32 (abfd
, raw
.version
);
4383 cmd
->rel
= ver
>> 16;
4384 cmd
->maj
= ver
>> 8;
4386 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
4391 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4393 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4394 struct mach_o_encryption_info_command_external raw
;
4396 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4397 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4400 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4401 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4402 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4407 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4409 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4410 struct mach_o_entry_point_command_external raw
;
4412 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4413 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4416 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4417 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4422 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4424 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4425 struct mach_o_source_version_command_external raw
;
4428 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4429 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4432 ver
= bfd_get_64 (abfd
, raw
.version
);
4433 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4434 generates warnings) in case of the host doesn't support 64 bit
4436 cmd
->e
= ver
& 0x3ff;
4438 cmd
->d
= ver
& 0x3ff;
4440 cmd
->c
= ver
& 0x3ff;
4442 cmd
->b
= ver
& 0x3ff;
4444 cmd
->a
= ver
& 0xffffff;
4449 bfd_mach_o_read_segment (bfd
*abfd
,
4450 bfd_mach_o_load_command
*command
,
4453 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4458 struct mach_o_segment_command_64_external raw
;
4460 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4462 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4463 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4466 memcpy (seg
->segname
, raw
.segname
, 16);
4467 seg
->segname
[16] = '\0';
4469 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4470 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4471 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4472 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4473 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4474 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4475 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4476 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4480 struct mach_o_segment_command_32_external raw
;
4482 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4484 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4485 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4488 memcpy (seg
->segname
, raw
.segname
, 16);
4489 seg
->segname
[16] = '\0';
4491 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4492 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4493 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4494 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4495 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4496 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4497 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4498 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4500 seg
->sect_head
= NULL
;
4501 seg
->sect_tail
= NULL
;
4503 for (i
= 0; i
< seg
->nsects
; i
++)
4509 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
4510 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
4512 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
4513 + (i
* BFD_MACH_O_SECTION_SIZE
);
4515 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
4519 bfd_mach_o_append_section_to_segment
4520 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4527 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4529 return bfd_mach_o_read_segment (abfd
, command
, 0);
4533 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4535 return bfd_mach_o_read_segment (abfd
, command
, 1);
4539 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4541 struct mach_o_load_command_external raw
;
4544 /* Read command type and length. */
4545 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
4546 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4549 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4550 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4551 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4552 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4554 switch (command
->type
)
4556 case BFD_MACH_O_LC_SEGMENT
:
4557 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4560 case BFD_MACH_O_LC_SEGMENT_64
:
4561 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4564 case BFD_MACH_O_LC_SYMTAB
:
4565 if (!bfd_mach_o_read_symtab (abfd
, command
))
4568 case BFD_MACH_O_LC_SYMSEG
:
4570 case BFD_MACH_O_LC_THREAD
:
4571 case BFD_MACH_O_LC_UNIXTHREAD
:
4572 if (!bfd_mach_o_read_thread (abfd
, command
))
4575 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4576 case BFD_MACH_O_LC_ID_DYLINKER
:
4577 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4578 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4581 case BFD_MACH_O_LC_LOAD_DYLIB
:
4582 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4583 case BFD_MACH_O_LC_ID_DYLIB
:
4584 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4585 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4586 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4587 if (!bfd_mach_o_read_dylib (abfd
, command
))
4590 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4591 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4594 case BFD_MACH_O_LC_LOADFVMLIB
:
4595 case BFD_MACH_O_LC_IDFVMLIB
:
4596 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4599 case BFD_MACH_O_LC_IDENT
:
4600 case BFD_MACH_O_LC_FVMFILE
:
4601 case BFD_MACH_O_LC_PREPAGE
:
4602 case BFD_MACH_O_LC_ROUTINES
:
4603 case BFD_MACH_O_LC_ROUTINES_64
:
4605 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4606 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4607 case BFD_MACH_O_LC_SUB_LIBRARY
:
4608 case BFD_MACH_O_LC_SUB_CLIENT
:
4609 case BFD_MACH_O_LC_RPATH
:
4610 if (!bfd_mach_o_read_str (abfd
, command
))
4613 case BFD_MACH_O_LC_DYSYMTAB
:
4614 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4617 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4618 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4621 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4622 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4625 case BFD_MACH_O_LC_UUID
:
4626 if (!bfd_mach_o_read_uuid (abfd
, command
))
4629 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4630 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4631 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4632 case BFD_MACH_O_LC_DATA_IN_CODE
:
4633 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4634 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4637 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4638 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4641 case BFD_MACH_O_LC_DYLD_INFO
:
4642 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
4645 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4646 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4647 if (!bfd_mach_o_read_version_min (abfd
, command
))
4650 case BFD_MACH_O_LC_MAIN
:
4651 if (!bfd_mach_o_read_main (abfd
, command
))
4654 case BFD_MACH_O_LC_SOURCE_VERSION
:
4655 if (!bfd_mach_o_read_source_version (abfd
, command
))
4659 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
4660 abfd
, (unsigned long) command
->type
);
4668 bfd_mach_o_flatten_sections (bfd
*abfd
)
4670 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4671 bfd_mach_o_load_command
*cmd
;
4674 /* Count total number of sections. */
4677 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4679 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4680 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4682 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4684 mdata
->nsects
+= seg
->nsects
;
4688 /* Allocate sections array. */
4689 mdata
->sections
= bfd_alloc (abfd
,
4690 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
4692 /* Fill the array. */
4695 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4697 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4698 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4700 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4701 bfd_mach_o_section
*sec
;
4703 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
4705 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
4706 mdata
->sections
[csect
++] = sec
;
4712 bfd_mach_o_scan_start_address (bfd
*abfd
)
4714 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4715 bfd_mach_o_thread_command
*thr
= NULL
;
4716 bfd_mach_o_load_command
*cmd
;
4719 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4720 if (cmd
->type
== BFD_MACH_O_LC_THREAD
4721 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
4723 thr
= &cmd
->command
.thread
;
4726 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
4728 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
4729 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
4733 abfd
->start_address
= main_cmd
->entryoff
4734 + (text_sect
->addr
- text_sect
->offset
);
4739 /* An object file has no start address, so do not fail if not found. */
4743 /* FIXME: create a subtarget hook ? */
4744 for (i
= 0; i
< thr
->nflavours
; i
++)
4746 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
4747 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
4749 unsigned char buf
[4];
4751 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
4752 || bfd_bread (buf
, 4, abfd
) != 4)
4755 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4757 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
4758 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
4760 unsigned char buf
[4];
4762 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4763 || bfd_bread (buf
, 4, abfd
) != 4)
4766 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4768 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
4769 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
4771 unsigned char buf
[8];
4773 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4774 || bfd_bread (buf
, 8, abfd
) != 8)
4777 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4779 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
4780 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
4782 unsigned char buf
[8];
4784 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
4785 || bfd_bread (buf
, 8, abfd
) != 8)
4788 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4796 bfd_mach_o_set_arch_mach (bfd
*abfd
,
4797 enum bfd_architecture arch
,
4798 unsigned long machine
)
4800 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4802 /* If this isn't the right architecture for this backend, and this
4803 isn't the generic backend, fail. */
4804 if (arch
!= bed
->arch
4805 && arch
!= bfd_arch_unknown
4806 && bed
->arch
!= bfd_arch_unknown
)
4809 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4813 bfd_mach_o_scan (bfd
*abfd
,
4814 bfd_mach_o_header
*header
,
4815 bfd_mach_o_data_struct
*mdata
)
4818 enum bfd_architecture cputype
;
4819 unsigned long cpusubtype
;
4820 unsigned int hdrsize
;
4822 hdrsize
= mach_o_wide_p (header
) ?
4823 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
4825 mdata
->header
= *header
;
4827 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
4828 switch (header
->filetype
)
4830 case BFD_MACH_O_MH_OBJECT
:
4831 abfd
->flags
|= HAS_RELOC
;
4833 case BFD_MACH_O_MH_EXECUTE
:
4834 abfd
->flags
|= EXEC_P
;
4836 case BFD_MACH_O_MH_DYLIB
:
4837 case BFD_MACH_O_MH_BUNDLE
:
4838 abfd
->flags
|= DYNAMIC
;
4842 abfd
->tdata
.mach_o_data
= mdata
;
4844 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
4845 &cputype
, &cpusubtype
);
4846 if (cputype
== bfd_arch_unknown
)
4848 (*_bfd_error_handler
)
4849 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4850 header
->cputype
, header
->cpusubtype
);
4854 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
4856 if (header
->ncmds
!= 0)
4858 bfd_mach_o_load_command
*cmd
;
4860 mdata
->first_command
= NULL
;
4861 mdata
->last_command
= NULL
;
4862 cmd
= bfd_alloc (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
4866 for (i
= 0; i
< header
->ncmds
; i
++)
4868 bfd_mach_o_load_command
*cur
= &cmd
[i
];
4870 bfd_mach_o_append_command (abfd
, cur
);
4873 cur
->offset
= hdrsize
;
4876 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
4877 cur
->offset
= prev
->offset
+ prev
->len
;
4880 if (!bfd_mach_o_read_command (abfd
, cur
))
4885 /* Sections should be flatten before scanning start address. */
4886 bfd_mach_o_flatten_sections (abfd
);
4887 if (!bfd_mach_o_scan_start_address (abfd
))
4894 bfd_mach_o_mkobject_init (bfd
*abfd
)
4896 bfd_mach_o_data_struct
*mdata
= NULL
;
4898 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
4901 abfd
->tdata
.mach_o_data
= mdata
;
4903 mdata
->header
.magic
= 0;
4904 mdata
->header
.cputype
= 0;
4905 mdata
->header
.cpusubtype
= 0;
4906 mdata
->header
.filetype
= 0;
4907 mdata
->header
.ncmds
= 0;
4908 mdata
->header
.sizeofcmds
= 0;
4909 mdata
->header
.flags
= 0;
4910 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
4911 mdata
->first_command
= NULL
;
4912 mdata
->last_command
= NULL
;
4914 mdata
->sections
= NULL
;
4915 mdata
->dyn_reloc_cache
= NULL
;
4921 bfd_mach_o_gen_mkobject (bfd
*abfd
)
4923 bfd_mach_o_data_struct
*mdata
;
4925 if (!bfd_mach_o_mkobject_init (abfd
))
4928 mdata
= bfd_mach_o_get_data (abfd
);
4929 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
4930 mdata
->header
.cputype
= 0;
4931 mdata
->header
.cpusubtype
= 0;
4932 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
4933 mdata
->header
.version
= 1;
4939 bfd_mach_o_header_p (bfd
*abfd
,
4940 bfd_mach_o_filetype filetype
,
4941 bfd_mach_o_cpu_type cputype
)
4943 bfd_mach_o_header header
;
4944 bfd_mach_o_data_struct
*mdata
;
4946 if (!bfd_mach_o_read_header (abfd
, &header
))
4949 if (! (header
.byteorder
== BFD_ENDIAN_BIG
4950 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
4952 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
4953 (unsigned long) header
.byteorder
);
4957 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
4958 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
4959 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
4960 || (header
.byteorder
== BFD_ENDIAN_LITTLE
4961 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
4962 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
4965 /* Check cputype and filetype.
4966 In case of wildcard, do not accept magics that are handled by existing
4970 if (header
.cputype
!= cputype
)
4976 /* Do not recognize 64 architectures if not configured for 64bit targets.
4977 This could happen only for generic targets. */
4978 if (mach_o_wide_p (&header
))
4985 if (header
.filetype
!= filetype
)
4990 switch (header
.filetype
)
4992 case BFD_MACH_O_MH_CORE
:
4993 /* Handled by core_p */
5000 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
5004 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
5010 bfd_set_error (bfd_error_wrong_format
);
5016 static const bfd_target
*
5017 bfd_mach_o_gen_object_p (bfd
*abfd
)
5019 return bfd_mach_o_header_p (abfd
, 0, 0);
5022 static const bfd_target
*
5023 bfd_mach_o_gen_core_p (bfd
*abfd
)
5025 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
5028 /* Return the base address of ABFD, ie the address at which the image is
5029 mapped. The possible initial pagezero is ignored. */
5032 bfd_mach_o_get_base_address (bfd
*abfd
)
5034 bfd_mach_o_data_struct
*mdata
;
5035 bfd_mach_o_load_command
*cmd
;
5037 /* Check for Mach-O. */
5038 if (!bfd_mach_o_valid (abfd
))
5040 mdata
= bfd_mach_o_get_data (abfd
);
5042 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5044 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5045 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5047 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5049 if (segcmd
->initprot
!= 0)
5050 return segcmd
->vmaddr
;
5056 typedef struct mach_o_fat_archentry
5058 unsigned long cputype
;
5059 unsigned long cpusubtype
;
5060 unsigned long offset
;
5062 unsigned long align
;
5063 } mach_o_fat_archentry
;
5065 typedef struct mach_o_fat_data_struct
5067 unsigned long magic
;
5068 unsigned long nfat_arch
;
5069 mach_o_fat_archentry
*archentries
;
5070 } mach_o_fat_data_struct
;
5073 bfd_mach_o_archive_p (bfd
*abfd
)
5075 mach_o_fat_data_struct
*adata
= NULL
;
5076 struct mach_o_fat_header_external hdr
;
5079 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5080 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5083 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5087 adata
->magic
= bfd_getb32 (hdr
.magic
);
5088 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5089 if (adata
->magic
!= 0xcafebabe)
5091 /* Avoid matching Java bytecode files, which have the same magic number.
5092 In the Java bytecode file format this field contains the JVM version,
5093 which starts at 43.0. */
5094 if (adata
->nfat_arch
> 30)
5097 adata
->archentries
=
5098 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
5099 if (adata
->archentries
== NULL
)
5102 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5104 struct mach_o_fat_arch_external arch
;
5105 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5107 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5108 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5109 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5110 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5111 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5114 abfd
->tdata
.mach_o_fat_data
= adata
;
5119 bfd_release (abfd
, adata
);
5120 bfd_set_error (bfd_error_wrong_format
);
5124 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5125 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5126 Set arelt_data and origin fields too. */
5129 bfd_mach_o_fat_member_init (bfd
*abfd
,
5130 enum bfd_architecture arch_type
,
5131 unsigned long arch_subtype
,
5132 mach_o_fat_archentry
*entry
)
5134 struct areltdata
*areltdata
;
5135 /* Create the member filename. Use ARCH_NAME. */
5136 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5140 /* Use the architecture name if known. */
5141 abfd
->filename
= xstrdup (ap
->printable_name
);
5145 /* Forge a uniq id. */
5146 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5147 char *name
= xmalloc (namelen
);
5148 snprintf (name
, namelen
, "0x%lx-0x%lx",
5149 entry
->cputype
, entry
->cpusubtype
);
5150 abfd
->filename
= name
;
5153 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5154 areltdata
->parsed_size
= entry
->size
;
5155 abfd
->arelt_data
= areltdata
;
5156 abfd
->iostream
= NULL
;
5157 abfd
->origin
= entry
->offset
;
5161 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5163 mach_o_fat_data_struct
*adata
;
5164 mach_o_fat_archentry
*entry
= NULL
;
5167 enum bfd_architecture arch_type
;
5168 unsigned long arch_subtype
;
5170 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5171 BFD_ASSERT (adata
!= NULL
);
5173 /* Find index of previous entry. */
5176 /* Start at first one. */
5181 /* Find index of PREV. */
5182 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5184 if (adata
->archentries
[i
].offset
== prev
->origin
)
5188 if (i
== adata
->nfat_arch
)
5191 bfd_set_error (bfd_error_bad_value
);
5195 /* Get next entry. */
5199 if (i
>= adata
->nfat_arch
)
5201 bfd_set_error (bfd_error_no_more_archived_files
);
5205 entry
= &adata
->archentries
[i
];
5206 nbfd
= _bfd_new_bfd_contained_in (archive
);
5210 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5211 &arch_type
, &arch_subtype
);
5213 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
5215 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5220 /* Analogous to stat call. */
5223 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5225 if (abfd
->arelt_data
== NULL
)
5227 bfd_set_error (bfd_error_invalid_operation
);
5234 buf
->st_mode
= 0644;
5235 buf
->st_size
= arelt_size (abfd
);
5240 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5241 If ABFD is a fat image containing a member that corresponds to FORMAT
5242 and ARCH, returns it.
5243 In other case, returns NULL.
5244 This function allows transparent uses of fat images. */
5247 bfd_mach_o_fat_extract (bfd
*abfd
,
5249 const bfd_arch_info_type
*arch
)
5252 mach_o_fat_data_struct
*adata
;
5255 if (bfd_check_format (abfd
, format
))
5257 if (bfd_get_arch_info (abfd
) == arch
)
5261 if (!bfd_check_format (abfd
, bfd_archive
)
5262 || abfd
->xvec
!= &mach_o_fat_vec
)
5265 /* This is a Mach-O fat image. */
5266 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5267 BFD_ASSERT (adata
!= NULL
);
5269 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5271 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5272 enum bfd_architecture cpu_type
;
5273 unsigned long cpu_subtype
;
5275 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5276 &cpu_type
, &cpu_subtype
);
5277 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5280 /* The architecture is found. */
5281 res
= _bfd_new_bfd_contained_in (abfd
);
5285 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
5287 if (bfd_check_format (res
, format
))
5289 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5300 bfd_mach_o_lookup_command (bfd
*abfd
,
5301 bfd_mach_o_load_command_type type
,
5302 bfd_mach_o_load_command
**mcommand
)
5304 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5305 struct bfd_mach_o_load_command
*cmd
;
5308 BFD_ASSERT (mdata
!= NULL
);
5309 BFD_ASSERT (mcommand
!= NULL
);
5312 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5314 if (cmd
->type
!= type
)
5326 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5330 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5332 case BFD_MACH_O_CPU_TYPE_MC88000
:
5334 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5336 case BFD_MACH_O_CPU_TYPE_I386
:
5338 case BFD_MACH_O_CPU_TYPE_SPARC
:
5340 case BFD_MACH_O_CPU_TYPE_I860
:
5342 case BFD_MACH_O_CPU_TYPE_HPPA
:
5343 return 0xc0000000 - 0x04000000;
5349 /* The following two tables should be kept, as far as possible, in order of
5350 most frequently used entries to optimize their use from gas. */
5352 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5354 { "regular", BFD_MACH_O_S_REGULAR
},
5355 { "coalesced", BFD_MACH_O_S_COALESCED
},
5356 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5357 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5358 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5359 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5360 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5361 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5362 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5363 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5364 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5365 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5366 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5367 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5368 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5369 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5370 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5374 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5376 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5377 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5378 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5379 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5380 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5381 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5382 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5383 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5384 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5385 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5386 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5390 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5393 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5395 const bfd_mach_o_xlat_name
*x
;
5396 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5398 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5399 if (strcmp (x
->name
, name
) == 0)
5401 /* We found it... does the target support it? */
5402 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5403 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5404 return x
->val
; /* OK. */
5406 break; /* Not supported. */
5408 /* Maximum section ID = 0xff. */
5412 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5415 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5417 const bfd_mach_o_xlat_name
*x
;
5419 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5420 if (strcmp (x
->name
, name
) == 0)
5422 return (unsigned int)-1;
5426 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5427 unsigned char **rbuf
,
5430 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5431 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5432 bfd_mach_o_load_command
*cmd
;
5434 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5436 bfd_mach_o_segment_command
*seg
;
5438 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5441 seg
= &cmd
->command
.segment
;
5443 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5445 unsigned long start
= seg
->fileoff
;
5446 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5447 unsigned char *buf
= bfd_malloc (1024);
5448 unsigned long size
= 1024;
5452 bfd_size_type nread
= 0;
5453 unsigned long offset
;
5454 int found_nonnull
= 0;
5456 if (size
> (end
- start
))
5457 size
= (end
- start
);
5459 buf
= bfd_realloc_or_free (buf
, size
);
5463 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5469 nread
= bfd_bread (buf
, size
, abfd
);
5477 for (offset
= 4; offset
<= size
; offset
+= 4)
5481 val
= *((unsigned long *) (buf
+ size
- offset
));
5482 if (! found_nonnull
)
5487 else if (val
== 0x0)
5489 unsigned long bottom
;
5492 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5493 top
= seg
->fileoff
+ seg
->filesize
- 4;
5494 *rbuf
= bfd_malloc (top
- bottom
);
5495 *rlen
= top
- bottom
;
5497 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5503 if (size
== (end
- start
))
5517 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5519 unsigned char *buf
= NULL
;
5520 unsigned int len
= 0;
5523 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5527 return (char *) buf
;
5531 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5536 static bfd_mach_o_uuid_command
*
5537 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5539 bfd_mach_o_load_command
*uuid_cmd
;
5540 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5543 return &uuid_cmd
->command
.uuid
;
5546 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5549 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5551 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5554 BFD_ASSERT (uuid_cmd
);
5556 if (!bfd_check_format (abfd
, bfd_object
))
5559 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5560 || bfd_mach_o_get_data (abfd
) == NULL
5561 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5564 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5565 if (dsym_uuid_cmd
== NULL
)
5568 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5569 sizeof (uuid_cmd
->uuid
)) != 0)
5575 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5576 The caller is responsible for closing the returned BFD object and
5577 its my_archive if the returned BFD is in a fat dSYM. */
5580 bfd_mach_o_find_dsym (const char *dsym_filename
,
5581 const bfd_mach_o_uuid_command
*uuid_cmd
,
5582 const bfd_arch_info_type
*arch
)
5584 bfd
*base_dsym_bfd
, *dsym_bfd
;
5586 BFD_ASSERT (uuid_cmd
);
5588 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
5589 if (base_dsym_bfd
== NULL
)
5592 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
5593 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
5596 bfd_close (dsym_bfd
);
5597 if (base_dsym_bfd
!= dsym_bfd
)
5598 bfd_close (base_dsym_bfd
);
5603 /* Return a BFD created from a dSYM file for ABFD.
5604 The caller is responsible for closing the returned BFD object, its
5605 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5608 bfd_mach_o_follow_dsym (bfd
*abfd
)
5610 char *dsym_filename
;
5611 bfd_mach_o_uuid_command
*uuid_cmd
;
5612 bfd
*dsym_bfd
, *base_bfd
= abfd
;
5613 const char *base_basename
;
5615 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
5618 if (abfd
->my_archive
)
5619 base_bfd
= abfd
->my_archive
;
5620 /* BFD may have been opened from a stream. */
5621 if (base_bfd
->filename
== NULL
)
5623 bfd_set_error (bfd_error_invalid_operation
);
5626 base_basename
= lbasename (base_bfd
->filename
);
5628 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5629 if (uuid_cmd
== NULL
)
5632 /* TODO: We assume the DWARF file has the same as the binary's.
5633 It seems apple's GDB checks all files in the dSYM bundle directory.
5634 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5636 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
5637 + strlen (dsym_subdir
) + 1
5638 + strlen (base_basename
) + 1);
5639 sprintf (dsym_filename
, "%s%s/%s",
5640 base_bfd
->filename
, dsym_subdir
, base_basename
);
5642 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
5643 bfd_get_arch_info (abfd
));
5644 if (dsym_bfd
== NULL
)
5645 free (dsym_filename
);
5651 bfd_mach_o_find_nearest_line (bfd
*abfd
,
5655 const char **filename_ptr
,
5656 const char **functionname_ptr
,
5657 unsigned int *line_ptr
,
5658 unsigned int *discriminator_ptr
)
5660 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5663 switch (mdata
->header
.filetype
)
5665 case BFD_MACH_O_MH_OBJECT
:
5667 case BFD_MACH_O_MH_EXECUTE
:
5668 case BFD_MACH_O_MH_DYLIB
:
5669 case BFD_MACH_O_MH_BUNDLE
:
5670 case BFD_MACH_O_MH_KEXT_BUNDLE
:
5671 if (mdata
->dwarf2_find_line_info
== NULL
)
5673 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
5674 /* When we couldn't find dSYM for this binary, we look for
5675 the debug information in the binary itself. In this way,
5676 we won't try finding separated dSYM again because
5677 mdata->dwarf2_find_line_info will be filled. */
5678 if (! mdata
->dsym_bfd
)
5680 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
5681 dwarf_debug_sections
, symbols
,
5682 &mdata
->dwarf2_find_line_info
,
5690 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
5691 filename_ptr
, functionname_ptr
,
5692 line_ptr
, discriminator_ptr
,
5693 dwarf_debug_sections
, 0,
5694 &mdata
->dwarf2_find_line_info
);
5698 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
5700 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5701 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
5703 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
5704 bfd_mach_o_free_cached_info (abfd
);
5705 if (mdata
->dsym_bfd
!= NULL
)
5707 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
5708 char *dsym_filename
= (char *)(fat_bfd
5710 : mdata
->dsym_bfd
->filename
);
5711 bfd_close (mdata
->dsym_bfd
);
5712 mdata
->dsym_bfd
= NULL
;
5714 bfd_close (fat_bfd
);
5715 free (dsym_filename
);
5719 if (bfd_get_format (abfd
) == bfd_archive
5720 && abfd
->xvec
== &mach_o_fat_vec
)
5722 return _bfd_generic_close_and_cleanup (abfd
);
5725 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
5727 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5729 free (mdata
->dyn_reloc_cache
);
5730 mdata
->dyn_reloc_cache
= NULL
;
5731 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
5733 free (asect
->relocation
);
5734 asect
->relocation
= NULL
;
5740 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5741 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5743 #define bfd_mach_o_swap_reloc_in NULL
5744 #define bfd_mach_o_swap_reloc_out NULL
5745 #define bfd_mach_o_print_thread NULL
5746 #define bfd_mach_o_tgt_seg_table NULL
5747 #define bfd_mach_o_section_type_valid_for_tgt NULL
5749 #define TARGET_NAME mach_o_be_vec
5750 #define TARGET_STRING "mach-o-be"
5751 #define TARGET_ARCHITECTURE bfd_arch_unknown
5752 #define TARGET_PAGESIZE 1
5753 #define TARGET_BIG_ENDIAN 1
5754 #define TARGET_ARCHIVE 0
5755 #define TARGET_PRIORITY 1
5756 #include "mach-o-target.c"
5759 #undef TARGET_STRING
5760 #undef TARGET_ARCHITECTURE
5761 #undef TARGET_PAGESIZE
5762 #undef TARGET_BIG_ENDIAN
5763 #undef TARGET_ARCHIVE
5764 #undef TARGET_PRIORITY
5766 #define TARGET_NAME mach_o_le_vec
5767 #define TARGET_STRING "mach-o-le"
5768 #define TARGET_ARCHITECTURE bfd_arch_unknown
5769 #define TARGET_PAGESIZE 1
5770 #define TARGET_BIG_ENDIAN 0
5771 #define TARGET_ARCHIVE 0
5772 #define TARGET_PRIORITY 1
5774 #include "mach-o-target.c"
5777 #undef TARGET_STRING
5778 #undef TARGET_ARCHITECTURE
5779 #undef TARGET_PAGESIZE
5780 #undef TARGET_BIG_ENDIAN
5781 #undef TARGET_ARCHIVE
5782 #undef TARGET_PRIORITY
5784 /* Not yet handled: creating an archive. */
5785 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5788 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5789 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5790 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5791 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5792 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5793 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5794 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5795 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5796 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5797 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5799 #define TARGET_NAME mach_o_fat_vec
5800 #define TARGET_STRING "mach-o-fat"
5801 #define TARGET_ARCHITECTURE bfd_arch_unknown
5802 #define TARGET_PAGESIZE 1
5803 #define TARGET_BIG_ENDIAN 1
5804 #define TARGET_ARCHIVE 1
5805 #define TARGET_PRIORITY 0
5807 #include "mach-o-target.c"
5810 #undef TARGET_STRING
5811 #undef TARGET_ARCHITECTURE
5812 #undef TARGET_PAGESIZE
5813 #undef TARGET_BIG_ENDIAN
5814 #undef TARGET_ARCHIVE
5815 #undef TARGET_PRIORITY