1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2015 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
;
795 unsigned long count
, i
, j
, n
;
799 const char stub
[] = "$stub";
803 /* Stop now if no symbols or no indirect symbols. */
804 if (dysymtab
== NULL
|| dysymtab
->nindirectsyms
== 0
805 || symtab
== NULL
|| symtab
->symbols
== NULL
)
808 /* We need to allocate a bfd symbol for every indirect symbol and to
809 allocate the memory for its name. */
810 count
= dysymtab
->nindirectsyms
;
811 size
= count
* sizeof (asymbol
) + 1;
813 for (j
= 0; j
< count
; j
++)
816 unsigned int isym
= dysymtab
->indirect_syms
[j
];
818 /* Some indirect symbols are anonymous. */
819 if (isym
< symtab
->nsyms
&& (strng
= symtab
->symbols
[isym
].symbol
.name
))
820 /* PR 17512: file: f5b8eeba. */
821 size
+= strnlen (strng
, symtab
->strsize
- (strng
- symtab
->strtab
)) + sizeof (stub
);
824 s_start
= bfd_malloc (size
);
825 s
= *ret
= (asymbol
*) s_start
;
828 names
= (char *) (s
+ count
);
831 s_end
= s_start
+ size
;
834 for (i
= 0; i
< mdata
->nsects
; i
++)
836 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
837 unsigned int first
, last
;
841 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
843 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
844 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
845 case BFD_MACH_O_S_SYMBOL_STUBS
:
846 /* Only these sections have indirect symbols. */
847 first
= sec
->reserved1
;
848 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
850 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
852 /* PR 17512: file: 08e15eec. */
853 if (first
>= count
|| last
>= count
|| first
> last
)
856 for (j
= first
; j
< last
; j
++)
858 unsigned int isym
= dysymtab
->indirect_syms
[j
];
860 /* PR 17512: file: 04d64d9b. */
861 if (((char *) s
) + sizeof (* s
) > s_end
)
864 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
865 s
->section
= sec
->bfdsection
;
866 s
->value
= addr
- sec
->addr
;
869 if (isym
< symtab
->nsyms
870 && symtab
->symbols
[isym
].symbol
.name
)
872 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
877 /* PR 17512: file: 47dfd4d2. */
878 if (names
+ len
>= s_end
)
880 memcpy (names
, sym
, len
);
882 /* PR 17512: file: 18f340a4. */
883 if (names
+ sizeof (stub
) >= s_end
)
885 memcpy (names
, stub
, sizeof (stub
));
886 names
+= sizeof (stub
);
910 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
914 bfd_symbol_info (symbol
, ret
);
918 bfd_mach_o_print_symbol (bfd
*abfd
,
921 bfd_print_symbol_type how
)
923 FILE *file
= (FILE *) afile
;
925 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
929 case bfd_print_symbol_name
:
930 fprintf (file
, "%s", symbol
->name
);
933 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
934 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
935 name
= bfd_get_stab_name (asym
->n_type
);
937 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
939 case BFD_MACH_O_N_UNDF
:
940 if (symbol
->value
== 0)
945 case BFD_MACH_O_N_ABS
:
948 case BFD_MACH_O_N_INDR
:
951 case BFD_MACH_O_N_PBUD
:
954 case BFD_MACH_O_N_SECT
:
963 fprintf (file
, " %02x %-6s %02x %04x",
964 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
965 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
966 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
967 fprintf (file
, " [%s]", symbol
->section
->name
);
968 fprintf (file
, " %s", symbol
->name
);
973 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
974 bfd_mach_o_cpu_subtype msubtype
,
975 enum bfd_architecture
*type
,
976 unsigned long *subtype
)
978 *subtype
= bfd_arch_unknown
;
982 case BFD_MACH_O_CPU_TYPE_VAX
:
983 *type
= bfd_arch_vax
;
985 case BFD_MACH_O_CPU_TYPE_MC680x0
:
986 *type
= bfd_arch_m68k
;
988 case BFD_MACH_O_CPU_TYPE_I386
:
989 *type
= bfd_arch_i386
;
990 *subtype
= bfd_mach_i386_i386
;
992 case BFD_MACH_O_CPU_TYPE_X86_64
:
993 *type
= bfd_arch_i386
;
994 *subtype
= bfd_mach_x86_64
;
996 case BFD_MACH_O_CPU_TYPE_MIPS
:
997 *type
= bfd_arch_mips
;
999 case BFD_MACH_O_CPU_TYPE_MC98000
:
1000 *type
= bfd_arch_m98k
;
1002 case BFD_MACH_O_CPU_TYPE_HPPA
:
1003 *type
= bfd_arch_hppa
;
1005 case BFD_MACH_O_CPU_TYPE_ARM
:
1006 *type
= bfd_arch_arm
;
1009 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
1010 *subtype
= bfd_mach_arm_4T
;
1012 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
1013 *subtype
= bfd_mach_arm_4T
; /* Best fit ? */
1015 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
1016 *subtype
= bfd_mach_arm_5TE
;
1018 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
1019 *subtype
= bfd_mach_arm_XScale
;
1021 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
1022 *subtype
= bfd_mach_arm_5TE
; /* Best fit ? */
1024 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
1029 case BFD_MACH_O_CPU_TYPE_MC88000
:
1030 *type
= bfd_arch_m88k
;
1032 case BFD_MACH_O_CPU_TYPE_SPARC
:
1033 *type
= bfd_arch_sparc
;
1034 *subtype
= bfd_mach_sparc
;
1036 case BFD_MACH_O_CPU_TYPE_I860
:
1037 *type
= bfd_arch_i860
;
1039 case BFD_MACH_O_CPU_TYPE_ALPHA
:
1040 *type
= bfd_arch_alpha
;
1042 case BFD_MACH_O_CPU_TYPE_POWERPC
:
1043 *type
= bfd_arch_powerpc
;
1044 *subtype
= bfd_mach_ppc
;
1046 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
1047 *type
= bfd_arch_powerpc
;
1048 *subtype
= bfd_mach_ppc64
;
1050 case BFD_MACH_O_CPU_TYPE_ARM64
:
1051 *type
= bfd_arch_aarch64
;
1052 *subtype
= bfd_mach_aarch64
;
1055 *type
= bfd_arch_unknown
;
1060 /* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4. Return the
1061 number of bytes written or -1 in case of error. */
1064 bfd_mach_o_pad4 (bfd
*abfd
, unsigned int len
)
1068 char pad
[4] = {0,0,0,0};
1069 unsigned int padlen
= 4 - (len
% 4);
1071 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1080 /* Likewise, but for a command. */
1083 bfd_mach_o_pad_command (bfd
*abfd
, unsigned int len
)
1085 unsigned int align
= bfd_mach_o_wide_p (abfd
) ? 8 : 4;
1087 if (len
% align
!= 0)
1090 unsigned int padlen
= align
- (len
% align
);
1092 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1102 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1104 struct mach_o_header_external raw
;
1107 size
= mach_o_wide_p (header
) ?
1108 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1110 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
1111 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
1112 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
1113 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
1114 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
1115 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
1116 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
1118 if (mach_o_wide_p (header
))
1119 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
1121 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1122 || bfd_bwrite (&raw
, size
, abfd
) != size
)
1129 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1131 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
1133 struct mach_o_thread_command_external raw
;
1134 unsigned int offset
;
1136 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
1137 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
1139 offset
= BFD_MACH_O_LC_SIZE
;
1140 for (i
= 0; i
< cmd
->nflavours
; i
++)
1142 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
1143 BFD_ASSERT (cmd
->flavours
[i
].offset
==
1144 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
1146 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
1147 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
1149 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
1150 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1153 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
1160 bfd_mach_o_write_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1162 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
1163 struct mach_o_str_command_external raw
;
1164 unsigned int namelen
;
1166 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.str
);
1168 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1169 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1172 namelen
= strlen (cmd
->name_str
) + 1;
1173 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1176 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1183 bfd_mach_o_write_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1185 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
1186 struct mach_o_dylib_command_external raw
;
1187 unsigned int namelen
;
1189 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.name
);
1190 bfd_h_put_32 (abfd
, cmd
->timestamp
, raw
.timestamp
);
1191 bfd_h_put_32 (abfd
, cmd
->current_version
, raw
.current_version
);
1192 bfd_h_put_32 (abfd
, cmd
->compatibility_version
, raw
.compatibility_version
);
1194 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1195 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1198 namelen
= strlen (cmd
->name_str
) + 1;
1199 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1202 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1209 bfd_mach_o_write_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1211 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
1212 struct mach_o_entry_point_command_external raw
;
1214 bfd_h_put_64 (abfd
, cmd
->entryoff
, raw
.entryoff
);
1215 bfd_h_put_64 (abfd
, cmd
->stacksize
, raw
.stacksize
);
1217 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1218 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1225 bfd_mach_o_write_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1227 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
1228 struct mach_o_dyld_info_command_external raw
;
1230 bfd_h_put_32 (abfd
, cmd
->rebase_off
, raw
.rebase_off
);
1231 bfd_h_put_32 (abfd
, cmd
->rebase_size
, raw
.rebase_size
);
1232 bfd_h_put_32 (abfd
, cmd
->bind_off
, raw
.bind_off
);
1233 bfd_h_put_32 (abfd
, cmd
->bind_size
, raw
.bind_size
);
1234 bfd_h_put_32 (abfd
, cmd
->weak_bind_off
, raw
.weak_bind_off
);
1235 bfd_h_put_32 (abfd
, cmd
->weak_bind_size
, raw
.weak_bind_size
);
1236 bfd_h_put_32 (abfd
, cmd
->lazy_bind_off
, raw
.lazy_bind_off
);
1237 bfd_h_put_32 (abfd
, cmd
->lazy_bind_size
, raw
.lazy_bind_size
);
1238 bfd_h_put_32 (abfd
, cmd
->export_off
, raw
.export_off
);
1239 bfd_h_put_32 (abfd
, cmd
->export_size
, raw
.export_size
);
1241 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1242 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1245 if (cmd
->rebase_size
!= 0)
1246 if (bfd_seek (abfd
, cmd
->rebase_off
, SEEK_SET
) != 0
1247 || (bfd_bwrite (cmd
->rebase_content
, cmd
->rebase_size
, abfd
) !=
1251 if (cmd
->bind_size
!= 0)
1252 if (bfd_seek (abfd
, cmd
->bind_off
, SEEK_SET
) != 0
1253 || (bfd_bwrite (cmd
->bind_content
, cmd
->bind_size
, abfd
) !=
1257 if (cmd
->weak_bind_size
!= 0)
1258 if (bfd_seek (abfd
, cmd
->weak_bind_off
, SEEK_SET
) != 0
1259 || (bfd_bwrite (cmd
->weak_bind_content
, cmd
->weak_bind_size
, abfd
) !=
1260 cmd
->weak_bind_size
))
1263 if (cmd
->lazy_bind_size
!= 0)
1264 if (bfd_seek (abfd
, cmd
->lazy_bind_off
, SEEK_SET
) != 0
1265 || (bfd_bwrite (cmd
->lazy_bind_content
, cmd
->lazy_bind_size
, abfd
) !=
1266 cmd
->lazy_bind_size
))
1269 if (cmd
->export_size
!= 0)
1270 if (bfd_seek (abfd
, cmd
->export_off
, SEEK_SET
) != 0
1271 || (bfd_bwrite (cmd
->export_content
, cmd
->export_size
, abfd
) !=
1279 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
1282 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1285 /* In addition to the need to byte-swap the symbol number, the bit positions
1286 of the fields in the relocation information vary per target endian-ness. */
1289 bfd_mach_o_swap_in_non_scattered_reloc (bfd
*abfd
, bfd_mach_o_reloc_info
*rel
,
1290 unsigned char *fields
)
1292 unsigned char info
= fields
[3];
1294 if (bfd_big_endian (abfd
))
1296 rel
->r_value
= (fields
[0] << 16) | (fields
[1] << 8) | fields
[2];
1297 rel
->r_type
= (info
>> BFD_MACH_O_BE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1298 rel
->r_pcrel
= (info
& BFD_MACH_O_BE_PCREL
) ? 1 : 0;
1299 rel
->r_length
= (info
>> BFD_MACH_O_BE_LENGTH_SHIFT
)
1300 & BFD_MACH_O_LENGTH_MASK
;
1301 rel
->r_extern
= (info
& BFD_MACH_O_BE_EXTERN
) ? 1 : 0;
1305 rel
->r_value
= (fields
[2] << 16) | (fields
[1] << 8) | fields
[0];
1306 rel
->r_type
= (info
>> BFD_MACH_O_LE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1307 rel
->r_pcrel
= (info
& BFD_MACH_O_LE_PCREL
) ? 1 : 0;
1308 rel
->r_length
= (info
>> BFD_MACH_O_LE_LENGTH_SHIFT
)
1309 & BFD_MACH_O_LENGTH_MASK
;
1310 rel
->r_extern
= (info
& BFD_MACH_O_LE_EXTERN
) ? 1 : 0;
1315 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
1316 struct mach_o_reloc_info_external
*raw
,
1317 arelent
*res
, asymbol
**syms
)
1319 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1320 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1321 bfd_mach_o_reloc_info reloc
;
1325 addr
= bfd_get_32 (abfd
, raw
->r_address
);
1326 res
->sym_ptr_ptr
= NULL
;
1329 if (addr
& BFD_MACH_O_SR_SCATTERED
)
1332 bfd_vma symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
1334 /* Scattered relocation, can't be extern. */
1335 reloc
.r_scattered
= 1;
1338 /* Extract section and offset from r_value (symnum). */
1339 reloc
.r_value
= symnum
;
1340 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1341 end of the data for the section (e.g. in a calculation of section
1342 data length). At present, the symbol will end up associated with
1343 the following section or, if it falls within alignment padding, as
1344 null - which will assert later. */
1345 for (j
= 0; j
< mdata
->nsects
; j
++)
1347 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
1348 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
1350 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
1351 res
->addend
= symnum
- sect
->addr
;
1356 /* Extract the info and address fields from r_address. */
1357 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
1358 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
1359 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
1360 reloc
.r_address
= BFD_MACH_O_GET_SR_TYPE (addr
);
1361 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
1367 /* Non-scattered relocation. */
1368 reloc
.r_scattered
= 0;
1370 /* The value and info fields have to be extracted dependent on target
1372 bfd_mach_o_swap_in_non_scattered_reloc (abfd
, &reloc
, raw
->r_symbolnum
);
1373 num
= reloc
.r_value
;
1377 /* PR 17512: file: 8396-1185-0.004. */
1378 if (bfd_get_symcount (abfd
) > 0 && num
> bfd_get_symcount (abfd
))
1379 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1380 else if (syms
== NULL
)
1381 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1383 /* An external symbol number. */
1386 else if (num
== 0x00ffffff || num
== 0)
1388 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1389 is generic code, we don't know wether this is really a PAIR.
1390 This value is almost certainly not a valid section number, hence
1391 this specific case to avoid an assertion failure.
1392 Target specific swap_reloc_in routine should adjust that. */
1393 sym
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1397 /* PR 17512: file: 006-2964-0.004. */
1398 if (num
> mdata
->nsects
)
1401 /* A section number. */
1402 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1403 /* For a symbol defined in section S, the addend (stored in the
1404 binary) contains the address of the section. To comply with
1405 bfd convention, subtract the section address.
1406 Use the address from the header, so that the user can modify
1407 the vma of the section. */
1408 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1410 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1411 in the lower 16bits of the address value. So we have to find the
1412 'symbol' from the preceding reloc. We do this even though the
1413 section symbol is probably not needed here, because NULL symbol
1414 values cause an assert in generic BFD code. This must be done in
1415 the PPC swap_reloc_in routine. */
1416 res
->sym_ptr_ptr
= sym
;
1418 /* The 'address' is just r_address.
1419 ??? maybe this should be masked with 0xffffff for safety. */
1420 res
->address
= addr
;
1421 reloc
.r_address
= addr
;
1424 /* We have set up a reloc with all the information present, so the swapper
1425 can modify address, value and addend fields, if necessary, to convey
1426 information in the generic BFD reloc that is mach-o specific. */
1428 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
1435 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1436 unsigned long count
,
1437 arelent
*res
, asymbol
**syms
)
1440 struct mach_o_reloc_info_external
*native_relocs
;
1441 bfd_size_type native_size
;
1443 /* Allocate and read relocs. */
1444 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1447 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1448 if (native_relocs
== NULL
)
1451 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1452 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1455 for (i
= 0; i
< count
; i
++)
1457 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
1461 free (native_relocs
);
1464 free (native_relocs
);
1469 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1470 arelent
**rels
, asymbol
**syms
)
1472 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1476 if (asect
->reloc_count
== 0)
1479 /* No need to go further if we don't know how to read relocs. */
1480 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1483 if (asect
->relocation
== NULL
)
1485 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1489 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1490 asect
->reloc_count
, res
, syms
) < 0)
1495 asect
->relocation
= res
;
1498 res
= asect
->relocation
;
1499 for (i
= 0; i
< asect
->reloc_count
; i
++)
1507 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1509 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1511 if (mdata
->dysymtab
== NULL
)
1513 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1514 * sizeof (arelent
*);
1518 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1519 struct bfd_symbol
**syms
)
1521 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1522 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1523 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1527 if (dysymtab
== NULL
)
1529 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1532 /* No need to go further if we don't know how to read relocs. */
1533 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1536 if (mdata
->dyn_reloc_cache
== NULL
)
1538 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1539 * sizeof (arelent
));
1543 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1544 dysymtab
->nextrel
, res
, syms
) < 0)
1550 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1552 res
+ dysymtab
->nextrel
, syms
) < 0)
1558 mdata
->dyn_reloc_cache
= res
;
1561 res
= mdata
->dyn_reloc_cache
;
1562 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1568 /* In addition to the need to byte-swap the symbol number, the bit positions
1569 of the fields in the relocation information vary per target endian-ness. */
1572 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1573 bfd_mach_o_reloc_info
*rel
)
1575 unsigned char info
= 0;
1577 BFD_ASSERT (rel
->r_type
<= 15);
1578 BFD_ASSERT (rel
->r_length
<= 3);
1580 if (bfd_big_endian (abfd
))
1582 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1583 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1584 fields
[2] = rel
->r_value
& 0xff;
1585 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1586 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1587 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1588 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1592 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1593 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1594 fields
[0] = rel
->r_value
& 0xff;
1595 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1596 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1597 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1598 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1604 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1609 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1611 sec
= section
->bfdsection
;
1612 if (sec
->reloc_count
== 0)
1615 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1618 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1621 /* Convert and write. */
1622 entries
= section
->bfdsection
->orelocation
;
1623 for (i
= 0; i
< section
->nreloc
; i
++)
1625 arelent
*rel
= entries
[i
];
1626 struct mach_o_reloc_info_external raw
;
1627 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1629 /* Convert relocation to an intermediate representation. */
1630 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1633 /* Lower the relocation info. */
1634 if (pinfo
->r_scattered
)
1638 v
= BFD_MACH_O_SR_SCATTERED
1639 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1640 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1641 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1642 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1643 /* Note: scattered relocs have field in reverse order... */
1644 bfd_put_32 (abfd
, v
, raw
.r_address
);
1645 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1649 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1650 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1654 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1655 != BFD_MACH_O_RELENT_SIZE
)
1662 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1664 struct mach_o_section_32_external raw
;
1666 memcpy (raw
.sectname
, section
->sectname
, 16);
1667 memcpy (raw
.segname
, section
->segname
, 16);
1668 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1669 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1670 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1671 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1672 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1673 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1674 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1675 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1676 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1678 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1679 != BFD_MACH_O_SECTION_SIZE
)
1686 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1688 struct mach_o_section_64_external raw
;
1690 memcpy (raw
.sectname
, section
->sectname
, 16);
1691 memcpy (raw
.segname
, section
->segname
, 16);
1692 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1693 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1694 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1695 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1696 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1697 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1698 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1699 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1700 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1701 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1703 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1704 != BFD_MACH_O_SECTION_64_SIZE
)
1711 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1713 struct mach_o_segment_command_32_external raw
;
1714 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1715 bfd_mach_o_section
*sec
;
1717 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1719 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1720 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1723 memcpy (raw
.segname
, seg
->segname
, 16);
1724 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1725 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1726 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1727 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1728 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1729 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1730 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1731 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1733 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1734 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1737 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1738 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1745 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1747 struct mach_o_segment_command_64_external raw
;
1748 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1749 bfd_mach_o_section
*sec
;
1751 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1753 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1754 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1757 memcpy (raw
.segname
, seg
->segname
, 16);
1758 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1759 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1760 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1761 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1762 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1763 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1764 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1765 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1767 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1768 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1771 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1772 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1779 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1781 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1783 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1784 struct bfd_strtab_hash
*strtab
;
1785 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1788 /* Write the symbols first. */
1789 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1792 strtab
= _bfd_stringtab_init ();
1797 /* Although we don't strictly need to do this, for compatibility with
1798 Darwin system tools, actually output an empty string for the index
1800 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1802 for (i
= 0; i
< sym
->nsyms
; i
++)
1804 bfd_size_type str_index
;
1805 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1807 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1808 /* An index of 0 always means the empty string. */
1812 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1814 if (str_index
== (bfd_size_type
) -1)
1820 struct mach_o_nlist_64_external raw
;
1822 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1823 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1824 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1825 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1826 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1829 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1834 struct mach_o_nlist_external raw
;
1836 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1837 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1838 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1839 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1840 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1843 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1847 sym
->strsize
= _bfd_stringtab_size (strtab
);
1848 sym
->stroff
= mdata
->filelen
;
1849 mdata
->filelen
+= sym
->strsize
;
1851 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
1854 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1856 _bfd_stringtab_free (strtab
);
1858 /* Pad string table. */
1859 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
1862 mdata
->filelen
+= padlen
;
1863 sym
->strsize
+= padlen
;
1868 _bfd_stringtab_free (strtab
);
1873 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1875 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1876 struct mach_o_symtab_command_external raw
;
1878 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1881 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1882 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1883 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1884 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1886 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1887 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1893 /* Count the number of indirect symbols in the image.
1894 Requires that the sections are in their final order. */
1897 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1900 unsigned int nisyms
= 0;
1902 for (i
= 0; i
< mdata
->nsects
; ++i
)
1904 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1906 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1908 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1909 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1910 case BFD_MACH_O_S_SYMBOL_STUBS
:
1911 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
1920 /* Create the dysymtab. */
1923 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
1925 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1928 We are not going to try and fill these in yet and, moreover, we are
1929 going to bail if they are already set. */
1930 if (cmd
->nmodtab
!= 0
1932 || cmd
->nextrefsyms
!= 0)
1934 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
1935 " implemented for dysymtab commands."));
1941 if (bfd_get_symcount (abfd
) > 0)
1943 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1946 /* Count the number of each kind of symbol. */
1947 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1949 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1950 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
1954 cmd
->iextdefsym
= i
;
1955 for (; i
< bfd_get_symcount (abfd
); ++i
)
1957 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1958 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
1961 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
1962 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
1963 cmd
->nundefsym
= bfd_get_symcount (abfd
)
1970 cmd
->iextdefsym
= 0;
1971 cmd
->nextdefsym
= 0;
1976 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
1977 if (cmd
->nindirectsyms
> 0)
1982 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
1983 cmd
->indirectsymoff
= mdata
->filelen
;
1984 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
1986 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
1987 if (cmd
->indirect_syms
== NULL
)
1991 for (i
= 0; i
< mdata
->nsects
; ++i
)
1993 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1995 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1997 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1998 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1999 case BFD_MACH_O_S_SYMBOL_STUBS
:
2002 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2004 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2005 if (isyms
== NULL
|| num
== 0)
2007 /* Record the starting index in the reserved1 field. */
2009 for (j
= 0; j
< num
; j
++, n
++)
2011 if (isyms
[j
] == NULL
)
2012 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2013 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
2014 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
2015 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2016 | BFD_MACH_O_INDIRECT_SYM_ABS
;
2018 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2031 /* Write a dysymtab command.
2032 TODO: Possibly coalesce writes of smaller objects. */
2035 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2037 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2039 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2041 if (cmd
->nmodtab
!= 0)
2045 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2048 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2050 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2054 iinit
= module
->iinit
& 0xffff;
2055 iinit
|= ((module
->iterm
& 0xffff) << 16);
2057 ninit
= module
->ninit
& 0xffff;
2058 ninit
|= ((module
->nterm
& 0xffff) << 16);
2060 if (bfd_mach_o_wide_p (abfd
))
2062 struct mach_o_dylib_module_64_external w
;
2064 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2065 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2066 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2067 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2068 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2069 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2070 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2071 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2072 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2073 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2074 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2075 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2076 &w
.objc_module_info_addr
);
2077 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2078 &w
.objc_module_info_size
);
2080 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2085 struct mach_o_dylib_module_external n
;
2087 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2088 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2089 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2090 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2091 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2092 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2093 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2094 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2095 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2096 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2097 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2098 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2099 &n
.objc_module_info_addr
);
2100 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2101 &n
.objc_module_info_size
);
2103 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2113 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2116 for (i
= 0; i
< cmd
->ntoc
; i
++)
2118 struct mach_o_dylib_table_of_contents_external raw
;
2119 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2121 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2122 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2124 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2129 if (cmd
->nindirectsyms
> 0)
2133 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2136 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2138 unsigned char raw
[4];
2140 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2141 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2146 if (cmd
->nextrefsyms
!= 0)
2150 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2153 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2156 unsigned char raw
[4];
2157 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2159 /* Fields isym and flags are written as bit-fields, thus we need
2160 a specific processing for endianness. */
2162 if (bfd_big_endian (abfd
))
2164 v
= ((ref
->isym
& 0xffffff) << 8);
2165 v
|= ref
->flags
& 0xff;
2169 v
= ref
->isym
& 0xffffff;
2170 v
|= ((ref
->flags
& 0xff) << 24);
2173 bfd_h_put_32 (abfd
, v
, raw
);
2174 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2180 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2184 struct mach_o_dysymtab_command_external raw
;
2186 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2187 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2188 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2189 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2190 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2191 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2192 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2193 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2194 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2195 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2196 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2197 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2198 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2199 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2200 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2201 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2202 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2203 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2205 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2213 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2215 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2217 /* Just leave debug symbols where they are (pretend they are local, and
2218 then they will just be sorted on position). */
2219 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2222 /* Local (we should never see an undefined local AFAICT). */
2223 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2226 /* Common symbols look like undefined externs. */
2227 if (mtyp
== BFD_MACH_O_N_UNDF
)
2230 /* A defined non-local, non-debug symbol. */
2235 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2237 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2238 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2239 unsigned int soa
, sob
;
2241 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2242 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2249 /* If it's local or stab, just preserve the input order. */
2252 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2254 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2257 /* This is probably an error. */
2261 /* The second sort key is name. */
2262 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2265 /* Process the symbols.
2267 This should be OK for single-module files - but it is not likely to work
2268 for multi-module shared libraries.
2270 (a) If the application has not filled in the relevant mach-o fields, make
2273 (b) Order them, like this:
2276 ( ii) external defined
2278 (iii) external undefined/common
2285 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2288 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2290 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2293 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2295 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2297 /* We use this value, which is out-of-range as a symbol index, to signal
2298 that the mach-o-specific data are not filled in and need to be created
2299 from the bfd values. It is much preferable for the application to do
2300 this, since more meaningful diagnostics can be made that way. */
2302 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2304 /* No symbol information has been set - therefore determine
2305 it from the bfd symbol flags/info. */
2306 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2307 s
->n_type
= BFD_MACH_O_N_ABS
;
2308 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2310 s
->n_type
= BFD_MACH_O_N_UNDF
;
2311 if (s
->symbol
.flags
& BSF_WEAK
)
2312 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2313 /* mach-o automatically makes undefined symbols extern. */
2314 s
->n_type
|= BFD_MACH_O_N_EXT
;
2315 s
->symbol
.flags
|= BSF_GLOBAL
;
2317 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2319 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2320 s
->symbol
.flags
|= BSF_GLOBAL
;
2323 s
->n_type
= BFD_MACH_O_N_SECT
;
2325 if (s
->symbol
.flags
& BSF_GLOBAL
)
2326 s
->n_type
|= BFD_MACH_O_N_EXT
;
2329 /* Put the section index in, where required. */
2330 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2331 && s
->symbol
.section
!= bfd_und_section_ptr
2332 && s
->symbol
.section
!= bfd_com_section_ptr
)
2333 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2334 && s
->symbol
.name
== NULL
))
2335 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2337 /* Number to preserve order for local and debug syms. */
2338 s
->symbol
.udata
.i
= i
;
2341 /* Sort the symbols. */
2342 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2343 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2345 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2347 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2348 s
->symbol
.udata
.i
= i
; /* renumber. */
2354 /* We build a flat table of sections, which can be re-ordered if necessary.
2355 Fill in the section number and other mach-o-specific data. */
2358 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2361 unsigned target_index
;
2364 nsect
= bfd_count_sections (abfd
);
2366 /* Don't do it if it's already set - assume the application knows what it's
2368 if (mdata
->nsects
== nsect
2369 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2372 /* We need to check that this can be done... */
2375 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%u)"
2376 " maximum is 255,\n"), nsect
);
2380 mdata
->nsects
= nsect
;
2381 mdata
->sections
= bfd_alloc (abfd
,
2382 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2383 if (mdata
->sections
== NULL
)
2386 /* Create Mach-O sections.
2387 Section type, attribute and align should have been set when the
2388 section was created - either read in or specified. */
2390 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2392 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
2393 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2395 mdata
->sections
[target_index
] = msect
;
2397 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
2398 msect
->size
= bfd_get_section_size (sec
);
2400 /* Use the largest alignment set, in case it was bumped after the
2401 section was created. */
2402 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2405 sec
->target_index
= ++target_index
;
2412 bfd_mach_o_write_contents (bfd
*abfd
)
2414 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2415 bfd_mach_o_load_command
*cmd
;
2416 bfd_mach_o_symtab_command
*symtab
= NULL
;
2417 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2418 bfd_mach_o_segment_command
*linkedit
= NULL
;
2420 /* Make the commands, if not already present. */
2421 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2423 abfd
->output_has_begun
= TRUE
;
2425 /* Write the header. */
2426 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2429 /* First pass: allocate the linkedit segment. */
2430 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2433 case BFD_MACH_O_LC_SEGMENT_64
:
2434 case BFD_MACH_O_LC_SEGMENT
:
2435 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2436 linkedit
= &cmd
->command
.segment
;
2438 case BFD_MACH_O_LC_SYMTAB
:
2439 symtab
= &cmd
->command
.symtab
;
2441 case BFD_MACH_O_LC_DYSYMTAB
:
2442 dysymtab
= &cmd
->command
.dysymtab
;
2444 case BFD_MACH_O_LC_DYLD_INFO
:
2446 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2448 if (di
->rebase_size
!= 0)
2450 di
->rebase_off
= mdata
->filelen
;
2451 mdata
->filelen
+= di
->rebase_size
;
2453 if (di
->bind_size
!= 0)
2455 di
->bind_off
= mdata
->filelen
;
2456 mdata
->filelen
+= di
->bind_size
;
2458 if (di
->weak_bind_size
!= 0)
2460 di
->weak_bind_off
= mdata
->filelen
;
2461 mdata
->filelen
+= di
->weak_bind_size
;
2463 if (di
->lazy_bind_size
!= 0)
2465 di
->lazy_bind_off
= mdata
->filelen
;
2466 mdata
->filelen
+= di
->lazy_bind_size
;
2468 if (di
->export_size
!= 0)
2470 di
->export_off
= mdata
->filelen
;
2471 mdata
->filelen
+= di
->export_size
;
2475 case BFD_MACH_O_LC_LOAD_DYLIB
:
2476 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2477 case BFD_MACH_O_LC_MAIN
:
2478 /* Nothing to do. */
2481 (*_bfd_error_handler
)
2482 (_("unable to allocate data for load command 0x%lx"),
2483 (unsigned long) cmd
->type
);
2487 /* Specially handle symtab and dysymtab. */
2489 /* Pre-allocate the symbol table (but not the string table). The reason
2490 is that the dysymtab is after the symbol table but before the string
2491 table (required by the native strip tool). */
2494 unsigned int symlen
;
2495 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2497 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2499 /* Align for symbols. */
2500 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2501 symtab
->symoff
= mdata
->filelen
;
2503 symtab
->nsyms
= bfd_get_symcount (abfd
);
2504 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2507 /* Build the dysymtab. */
2508 if (dysymtab
!= NULL
)
2509 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2512 /* Write symtab and strtab. */
2514 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2517 /* Adjust linkedit size. */
2518 if (linkedit
!= NULL
)
2520 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2522 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2523 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2524 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2526 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2527 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2528 | BFD_MACH_O_PROT_EXECUTE
;
2531 /* Second pass: write commands. */
2532 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2534 struct mach_o_load_command_external raw
;
2535 unsigned long typeflag
;
2537 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2539 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2540 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2542 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2543 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2548 case BFD_MACH_O_LC_SEGMENT
:
2549 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2552 case BFD_MACH_O_LC_SEGMENT_64
:
2553 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2556 case BFD_MACH_O_LC_SYMTAB
:
2557 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2560 case BFD_MACH_O_LC_DYSYMTAB
:
2561 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2564 case BFD_MACH_O_LC_THREAD
:
2565 case BFD_MACH_O_LC_UNIXTHREAD
:
2566 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2569 case BFD_MACH_O_LC_LOAD_DYLIB
:
2570 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2573 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2574 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2577 case BFD_MACH_O_LC_MAIN
:
2578 if (!bfd_mach_o_write_main (abfd
, cmd
))
2581 case BFD_MACH_O_LC_DYLD_INFO
:
2582 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2586 (*_bfd_error_handler
)
2587 (_("unable to write unknown load command 0x%lx"),
2588 (unsigned long) cmd
->type
);
2597 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2598 bfd_mach_o_section
*s
)
2600 if (seg
->sect_head
== NULL
)
2603 seg
->sect_tail
->next
= s
;
2607 /* Create section Mach-O flags from BFD flags. */
2610 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2614 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2616 /* Create default flags. */
2617 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2618 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2619 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2620 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2621 | BFD_MACH_O_S_REGULAR
;
2622 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2623 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2624 else if (bfd_flags
& SEC_DEBUGGING
)
2625 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2627 s
->flags
= BFD_MACH_O_S_REGULAR
;
2631 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2633 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2637 seg
->fileoff
= mdata
->filelen
;
2638 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2639 | BFD_MACH_O_PROT_EXECUTE
;
2640 seg
->maxprot
= seg
->initprot
;
2642 /* Append sections to the segment.
2644 This is a little tedious, we have to honor the need to account zerofill
2645 sections after all the rest. This forces us to do the calculation of
2646 total vmsize in three passes so that any alignment increments are
2647 properly accounted. */
2648 for (i
= 0; i
< mdata
->nsects
; ++i
)
2650 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2651 asection
*sec
= s
->bfdsection
;
2653 /* Although we account for zerofill section sizes in vm order, they are
2654 placed in the file in source sequence. */
2655 bfd_mach_o_append_section_to_segment (seg
, s
);
2658 /* Zerofill sections have zero file size & offset, the only content
2659 written to the file is the symbols. */
2660 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2661 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2662 == BFD_MACH_O_S_GB_ZEROFILL
))
2665 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2666 sections, even those with zero size. */
2669 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2670 seg
->vmsize
+= s
->size
;
2672 /* MH_OBJECT files have unaligned content. */
2675 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2676 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2678 seg
->filesize
+= s
->size
;
2680 /* The system tools write even zero-sized sections with an offset
2681 field set to the current file position. */
2682 s
->offset
= mdata
->filelen
;
2685 sec
->filepos
= s
->offset
;
2686 mdata
->filelen
+= s
->size
;
2689 /* Now pass through again, for zerofill, only now we just update the
2690 vmsize, and then for zerofill_GB. */
2691 for (j
= 0; j
< 2; j
++)
2696 stype
= BFD_MACH_O_S_ZEROFILL
;
2698 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2700 for (i
= 0; i
< mdata
->nsects
; ++i
)
2702 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2704 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2709 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2710 seg
->vmsize
+= s
->size
;
2715 /* Allocate space for the relocations. */
2716 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2718 for (i
= 0; i
< mdata
->nsects
; ++i
)
2720 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2721 asection
*sec
= ms
->bfdsection
;
2723 ms
->nreloc
= sec
->reloc_count
;
2724 if (ms
->nreloc
== 0)
2726 /* Clear nreloc and reloff if there is no relocs. */
2730 sec
->rel_filepos
= mdata
->filelen
;
2731 ms
->reloff
= sec
->rel_filepos
;
2732 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2739 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2741 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2743 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2745 bfd_mach_o_section
*s
;
2749 seg
->fileoff
= mdata
->filelen
;
2754 /* Append sections to the segment. We assume they are properly ordered
2755 by vma (but we check that). */
2757 for (i
= 0; i
< mdata
->nsects
; ++i
)
2759 s
= mdata
->sections
[i
];
2761 /* Consider only sections for this segment. */
2762 if (strcmp (seg
->segname
, s
->segname
) != 0)
2765 bfd_mach_o_append_section_to_segment (seg
, s
);
2767 BFD_ASSERT (s
->addr
>= vma
);
2768 vma
= s
->addr
+ s
->size
;
2771 /* Set segment file offset: make it page aligned. */
2772 vma
= seg
->sect_head
->addr
;
2773 seg
->vmaddr
= vma
& ~pagemask
;
2774 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2775 mdata
->filelen
+= pagemask
+ 1;
2776 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2777 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2779 /* Set section file offset. */
2780 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2782 asection
*sec
= s
->bfdsection
;
2783 flagword flags
= bfd_get_section_flags (abfd
, sec
);
2785 /* Adjust segment size. */
2786 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2787 seg
->vmsize
+= s
->size
;
2789 /* File offset and length. */
2790 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2792 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
2793 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2794 != BFD_MACH_O_S_GB_ZEROFILL
))
2796 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2798 s
->offset
= mdata
->filelen
;
2799 s
->bfdsection
->filepos
= s
->offset
;
2801 seg
->filesize
+= s
->size
;
2802 mdata
->filelen
+= s
->size
;
2807 s
->bfdsection
->filepos
= 0;
2810 /* Set protection. */
2811 if (flags
& SEC_LOAD
)
2813 if (flags
& SEC_CODE
)
2814 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
2815 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
2816 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
2819 /* Relocs shouldn't appear in non-object files. */
2820 if (s
->bfdsection
->reloc_count
!= 0)
2825 if (seg
->initprot
!= 0)
2826 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2827 | BFD_MACH_O_PROT_EXECUTE
;
2831 /* Round segment size (and file size). */
2832 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
2833 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
2834 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
2839 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2840 fields in header. */
2843 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
2845 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2846 unsigned int hdrlen
;
2848 bfd_mach_o_load_command
*cmd
;
2851 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2852 align
= wide
? 8 - 1 : 4 - 1;
2854 mdata
->header
.ncmds
= 0;
2856 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
2858 mdata
->header
.ncmds
++;
2859 cmd
->offset
= offset
;
2863 case BFD_MACH_O_LC_SEGMENT_64
:
2864 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2865 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
2867 case BFD_MACH_O_LC_SEGMENT
:
2868 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2869 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
2871 case BFD_MACH_O_LC_SYMTAB
:
2872 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2873 + BFD_MACH_O_LC_SIZE
;
2875 case BFD_MACH_O_LC_DYSYMTAB
:
2876 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2877 + BFD_MACH_O_LC_SIZE
;
2879 case BFD_MACH_O_LC_LOAD_DYLIB
:
2880 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
2881 + BFD_MACH_O_LC_SIZE
;
2882 cmd
->command
.dylib
.name_offset
= cmd
->len
;
2883 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
2884 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2886 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2887 cmd
->len
= sizeof (struct mach_o_str_command_external
)
2888 + BFD_MACH_O_LC_SIZE
;
2889 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
2890 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
2891 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2893 case BFD_MACH_O_LC_MAIN
:
2894 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
2895 + BFD_MACH_O_LC_SIZE
;
2897 case BFD_MACH_O_LC_DYLD_INFO
:
2898 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
2899 + BFD_MACH_O_LC_SIZE
;
2902 (*_bfd_error_handler
)
2903 (_("unable to layout unknown load command 0x%lx"),
2904 (unsigned long) cmd
->type
);
2908 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
2911 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
2912 mdata
->filelen
= offset
;
2915 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2919 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
2920 bfd_mach_o_load_command
*cmd
,
2921 const char *segname
, unsigned int nbr_sect
)
2923 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2924 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2926 /* Init segment command. */
2927 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
2928 cmd
->type_required
= FALSE
;
2930 strcpy (seg
->segname
, segname
);
2931 seg
->nsects
= nbr_sect
;
2941 seg
->sect_head
= NULL
;
2942 seg
->sect_tail
= NULL
;
2945 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2946 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2947 and copy functionality. */
2950 bfd_mach_o_build_commands (bfd
*abfd
)
2952 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2953 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2954 unsigned int nbr_segcmd
= 0;
2955 bfd_mach_o_load_command
*commands
;
2956 unsigned int nbr_commands
;
2957 int symtab_idx
= -1;
2958 int dysymtab_idx
= -1;
2962 /* Return now if already built. */
2963 if (mdata
->header
.ncmds
!= 0)
2966 /* Fill in the file type, if not already set. */
2967 if (mdata
->header
.filetype
== 0)
2969 if (abfd
->flags
& EXEC_P
)
2970 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2971 else if (abfd
->flags
& DYNAMIC
)
2972 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2974 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2977 /* If hasn't already been done, flatten sections list, and sort
2978 if/when required. Must be done before the symbol table is adjusted,
2979 since that depends on properly numbered sections. */
2980 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2981 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2984 /* Order the symbol table, fill-in/check mach-o specific fields and
2985 partition out any indirect symbols. */
2986 if (!bfd_mach_o_mangle_symbols (abfd
))
2989 /* Segment commands. */
2990 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
2992 /* Only one segment for all the sections. But the segment is
2993 optional if there is no sections. */
2994 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
2998 bfd_mach_o_section
*prev_sect
= NULL
;
3000 /* One pagezero segment and one linkedit segment. */
3003 /* Create one segment for associated segment name in sections.
3004 Assume that sections with the same segment name are consecutive. */
3005 for (i
= 0; i
< mdata
->nsects
; i
++)
3007 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
3009 if (prev_sect
== NULL
3010 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
3013 prev_sect
= this_sect
;
3018 nbr_commands
= nbr_segcmd
;
3020 /* One command for the symbol table (only if there are symbols. */
3021 if (bfd_get_symcount (abfd
) > 0)
3022 symtab_idx
= nbr_commands
++;
3025 This is a rather crude test for whether we should build a dysymtab. */
3026 if (bfd_mach_o_should_emit_dysymtab ()
3027 && bfd_get_symcount (abfd
))
3029 /* If there should be a case where a dysymtab could be emitted without
3030 a symtab (seems improbable), this would need amending. */
3031 dysymtab_idx
= nbr_commands
++;
3034 /* Add an entry point command. */
3035 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3036 && bfd_get_start_address (abfd
) != 0)
3037 main_idx
= nbr_commands
++;
3039 /* Well, we must have a header, at least. */
3040 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3042 /* A bit unusual, but no content is valid;
3043 as -n empty.s -o empty.o */
3044 if (nbr_commands
== 0)
3046 /* Layout commands (well none...) and set headers command fields. */
3047 bfd_mach_o_layout_commands (mdata
);
3051 /* Create commands for segments (and symtabs), prepend them. */
3052 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3053 if (commands
== NULL
)
3055 for (i
= 0; i
< nbr_commands
- 1; i
++)
3056 commands
[i
].next
= &commands
[i
+ 1];
3057 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3058 if (mdata
->first_command
== NULL
)
3059 mdata
->last_command
= &commands
[nbr_commands
- 1];
3060 mdata
->first_command
= &commands
[0];
3062 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3064 /* For object file, there is only one segment. */
3065 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3067 else if (nbr_segcmd
!= 0)
3069 bfd_mach_o_load_command
*cmd
;
3071 BFD_ASSERT (nbr_segcmd
>= 2);
3075 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3077 /* Segments from sections. */
3079 for (i
= 0; i
< mdata
->nsects
;)
3081 const char *segname
= mdata
->sections
[i
]->segname
;
3082 unsigned int nbr_sect
= 1;
3084 /* Count number of sections for this segment. */
3085 for (i
++; i
< mdata
->nsects
; i
++)
3086 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3091 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3096 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3099 if (symtab_idx
>= 0)
3101 /* Init symtab command. */
3102 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3104 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3105 cmd
->type_required
= FALSE
;
3108 /* If required, setup symtab command, see comment above about the quality
3110 if (dysymtab_idx
>= 0)
3112 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3114 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3115 cmd
->type_required
= FALSE
;
3118 /* Create the main command. */
3121 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3123 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3124 cmd
->type_required
= TRUE
;
3126 cmd
->command
.main
.entryoff
= 0;
3127 cmd
->command
.main
.stacksize
= 0;
3130 /* Layout commands. */
3131 bfd_mach_o_layout_commands (mdata
);
3133 /* So, now we have sized the commands and the filelen set to that.
3134 Now we can build the segment command and set the section file offsets. */
3135 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3137 for (i
= 0; i
< nbr_segcmd
; i
++)
3138 if (!bfd_mach_o_build_obj_seg_command
3139 (abfd
, &commands
[i
].command
.segment
))
3146 /* Skip pagezero and linkedit segments. */
3147 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3149 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3151 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3154 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3155 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3158 /* Set the size of __PAGEZERO. */
3159 commands
[0].command
.segment
.vmsize
=
3160 commands
[1].command
.segment
.vmaddr
;
3162 /* Set the vma and fileoff of __LINKEDIT. */
3163 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3164 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3166 /* Set entry point (once segments have been laid out). */
3168 commands
[main_idx
].command
.main
.entryoff
=
3169 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3175 /* Set the contents of a section. */
3178 bfd_mach_o_set_section_contents (bfd
*abfd
,
3180 const void * location
,
3182 bfd_size_type count
)
3186 /* Trying to write the first section contents will trigger the creation of
3187 the load commands if they are not already present. */
3188 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3194 pos
= section
->filepos
+ offset
;
3195 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3196 || bfd_bwrite (location
, count
, abfd
) != count
)
3203 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3204 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3209 /* Make an empty symbol. This is required only because
3210 bfd_make_section_anyway wants to create a symbol for the section. */
3213 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3215 asymbol
*new_symbol
;
3217 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3218 if (new_symbol
== NULL
)
3220 new_symbol
->the_bfd
= abfd
;
3221 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3226 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
3228 struct mach_o_header_external raw
;
3230 bfd_vma (*get32
) (const void *) = NULL
;
3232 /* Just read the magic number. */
3233 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3234 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3237 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3239 header
->byteorder
= BFD_ENDIAN_BIG
;
3240 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3241 header
->version
= 1;
3244 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3246 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3247 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3248 header
->version
= 1;
3251 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3253 header
->byteorder
= BFD_ENDIAN_BIG
;
3254 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3255 header
->version
= 2;
3258 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3260 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3261 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3262 header
->version
= 2;
3267 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3271 /* Once the size of the header is known, read the full header. */
3272 size
= mach_o_wide_p (header
) ?
3273 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3275 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3276 || bfd_bread (&raw
, size
, abfd
) != size
)
3279 header
->cputype
= (*get32
) (raw
.cputype
);
3280 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3281 header
->filetype
= (*get32
) (raw
.filetype
);
3282 header
->ncmds
= (*get32
) (raw
.ncmds
);
3283 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3284 header
->flags
= (*get32
) (raw
.flags
);
3286 if (mach_o_wide_p (header
))
3287 header
->reserved
= (*get32
) (raw
.reserved
);
3289 header
->reserved
= 0;
3295 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3297 bfd_mach_o_section
*s
;
3298 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
3300 s
= bfd_mach_o_get_mach_o_section (sec
);
3304 static const mach_o_section_name_xlat
* xlat
;
3306 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3309 sec
->used_by_bfd
= s
;
3310 s
->bfdsection
= sec
;
3312 /* Create the Darwin seg/sect name pair from the bfd name.
3313 If this is a canonical name for which a specific paiting exists
3314 there will also be defined flags, type, attribute and alignment
3316 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3319 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3320 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3322 (void) bfd_set_section_alignment (abfd
, sec
, s
->align
);
3323 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
3324 if (bfd_flags
== SEC_NO_FLAGS
)
3325 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
3328 /* Create default flags. */
3329 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3332 return _bfd_generic_new_section_hook (abfd
, sec
);
3336 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
3340 bfd_mach_o_section
*section
;
3342 flags
= bfd_get_section_flags (abfd
, sec
);
3343 section
= bfd_mach_o_get_mach_o_section (sec
);
3345 /* TODO: see if we should use the xlat system for doing this by
3346 preference and fall back to this for unknown sections. */
3348 if (flags
== SEC_NO_FLAGS
)
3350 /* Try to guess flags. */
3351 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3352 flags
= SEC_DEBUGGING
;
3356 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3357 != BFD_MACH_O_S_ZEROFILL
)
3360 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3362 if (prot
& BFD_MACH_O_PROT_WRITE
)
3364 else if (prot
& BFD_MACH_O_PROT_READ
)
3365 flags
|= SEC_READONLY
;
3371 if ((flags
& SEC_DEBUGGING
) == 0)
3375 if (section
->offset
!= 0)
3376 flags
|= SEC_HAS_CONTENTS
;
3377 if (section
->nreloc
!= 0)
3380 bfd_set_section_flags (abfd
, sec
, flags
);
3382 sec
->vma
= section
->addr
;
3383 sec
->lma
= section
->addr
;
3384 sec
->size
= section
->size
;
3385 sec
->filepos
= section
->offset
;
3386 sec
->alignment_power
= section
->align
;
3387 sec
->segment_mark
= 0;
3388 sec
->reloc_count
= section
->nreloc
;
3389 sec
->rel_filepos
= section
->reloff
;
3393 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3394 const unsigned char *segname
,
3395 const unsigned char *sectname
)
3400 bfd_mach_o_convert_section_name_to_bfd
3401 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3405 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3409 bfd_mach_o_read_section_32 (bfd
*abfd
,
3410 unsigned int offset
,
3413 struct mach_o_section_32_external raw
;
3415 bfd_mach_o_section
*section
;
3417 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3418 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3419 != BFD_MACH_O_SECTION_SIZE
))
3422 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3426 section
= bfd_mach_o_get_mach_o_section (sec
);
3427 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3428 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3429 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3430 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3431 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3432 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3433 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3434 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3435 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3436 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3437 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3438 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3439 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3440 section
->reserved3
= 0;
3442 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3448 bfd_mach_o_read_section_64 (bfd
*abfd
,
3449 unsigned int offset
,
3452 struct mach_o_section_64_external raw
;
3454 bfd_mach_o_section
*section
;
3456 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3457 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3458 != BFD_MACH_O_SECTION_64_SIZE
))
3461 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3465 section
= bfd_mach_o_get_mach_o_section (sec
);
3466 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3467 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3468 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3469 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3470 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3471 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3472 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3473 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3474 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3475 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3476 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3477 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3478 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3479 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3481 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3487 bfd_mach_o_read_section (bfd
*abfd
,
3488 unsigned int offset
,
3493 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
3495 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
3499 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3500 bfd_mach_o_symtab_command
*sym
,
3501 bfd_mach_o_asymbol
*s
,
3504 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3505 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3506 unsigned int symwidth
=
3507 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3508 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3509 struct mach_o_nlist_64_external raw
;
3510 unsigned char type
= -1;
3511 unsigned char section
= -1;
3513 symvalue value
= -1;
3514 unsigned long stroff
= -1;
3515 unsigned int symtype
= -1;
3517 BFD_ASSERT (sym
->strtab
!= NULL
);
3519 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3520 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3522 (*_bfd_error_handler
)
3523 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3524 symwidth
, (unsigned long) symoff
);
3528 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3529 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3530 symtype
= type
& BFD_MACH_O_N_TYPE
;
3531 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3532 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3534 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3536 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3538 if (stroff
>= sym
->strsize
)
3540 (*_bfd_error_handler
)
3541 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3542 (unsigned long) stroff
,
3543 (unsigned long) sym
->strsize
);
3547 s
->symbol
.the_bfd
= abfd
;
3548 s
->symbol
.name
= sym
->strtab
+ stroff
;
3549 s
->symbol
.value
= value
;
3550 s
->symbol
.flags
= 0x0;
3551 s
->symbol
.udata
.i
= i
;
3553 s
->n_sect
= section
;
3556 if (type
& BFD_MACH_O_N_STAB
)
3558 s
->symbol
.flags
|= BSF_DEBUGGING
;
3559 s
->symbol
.section
= bfd_und_section_ptr
;
3571 if ((section
> 0) && (section
<= mdata
->nsects
))
3573 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3575 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3582 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3583 s
->symbol
.flags
|= BSF_GLOBAL
;
3585 s
->symbol
.flags
|= BSF_LOCAL
;
3589 case BFD_MACH_O_N_UNDF
:
3590 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3591 && s
->symbol
.value
!= 0)
3593 /* A common symbol. */
3594 s
->symbol
.section
= bfd_com_section_ptr
;
3595 s
->symbol
.flags
= BSF_NO_FLAGS
;
3599 s
->symbol
.section
= bfd_und_section_ptr
;
3600 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3601 s
->symbol
.flags
|= BSF_WEAK
;
3604 case BFD_MACH_O_N_PBUD
:
3605 s
->symbol
.section
= bfd_und_section_ptr
;
3607 case BFD_MACH_O_N_ABS
:
3608 s
->symbol
.section
= bfd_abs_section_ptr
;
3610 case BFD_MACH_O_N_SECT
:
3611 if ((section
> 0) && (section
<= mdata
->nsects
))
3613 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3615 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3619 /* Mach-O uses 0 to mean "no section"; not an error. */
3622 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3623 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3624 s
->symbol
.name
, section
, mdata
->nsects
);
3626 s
->symbol
.section
= bfd_und_section_ptr
;
3629 case BFD_MACH_O_N_INDR
:
3630 /* FIXME: we don't follow the BFD convention as this indirect symbol
3631 won't be followed by the referenced one. This looks harmless
3632 unless we start using the linker. */
3633 s
->symbol
.flags
|= BSF_INDIRECT
;
3634 s
->symbol
.section
= bfd_ind_section_ptr
;
3635 s
->symbol
.value
= 0;
3638 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3639 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3640 s
->symbol
.name
, symtype
);
3641 s
->symbol
.section
= bfd_und_section_ptr
;
3650 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3652 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3653 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3655 /* Fail if there is no symtab. */
3659 /* Success if already loaded. */
3663 if (abfd
->flags
& BFD_IN_MEMORY
)
3665 struct bfd_in_memory
*b
;
3667 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3669 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3671 bfd_set_error (bfd_error_file_truncated
);
3674 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3678 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
3679 if (sym
->strtab
== NULL
)
3682 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
3683 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
3685 /* PR 17512: file: 10888-1609-0.004. */
3686 bfd_release (abfd
, sym
->strtab
);
3688 bfd_set_error (bfd_error_file_truncated
);
3697 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3699 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3700 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3703 if (sym
== NULL
|| sym
->symbols
)
3704 /* Return now if there are no symbols or if already loaded. */
3707 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
3709 if (sym
->symbols
== NULL
)
3711 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3715 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3717 bfd_release (abfd
, sym
->symbols
);
3718 sym
->symbols
= NULL
;
3722 for (i
= 0; i
< sym
->nsyms
; i
++)
3724 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3726 bfd_release (abfd
, sym
->symbols
);
3727 sym
->symbols
= NULL
;
3736 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3738 switch ((int) flavour
)
3740 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3741 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3742 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3743 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3744 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3745 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3746 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3747 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3748 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3749 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3750 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3751 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3752 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3753 default: return "UNKNOWN";
3758 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3760 switch ((int) flavour
)
3762 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3763 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3764 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3765 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3766 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3767 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3768 default: return "UNKNOWN";
3773 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3775 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
3776 struct mach_o_str_command_external raw
;
3777 unsigned int nameoff
;
3778 unsigned int namelen
;
3780 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3781 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3784 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
3786 cmd
->name_offset
= nameoff
;
3787 namelen
= command
->len
- nameoff
;
3788 nameoff
+= command
->offset
;
3789 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3790 if (cmd
->name_str
== NULL
)
3792 if (bfd_seek (abfd
, nameoff
, SEEK_SET
) != 0
3793 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3799 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3801 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3802 struct mach_o_dylib_command_external raw
;
3803 unsigned int nameoff
;
3804 unsigned int namelen
;
3806 switch (command
->type
)
3808 case BFD_MACH_O_LC_LOAD_DYLIB
:
3809 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
3810 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3811 case BFD_MACH_O_LC_ID_DYLIB
:
3812 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3813 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3820 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3821 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3824 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3825 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3826 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3827 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3829 cmd
->name_offset
= command
->offset
+ nameoff
;
3830 namelen
= command
->len
- nameoff
;
3831 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3832 if (cmd
->name_str
== NULL
)
3834 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3835 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3841 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
3842 bfd_mach_o_load_command
*command
)
3844 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
3845 struct mach_o_prebound_dylib_command_external raw
;
3846 unsigned int nameoff
;
3847 unsigned int modoff
;
3848 unsigned int str_len
;
3851 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3852 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3855 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3856 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
3857 if (nameoff
> command
->len
|| modoff
> command
->len
)
3860 str_len
= command
->len
- sizeof (raw
);
3861 str
= bfd_alloc (abfd
, str_len
);
3864 if (bfd_bread (str
, str_len
, abfd
) != str_len
)
3867 cmd
->name_offset
= command
->offset
+ nameoff
;
3868 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
3869 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
3871 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3872 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3877 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
3878 bfd_mach_o_load_command
*command
)
3880 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
3881 struct mach_o_prebind_cksum_command_external raw
;
3883 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3884 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3887 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
3892 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
3893 bfd_mach_o_load_command
*command
)
3895 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
3896 struct mach_o_twolevel_hints_command_external raw
;
3898 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3899 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3902 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
3903 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
3908 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3910 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
3911 struct mach_o_fvmlib_command_external raw
;
3912 unsigned int nameoff
;
3913 unsigned int namelen
;
3915 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3916 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3919 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3920 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3921 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3923 fvm
->name_offset
= command
->offset
+ nameoff
;
3924 namelen
= command
->len
- nameoff
;
3925 fvm
->name_str
= bfd_alloc (abfd
, namelen
);
3926 if (fvm
->name_str
== NULL
)
3928 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3929 || bfd_bread (fvm
->name_str
, namelen
, abfd
) != namelen
)
3935 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3937 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3938 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3939 unsigned int offset
;
3940 unsigned int nflavours
;
3943 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3944 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3946 /* Count the number of threads. */
3949 while (offset
!= command
->len
)
3951 struct mach_o_thread_command_external raw
;
3953 if (offset
>= command
->len
)
3956 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3957 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3960 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3964 /* Allocate threads. */
3965 cmd
->flavours
= bfd_alloc
3966 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3967 if (cmd
->flavours
== NULL
)
3969 cmd
->nflavours
= nflavours
;
3973 while (offset
!= command
->len
)
3975 struct mach_o_thread_command_external raw
;
3977 if (offset
>= command
->len
)
3980 if (nflavours
>= cmd
->nflavours
)
3983 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3984 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3987 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3988 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3989 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3990 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3994 for (i
= 0; i
< nflavours
; i
++)
3997 unsigned int snamelen
;
3999 const char *flavourstr
;
4000 const char *prefix
= "LC_THREAD";
4003 switch (mdata
->header
.cputype
)
4005 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4006 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
4008 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
4010 case BFD_MACH_O_CPU_TYPE_I386
:
4011 case BFD_MACH_O_CPU_TYPE_X86_64
:
4013 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
4016 flavourstr
= "UNKNOWN_ARCHITECTURE";
4020 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
4021 sname
= bfd_alloc (abfd
, snamelen
);
4027 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
4028 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
4033 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
4037 bfdsec
->size
= cmd
->flavours
[i
].size
;
4038 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
4039 bfdsec
->alignment_power
= 0x0;
4041 cmd
->section
= bfdsec
;
4048 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4050 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4051 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4053 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4056 struct mach_o_dysymtab_command_external raw
;
4058 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4059 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4062 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4063 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4064 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4065 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4066 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4067 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4068 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4069 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4070 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4071 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4072 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4073 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4074 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4075 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4076 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4077 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4078 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4079 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4082 if (cmd
->nmodtab
!= 0)
4085 int wide
= bfd_mach_o_wide_p (abfd
);
4086 unsigned int module_len
= wide
? 56 : 52;
4089 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
4090 if (cmd
->dylib_module
== NULL
)
4093 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4096 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4098 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4100 unsigned char buf
[56];
4102 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4105 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4106 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4107 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4108 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4109 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4110 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4111 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4112 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4113 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4114 v
= bfd_h_get_32 (abfd
, buf
+36);
4115 module
->iinit
= v
& 0xffff;
4116 module
->iterm
= (v
>> 16) & 0xffff;
4117 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4118 module
->ninit
= v
& 0xffff;
4119 module
->nterm
= (v
>> 16) & 0xffff;
4122 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4123 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4127 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4128 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4137 cmd
->dylib_toc
= bfd_alloc
4138 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
4139 if (cmd
->dylib_toc
== NULL
)
4142 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4145 for (i
= 0; i
< cmd
->ntoc
; i
++)
4147 struct mach_o_dylib_table_of_contents_external raw
;
4148 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4150 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4153 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4154 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4158 if (cmd
->nindirectsyms
!= 0)
4162 cmd
->indirect_syms
= bfd_alloc
4163 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
4164 if (cmd
->indirect_syms
== NULL
)
4167 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4170 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4172 unsigned char raw
[4];
4173 unsigned int *is
= &cmd
->indirect_syms
[i
];
4175 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4178 *is
= bfd_h_get_32 (abfd
, raw
);
4182 if (cmd
->nextrefsyms
!= 0)
4187 cmd
->ext_refs
= bfd_alloc
4188 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
4189 if (cmd
->ext_refs
== NULL
)
4192 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4195 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4197 unsigned char raw
[4];
4198 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4200 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4203 /* Fields isym and flags are written as bit-fields, thus we need
4204 a specific processing for endianness. */
4205 v
= bfd_h_get_32 (abfd
, raw
);
4206 if (bfd_big_endian (abfd
))
4208 ref
->isym
= (v
>> 8) & 0xffffff;
4209 ref
->flags
= v
& 0xff;
4213 ref
->isym
= v
& 0xffffff;
4214 ref
->flags
= (v
>> 24) & 0xff;
4219 if (mdata
->dysymtab
)
4221 mdata
->dysymtab
= cmd
;
4227 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4229 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4230 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4231 struct mach_o_symtab_command_external raw
;
4233 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4235 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4236 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4239 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4240 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4241 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4242 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4243 symtab
->symbols
= NULL
;
4244 symtab
->strtab
= NULL
;
4246 if (symtab
->nsyms
!= 0)
4247 abfd
->flags
|= HAS_SYMS
;
4251 mdata
->symtab
= symtab
;
4256 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4258 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4260 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4262 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4263 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4270 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4272 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4273 struct mach_o_linkedit_data_command_external raw
;
4275 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4276 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4279 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4280 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4285 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4287 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4288 struct mach_o_str_command_external raw
;
4291 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4292 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4295 off
= bfd_get_32 (abfd
, raw
.str
);
4296 cmd
->stroff
= command
->offset
+ off
;
4297 cmd
->str_len
= command
->len
- off
;
4298 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
4299 if (cmd
->str
== NULL
)
4301 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
4302 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
4307 static unsigned char *
4308 bfd_mach_o_alloc_and_read (bfd
*abfd
, unsigned int off
, unsigned int size
)
4312 buf
= bfd_alloc (abfd
, size
);
4315 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4316 || bfd_bread (buf
, size
, abfd
) != size
)
4322 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4324 /* Read rebase content. */
4325 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4327 cmd
->rebase_content
=
4328 bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4329 if (cmd
->rebase_content
== NULL
)
4333 /* Read bind content. */
4334 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4337 bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4338 if (cmd
->bind_content
== NULL
)
4342 /* Read weak bind content. */
4343 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4345 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4346 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4347 if (cmd
->weak_bind_content
== NULL
)
4351 /* Read lazy bind content. */
4352 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4354 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4355 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4356 if (cmd
->lazy_bind_content
== NULL
)
4360 /* Read export content. */
4361 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4363 cmd
->export_content
= bfd_mach_o_alloc_and_read
4364 (abfd
, cmd
->export_off
, cmd
->export_size
);
4365 if (cmd
->export_content
== NULL
)
4373 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4375 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4376 struct mach_o_dyld_info_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 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4383 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4384 cmd
->rebase_content
= NULL
;
4385 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4386 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4387 cmd
->bind_content
= NULL
;
4388 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4389 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4390 cmd
->weak_bind_content
= NULL
;
4391 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4392 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4393 cmd
->lazy_bind_content
= NULL
;
4394 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4395 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4396 cmd
->export_content
= NULL
;
4401 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4403 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4404 struct mach_o_version_min_command_external raw
;
4407 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4408 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4411 ver
= bfd_get_32 (abfd
, raw
.version
);
4412 cmd
->rel
= ver
>> 16;
4413 cmd
->maj
= ver
>> 8;
4415 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
4420 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4422 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4423 struct mach_o_encryption_info_command_external raw
;
4425 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4426 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4429 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4430 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4431 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4436 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4438 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4439 struct mach_o_entry_point_command_external raw
;
4441 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4442 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4445 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4446 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4451 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4453 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4454 struct mach_o_source_version_command_external raw
;
4457 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4458 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4461 ver
= bfd_get_64 (abfd
, raw
.version
);
4462 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4463 generates warnings) in case of the host doesn't support 64 bit
4465 cmd
->e
= ver
& 0x3ff;
4467 cmd
->d
= ver
& 0x3ff;
4469 cmd
->c
= ver
& 0x3ff;
4471 cmd
->b
= ver
& 0x3ff;
4473 cmd
->a
= ver
& 0xffffff;
4478 bfd_mach_o_read_segment (bfd
*abfd
,
4479 bfd_mach_o_load_command
*command
,
4482 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4487 struct mach_o_segment_command_64_external raw
;
4489 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4491 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4492 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4495 memcpy (seg
->segname
, raw
.segname
, 16);
4496 seg
->segname
[16] = '\0';
4498 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4499 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4500 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4501 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4502 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4503 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4504 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4505 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4509 struct mach_o_segment_command_32_external raw
;
4511 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4513 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4514 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4517 memcpy (seg
->segname
, raw
.segname
, 16);
4518 seg
->segname
[16] = '\0';
4520 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4521 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4522 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4523 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4524 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4525 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4526 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4527 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4529 seg
->sect_head
= NULL
;
4530 seg
->sect_tail
= NULL
;
4532 for (i
= 0; i
< seg
->nsects
; i
++)
4538 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
4539 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
4541 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
4542 + (i
* BFD_MACH_O_SECTION_SIZE
);
4544 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
4548 bfd_mach_o_append_section_to_segment
4549 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4556 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4558 return bfd_mach_o_read_segment (abfd
, command
, 0);
4562 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4564 return bfd_mach_o_read_segment (abfd
, command
, 1);
4568 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4570 struct mach_o_load_command_external raw
;
4573 /* Read command type and length. */
4574 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
4575 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4578 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4579 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4580 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4581 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4583 switch (command
->type
)
4585 case BFD_MACH_O_LC_SEGMENT
:
4586 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4589 case BFD_MACH_O_LC_SEGMENT_64
:
4590 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4593 case BFD_MACH_O_LC_SYMTAB
:
4594 if (!bfd_mach_o_read_symtab (abfd
, command
))
4597 case BFD_MACH_O_LC_SYMSEG
:
4599 case BFD_MACH_O_LC_THREAD
:
4600 case BFD_MACH_O_LC_UNIXTHREAD
:
4601 if (!bfd_mach_o_read_thread (abfd
, command
))
4604 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4605 case BFD_MACH_O_LC_ID_DYLINKER
:
4606 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4607 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4610 case BFD_MACH_O_LC_LOAD_DYLIB
:
4611 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4612 case BFD_MACH_O_LC_ID_DYLIB
:
4613 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4614 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4615 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4616 if (!bfd_mach_o_read_dylib (abfd
, command
))
4619 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4620 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4623 case BFD_MACH_O_LC_LOADFVMLIB
:
4624 case BFD_MACH_O_LC_IDFVMLIB
:
4625 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4628 case BFD_MACH_O_LC_IDENT
:
4629 case BFD_MACH_O_LC_FVMFILE
:
4630 case BFD_MACH_O_LC_PREPAGE
:
4631 case BFD_MACH_O_LC_ROUTINES
:
4632 case BFD_MACH_O_LC_ROUTINES_64
:
4634 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4635 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4636 case BFD_MACH_O_LC_SUB_LIBRARY
:
4637 case BFD_MACH_O_LC_SUB_CLIENT
:
4638 case BFD_MACH_O_LC_RPATH
:
4639 if (!bfd_mach_o_read_str (abfd
, command
))
4642 case BFD_MACH_O_LC_DYSYMTAB
:
4643 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4646 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4647 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4650 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4651 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4654 case BFD_MACH_O_LC_UUID
:
4655 if (!bfd_mach_o_read_uuid (abfd
, command
))
4658 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4659 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4660 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4661 case BFD_MACH_O_LC_DATA_IN_CODE
:
4662 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4663 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4666 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4667 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4670 case BFD_MACH_O_LC_DYLD_INFO
:
4671 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
4674 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4675 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4676 if (!bfd_mach_o_read_version_min (abfd
, command
))
4679 case BFD_MACH_O_LC_MAIN
:
4680 if (!bfd_mach_o_read_main (abfd
, command
))
4683 case BFD_MACH_O_LC_SOURCE_VERSION
:
4684 if (!bfd_mach_o_read_source_version (abfd
, command
))
4689 static bfd_boolean unknown_set
= FALSE
;
4690 static unsigned long unknown_command
= 0;
4692 /* Prevent reams of error messages when parsing corrupt binaries. */
4695 else if (command
->type
== unknown_command
)
4697 unknown_command
= command
->type
;
4699 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
4700 abfd
, (unsigned long) command
->type
);
4709 bfd_mach_o_flatten_sections (bfd
*abfd
)
4711 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4712 bfd_mach_o_load_command
*cmd
;
4715 /* Count total number of sections. */
4718 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4720 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4721 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4723 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4725 mdata
->nsects
+= seg
->nsects
;
4729 /* Allocate sections array. */
4730 mdata
->sections
= bfd_alloc (abfd
,
4731 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
4733 /* Fill the array. */
4736 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4738 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4739 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4741 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4742 bfd_mach_o_section
*sec
;
4744 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
4746 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
4747 mdata
->sections
[csect
++] = sec
;
4753 bfd_mach_o_scan_start_address (bfd
*abfd
)
4755 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4756 bfd_mach_o_thread_command
*thr
= NULL
;
4757 bfd_mach_o_load_command
*cmd
;
4760 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4761 if (cmd
->type
== BFD_MACH_O_LC_THREAD
4762 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
4764 thr
= &cmd
->command
.thread
;
4767 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
4769 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
4770 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
4774 abfd
->start_address
= main_cmd
->entryoff
4775 + (text_sect
->addr
- text_sect
->offset
);
4780 /* An object file has no start address, so do not fail if not found. */
4784 /* FIXME: create a subtarget hook ? */
4785 for (i
= 0; i
< thr
->nflavours
; i
++)
4787 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
4788 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
4790 unsigned char buf
[4];
4792 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
4793 || bfd_bread (buf
, 4, abfd
) != 4)
4796 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4798 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
4799 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
4801 unsigned char buf
[4];
4803 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4804 || bfd_bread (buf
, 4, abfd
) != 4)
4807 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4809 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
4810 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
4812 unsigned char buf
[8];
4814 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4815 || bfd_bread (buf
, 8, abfd
) != 8)
4818 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4820 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
4821 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
4823 unsigned char buf
[8];
4825 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
4826 || bfd_bread (buf
, 8, abfd
) != 8)
4829 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4837 bfd_mach_o_set_arch_mach (bfd
*abfd
,
4838 enum bfd_architecture arch
,
4839 unsigned long machine
)
4841 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4843 /* If this isn't the right architecture for this backend, and this
4844 isn't the generic backend, fail. */
4845 if (arch
!= bed
->arch
4846 && arch
!= bfd_arch_unknown
4847 && bed
->arch
!= bfd_arch_unknown
)
4850 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4854 bfd_mach_o_scan (bfd
*abfd
,
4855 bfd_mach_o_header
*header
,
4856 bfd_mach_o_data_struct
*mdata
)
4859 enum bfd_architecture cputype
;
4860 unsigned long cpusubtype
;
4861 unsigned int hdrsize
;
4863 hdrsize
= mach_o_wide_p (header
) ?
4864 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
4866 mdata
->header
= *header
;
4868 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
4869 switch (header
->filetype
)
4871 case BFD_MACH_O_MH_OBJECT
:
4872 abfd
->flags
|= HAS_RELOC
;
4874 case BFD_MACH_O_MH_EXECUTE
:
4875 abfd
->flags
|= EXEC_P
;
4877 case BFD_MACH_O_MH_DYLIB
:
4878 case BFD_MACH_O_MH_BUNDLE
:
4879 abfd
->flags
|= DYNAMIC
;
4883 abfd
->tdata
.mach_o_data
= mdata
;
4885 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
4886 &cputype
, &cpusubtype
);
4887 if (cputype
== bfd_arch_unknown
)
4889 (*_bfd_error_handler
)
4890 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4891 header
->cputype
, header
->cpusubtype
);
4895 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
4897 if (header
->ncmds
!= 0)
4899 bfd_mach_o_load_command
*cmd
;
4901 mdata
->first_command
= NULL
;
4902 mdata
->last_command
= NULL
;
4903 cmd
= bfd_alloc (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
4907 for (i
= 0; i
< header
->ncmds
; i
++)
4909 bfd_mach_o_load_command
*cur
= &cmd
[i
];
4911 bfd_mach_o_append_command (abfd
, cur
);
4914 cur
->offset
= hdrsize
;
4917 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
4918 cur
->offset
= prev
->offset
+ prev
->len
;
4921 if (!bfd_mach_o_read_command (abfd
, cur
))
4926 /* Sections should be flatten before scanning start address. */
4927 bfd_mach_o_flatten_sections (abfd
);
4928 if (!bfd_mach_o_scan_start_address (abfd
))
4935 bfd_mach_o_mkobject_init (bfd
*abfd
)
4937 bfd_mach_o_data_struct
*mdata
= NULL
;
4939 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
4942 abfd
->tdata
.mach_o_data
= mdata
;
4944 mdata
->header
.magic
= 0;
4945 mdata
->header
.cputype
= 0;
4946 mdata
->header
.cpusubtype
= 0;
4947 mdata
->header
.filetype
= 0;
4948 mdata
->header
.ncmds
= 0;
4949 mdata
->header
.sizeofcmds
= 0;
4950 mdata
->header
.flags
= 0;
4951 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
4952 mdata
->first_command
= NULL
;
4953 mdata
->last_command
= NULL
;
4955 mdata
->sections
= NULL
;
4956 mdata
->dyn_reloc_cache
= NULL
;
4962 bfd_mach_o_gen_mkobject (bfd
*abfd
)
4964 bfd_mach_o_data_struct
*mdata
;
4966 if (!bfd_mach_o_mkobject_init (abfd
))
4969 mdata
= bfd_mach_o_get_data (abfd
);
4970 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
4971 mdata
->header
.cputype
= 0;
4972 mdata
->header
.cpusubtype
= 0;
4973 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
4974 mdata
->header
.version
= 1;
4980 bfd_mach_o_header_p (bfd
*abfd
,
4981 bfd_mach_o_filetype filetype
,
4982 bfd_mach_o_cpu_type cputype
)
4984 bfd_mach_o_header header
;
4985 bfd_mach_o_data_struct
*mdata
;
4987 if (!bfd_mach_o_read_header (abfd
, &header
))
4990 if (! (header
.byteorder
== BFD_ENDIAN_BIG
4991 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
4993 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
4994 (unsigned long) header
.byteorder
);
4998 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
4999 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
5000 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
5001 || (header
.byteorder
== BFD_ENDIAN_LITTLE
5002 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
5003 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
5006 /* Check cputype and filetype.
5007 In case of wildcard, do not accept magics that are handled by existing
5011 if (header
.cputype
!= cputype
)
5017 /* Do not recognize 64 architectures if not configured for 64bit targets.
5018 This could happen only for generic targets. */
5019 if (mach_o_wide_p (&header
))
5026 if (header
.filetype
!= filetype
)
5031 switch (header
.filetype
)
5033 case BFD_MACH_O_MH_CORE
:
5034 /* Handled by core_p */
5041 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
5045 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
5051 bfd_set_error (bfd_error_wrong_format
);
5057 static const bfd_target
*
5058 bfd_mach_o_gen_object_p (bfd
*abfd
)
5060 return bfd_mach_o_header_p (abfd
, 0, 0);
5063 static const bfd_target
*
5064 bfd_mach_o_gen_core_p (bfd
*abfd
)
5066 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
5069 /* Return the base address of ABFD, ie the address at which the image is
5070 mapped. The possible initial pagezero is ignored. */
5073 bfd_mach_o_get_base_address (bfd
*abfd
)
5075 bfd_mach_o_data_struct
*mdata
;
5076 bfd_mach_o_load_command
*cmd
;
5078 /* Check for Mach-O. */
5079 if (!bfd_mach_o_valid (abfd
))
5081 mdata
= bfd_mach_o_get_data (abfd
);
5083 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5085 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5086 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5088 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5090 if (segcmd
->initprot
!= 0)
5091 return segcmd
->vmaddr
;
5097 typedef struct mach_o_fat_archentry
5099 unsigned long cputype
;
5100 unsigned long cpusubtype
;
5101 unsigned long offset
;
5103 unsigned long align
;
5104 } mach_o_fat_archentry
;
5106 typedef struct mach_o_fat_data_struct
5108 unsigned long magic
;
5109 unsigned long nfat_arch
;
5110 mach_o_fat_archentry
*archentries
;
5111 } mach_o_fat_data_struct
;
5114 bfd_mach_o_archive_p (bfd
*abfd
)
5116 mach_o_fat_data_struct
*adata
= NULL
;
5117 struct mach_o_fat_header_external hdr
;
5120 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5121 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5124 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5128 adata
->magic
= bfd_getb32 (hdr
.magic
);
5129 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5130 if (adata
->magic
!= 0xcafebabe)
5132 /* Avoid matching Java bytecode files, which have the same magic number.
5133 In the Java bytecode file format this field contains the JVM version,
5134 which starts at 43.0. */
5135 if (adata
->nfat_arch
> 30)
5138 adata
->archentries
=
5139 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
5140 if (adata
->archentries
== NULL
)
5143 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5145 struct mach_o_fat_arch_external arch
;
5146 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5148 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5149 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5150 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5151 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5152 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5155 abfd
->tdata
.mach_o_fat_data
= adata
;
5160 bfd_release (abfd
, adata
);
5161 bfd_set_error (bfd_error_wrong_format
);
5165 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5166 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5167 Set arelt_data and origin fields too. */
5170 bfd_mach_o_fat_member_init (bfd
*abfd
,
5171 enum bfd_architecture arch_type
,
5172 unsigned long arch_subtype
,
5173 mach_o_fat_archentry
*entry
)
5175 struct areltdata
*areltdata
;
5176 /* Create the member filename. Use ARCH_NAME. */
5177 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5181 /* Use the architecture name if known. */
5182 abfd
->filename
= xstrdup (ap
->printable_name
);
5186 /* Forge a uniq id. */
5187 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5188 char *name
= xmalloc (namelen
);
5189 snprintf (name
, namelen
, "0x%lx-0x%lx",
5190 entry
->cputype
, entry
->cpusubtype
);
5191 abfd
->filename
= name
;
5194 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5195 areltdata
->parsed_size
= entry
->size
;
5196 abfd
->arelt_data
= areltdata
;
5197 abfd
->iostream
= NULL
;
5198 abfd
->origin
= entry
->offset
;
5202 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5204 mach_o_fat_data_struct
*adata
;
5205 mach_o_fat_archentry
*entry
= NULL
;
5208 enum bfd_architecture arch_type
;
5209 unsigned long arch_subtype
;
5211 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5212 BFD_ASSERT (adata
!= NULL
);
5214 /* Find index of previous entry. */
5217 /* Start at first one. */
5222 /* Find index of PREV. */
5223 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5225 if (adata
->archentries
[i
].offset
== prev
->origin
)
5229 if (i
== adata
->nfat_arch
)
5232 bfd_set_error (bfd_error_bad_value
);
5236 /* Get next entry. */
5240 if (i
>= adata
->nfat_arch
)
5242 bfd_set_error (bfd_error_no_more_archived_files
);
5246 entry
= &adata
->archentries
[i
];
5247 nbfd
= _bfd_new_bfd_contained_in (archive
);
5251 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5252 &arch_type
, &arch_subtype
);
5254 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
5256 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5261 /* Analogous to stat call. */
5264 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5266 if (abfd
->arelt_data
== NULL
)
5268 bfd_set_error (bfd_error_invalid_operation
);
5275 buf
->st_mode
= 0644;
5276 buf
->st_size
= arelt_size (abfd
);
5281 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5282 If ABFD is a fat image containing a member that corresponds to FORMAT
5283 and ARCH, returns it.
5284 In other case, returns NULL.
5285 This function allows transparent uses of fat images. */
5288 bfd_mach_o_fat_extract (bfd
*abfd
,
5290 const bfd_arch_info_type
*arch
)
5293 mach_o_fat_data_struct
*adata
;
5296 if (bfd_check_format (abfd
, format
))
5298 if (bfd_get_arch_info (abfd
) == arch
)
5302 if (!bfd_check_format (abfd
, bfd_archive
)
5303 || abfd
->xvec
!= &mach_o_fat_vec
)
5306 /* This is a Mach-O fat image. */
5307 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5308 BFD_ASSERT (adata
!= NULL
);
5310 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5312 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5313 enum bfd_architecture cpu_type
;
5314 unsigned long cpu_subtype
;
5316 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5317 &cpu_type
, &cpu_subtype
);
5318 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5321 /* The architecture is found. */
5322 res
= _bfd_new_bfd_contained_in (abfd
);
5326 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
5328 if (bfd_check_format (res
, format
))
5330 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5341 bfd_mach_o_lookup_command (bfd
*abfd
,
5342 bfd_mach_o_load_command_type type
,
5343 bfd_mach_o_load_command
**mcommand
)
5345 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5346 struct bfd_mach_o_load_command
*cmd
;
5349 BFD_ASSERT (mdata
!= NULL
);
5350 BFD_ASSERT (mcommand
!= NULL
);
5353 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5355 if (cmd
->type
!= type
)
5367 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5371 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5373 case BFD_MACH_O_CPU_TYPE_MC88000
:
5375 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5377 case BFD_MACH_O_CPU_TYPE_I386
:
5379 case BFD_MACH_O_CPU_TYPE_SPARC
:
5381 case BFD_MACH_O_CPU_TYPE_I860
:
5383 case BFD_MACH_O_CPU_TYPE_HPPA
:
5384 return 0xc0000000 - 0x04000000;
5390 /* The following two tables should be kept, as far as possible, in order of
5391 most frequently used entries to optimize their use from gas. */
5393 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5395 { "regular", BFD_MACH_O_S_REGULAR
},
5396 { "coalesced", BFD_MACH_O_S_COALESCED
},
5397 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5398 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5399 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5400 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5401 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5402 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5403 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5404 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5405 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5406 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5407 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5408 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5409 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5410 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5411 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5415 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5417 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5418 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5419 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5420 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5421 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5422 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5423 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5424 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5425 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5426 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5427 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5431 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5434 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5436 const bfd_mach_o_xlat_name
*x
;
5437 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5439 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5440 if (strcmp (x
->name
, name
) == 0)
5442 /* We found it... does the target support it? */
5443 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5444 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5445 return x
->val
; /* OK. */
5447 break; /* Not supported. */
5449 /* Maximum section ID = 0xff. */
5453 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5456 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5458 const bfd_mach_o_xlat_name
*x
;
5460 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5461 if (strcmp (x
->name
, name
) == 0)
5463 return (unsigned int)-1;
5467 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5468 unsigned char **rbuf
,
5471 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5472 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5473 bfd_mach_o_load_command
*cmd
;
5475 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5477 bfd_mach_o_segment_command
*seg
;
5479 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5482 seg
= &cmd
->command
.segment
;
5484 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5486 unsigned long start
= seg
->fileoff
;
5487 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5488 unsigned char *buf
= bfd_malloc (1024);
5489 unsigned long size
= 1024;
5493 bfd_size_type nread
= 0;
5494 unsigned long offset
;
5495 int found_nonnull
= 0;
5497 if (size
> (end
- start
))
5498 size
= (end
- start
);
5500 buf
= bfd_realloc_or_free (buf
, size
);
5504 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5510 nread
= bfd_bread (buf
, size
, abfd
);
5518 for (offset
= 4; offset
<= size
; offset
+= 4)
5522 val
= *((unsigned long *) (buf
+ size
- offset
));
5523 if (! found_nonnull
)
5528 else if (val
== 0x0)
5530 unsigned long bottom
;
5533 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5534 top
= seg
->fileoff
+ seg
->filesize
- 4;
5535 *rbuf
= bfd_malloc (top
- bottom
);
5536 *rlen
= top
- bottom
;
5538 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5544 if (size
== (end
- start
))
5558 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5560 unsigned char *buf
= NULL
;
5561 unsigned int len
= 0;
5564 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5568 return (char *) buf
;
5572 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5577 static bfd_mach_o_uuid_command
*
5578 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5580 bfd_mach_o_load_command
*uuid_cmd
;
5581 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5584 return &uuid_cmd
->command
.uuid
;
5587 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5590 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5592 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5595 BFD_ASSERT (uuid_cmd
);
5597 if (!bfd_check_format (abfd
, bfd_object
))
5600 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5601 || bfd_mach_o_get_data (abfd
) == NULL
5602 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5605 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5606 if (dsym_uuid_cmd
== NULL
)
5609 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5610 sizeof (uuid_cmd
->uuid
)) != 0)
5616 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5617 The caller is responsible for closing the returned BFD object and
5618 its my_archive if the returned BFD is in a fat dSYM. */
5621 bfd_mach_o_find_dsym (const char *dsym_filename
,
5622 const bfd_mach_o_uuid_command
*uuid_cmd
,
5623 const bfd_arch_info_type
*arch
)
5625 bfd
*base_dsym_bfd
, *dsym_bfd
;
5627 BFD_ASSERT (uuid_cmd
);
5629 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
5630 if (base_dsym_bfd
== NULL
)
5633 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
5634 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
5637 bfd_close (dsym_bfd
);
5638 if (base_dsym_bfd
!= dsym_bfd
)
5639 bfd_close (base_dsym_bfd
);
5644 /* Return a BFD created from a dSYM file for ABFD.
5645 The caller is responsible for closing the returned BFD object, its
5646 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5649 bfd_mach_o_follow_dsym (bfd
*abfd
)
5651 char *dsym_filename
;
5652 bfd_mach_o_uuid_command
*uuid_cmd
;
5653 bfd
*dsym_bfd
, *base_bfd
= abfd
;
5654 const char *base_basename
;
5656 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
5659 if (abfd
->my_archive
)
5660 base_bfd
= abfd
->my_archive
;
5661 /* BFD may have been opened from a stream. */
5662 if (base_bfd
->filename
== NULL
)
5664 bfd_set_error (bfd_error_invalid_operation
);
5667 base_basename
= lbasename (base_bfd
->filename
);
5669 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5670 if (uuid_cmd
== NULL
)
5673 /* TODO: We assume the DWARF file has the same as the binary's.
5674 It seems apple's GDB checks all files in the dSYM bundle directory.
5675 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5677 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
5678 + strlen (dsym_subdir
) + 1
5679 + strlen (base_basename
) + 1);
5680 sprintf (dsym_filename
, "%s%s/%s",
5681 base_bfd
->filename
, dsym_subdir
, base_basename
);
5683 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
5684 bfd_get_arch_info (abfd
));
5685 if (dsym_bfd
== NULL
)
5686 free (dsym_filename
);
5692 bfd_mach_o_find_nearest_line (bfd
*abfd
,
5696 const char **filename_ptr
,
5697 const char **functionname_ptr
,
5698 unsigned int *line_ptr
,
5699 unsigned int *discriminator_ptr
)
5701 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5704 switch (mdata
->header
.filetype
)
5706 case BFD_MACH_O_MH_OBJECT
:
5708 case BFD_MACH_O_MH_EXECUTE
:
5709 case BFD_MACH_O_MH_DYLIB
:
5710 case BFD_MACH_O_MH_BUNDLE
:
5711 case BFD_MACH_O_MH_KEXT_BUNDLE
:
5712 if (mdata
->dwarf2_find_line_info
== NULL
)
5714 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
5715 /* When we couldn't find dSYM for this binary, we look for
5716 the debug information in the binary itself. In this way,
5717 we won't try finding separated dSYM again because
5718 mdata->dwarf2_find_line_info will be filled. */
5719 if (! mdata
->dsym_bfd
)
5721 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
5722 dwarf_debug_sections
, symbols
,
5723 &mdata
->dwarf2_find_line_info
,
5731 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
5732 filename_ptr
, functionname_ptr
,
5733 line_ptr
, discriminator_ptr
,
5734 dwarf_debug_sections
, 0,
5735 &mdata
->dwarf2_find_line_info
);
5739 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
5741 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5742 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
5744 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
5745 bfd_mach_o_free_cached_info (abfd
);
5746 if (mdata
->dsym_bfd
!= NULL
)
5748 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
5749 char *dsym_filename
= (char *)(fat_bfd
5751 : mdata
->dsym_bfd
->filename
);
5752 bfd_close (mdata
->dsym_bfd
);
5753 mdata
->dsym_bfd
= NULL
;
5755 bfd_close (fat_bfd
);
5756 free (dsym_filename
);
5760 if (bfd_get_format (abfd
) == bfd_archive
5761 && abfd
->xvec
== &mach_o_fat_vec
)
5763 return _bfd_generic_close_and_cleanup (abfd
);
5766 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
5768 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5770 free (mdata
->dyn_reloc_cache
);
5771 mdata
->dyn_reloc_cache
= NULL
;
5772 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
5774 free (asect
->relocation
);
5775 asect
->relocation
= NULL
;
5781 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5782 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5784 #define bfd_mach_o_swap_reloc_in NULL
5785 #define bfd_mach_o_swap_reloc_out NULL
5786 #define bfd_mach_o_print_thread NULL
5787 #define bfd_mach_o_tgt_seg_table NULL
5788 #define bfd_mach_o_section_type_valid_for_tgt NULL
5790 #define TARGET_NAME mach_o_be_vec
5791 #define TARGET_STRING "mach-o-be"
5792 #define TARGET_ARCHITECTURE bfd_arch_unknown
5793 #define TARGET_PAGESIZE 1
5794 #define TARGET_BIG_ENDIAN 1
5795 #define TARGET_ARCHIVE 0
5796 #define TARGET_PRIORITY 1
5797 #include "mach-o-target.c"
5800 #undef TARGET_STRING
5801 #undef TARGET_ARCHITECTURE
5802 #undef TARGET_PAGESIZE
5803 #undef TARGET_BIG_ENDIAN
5804 #undef TARGET_ARCHIVE
5805 #undef TARGET_PRIORITY
5807 #define TARGET_NAME mach_o_le_vec
5808 #define TARGET_STRING "mach-o-le"
5809 #define TARGET_ARCHITECTURE bfd_arch_unknown
5810 #define TARGET_PAGESIZE 1
5811 #define TARGET_BIG_ENDIAN 0
5812 #define TARGET_ARCHIVE 0
5813 #define TARGET_PRIORITY 1
5815 #include "mach-o-target.c"
5818 #undef TARGET_STRING
5819 #undef TARGET_ARCHITECTURE
5820 #undef TARGET_PAGESIZE
5821 #undef TARGET_BIG_ENDIAN
5822 #undef TARGET_ARCHIVE
5823 #undef TARGET_PRIORITY
5825 /* Not yet handled: creating an archive. */
5826 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5829 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5830 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5831 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5832 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5833 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5834 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5835 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5836 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5837 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5838 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5840 #define TARGET_NAME mach_o_fat_vec
5841 #define TARGET_STRING "mach-o-fat"
5842 #define TARGET_ARCHITECTURE bfd_arch_unknown
5843 #define TARGET_PAGESIZE 1
5844 #define TARGET_BIG_ENDIAN 1
5845 #define TARGET_ARCHIVE 1
5846 #define TARGET_PRIORITY 0
5848 #include "mach-o-target.c"
5851 #undef TARGET_STRING
5852 #undef TARGET_ARCHITECTURE
5853 #undef TARGET_PAGESIZE
5854 #undef TARGET_BIG_ENDIAN
5855 #undef TARGET_ARCHIVE
5856 #undef TARGET_PRIORITY