1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2019 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"
27 #include "aout/stab_gnu.h"
28 #include "mach-o/reloc.h"
29 #include "mach-o/external.h"
34 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
35 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
36 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
38 #define FILE_ALIGN(off, algn) \
39 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1U << (algn)))
42 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
);
45 bfd_mach_o_version (bfd
*abfd
)
47 bfd_mach_o_data_struct
*mdata
= NULL
;
49 BFD_ASSERT (bfd_mach_o_valid (abfd
));
50 mdata
= bfd_mach_o_get_data (abfd
);
52 return mdata
->header
.version
;
56 bfd_mach_o_valid (bfd
*abfd
)
58 if (abfd
== NULL
|| abfd
->xvec
== NULL
)
61 if (abfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
64 if (bfd_mach_o_get_data (abfd
) == NULL
)
69 static INLINE bfd_boolean
70 mach_o_wide_p (bfd_mach_o_header
*header
)
72 switch (header
->version
)
84 static INLINE bfd_boolean
85 bfd_mach_o_wide_p (bfd
*abfd
)
87 return mach_o_wide_p (&bfd_mach_o_get_data (abfd
)->header
);
90 /* Tables to translate well known Mach-O segment/section names to bfd
91 names. Use of canonical names (such as .text or .debug_frame) is required
95 static const mach_o_section_name_xlat text_section_names_xlat
[] =
98 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
99 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
, 0},
100 { ".const", "__const",
101 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
102 BFD_MACH_O_S_ATTR_NONE
, 0},
103 { ".static_const", "__static_const",
104 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
105 BFD_MACH_O_S_ATTR_NONE
, 0},
106 { ".cstring", "__cstring",
107 SEC_READONLY
| SEC_DATA
| SEC_LOAD
| SEC_MERGE
| SEC_STRINGS
,
108 BFD_MACH_O_S_CSTRING_LITERALS
,
109 BFD_MACH_O_S_ATTR_NONE
, 0},
110 { ".literal4", "__literal4",
111 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_4BYTE_LITERALS
,
112 BFD_MACH_O_S_ATTR_NONE
, 2},
113 { ".literal8", "__literal8",
114 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_8BYTE_LITERALS
,
115 BFD_MACH_O_S_ATTR_NONE
, 3},
116 { ".literal16", "__literal16",
117 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_16BYTE_LITERALS
,
118 BFD_MACH_O_S_ATTR_NONE
, 4},
119 { ".constructor", "__constructor",
120 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
121 BFD_MACH_O_S_ATTR_NONE
, 0},
122 { ".destructor", "__destructor",
123 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
124 BFD_MACH_O_S_ATTR_NONE
, 0},
125 { ".eh_frame", "__eh_frame",
126 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_COALESCED
,
127 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
128 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
129 | BFD_MACH_O_S_ATTR_NO_TOC
, 2},
130 { NULL
, NULL
, 0, 0, 0, 0}
133 /* __DATA Segment. */
134 static const mach_o_section_name_xlat data_section_names_xlat
[] =
137 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
138 BFD_MACH_O_S_ATTR_NONE
, 0},
140 SEC_NO_FLAGS
, BFD_MACH_O_S_ZEROFILL
,
141 BFD_MACH_O_S_ATTR_NONE
, 0},
142 { ".const_data", "__const",
143 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
144 BFD_MACH_O_S_ATTR_NONE
, 0},
145 { ".static_data", "__static_data",
146 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
147 BFD_MACH_O_S_ATTR_NONE
, 0},
148 { ".mod_init_func", "__mod_init_func",
149 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
,
150 BFD_MACH_O_S_ATTR_NONE
, 2},
151 { ".mod_term_func", "__mod_term_func",
152 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
,
153 BFD_MACH_O_S_ATTR_NONE
, 2},
155 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
156 BFD_MACH_O_S_ATTR_NONE
, 0},
157 { ".cfstring", "__cfstring",
158 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
159 BFD_MACH_O_S_ATTR_NONE
, 2},
160 { NULL
, NULL
, 0, 0, 0, 0}
163 /* __DWARF Segment. */
164 static const mach_o_section_name_xlat dwarf_section_names_xlat
[] =
166 { ".debug_frame", "__debug_frame",
167 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
168 BFD_MACH_O_S_ATTR_DEBUG
, 0},
169 { ".debug_info", "__debug_info",
170 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
171 BFD_MACH_O_S_ATTR_DEBUG
, 0},
172 { ".debug_abbrev", "__debug_abbrev",
173 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
174 BFD_MACH_O_S_ATTR_DEBUG
, 0},
175 { ".debug_aranges", "__debug_aranges",
176 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
177 BFD_MACH_O_S_ATTR_DEBUG
, 0},
178 { ".debug_macinfo", "__debug_macinfo",
179 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
180 BFD_MACH_O_S_ATTR_DEBUG
, 0},
181 { ".debug_line", "__debug_line",
182 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
183 BFD_MACH_O_S_ATTR_DEBUG
, 0},
184 { ".debug_loc", "__debug_loc",
185 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
186 BFD_MACH_O_S_ATTR_DEBUG
, 0},
187 { ".debug_pubnames", "__debug_pubnames",
188 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
189 BFD_MACH_O_S_ATTR_DEBUG
, 0},
190 { ".debug_pubtypes", "__debug_pubtypes",
191 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
192 BFD_MACH_O_S_ATTR_DEBUG
, 0},
193 { ".debug_str", "__debug_str",
194 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
195 BFD_MACH_O_S_ATTR_DEBUG
, 0},
196 { ".debug_ranges", "__debug_ranges",
197 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
198 BFD_MACH_O_S_ATTR_DEBUG
, 0},
199 { ".debug_macro", "__debug_macro",
200 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
201 BFD_MACH_O_S_ATTR_DEBUG
, 0},
202 { ".debug_gdb_scripts", "__debug_gdb_scri",
203 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
204 BFD_MACH_O_S_ATTR_DEBUG
, 0},
205 { NULL
, NULL
, 0, 0, 0, 0}
208 /* __OBJC Segment. */
209 static const mach_o_section_name_xlat objc_section_names_xlat
[] =
211 { ".objc_class", "__class",
212 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
213 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
214 { ".objc_meta_class", "__meta_class",
215 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
216 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
217 { ".objc_cat_cls_meth", "__cat_cls_meth",
218 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
219 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
220 { ".objc_cat_inst_meth", "__cat_inst_meth",
221 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
222 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
223 { ".objc_protocol", "__protocol",
224 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
225 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
226 { ".objc_string_object", "__string_object",
227 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
228 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
229 { ".objc_cls_meth", "__cls_meth",
230 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
231 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
232 { ".objc_inst_meth", "__inst_meth",
233 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
234 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
235 { ".objc_cls_refs", "__cls_refs",
236 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
237 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
238 { ".objc_message_refs", "__message_refs",
239 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
240 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
241 { ".objc_symbols", "__symbols",
242 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
243 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
244 { ".objc_category", "__category",
245 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
246 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
247 { ".objc_class_vars", "__class_vars",
248 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
249 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
250 { ".objc_instance_vars", "__instance_vars",
251 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
252 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
253 { ".objc_module_info", "__module_info",
254 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
255 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
256 { ".objc_selector_strs", "__selector_strs",
257 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_CSTRING_LITERALS
,
258 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
259 { ".objc_image_info", "__image_info",
260 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
261 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
262 { ".objc_selector_fixup", "__sel_fixup",
263 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
264 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
266 { ".objc1_class_ext", "__class_ext",
267 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
268 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
269 { ".objc1_property_list", "__property",
270 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
271 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
272 { ".objc1_protocol_ext", "__protocol_ext",
273 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
274 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
275 { NULL
, NULL
, 0, 0, 0, 0}
278 static const mach_o_segment_name_xlat segsec_names_xlat
[] =
280 { "__TEXT", text_section_names_xlat
},
281 { "__DATA", data_section_names_xlat
},
282 { "__DWARF", dwarf_section_names_xlat
},
283 { "__OBJC", objc_section_names_xlat
},
287 static const char dsym_subdir
[] = ".dSYM/Contents/Resources/DWARF";
289 /* For both cases bfd-name => mach-o name and vice versa, the specific target
290 is checked before the generic. This allows a target (e.g. ppc for cstring)
291 to override the generic definition with a more specific one. */
293 /* Fetch the translation from a Mach-O section designation (segment, section)
294 as a bfd short name, if one exists. Otherwise return NULL.
296 Allow the segment and section names to be unterminated 16 byte arrays. */
298 const mach_o_section_name_xlat
*
299 bfd_mach_o_section_data_for_mach_sect (bfd
*abfd
, const char *segname
,
300 const char *sectname
)
302 const struct mach_o_segment_name_xlat
*seg
;
303 const mach_o_section_name_xlat
*sec
;
304 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
306 /* First try any target-specific translations defined... */
307 if (bed
->segsec_names_xlat
)
308 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
309 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
310 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
311 if (strncmp (sec
->mach_o_name
, sectname
,
312 BFD_MACH_O_SECTNAME_SIZE
) == 0)
315 /* ... and then the Mach-O generic ones. */
316 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
317 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
318 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
319 if (strncmp (sec
->mach_o_name
, sectname
,
320 BFD_MACH_O_SECTNAME_SIZE
) == 0)
326 /* If the bfd_name for this section is a 'canonical' form for which we
327 know the Mach-O data, return the segment name and the data for the
328 Mach-O equivalent. Otherwise return NULL. */
330 const mach_o_section_name_xlat
*
331 bfd_mach_o_section_data_for_bfd_name (bfd
*abfd
, const char *bfd_name
,
332 const char **segname
)
334 const struct mach_o_segment_name_xlat
*seg
;
335 const mach_o_section_name_xlat
*sec
;
336 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
339 if (bfd_name
[0] != '.')
342 /* First try any target-specific translations defined... */
343 if (bed
->segsec_names_xlat
)
344 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
345 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
346 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
348 *segname
= seg
->segname
;
352 /* ... and then the Mach-O generic ones. */
353 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
354 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
355 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
357 *segname
= seg
->segname
;
364 /* Convert Mach-O section name to BFD.
366 Try to use standard/canonical names, for which we have tables including
367 default flag settings - which are returned. Otherwise forge a new name
368 in the form "<segmentname>.<sectionname>" this will be prefixed with
369 LC_SEGMENT. if the segment name does not begin with an underscore.
371 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
372 terminated if the name length is exactly 16 bytes - but must be if the name
373 length is less than 16 characters). */
376 bfd_mach_o_convert_section_name_to_bfd (bfd
*abfd
, const char *segname
,
377 const char *secname
, const char **name
,
380 const mach_o_section_name_xlat
*xlat
;
383 const char *pfx
= "";
386 *flags
= SEC_NO_FLAGS
;
388 /* First search for a canonical name...
389 xlat will be non-null if there is an entry for segname, secname. */
390 xlat
= bfd_mach_o_section_data_for_mach_sect (abfd
, segname
, secname
);
393 len
= strlen (xlat
->bfd_name
);
394 res
= bfd_alloc (abfd
, len
+ 1);
397 memcpy (res
, xlat
->bfd_name
, len
+1);
399 *flags
= xlat
->bfd_flags
;
403 /* ... else we make up a bfd name from the segment concatenated with the
406 len
= 16 + 1 + 16 + 1;
408 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
409 with an underscore. */
410 if (segname
[0] != '_')
412 static const char seg_pfx
[] = "LC_SEGMENT.";
415 len
+= sizeof (seg_pfx
) - 1;
418 res
= bfd_alloc (abfd
, len
);
421 snprintf (res
, len
, "%s%.16s.%.16s", pfx
, segname
, secname
);
425 /* Convert a bfd section name to a Mach-O segment + section name.
427 If the name is a canonical one for which we have a Darwin match
428 return the translation table - which contains defaults for flags,
429 type, attribute and default alignment data.
431 Otherwise, expand the bfd_name (assumed to be in the form
432 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
434 static const mach_o_section_name_xlat
*
435 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
437 bfd_mach_o_section
*section
)
439 const mach_o_section_name_xlat
*xlat
;
440 const char *name
= bfd_get_section_name (abfd
, sect
);
447 memset (section
->segname
, 0, BFD_MACH_O_SEGNAME_SIZE
+ 1);
448 memset (section
->sectname
, 0, BFD_MACH_O_SECTNAME_SIZE
+ 1);
450 /* See if is a canonical name ... */
451 xlat
= bfd_mach_o_section_data_for_bfd_name (abfd
, name
, &segname
);
454 strcpy (section
->segname
, segname
);
455 strcpy (section
->sectname
, xlat
->mach_o_name
);
459 /* .. else we convert our constructed one back to Mach-O.
460 Strip LC_SEGMENT. prefix, if present. */
461 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
465 dot
= strchr (name
, '.');
468 /* Try to split name into segment and section names. */
469 if (dot
&& dot
!= name
)
472 seclen
= len
- (dot
+ 1 - name
);
474 if (seglen
<= BFD_MACH_O_SEGNAME_SIZE
475 && seclen
<= BFD_MACH_O_SECTNAME_SIZE
)
477 memcpy (section
->segname
, name
, seglen
);
478 section
->segname
[seglen
] = 0;
479 memcpy (section
->sectname
, dot
+ 1, seclen
);
480 section
->sectname
[seclen
] = 0;
485 /* The segment and section names are both missing - don't make them
487 if (dot
&& dot
== name
)
490 /* Just duplicate the name into both segment and section. */
493 memcpy (section
->segname
, name
, len
);
494 section
->segname
[len
] = 0;
495 memcpy (section
->sectname
, name
, len
);
496 section
->sectname
[len
] = 0;
500 /* Return the size of an entry for section SEC.
501 Must be called only for symbol pointer section and symbol stubs
505 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
507 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
509 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
510 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
511 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
512 case BFD_MACH_O_S_SYMBOL_STUBS
:
513 return sec
->reserved2
;
520 /* Return the number of indirect symbols for a section.
521 Must be called only for symbol pointer section and symbol stubs
525 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
529 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
533 return sec
->size
/ elsz
;
536 /* Append command CMD to ABFD. Note that header.ncmds is not updated. */
539 bfd_mach_o_append_command (bfd
*abfd
, bfd_mach_o_load_command
*cmd
)
541 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
543 if (mdata
->last_command
!= NULL
)
544 mdata
->last_command
->next
= cmd
;
546 mdata
->first_command
= cmd
;
547 mdata
->last_command
= cmd
;
551 /* Copy any private info we understand from the input symbol
552 to the output symbol. */
555 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
557 bfd
*obfd ATTRIBUTE_UNUSED
,
560 bfd_mach_o_asymbol
*os
, *is
;
562 os
= (bfd_mach_o_asymbol
*)osymbol
;
563 is
= (bfd_mach_o_asymbol
*)isymbol
;
564 os
->n_type
= is
->n_type
;
565 os
->n_sect
= is
->n_sect
;
566 os
->n_desc
= is
->n_desc
;
567 os
->symbol
.udata
.i
= is
->symbol
.udata
.i
;
572 /* Copy any private info we understand from the input section
573 to the output section. */
576 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd
, asection
*isection
,
577 bfd
*obfd
, asection
*osection
)
579 bfd_mach_o_section
*os
= bfd_mach_o_get_mach_o_section (osection
);
580 bfd_mach_o_section
*is
= bfd_mach_o_get_mach_o_section (isection
);
582 if (ibfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
583 || obfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
586 BFD_ASSERT (is
!= NULL
&& os
!= NULL
);
588 os
->flags
= is
->flags
;
589 os
->reserved1
= is
->reserved1
;
590 os
->reserved2
= is
->reserved2
;
591 os
->reserved3
= is
->reserved3
;
597 cputype (unsigned long value
)
601 case BFD_MACH_O_CPU_TYPE_VAX
: return "VAX";
602 case BFD_MACH_O_CPU_TYPE_MC680x0
: return "MC68k";
603 case BFD_MACH_O_CPU_TYPE_I386
: return "I386";
604 case BFD_MACH_O_CPU_TYPE_MIPS
: return "MIPS";
605 case BFD_MACH_O_CPU_TYPE_MC98000
: return "MC98k";
606 case BFD_MACH_O_CPU_TYPE_HPPA
: return "HPPA";
607 case BFD_MACH_O_CPU_TYPE_ARM
: return "ARM";
608 case BFD_MACH_O_CPU_TYPE_MC88000
: return "MC88K";
609 case BFD_MACH_O_CPU_TYPE_SPARC
: return "SPARC";
610 case BFD_MACH_O_CPU_TYPE_I860
: return "I860";
611 case BFD_MACH_O_CPU_TYPE_ALPHA
: return "ALPHA";
612 case BFD_MACH_O_CPU_TYPE_POWERPC
: return "PPC";
613 case BFD_MACH_O_CPU_TYPE_POWERPC_64
: return "PPC64";
614 case BFD_MACH_O_CPU_TYPE_X86_64
: return "X86_64";
615 case BFD_MACH_O_CPU_TYPE_ARM64
: return "ARM64";
616 default: return _("<unknown>");
621 cpusubtype (unsigned long cputype
, unsigned long cpusubtype
)
623 static char buffer
[128];
626 switch (cpusubtype
& BFD_MACH_O_CPU_SUBTYPE_MASK
)
630 case BFD_MACH_O_CPU_SUBTYPE_LIB64
:
631 sprintf (buffer
, " (LIB64)"); break;
633 sprintf (buffer
, _("<unknown mask flags>")); break;
636 cpusubtype
&= ~ BFD_MACH_O_CPU_SUBTYPE_MASK
;
640 case BFD_MACH_O_CPU_TYPE_X86_64
:
641 case BFD_MACH_O_CPU_TYPE_I386
:
644 case BFD_MACH_O_CPU_SUBTYPE_X86_ALL
:
645 return strcat (buffer
, " (X86_ALL)");
651 case BFD_MACH_O_CPU_TYPE_ARM
:
654 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
655 return strcat (buffer
, " (ARM_ALL)");
656 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
657 return strcat (buffer
, " (ARM_V4T)");
658 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
659 return strcat (buffer
, " (ARM_V6)");
660 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
661 return strcat (buffer
, " (ARM_V5TEJ)");
662 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
663 return strcat (buffer
, " (ARM_XSCALE)");
664 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
665 return strcat (buffer
, " (ARM_V7)");
671 case BFD_MACH_O_CPU_TYPE_ARM64
:
674 case BFD_MACH_O_CPU_SUBTYPE_ARM64_ALL
:
675 return strcat (buffer
, " (ARM64_ALL)");
676 case BFD_MACH_O_CPU_SUBTYPE_ARM64_V8
:
677 return strcat (buffer
, " (ARM64_V8)");
688 return strcat (buffer
, _(" (<unknown>)"));
694 bfd_mach_o_bfd_print_private_bfd_data (bfd
*abfd
, void *ptr
)
696 FILE * file
= (FILE *) ptr
;
697 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
699 fprintf (file
, _(" MACH-O header:\n"));
700 fprintf (file
, _(" magic: %#lx\n"), (long) mdata
->header
.magic
);
701 fprintf (file
, _(" cputype: %#lx (%s)\n"), (long) mdata
->header
.cputype
,
702 cputype (mdata
->header
.cputype
));
703 fprintf (file
, _(" cpusubtype: %#lx%s\n"), (long) mdata
->header
.cpusubtype
,
704 cpusubtype (mdata
->header
.cputype
, mdata
->header
.cpusubtype
));
705 fprintf (file
, _(" filetype: %#lx\n"), (long) mdata
->header
.filetype
);
706 fprintf (file
, _(" ncmds: %#lx\n"), (long) mdata
->header
.ncmds
);
707 fprintf (file
, _(" sizeocmds: %#lx\n"), (long) mdata
->header
.sizeofcmds
);
708 fprintf (file
, _(" flags: %#lx\n"), (long) mdata
->header
.flags
);
709 fprintf (file
, _(" version: %x\n"), mdata
->header
.version
);
714 /* Copy any private info we understand from the input bfd
715 to the output bfd. */
718 bfd_mach_o_bfd_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
720 bfd_mach_o_data_struct
*imdata
;
721 bfd_mach_o_data_struct
*omdata
;
722 bfd_mach_o_load_command
*icmd
;
724 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
725 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
728 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
729 BFD_ASSERT (bfd_mach_o_valid (obfd
));
731 imdata
= bfd_mach_o_get_data (ibfd
);
732 omdata
= bfd_mach_o_get_data (obfd
);
734 /* Copy header flags. */
735 omdata
->header
.flags
= imdata
->header
.flags
;
737 /* PR 23299. Copy the cputype. */
738 if (imdata
->header
.cputype
!= omdata
->header
.cputype
)
740 if (omdata
->header
.cputype
== 0)
741 omdata
->header
.cputype
= imdata
->header
.cputype
;
742 else if (imdata
->header
.cputype
!= 0)
743 /* Urg - what has happened ? */
744 _bfd_error_handler (_("incompatible cputypes in mach-o files: %ld vs %ld"),
745 (long) imdata
->header
.cputype
,
746 (long) omdata
->header
.cputype
);
749 /* Copy the cpusubtype. */
750 omdata
->header
.cpusubtype
= imdata
->header
.cpusubtype
;
753 for (icmd
= imdata
->first_command
; icmd
!= NULL
; icmd
= icmd
->next
)
755 bfd_mach_o_load_command
*ocmd
;
759 case BFD_MACH_O_LC_LOAD_DYLIB
:
760 case BFD_MACH_O_LC_LOAD_DYLINKER
:
761 case BFD_MACH_O_LC_DYLD_INFO
:
762 /* Command is copied. */
763 ocmd
= bfd_alloc (obfd
, sizeof (bfd_mach_o_load_command
));
767 /* Copy common fields. */
768 ocmd
->type
= icmd
->type
;
769 ocmd
->type_required
= icmd
->type_required
;
771 ocmd
->len
= icmd
->len
;
775 /* Command is not copied. */
782 case BFD_MACH_O_LC_LOAD_DYLIB
:
784 bfd_mach_o_dylib_command
*idy
= &icmd
->command
.dylib
;
785 bfd_mach_o_dylib_command
*ody
= &ocmd
->command
.dylib
;
787 ody
->name_offset
= idy
->name_offset
;
788 ody
->timestamp
= idy
->timestamp
;
789 ody
->current_version
= idy
->current_version
;
790 ody
->compatibility_version
= idy
->compatibility_version
;
791 ody
->name_str
= idy
->name_str
;
795 case BFD_MACH_O_LC_LOAD_DYLINKER
:
797 bfd_mach_o_dylinker_command
*idy
= &icmd
->command
.dylinker
;
798 bfd_mach_o_dylinker_command
*ody
= &ocmd
->command
.dylinker
;
800 ody
->name_offset
= idy
->name_offset
;
801 ody
->name_str
= idy
->name_str
;
805 case BFD_MACH_O_LC_DYLD_INFO
:
807 bfd_mach_o_dyld_info_command
*idy
= &icmd
->command
.dyld_info
;
808 bfd_mach_o_dyld_info_command
*ody
= &ocmd
->command
.dyld_info
;
810 if (bfd_mach_o_read_dyld_content (ibfd
, idy
))
812 ody
->rebase_size
= idy
->rebase_size
;
813 ody
->rebase_content
= idy
->rebase_content
;
815 ody
->bind_size
= idy
->bind_size
;
816 ody
->bind_content
= idy
->bind_content
;
818 ody
->weak_bind_size
= idy
->weak_bind_size
;
819 ody
->weak_bind_content
= idy
->weak_bind_content
;
821 ody
->lazy_bind_size
= idy
->lazy_bind_size
;
822 ody
->lazy_bind_content
= idy
->lazy_bind_content
;
824 ody
->export_size
= idy
->export_size
;
825 ody
->export_content
= idy
->export_content
;
827 /* PR 17512L: file: 730e492d. */
832 ody
->weak_bind_size
=
833 ody
->lazy_bind_size
=
834 ody
->export_size
= 0;
835 ody
->rebase_content
=
837 ody
->weak_bind_content
=
838 ody
->lazy_bind_content
=
839 ody
->export_content
= NULL
;
845 /* That command should be handled. */
849 /* Insert command. */
850 bfd_mach_o_append_command (obfd
, ocmd
);
856 /* This allows us to set up to 32 bits of flags (unless we invent some
857 fiendish scheme to subdivide). For now, we'll just set the file flags
858 without error checking - just overwrite. */
861 bfd_mach_o_bfd_set_private_flags (bfd
*abfd
, flagword flags
)
863 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
868 mdata
->header
.flags
= flags
;
872 /* Count the total number of symbols. */
875 bfd_mach_o_count_symbols (bfd
*abfd
)
877 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
879 if (mdata
->symtab
== NULL
)
881 return mdata
->symtab
->nsyms
;
885 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
887 long nsyms
= bfd_mach_o_count_symbols (abfd
);
889 return ((nsyms
+ 1) * sizeof (asymbol
*));
893 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
895 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
896 long nsyms
= bfd_mach_o_count_symbols (abfd
);
897 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
905 /* Do not try to read symbols if there are none. */
910 if (!bfd_mach_o_read_symtab_symbols (abfd
))
913 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
917 BFD_ASSERT (sym
->symbols
!= NULL
);
919 for (j
= 0; j
< sym
->nsyms
; j
++)
920 alocation
[j
] = &sym
->symbols
[j
].symbol
;
927 /* Create synthetic symbols for indirect symbols. */
930 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
931 long symcount ATTRIBUTE_UNUSED
,
932 asymbol
**syms ATTRIBUTE_UNUSED
,
933 long dynsymcount ATTRIBUTE_UNUSED
,
934 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
937 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
938 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
939 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
943 unsigned long count
, i
, j
, n
;
947 const char stub
[] = "$stub";
951 /* Stop now if no symbols or no indirect symbols. */
952 if (dysymtab
== NULL
|| dysymtab
->nindirectsyms
== 0
953 || symtab
== NULL
|| symtab
->symbols
== NULL
)
956 /* We need to allocate a bfd symbol for every indirect symbol and to
957 allocate the memory for its name. */
958 count
= dysymtab
->nindirectsyms
;
959 size
= count
* sizeof (asymbol
) + 1;
961 for (j
= 0; j
< count
; j
++)
964 unsigned int isym
= dysymtab
->indirect_syms
[j
];
966 /* Some indirect symbols are anonymous. */
967 if (isym
< symtab
->nsyms
&& (strng
= symtab
->symbols
[isym
].symbol
.name
))
968 /* PR 17512: file: f5b8eeba. */
969 size
+= strnlen (strng
, symtab
->strsize
- (strng
- symtab
->strtab
)) + sizeof (stub
);
972 s_start
= bfd_malloc (size
);
973 s
= *ret
= (asymbol
*) s_start
;
976 names
= (char *) (s
+ count
);
979 s_end
= s_start
+ size
;
982 for (i
= 0; i
< mdata
->nsects
; i
++)
984 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
985 unsigned int first
, last
;
989 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
991 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
992 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
993 case BFD_MACH_O_S_SYMBOL_STUBS
:
994 /* Only these sections have indirect symbols. */
995 first
= sec
->reserved1
;
996 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
998 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
1000 /* PR 17512: file: 08e15eec. */
1001 if (first
>= count
|| last
>= count
|| first
> last
)
1004 for (j
= first
; j
< last
; j
++)
1006 unsigned int isym
= dysymtab
->indirect_syms
[j
];
1008 /* PR 17512: file: 04d64d9b. */
1009 if (((char *) s
) + sizeof (* s
) > s_end
)
1012 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
1013 s
->section
= sec
->bfdsection
;
1014 s
->value
= addr
- sec
->addr
;
1017 if (isym
< symtab
->nsyms
1018 && symtab
->symbols
[isym
].symbol
.name
)
1020 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
1025 /* PR 17512: file: 47dfd4d2. */
1026 if (names
+ len
>= s_end
)
1028 memcpy (names
, sym
, len
);
1030 /* PR 17512: file: 18f340a4. */
1031 if (names
+ sizeof (stub
) >= s_end
)
1033 memcpy (names
, stub
, sizeof (stub
));
1034 names
+= sizeof (stub
);
1058 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1062 bfd_symbol_info (symbol
, ret
);
1066 bfd_mach_o_print_symbol (bfd
*abfd
,
1069 bfd_print_symbol_type how
)
1071 FILE *file
= (FILE *) afile
;
1073 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
1077 case bfd_print_symbol_name
:
1078 fprintf (file
, "%s", symbol
->name
);
1081 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
1082 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
1083 name
= bfd_get_stab_name (asym
->n_type
);
1085 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
1087 case BFD_MACH_O_N_UNDF
:
1088 if (symbol
->value
== 0)
1093 case BFD_MACH_O_N_ABS
:
1096 case BFD_MACH_O_N_INDR
:
1099 case BFD_MACH_O_N_PBUD
:
1102 case BFD_MACH_O_N_SECT
:
1111 fprintf (file
, " %02x %-6s %02x %04x",
1112 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
1113 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
1114 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
1115 fprintf (file
, " [%s]", symbol
->section
->name
);
1116 fprintf (file
, " %s", symbol
->name
);
1121 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
1122 bfd_mach_o_cpu_subtype msubtype
,
1123 enum bfd_architecture
*type
,
1124 unsigned long *subtype
)
1126 *subtype
= bfd_arch_unknown
;
1130 case BFD_MACH_O_CPU_TYPE_VAX
:
1131 *type
= bfd_arch_vax
;
1133 case BFD_MACH_O_CPU_TYPE_MC680x0
:
1134 *type
= bfd_arch_m68k
;
1136 case BFD_MACH_O_CPU_TYPE_I386
:
1137 *type
= bfd_arch_i386
;
1138 *subtype
= bfd_mach_i386_i386
;
1140 case BFD_MACH_O_CPU_TYPE_X86_64
:
1141 *type
= bfd_arch_i386
;
1142 *subtype
= bfd_mach_x86_64
;
1144 case BFD_MACH_O_CPU_TYPE_MIPS
:
1145 *type
= bfd_arch_mips
;
1147 case BFD_MACH_O_CPU_TYPE_MC98000
:
1148 *type
= bfd_arch_m98k
;
1150 case BFD_MACH_O_CPU_TYPE_HPPA
:
1151 *type
= bfd_arch_hppa
;
1153 case BFD_MACH_O_CPU_TYPE_ARM
:
1154 *type
= bfd_arch_arm
;
1157 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
1158 *subtype
= bfd_mach_arm_4T
;
1160 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
1161 *subtype
= bfd_mach_arm_4T
; /* Best fit ? */
1163 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
1164 *subtype
= bfd_mach_arm_5TE
;
1166 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
1167 *subtype
= bfd_mach_arm_XScale
;
1169 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
1170 *subtype
= bfd_mach_arm_5TE
; /* Best fit ? */
1172 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
1177 case BFD_MACH_O_CPU_TYPE_SPARC
:
1178 *type
= bfd_arch_sparc
;
1179 *subtype
= bfd_mach_sparc
;
1181 case BFD_MACH_O_CPU_TYPE_ALPHA
:
1182 *type
= bfd_arch_alpha
;
1184 case BFD_MACH_O_CPU_TYPE_POWERPC
:
1185 *type
= bfd_arch_powerpc
;
1186 *subtype
= bfd_mach_ppc
;
1188 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
1189 *type
= bfd_arch_powerpc
;
1190 *subtype
= bfd_mach_ppc64
;
1192 case BFD_MACH_O_CPU_TYPE_ARM64
:
1193 *type
= bfd_arch_aarch64
;
1194 *subtype
= bfd_mach_aarch64
;
1197 *type
= bfd_arch_unknown
;
1202 /* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4. Return the
1203 number of bytes written or -1 in case of error. */
1206 bfd_mach_o_pad4 (bfd
*abfd
, unsigned int len
)
1210 char pad
[4] = {0,0,0,0};
1211 unsigned int padlen
= 4 - (len
% 4);
1213 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1222 /* Likewise, but for a command. */
1225 bfd_mach_o_pad_command (bfd
*abfd
, unsigned int len
)
1227 unsigned int align
= bfd_mach_o_wide_p (abfd
) ? 8 : 4;
1229 if (len
% align
!= 0)
1232 unsigned int padlen
= align
- (len
% align
);
1234 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1244 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1246 struct mach_o_header_external raw
;
1249 size
= mach_o_wide_p (header
) ?
1250 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1252 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
1253 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
1254 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
1255 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
1256 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
1257 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
1258 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
1260 if (mach_o_wide_p (header
))
1261 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
1263 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1264 || bfd_bwrite (&raw
, size
, abfd
) != size
)
1271 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1273 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
1275 struct mach_o_thread_command_external raw
;
1276 unsigned int offset
;
1278 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
1279 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
1281 offset
= BFD_MACH_O_LC_SIZE
;
1282 for (i
= 0; i
< cmd
->nflavours
; i
++)
1284 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
1285 BFD_ASSERT (cmd
->flavours
[i
].offset
==
1286 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
1288 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
1289 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
1291 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
1292 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1295 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
1302 bfd_mach_o_write_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1304 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
1305 struct mach_o_str_command_external raw
;
1306 unsigned int namelen
;
1308 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.str
);
1310 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1311 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1314 namelen
= strlen (cmd
->name_str
) + 1;
1315 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1318 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1325 bfd_mach_o_write_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1327 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
1328 struct mach_o_dylib_command_external raw
;
1329 unsigned int namelen
;
1331 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.name
);
1332 bfd_h_put_32 (abfd
, cmd
->timestamp
, raw
.timestamp
);
1333 bfd_h_put_32 (abfd
, cmd
->current_version
, raw
.current_version
);
1334 bfd_h_put_32 (abfd
, cmd
->compatibility_version
, raw
.compatibility_version
);
1336 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1337 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1340 namelen
= strlen (cmd
->name_str
) + 1;
1341 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1344 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1351 bfd_mach_o_write_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1353 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
1354 struct mach_o_entry_point_command_external raw
;
1356 bfd_h_put_64 (abfd
, cmd
->entryoff
, raw
.entryoff
);
1357 bfd_h_put_64 (abfd
, cmd
->stacksize
, raw
.stacksize
);
1359 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1360 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1367 bfd_mach_o_write_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1369 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
1370 struct mach_o_dyld_info_command_external raw
;
1372 bfd_h_put_32 (abfd
, cmd
->rebase_off
, raw
.rebase_off
);
1373 bfd_h_put_32 (abfd
, cmd
->rebase_size
, raw
.rebase_size
);
1374 bfd_h_put_32 (abfd
, cmd
->bind_off
, raw
.bind_off
);
1375 bfd_h_put_32 (abfd
, cmd
->bind_size
, raw
.bind_size
);
1376 bfd_h_put_32 (abfd
, cmd
->weak_bind_off
, raw
.weak_bind_off
);
1377 bfd_h_put_32 (abfd
, cmd
->weak_bind_size
, raw
.weak_bind_size
);
1378 bfd_h_put_32 (abfd
, cmd
->lazy_bind_off
, raw
.lazy_bind_off
);
1379 bfd_h_put_32 (abfd
, cmd
->lazy_bind_size
, raw
.lazy_bind_size
);
1380 bfd_h_put_32 (abfd
, cmd
->export_off
, raw
.export_off
);
1381 bfd_h_put_32 (abfd
, cmd
->export_size
, raw
.export_size
);
1383 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1384 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1387 if (cmd
->rebase_size
!= 0)
1388 if (bfd_seek (abfd
, cmd
->rebase_off
, SEEK_SET
) != 0
1389 || (bfd_bwrite (cmd
->rebase_content
, cmd
->rebase_size
, abfd
) !=
1393 if (cmd
->bind_size
!= 0)
1394 if (bfd_seek (abfd
, cmd
->bind_off
, SEEK_SET
) != 0
1395 || (bfd_bwrite (cmd
->bind_content
, cmd
->bind_size
, abfd
) !=
1399 if (cmd
->weak_bind_size
!= 0)
1400 if (bfd_seek (abfd
, cmd
->weak_bind_off
, SEEK_SET
) != 0
1401 || (bfd_bwrite (cmd
->weak_bind_content
, cmd
->weak_bind_size
, abfd
) !=
1402 cmd
->weak_bind_size
))
1405 if (cmd
->lazy_bind_size
!= 0)
1406 if (bfd_seek (abfd
, cmd
->lazy_bind_off
, SEEK_SET
) != 0
1407 || (bfd_bwrite (cmd
->lazy_bind_content
, cmd
->lazy_bind_size
, abfd
) !=
1408 cmd
->lazy_bind_size
))
1411 if (cmd
->export_size
!= 0)
1412 if (bfd_seek (abfd
, cmd
->export_off
, SEEK_SET
) != 0
1413 || (bfd_bwrite (cmd
->export_content
, cmd
->export_size
, abfd
) !=
1421 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
1424 #if SIZEOF_LONG == SIZEOF_INT
1425 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
1427 bfd_set_error (bfd_error_file_too_big
);
1431 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1434 /* In addition to the need to byte-swap the symbol number, the bit positions
1435 of the fields in the relocation information vary per target endian-ness. */
1438 bfd_mach_o_swap_in_non_scattered_reloc (bfd
*abfd
, bfd_mach_o_reloc_info
*rel
,
1439 unsigned char *fields
)
1441 unsigned char info
= fields
[3];
1443 if (bfd_big_endian (abfd
))
1445 rel
->r_value
= (fields
[0] << 16) | (fields
[1] << 8) | fields
[2];
1446 rel
->r_type
= (info
>> BFD_MACH_O_BE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1447 rel
->r_pcrel
= (info
& BFD_MACH_O_BE_PCREL
) ? 1 : 0;
1448 rel
->r_length
= (info
>> BFD_MACH_O_BE_LENGTH_SHIFT
)
1449 & BFD_MACH_O_LENGTH_MASK
;
1450 rel
->r_extern
= (info
& BFD_MACH_O_BE_EXTERN
) ? 1 : 0;
1454 rel
->r_value
= (fields
[2] << 16) | (fields
[1] << 8) | fields
[0];
1455 rel
->r_type
= (info
>> BFD_MACH_O_LE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1456 rel
->r_pcrel
= (info
& BFD_MACH_O_LE_PCREL
) ? 1 : 0;
1457 rel
->r_length
= (info
>> BFD_MACH_O_LE_LENGTH_SHIFT
)
1458 & BFD_MACH_O_LENGTH_MASK
;
1459 rel
->r_extern
= (info
& BFD_MACH_O_LE_EXTERN
) ? 1 : 0;
1463 /* Set syms_ptr_ptr and addend of RES. */
1466 bfd_mach_o_canonicalize_non_scattered_reloc (bfd
*abfd
,
1467 bfd_mach_o_reloc_info
*reloc
,
1468 arelent
*res
, asymbol
**syms
)
1470 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1474 /* Non-scattered relocation. */
1475 reloc
->r_scattered
= 0;
1478 num
= reloc
->r_value
;
1480 if (reloc
->r_extern
)
1482 /* PR 17512: file: 8396-1185-0.004. */
1483 if (num
>= (unsigned) bfd_mach_o_count_symbols (abfd
))
1484 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1485 else if (syms
== NULL
)
1486 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1488 /* An external symbol number. */
1491 else if (num
== 0x00ffffff || num
== 0)
1493 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1494 is generic code, we don't know wether this is really a PAIR.
1495 This value is almost certainly not a valid section number, hence
1496 this specific case to avoid an assertion failure.
1497 Target specific swap_reloc_in routine should adjust that. */
1498 sym
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1502 /* PR 17512: file: 006-2964-0.004. */
1503 if (num
> mdata
->nsects
)
1505 _bfd_error_handler (_("\
1506 malformed mach-o reloc: section index is greater than the number of sections"));
1510 /* A section number. */
1511 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1512 /* For a symbol defined in section S, the addend (stored in the
1513 binary) contains the address of the section. To comply with
1514 bfd convention, subtract the section address.
1515 Use the address from the header, so that the user can modify
1516 the vma of the section. */
1517 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1520 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1521 in the lower 16bits of the address value. So we have to find the
1522 'symbol' from the preceding reloc. We do this even though the
1523 section symbol is probably not needed here, because NULL symbol
1524 values cause an assert in generic BFD code. This must be done in
1525 the PPC swap_reloc_in routine. */
1526 res
->sym_ptr_ptr
= sym
;
1531 /* Do most of the work for canonicalize_relocs on RAW: create internal
1532 representation RELOC and set most fields of RES using symbol table SYMS.
1533 Each target still has to set the howto of RES and possibly adjust other
1535 Previously the Mach-O hook point was simply swap_in, but some targets
1536 (like arm64) don't follow the generic rules (symnum is a value for the
1537 non-scattered relocation ADDEND). */
1540 bfd_mach_o_pre_canonicalize_one_reloc (bfd
*abfd
,
1541 struct mach_o_reloc_info_external
*raw
,
1542 bfd_mach_o_reloc_info
*reloc
,
1543 arelent
*res
, asymbol
**syms
)
1545 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1548 addr
= bfd_get_32 (abfd
, raw
->r_address
);
1549 res
->sym_ptr_ptr
= NULL
;
1552 if (addr
& BFD_MACH_O_SR_SCATTERED
)
1555 bfd_vma symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
1557 /* Scattered relocation, can't be extern. */
1558 reloc
->r_scattered
= 1;
1559 reloc
->r_extern
= 0;
1561 /* Extract section and offset from r_value (symnum). */
1562 reloc
->r_value
= symnum
;
1563 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1564 end of the data for the section (e.g. in a calculation of section
1565 data length). At present, the symbol will end up associated with
1566 the following section or, if it falls within alignment padding, as
1567 null - which will assert later. */
1568 for (j
= 0; j
< mdata
->nsects
; j
++)
1570 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
1571 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
1573 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
1574 res
->addend
= symnum
- sect
->addr
;
1579 /* Extract the info and address fields from r_address. */
1580 reloc
->r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
1581 reloc
->r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
1582 reloc
->r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
1583 reloc
->r_address
= BFD_MACH_O_GET_SR_TYPE (addr
);
1584 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
1588 /* Non-scattered relocation. */
1589 reloc
->r_scattered
= 0;
1590 reloc
->r_address
= addr
;
1591 res
->address
= addr
;
1593 /* The value and info fields have to be extracted dependent on target
1595 bfd_mach_o_swap_in_non_scattered_reloc (abfd
, reloc
, raw
->r_symbolnum
);
1597 if (!bfd_mach_o_canonicalize_non_scattered_reloc (abfd
, reloc
,
1602 /* We have set up a reloc with all the information present, so the swapper
1603 can modify address, value and addend fields, if necessary, to convey
1604 information in the generic BFD reloc that is mach-o specific. */
1610 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1611 unsigned long count
,
1612 arelent
*res
, asymbol
**syms
)
1614 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1616 struct mach_o_reloc_info_external
*native_relocs
= NULL
;
1617 bfd_size_type native_size
;
1619 /* Allocate and read relocs. */
1620 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1622 /* PR 17512: file: 09477b57. */
1623 if (native_size
< count
)
1627 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1628 if (native_relocs
== NULL
)
1631 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1632 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1635 for (i
= 0; i
< count
; i
++)
1637 if (!(*bed
->_bfd_mach_o_canonicalize_one_reloc
)(abfd
, &native_relocs
[i
],
1638 &res
[i
], syms
, res
))
1641 free (native_relocs
);
1645 free (native_relocs
);
1646 if (bfd_get_error () == bfd_error_no_error
)
1647 bfd_set_error (bfd_error_invalid_operation
);
1652 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1653 arelent
**rels
, asymbol
**syms
)
1655 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1659 if (asect
->reloc_count
== 0)
1662 /* No need to go further if we don't know how to read relocs. */
1663 if (bed
->_bfd_mach_o_canonicalize_one_reloc
== NULL
)
1666 if (asect
->relocation
== NULL
)
1668 if (asect
->reloc_count
* sizeof (arelent
) < asect
->reloc_count
)
1670 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1674 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1675 asect
->reloc_count
, res
, syms
) < 0)
1680 asect
->relocation
= res
;
1683 res
= asect
->relocation
;
1684 for (i
= 0; i
< asect
->reloc_count
; i
++)
1692 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1694 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1696 if (mdata
->dysymtab
== NULL
)
1698 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1699 * sizeof (arelent
*);
1703 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1704 struct bfd_symbol
**syms
)
1706 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1707 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1708 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1712 if (dysymtab
== NULL
)
1714 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1717 /* No need to go further if we don't know how to read relocs. */
1718 if (bed
->_bfd_mach_o_canonicalize_one_reloc
== NULL
)
1721 if (mdata
->dyn_reloc_cache
== NULL
)
1723 if ((dysymtab
->nextrel
+ dysymtab
->nlocrel
) * sizeof (arelent
)
1724 < (dysymtab
->nextrel
+ dysymtab
->nlocrel
))
1727 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1728 * sizeof (arelent
));
1732 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1733 dysymtab
->nextrel
, res
, syms
) < 0)
1739 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1741 res
+ dysymtab
->nextrel
, syms
) < 0)
1747 mdata
->dyn_reloc_cache
= res
;
1750 res
= mdata
->dyn_reloc_cache
;
1751 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1757 /* In addition to the need to byte-swap the symbol number, the bit positions
1758 of the fields in the relocation information vary per target endian-ness. */
1761 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1762 bfd_mach_o_reloc_info
*rel
)
1764 unsigned char info
= 0;
1766 BFD_ASSERT (rel
->r_type
<= 15);
1767 BFD_ASSERT (rel
->r_length
<= 3);
1769 if (bfd_big_endian (abfd
))
1771 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1772 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1773 fields
[2] = rel
->r_value
& 0xff;
1774 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1775 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1776 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1777 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1781 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1782 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1783 fields
[0] = rel
->r_value
& 0xff;
1784 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1785 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1786 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1787 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1793 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1798 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1800 sec
= section
->bfdsection
;
1801 if (sec
->reloc_count
== 0)
1804 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1807 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1810 /* Convert and write. */
1811 entries
= section
->bfdsection
->orelocation
;
1812 for (i
= 0; i
< section
->nreloc
; i
++)
1814 arelent
*rel
= entries
[i
];
1815 struct mach_o_reloc_info_external raw
;
1816 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1818 /* Convert relocation to an intermediate representation. */
1819 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1822 /* Lower the relocation info. */
1823 if (pinfo
->r_scattered
)
1827 v
= BFD_MACH_O_SR_SCATTERED
1828 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1829 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1830 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1831 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1832 /* Note: scattered relocs have field in reverse order... */
1833 bfd_put_32 (abfd
, v
, raw
.r_address
);
1834 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1838 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1839 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1843 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1844 != BFD_MACH_O_RELENT_SIZE
)
1851 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1853 struct mach_o_section_32_external raw
;
1855 memcpy (raw
.sectname
, section
->sectname
, 16);
1856 memcpy (raw
.segname
, section
->segname
, 16);
1857 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1858 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1859 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1860 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1861 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1862 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1863 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1864 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1865 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1867 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1868 != BFD_MACH_O_SECTION_SIZE
)
1875 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1877 struct mach_o_section_64_external raw
;
1879 memcpy (raw
.sectname
, section
->sectname
, 16);
1880 memcpy (raw
.segname
, section
->segname
, 16);
1881 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1882 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1883 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1884 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1885 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1886 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1887 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1888 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1889 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1890 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1892 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1893 != BFD_MACH_O_SECTION_64_SIZE
)
1900 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1902 struct mach_o_segment_command_32_external raw
;
1903 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1904 bfd_mach_o_section
*sec
;
1906 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1908 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1909 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1912 memcpy (raw
.segname
, seg
->segname
, 16);
1913 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1914 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1915 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1916 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1917 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1918 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1919 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1920 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1922 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1923 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1926 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1927 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1934 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1936 struct mach_o_segment_command_64_external raw
;
1937 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1938 bfd_mach_o_section
*sec
;
1940 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1942 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1943 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1946 memcpy (raw
.segname
, seg
->segname
, 16);
1947 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1948 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1949 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1950 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1951 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1952 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1953 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1954 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1956 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1957 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1960 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1961 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1968 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1970 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1972 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1973 struct bfd_strtab_hash
*strtab
;
1974 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1977 /* Write the symbols first. */
1978 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1981 strtab
= _bfd_stringtab_init ();
1986 /* Although we don't strictly need to do this, for compatibility with
1987 Darwin system tools, actually output an empty string for the index
1989 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1991 for (i
= 0; i
< sym
->nsyms
; i
++)
1993 bfd_size_type str_index
;
1994 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1996 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1997 /* An index of 0 always means the empty string. */
2001 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
2003 if (str_index
== (bfd_size_type
) -1)
2009 struct mach_o_nlist_64_external raw
;
2011 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
2012 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
2013 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
2014 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
2015 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
2018 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2023 struct mach_o_nlist_external raw
;
2025 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
2026 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
2027 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
2028 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
2029 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
2032 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2036 sym
->strsize
= _bfd_stringtab_size (strtab
);
2037 sym
->stroff
= mdata
->filelen
;
2038 mdata
->filelen
+= sym
->strsize
;
2040 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
2043 if (!_bfd_stringtab_emit (abfd
, strtab
))
2046 /* Pad string table. */
2047 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
2050 mdata
->filelen
+= padlen
;
2051 sym
->strsize
+= padlen
;
2056 _bfd_stringtab_free (strtab
);
2062 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2064 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
2065 struct mach_o_symtab_command_external raw
;
2067 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2070 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
2071 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
2072 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
2073 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
2075 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2076 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2082 /* Count the number of indirect symbols in the image.
2083 Requires that the sections are in their final order. */
2086 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2089 unsigned int nisyms
= 0;
2091 for (i
= 0; i
< mdata
->nsects
; ++i
)
2093 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2095 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2097 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2098 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2099 case BFD_MACH_O_S_SYMBOL_STUBS
:
2100 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2109 /* Create the dysymtab. */
2112 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
2114 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2117 We are not going to try and fill these in yet and, moreover, we are
2118 going to bail if they are already set. */
2119 if (cmd
->nmodtab
!= 0
2121 || cmd
->nextrefsyms
!= 0)
2123 _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
2124 " implemented for dysymtab commands."));
2130 if (bfd_get_symcount (abfd
) > 0)
2132 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2135 /* Count the number of each kind of symbol. */
2136 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2138 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2139 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
2143 cmd
->iextdefsym
= i
;
2144 for (; i
< bfd_get_symcount (abfd
); ++i
)
2146 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2147 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
2150 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
2151 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
2152 cmd
->nundefsym
= bfd_get_symcount (abfd
)
2159 cmd
->iextdefsym
= 0;
2160 cmd
->nextdefsym
= 0;
2165 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
2166 if (cmd
->nindirectsyms
> 0)
2171 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2172 cmd
->indirectsymoff
= mdata
->filelen
;
2173 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
2175 if (cmd
->nindirectsyms
* 4 < cmd
->nindirectsyms
)
2177 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
2178 if (cmd
->indirect_syms
== NULL
)
2182 for (i
= 0; i
< mdata
->nsects
; ++i
)
2184 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2186 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2188 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2189 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2190 case BFD_MACH_O_S_SYMBOL_STUBS
:
2193 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2195 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2196 if (isyms
== NULL
|| num
== 0)
2198 /* Record the starting index in the reserved1 field. */
2200 for (j
= 0; j
< num
; j
++, n
++)
2202 if (isyms
[j
] == NULL
)
2203 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2204 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
2205 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
2206 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2207 | BFD_MACH_O_INDIRECT_SYM_ABS
;
2209 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2222 /* Write a dysymtab command.
2223 TODO: Possibly coalesce writes of smaller objects. */
2226 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2228 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2230 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2232 if (cmd
->nmodtab
!= 0)
2236 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2239 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2241 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2245 iinit
= module
->iinit
& 0xffff;
2246 iinit
|= ((module
->iterm
& 0xffff) << 16);
2248 ninit
= module
->ninit
& 0xffff;
2249 ninit
|= ((module
->nterm
& 0xffff) << 16);
2251 if (bfd_mach_o_wide_p (abfd
))
2253 struct mach_o_dylib_module_64_external w
;
2255 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2256 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2257 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2258 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2259 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2260 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2261 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2262 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2263 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2264 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2265 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2266 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2267 &w
.objc_module_info_addr
);
2268 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2269 &w
.objc_module_info_size
);
2271 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2276 struct mach_o_dylib_module_external n
;
2278 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2279 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2280 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2281 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2282 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2283 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2284 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2285 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2286 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2287 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2288 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2289 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2290 &n
.objc_module_info_addr
);
2291 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2292 &n
.objc_module_info_size
);
2294 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2304 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2307 for (i
= 0; i
< cmd
->ntoc
; i
++)
2309 struct mach_o_dylib_table_of_contents_external raw
;
2310 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2312 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2313 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2315 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2320 if (cmd
->nindirectsyms
> 0)
2324 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2327 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2329 unsigned char raw
[4];
2331 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2332 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2337 if (cmd
->nextrefsyms
!= 0)
2341 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2344 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2347 unsigned char raw
[4];
2348 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2350 /* Fields isym and flags are written as bit-fields, thus we need
2351 a specific processing for endianness. */
2353 if (bfd_big_endian (abfd
))
2355 v
= ((ref
->isym
& 0xffffff) << 8);
2356 v
|= ref
->flags
& 0xff;
2360 v
= ref
->isym
& 0xffffff;
2361 v
|= ((ref
->flags
& 0xff) << 24);
2364 bfd_h_put_32 (abfd
, v
, raw
);
2365 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2371 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2375 struct mach_o_dysymtab_command_external raw
;
2377 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2378 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2379 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2380 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2381 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2382 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2383 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2384 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2385 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2386 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2387 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2388 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2389 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2390 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2391 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2392 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2393 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2394 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2396 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2404 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2406 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2408 /* Just leave debug symbols where they are (pretend they are local, and
2409 then they will just be sorted on position). */
2410 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2413 /* Local (we should never see an undefined local AFAICT). */
2414 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2417 /* Common symbols look like undefined externs. */
2418 if (mtyp
== BFD_MACH_O_N_UNDF
)
2421 /* A defined non-local, non-debug symbol. */
2426 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2428 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2429 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2430 unsigned int soa
, sob
;
2432 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2433 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2440 /* If it's local or stab, just preserve the input order. */
2443 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2445 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2448 /* This is probably an error. */
2452 /* The second sort key is name. */
2453 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2456 /* Process the symbols.
2458 This should be OK for single-module files - but it is not likely to work
2459 for multi-module shared libraries.
2461 (a) If the application has not filled in the relevant mach-o fields, make
2464 (b) Order them, like this:
2467 ( ii) external defined
2469 (iii) external undefined/common
2476 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2479 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2481 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2484 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2486 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2488 /* We use this value, which is out-of-range as a symbol index, to signal
2489 that the mach-o-specific data are not filled in and need to be created
2490 from the bfd values. It is much preferable for the application to do
2491 this, since more meaningful diagnostics can be made that way. */
2493 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2495 /* No symbol information has been set - therefore determine
2496 it from the bfd symbol flags/info. */
2497 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2498 s
->n_type
= BFD_MACH_O_N_ABS
;
2499 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2501 s
->n_type
= BFD_MACH_O_N_UNDF
;
2502 if (s
->symbol
.flags
& BSF_WEAK
)
2503 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2504 /* mach-o automatically makes undefined symbols extern. */
2505 s
->n_type
|= BFD_MACH_O_N_EXT
;
2506 s
->symbol
.flags
|= BSF_GLOBAL
;
2508 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2510 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2511 s
->symbol
.flags
|= BSF_GLOBAL
;
2514 s
->n_type
= BFD_MACH_O_N_SECT
;
2517 /* Update external symbol bit in case objcopy changed it. */
2518 if (s
->symbol
.flags
& BSF_GLOBAL
)
2519 s
->n_type
|= BFD_MACH_O_N_EXT
;
2521 s
->n_type
&= ~BFD_MACH_O_N_EXT
;
2523 /* Put the section index in, where required. */
2524 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2525 && s
->symbol
.section
!= bfd_und_section_ptr
2526 && s
->symbol
.section
!= bfd_com_section_ptr
)
2527 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2528 && s
->symbol
.name
== NULL
))
2529 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2531 /* Number to preserve order for local and debug syms. */
2532 s
->symbol
.udata
.i
= i
;
2535 /* Sort the symbols. */
2536 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2537 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2539 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2541 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2542 s
->symbol
.udata
.i
= i
; /* renumber. */
2548 /* We build a flat table of sections, which can be re-ordered if necessary.
2549 Fill in the section number and other mach-o-specific data. */
2552 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2555 unsigned target_index
;
2558 nsect
= bfd_count_sections (abfd
);
2560 /* Don't do it if it's already set - assume the application knows what it's
2562 if (mdata
->nsects
== nsect
2563 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2566 /* We need to check that this can be done... */
2569 _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2570 " maximum is 255,\n"), nsect
);
2574 mdata
->nsects
= nsect
;
2575 mdata
->sections
= bfd_alloc2 (abfd
,
2576 mdata
->nsects
, sizeof (bfd_mach_o_section
*));
2577 if (mdata
->sections
== NULL
)
2580 /* Create Mach-O sections.
2581 Section type, attribute and align should have been set when the
2582 section was created - either read in or specified. */
2584 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2586 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
2587 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2589 mdata
->sections
[target_index
] = msect
;
2591 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
2592 msect
->size
= bfd_get_section_size (sec
);
2594 /* Use the largest alignment set, in case it was bumped after the
2595 section was created. */
2596 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2599 sec
->target_index
= ++target_index
;
2606 bfd_mach_o_write_contents (bfd
*abfd
)
2608 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2609 bfd_mach_o_load_command
*cmd
;
2610 bfd_mach_o_symtab_command
*symtab
= NULL
;
2611 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2612 bfd_mach_o_segment_command
*linkedit
= NULL
;
2614 /* Make the commands, if not already present. */
2615 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2617 abfd
->output_has_begun
= TRUE
;
2619 /* Write the header. */
2620 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2623 /* First pass: allocate the linkedit segment. */
2624 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2627 case BFD_MACH_O_LC_SEGMENT_64
:
2628 case BFD_MACH_O_LC_SEGMENT
:
2629 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2630 linkedit
= &cmd
->command
.segment
;
2632 case BFD_MACH_O_LC_SYMTAB
:
2633 symtab
= &cmd
->command
.symtab
;
2635 case BFD_MACH_O_LC_DYSYMTAB
:
2636 dysymtab
= &cmd
->command
.dysymtab
;
2638 case BFD_MACH_O_LC_DYLD_INFO
:
2640 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2642 if (di
->rebase_size
!= 0)
2644 di
->rebase_off
= mdata
->filelen
;
2645 mdata
->filelen
+= di
->rebase_size
;
2647 if (di
->bind_size
!= 0)
2649 di
->bind_off
= mdata
->filelen
;
2650 mdata
->filelen
+= di
->bind_size
;
2652 if (di
->weak_bind_size
!= 0)
2654 di
->weak_bind_off
= mdata
->filelen
;
2655 mdata
->filelen
+= di
->weak_bind_size
;
2657 if (di
->lazy_bind_size
!= 0)
2659 di
->lazy_bind_off
= mdata
->filelen
;
2660 mdata
->filelen
+= di
->lazy_bind_size
;
2662 if (di
->export_size
!= 0)
2664 di
->export_off
= mdata
->filelen
;
2665 mdata
->filelen
+= di
->export_size
;
2669 case BFD_MACH_O_LC_LOAD_DYLIB
:
2670 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2671 case BFD_MACH_O_LC_MAIN
:
2672 /* Nothing to do. */
2676 (_("unable to allocate data for load command %#x"),
2681 /* Specially handle symtab and dysymtab. */
2683 /* Pre-allocate the symbol table (but not the string table). The reason
2684 is that the dysymtab is after the symbol table but before the string
2685 table (required by the native strip tool). */
2688 unsigned int symlen
;
2689 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2691 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2693 /* Align for symbols. */
2694 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2695 symtab
->symoff
= mdata
->filelen
;
2697 symtab
->nsyms
= bfd_get_symcount (abfd
);
2698 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2701 /* Build the dysymtab. */
2702 if (dysymtab
!= NULL
)
2703 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2706 /* Write symtab and strtab. */
2708 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2711 /* Adjust linkedit size. */
2712 if (linkedit
!= NULL
)
2714 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2716 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2717 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2718 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2720 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2721 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2722 | BFD_MACH_O_PROT_EXECUTE
;
2725 /* Second pass: write commands. */
2726 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2728 struct mach_o_load_command_external raw
;
2729 unsigned long typeflag
;
2731 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2733 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2734 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2736 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2737 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2742 case BFD_MACH_O_LC_SEGMENT
:
2743 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2746 case BFD_MACH_O_LC_SEGMENT_64
:
2747 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2750 case BFD_MACH_O_LC_SYMTAB
:
2751 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2754 case BFD_MACH_O_LC_DYSYMTAB
:
2755 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2758 case BFD_MACH_O_LC_THREAD
:
2759 case BFD_MACH_O_LC_UNIXTHREAD
:
2760 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2763 case BFD_MACH_O_LC_LOAD_DYLIB
:
2764 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2767 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2768 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2771 case BFD_MACH_O_LC_MAIN
:
2772 if (!bfd_mach_o_write_main (abfd
, cmd
))
2775 case BFD_MACH_O_LC_DYLD_INFO
:
2776 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2781 (_("unable to write unknown load command %#x"),
2791 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2792 bfd_mach_o_section
*s
)
2794 if (seg
->sect_head
== NULL
)
2797 seg
->sect_tail
->next
= s
;
2801 /* Create section Mach-O flags from BFD flags. */
2804 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2808 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2810 /* Create default flags. */
2811 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2812 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2813 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2814 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2815 | BFD_MACH_O_S_REGULAR
;
2816 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2817 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2818 else if (bfd_flags
& SEC_DEBUGGING
)
2819 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2821 s
->flags
= BFD_MACH_O_S_REGULAR
;
2825 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2827 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2831 seg
->fileoff
= mdata
->filelen
;
2832 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2833 | BFD_MACH_O_PROT_EXECUTE
;
2834 seg
->maxprot
= seg
->initprot
;
2836 /* Append sections to the segment.
2838 This is a little tedious, we have to honor the need to account zerofill
2839 sections after all the rest. This forces us to do the calculation of
2840 total vmsize in three passes so that any alignment increments are
2841 properly accounted. */
2842 for (i
= 0; i
< mdata
->nsects
; ++i
)
2844 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2845 asection
*sec
= s
->bfdsection
;
2847 /* Although we account for zerofill section sizes in vm order, they are
2848 placed in the file in source sequence. */
2849 bfd_mach_o_append_section_to_segment (seg
, s
);
2852 /* Zerofill sections have zero file size & offset, the only content
2853 written to the file is the symbols. */
2854 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2855 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2856 == BFD_MACH_O_S_GB_ZEROFILL
))
2859 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2860 sections, even those with zero size. */
2863 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2864 seg
->vmsize
+= s
->size
;
2866 /* MH_OBJECT files have unaligned content. */
2869 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2870 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2872 seg
->filesize
+= s
->size
;
2874 /* The system tools write even zero-sized sections with an offset
2875 field set to the current file position. */
2876 s
->offset
= mdata
->filelen
;
2879 sec
->filepos
= s
->offset
;
2880 mdata
->filelen
+= s
->size
;
2883 /* Now pass through again, for zerofill, only now we just update the
2884 vmsize, and then for zerofill_GB. */
2885 for (j
= 0; j
< 2; j
++)
2890 stype
= BFD_MACH_O_S_ZEROFILL
;
2892 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2894 for (i
= 0; i
< mdata
->nsects
; ++i
)
2896 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2898 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2903 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2904 seg
->vmsize
+= s
->size
;
2909 /* Allocate space for the relocations. */
2910 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2912 for (i
= 0; i
< mdata
->nsects
; ++i
)
2914 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2915 asection
*sec
= ms
->bfdsection
;
2917 ms
->nreloc
= sec
->reloc_count
;
2918 if (ms
->nreloc
== 0)
2920 /* Clear nreloc and reloff if there is no relocs. */
2924 sec
->rel_filepos
= mdata
->filelen
;
2925 ms
->reloff
= sec
->rel_filepos
;
2926 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2933 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2935 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2937 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2939 bfd_mach_o_section
*s
;
2943 seg
->fileoff
= mdata
->filelen
;
2948 /* Append sections to the segment. We assume they are properly ordered
2949 by vma (but we check that). */
2951 for (i
= 0; i
< mdata
->nsects
; ++i
)
2953 s
= mdata
->sections
[i
];
2955 /* Consider only sections for this segment. */
2956 if (strcmp (seg
->segname
, s
->segname
) != 0)
2959 bfd_mach_o_append_section_to_segment (seg
, s
);
2964 /* xgettext:c-format */
2965 (_("section address (%#" PRIx64
") "
2966 "below start of segment (%#" PRIx64
")"),
2967 (uint64_t) s
->addr
, (uint64_t) vma
);
2971 vma
= s
->addr
+ s
->size
;
2974 /* Set segment file offset: make it page aligned. */
2975 vma
= seg
->sect_head
->addr
;
2976 seg
->vmaddr
= vma
& ~pagemask
;
2977 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2978 mdata
->filelen
+= pagemask
+ 1;
2979 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2980 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2982 /* Set section file offset. */
2983 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2985 asection
*sec
= s
->bfdsection
;
2986 flagword flags
= bfd_get_section_flags (abfd
, sec
);
2988 /* Adjust segment size. */
2989 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2990 seg
->vmsize
+= s
->size
;
2992 /* File offset and length. */
2993 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2995 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
2996 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2997 != BFD_MACH_O_S_GB_ZEROFILL
))
2999 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
3001 s
->offset
= mdata
->filelen
;
3002 s
->bfdsection
->filepos
= s
->offset
;
3004 seg
->filesize
+= s
->size
;
3005 mdata
->filelen
+= s
->size
;
3010 s
->bfdsection
->filepos
= 0;
3013 /* Set protection. */
3014 if (flags
& SEC_LOAD
)
3016 if (flags
& SEC_CODE
)
3017 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
3018 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
3019 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
3022 /* Relocs shouldn't appear in non-object files. */
3023 if (s
->bfdsection
->reloc_count
!= 0)
3028 if (seg
->initprot
!= 0)
3029 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
3030 | BFD_MACH_O_PROT_EXECUTE
;
3034 /* Round segment size (and file size). */
3035 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
3036 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
3037 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
3042 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3043 fields in header. */
3046 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
3048 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3049 unsigned int hdrlen
;
3051 bfd_mach_o_load_command
*cmd
;
3053 bfd_boolean ret
= TRUE
;
3055 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3056 align
= wide
? 8 - 1 : 4 - 1;
3058 mdata
->header
.ncmds
= 0;
3060 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
3062 mdata
->header
.ncmds
++;
3063 cmd
->offset
= offset
;
3067 case BFD_MACH_O_LC_SEGMENT_64
:
3068 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
3069 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
3071 case BFD_MACH_O_LC_SEGMENT
:
3072 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
3073 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
3075 case BFD_MACH_O_LC_SYMTAB
:
3076 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
3077 + BFD_MACH_O_LC_SIZE
;
3079 case BFD_MACH_O_LC_DYSYMTAB
:
3080 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
3081 + BFD_MACH_O_LC_SIZE
;
3083 case BFD_MACH_O_LC_LOAD_DYLIB
:
3084 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
3085 + BFD_MACH_O_LC_SIZE
;
3086 cmd
->command
.dylib
.name_offset
= cmd
->len
;
3087 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
3088 cmd
->len
= (cmd
->len
+ align
) & ~align
;
3090 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3091 cmd
->len
= sizeof (struct mach_o_str_command_external
)
3092 + BFD_MACH_O_LC_SIZE
;
3093 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
3094 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
3095 cmd
->len
= (cmd
->len
+ align
) & ~align
;
3097 case BFD_MACH_O_LC_MAIN
:
3098 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
3099 + BFD_MACH_O_LC_SIZE
;
3101 case BFD_MACH_O_LC_DYLD_INFO
:
3102 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
3103 + BFD_MACH_O_LC_SIZE
;
3107 (_("unable to layout unknown load command %#x"),
3113 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
3116 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
3117 mdata
->filelen
= offset
;
3122 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3126 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
3127 bfd_mach_o_load_command
*cmd
,
3128 const char *segname
, unsigned int nbr_sect
)
3130 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3131 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3133 /* Init segment command. */
3134 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
3135 cmd
->type_required
= FALSE
;
3137 strcpy (seg
->segname
, segname
);
3138 seg
->nsects
= nbr_sect
;
3148 seg
->sect_head
= NULL
;
3149 seg
->sect_tail
= NULL
;
3152 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3153 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3154 and copy functionality. */
3157 bfd_mach_o_build_commands (bfd
*abfd
)
3159 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3160 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3161 unsigned int nbr_segcmd
= 0;
3162 bfd_mach_o_load_command
*commands
;
3163 unsigned int nbr_commands
;
3164 int symtab_idx
= -1;
3165 int dysymtab_idx
= -1;
3169 /* Return now if already built. */
3170 if (mdata
->header
.ncmds
!= 0)
3173 /* Fill in the file type, if not already set. */
3174 if (mdata
->header
.filetype
== 0)
3176 if (abfd
->flags
& EXEC_P
)
3177 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
3178 else if (abfd
->flags
& DYNAMIC
)
3179 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
3181 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
3184 /* If hasn't already been done, flatten sections list, and sort
3185 if/when required. Must be done before the symbol table is adjusted,
3186 since that depends on properly numbered sections. */
3187 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
3188 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
3191 /* Order the symbol table, fill-in/check mach-o specific fields and
3192 partition out any indirect symbols. */
3193 if (!bfd_mach_o_mangle_symbols (abfd
))
3196 /* Segment commands. */
3197 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3199 /* Only one segment for all the sections. But the segment is
3200 optional if there is no sections. */
3201 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
3205 bfd_mach_o_section
*prev_sect
= NULL
;
3207 /* One pagezero segment and one linkedit segment. */
3210 /* Create one segment for associated segment name in sections.
3211 Assume that sections with the same segment name are consecutive. */
3212 for (i
= 0; i
< mdata
->nsects
; i
++)
3214 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
3216 if (prev_sect
== NULL
3217 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
3220 prev_sect
= this_sect
;
3225 nbr_commands
= nbr_segcmd
;
3227 /* One command for the symbol table (only if there are symbols. */
3228 if (bfd_get_symcount (abfd
) > 0)
3229 symtab_idx
= nbr_commands
++;
3232 This is a rather crude test for whether we should build a dysymtab. */
3233 if (bfd_mach_o_should_emit_dysymtab ()
3234 && bfd_get_symcount (abfd
))
3236 /* If there should be a case where a dysymtab could be emitted without
3237 a symtab (seems improbable), this would need amending. */
3238 dysymtab_idx
= nbr_commands
++;
3241 /* Add an entry point command. */
3242 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3243 && bfd_get_start_address (abfd
) != 0)
3244 main_idx
= nbr_commands
++;
3246 /* Well, we must have a header, at least. */
3247 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3249 /* A bit unusual, but no content is valid;
3250 as -n empty.s -o empty.o */
3251 if (nbr_commands
== 0)
3253 /* Layout commands (well none...) and set headers command fields. */
3254 return bfd_mach_o_layout_commands (mdata
);
3257 /* Create commands for segments (and symtabs), prepend them. */
3258 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3259 if (commands
== NULL
)
3261 for (i
= 0; i
< nbr_commands
- 1; i
++)
3262 commands
[i
].next
= &commands
[i
+ 1];
3263 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3264 if (mdata
->first_command
== NULL
)
3265 mdata
->last_command
= &commands
[nbr_commands
- 1];
3266 mdata
->first_command
= &commands
[0];
3268 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3270 /* For object file, there is only one segment. */
3271 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3273 else if (nbr_segcmd
!= 0)
3275 bfd_mach_o_load_command
*cmd
;
3277 BFD_ASSERT (nbr_segcmd
>= 2);
3281 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3283 /* Segments from sections. */
3285 for (i
= 0; i
< mdata
->nsects
;)
3287 const char *segname
= mdata
->sections
[i
]->segname
;
3288 unsigned int nbr_sect
= 1;
3290 /* Count number of sections for this segment. */
3291 for (i
++; i
< mdata
->nsects
; i
++)
3292 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3297 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3302 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3305 if (symtab_idx
>= 0)
3307 /* Init symtab command. */
3308 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3310 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3311 cmd
->type_required
= FALSE
;
3314 /* If required, setup symtab command, see comment above about the quality
3316 if (dysymtab_idx
>= 0)
3318 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3320 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3321 cmd
->type_required
= FALSE
;
3324 /* Create the main command. */
3327 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3329 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3330 cmd
->type_required
= TRUE
;
3332 cmd
->command
.main
.entryoff
= 0;
3333 cmd
->command
.main
.stacksize
= 0;
3336 /* Layout commands. */
3337 if (! bfd_mach_o_layout_commands (mdata
))
3340 /* So, now we have sized the commands and the filelen set to that.
3341 Now we can build the segment command and set the section file offsets. */
3342 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3344 for (i
= 0; i
< nbr_segcmd
; i
++)
3345 if (!bfd_mach_o_build_obj_seg_command
3346 (abfd
, &commands
[i
].command
.segment
))
3353 /* Skip pagezero and linkedit segments. */
3354 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3356 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3358 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3361 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3362 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3365 /* Set the size of __PAGEZERO. */
3366 commands
[0].command
.segment
.vmsize
=
3367 commands
[1].command
.segment
.vmaddr
;
3369 /* Set the vma and fileoff of __LINKEDIT. */
3370 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3371 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3373 /* Set entry point (once segments have been laid out). */
3375 commands
[main_idx
].command
.main
.entryoff
=
3376 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3382 /* Set the contents of a section. */
3385 bfd_mach_o_set_section_contents (bfd
*abfd
,
3387 const void * location
,
3389 bfd_size_type count
)
3393 /* Trying to write the first section contents will trigger the creation of
3394 the load commands if they are not already present. */
3395 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3401 pos
= section
->filepos
+ offset
;
3402 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3403 || bfd_bwrite (location
, count
, abfd
) != count
)
3410 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3411 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3416 /* Make an empty symbol. This is required only because
3417 bfd_make_section_anyway wants to create a symbol for the section. */
3420 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3422 asymbol
*new_symbol
;
3424 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3425 if (new_symbol
== NULL
)
3427 new_symbol
->the_bfd
= abfd
;
3428 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3433 bfd_mach_o_read_header (bfd
*abfd
, file_ptr hdr_off
, bfd_mach_o_header
*header
)
3435 struct mach_o_header_external raw
;
3437 bfd_vma (*get32
) (const void *) = NULL
;
3439 /* Just read the magic number. */
3440 if (bfd_seek (abfd
, hdr_off
, SEEK_SET
) != 0
3441 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3444 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3446 header
->byteorder
= BFD_ENDIAN_BIG
;
3447 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3448 header
->version
= 1;
3451 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3453 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3454 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3455 header
->version
= 1;
3458 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3460 header
->byteorder
= BFD_ENDIAN_BIG
;
3461 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3462 header
->version
= 2;
3465 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3467 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3468 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3469 header
->version
= 2;
3474 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3478 /* Once the size of the header is known, read the full header. */
3479 size
= mach_o_wide_p (header
) ?
3480 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3482 if (bfd_seek (abfd
, hdr_off
, SEEK_SET
) != 0
3483 || bfd_bread (&raw
, size
, abfd
) != size
)
3486 header
->cputype
= (*get32
) (raw
.cputype
);
3487 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3488 header
->filetype
= (*get32
) (raw
.filetype
);
3489 header
->ncmds
= (*get32
) (raw
.ncmds
);
3490 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3491 header
->flags
= (*get32
) (raw
.flags
);
3493 if (mach_o_wide_p (header
))
3494 header
->reserved
= (*get32
) (raw
.reserved
);
3496 header
->reserved
= 0;
3502 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3504 bfd_mach_o_section
*s
;
3505 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
3507 s
= bfd_mach_o_get_mach_o_section (sec
);
3511 static const mach_o_section_name_xlat
* xlat
;
3513 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3516 sec
->used_by_bfd
= s
;
3517 s
->bfdsection
= sec
;
3519 /* Create the Darwin seg/sect name pair from the bfd name.
3520 If this is a canonical name for which a specific paiting exists
3521 there will also be defined flags, type, attribute and alignment
3523 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3526 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3527 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3529 (void) bfd_set_section_alignment (abfd
, sec
, s
->align
);
3530 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
3531 if (bfd_flags
== SEC_NO_FLAGS
)
3532 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
3535 /* Create default flags. */
3536 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3539 return _bfd_generic_new_section_hook (abfd
, sec
);
3543 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
3547 bfd_mach_o_section
*section
;
3549 flags
= bfd_get_section_flags (abfd
, sec
);
3550 section
= bfd_mach_o_get_mach_o_section (sec
);
3552 /* TODO: see if we should use the xlat system for doing this by
3553 preference and fall back to this for unknown sections. */
3555 if (flags
== SEC_NO_FLAGS
)
3557 /* Try to guess flags. */
3558 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3559 flags
= SEC_DEBUGGING
;
3563 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3564 != BFD_MACH_O_S_ZEROFILL
)
3567 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3569 if (prot
& BFD_MACH_O_PROT_WRITE
)
3571 else if (prot
& BFD_MACH_O_PROT_READ
)
3572 flags
|= SEC_READONLY
;
3578 if ((flags
& SEC_DEBUGGING
) == 0)
3582 if (section
->offset
!= 0)
3583 flags
|= SEC_HAS_CONTENTS
;
3584 if (section
->nreloc
!= 0)
3587 bfd_set_section_flags (abfd
, sec
, flags
);
3589 sec
->vma
= section
->addr
;
3590 sec
->lma
= section
->addr
;
3591 sec
->size
= section
->size
;
3592 sec
->filepos
= section
->offset
;
3593 sec
->alignment_power
= section
->align
;
3594 sec
->segment_mark
= 0;
3595 sec
->reloc_count
= section
->nreloc
;
3596 sec
->rel_filepos
= section
->reloff
;
3600 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3601 const unsigned char *segname
,
3602 const unsigned char *sectname
)
3607 bfd_mach_o_convert_section_name_to_bfd
3608 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3612 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3616 bfd_mach_o_read_section_32 (bfd
*abfd
, unsigned long prot
)
3618 struct mach_o_section_32_external raw
;
3620 bfd_mach_o_section
*section
;
3622 if (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3623 != BFD_MACH_O_SECTION_SIZE
)
3626 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3630 section
= bfd_mach_o_get_mach_o_section (sec
);
3631 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3632 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3633 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3634 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3635 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3636 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3637 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3638 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3639 /* PR 17512: file: 0017eb76. */
3640 if (section
->align
> 64)
3643 (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx, "
3644 "using 32 instead"), section
->align
);
3645 section
->align
= 32;
3647 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3648 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3649 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3650 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3651 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3652 section
->reserved3
= 0;
3654 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3660 bfd_mach_o_read_section_64 (bfd
*abfd
, unsigned long prot
)
3662 struct mach_o_section_64_external raw
;
3664 bfd_mach_o_section
*section
;
3666 if (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3667 != BFD_MACH_O_SECTION_64_SIZE
)
3670 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3674 section
= bfd_mach_o_get_mach_o_section (sec
);
3675 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3676 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3677 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3678 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3679 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3680 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3681 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3682 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3683 if (section
->align
> 64)
3686 (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx, "
3687 "using 32 instead"), section
->align
);
3688 section
->align
= 32;
3690 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3691 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3692 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3693 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3694 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3695 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3697 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3703 bfd_mach_o_read_section (bfd
*abfd
, unsigned long prot
, unsigned int wide
)
3706 return bfd_mach_o_read_section_64 (abfd
, prot
);
3708 return bfd_mach_o_read_section_32 (abfd
, prot
);
3712 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3713 bfd_mach_o_symtab_command
*sym
,
3714 bfd_mach_o_asymbol
*s
,
3717 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3718 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3719 unsigned int symwidth
=
3720 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3721 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3722 struct mach_o_nlist_64_external raw
;
3723 unsigned char type
= -1;
3724 unsigned char section
= -1;
3726 symvalue value
= -1;
3727 unsigned long stroff
= -1;
3728 unsigned int symtype
= -1;
3730 BFD_ASSERT (sym
->strtab
!= NULL
);
3732 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3733 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3736 /* xgettext:c-format */
3737 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3742 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3743 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3744 symtype
= type
& BFD_MACH_O_N_TYPE
;
3745 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3746 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3748 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3750 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3752 if (stroff
>= sym
->strsize
)
3755 /* xgettext:c-format */
3756 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3762 s
->symbol
.the_bfd
= abfd
;
3763 s
->symbol
.name
= sym
->strtab
+ stroff
;
3764 s
->symbol
.value
= value
;
3765 s
->symbol
.flags
= 0x0;
3766 s
->symbol
.udata
.i
= i
;
3768 s
->n_sect
= section
;
3771 if (type
& BFD_MACH_O_N_STAB
)
3773 s
->symbol
.flags
|= BSF_DEBUGGING
;
3774 s
->symbol
.section
= bfd_und_section_ptr
;
3786 if ((section
> 0) && (section
<= mdata
->nsects
))
3788 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3790 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3797 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3798 s
->symbol
.flags
|= BSF_GLOBAL
;
3800 s
->symbol
.flags
|= BSF_LOCAL
;
3804 case BFD_MACH_O_N_UNDF
:
3805 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3806 && s
->symbol
.value
!= 0)
3808 /* A common symbol. */
3809 s
->symbol
.section
= bfd_com_section_ptr
;
3810 s
->symbol
.flags
= BSF_NO_FLAGS
;
3814 s
->symbol
.section
= bfd_und_section_ptr
;
3815 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3816 s
->symbol
.flags
|= BSF_WEAK
;
3819 case BFD_MACH_O_N_PBUD
:
3820 s
->symbol
.section
= bfd_und_section_ptr
;
3822 case BFD_MACH_O_N_ABS
:
3823 s
->symbol
.section
= bfd_abs_section_ptr
;
3825 case BFD_MACH_O_N_SECT
:
3826 if ((section
> 0) && (section
<= mdata
->nsects
))
3828 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3830 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3834 /* Mach-O uses 0 to mean "no section"; not an error. */
3838 /* xgettext:c-format */
3839 (_("bfd_mach_o_read_symtab_symbol: "
3840 "symbol \"%s\" specified invalid section %d (max %lu): "
3841 "setting to undefined"),
3842 s
->symbol
.name
, section
, mdata
->nsects
);
3844 s
->symbol
.section
= bfd_und_section_ptr
;
3847 case BFD_MACH_O_N_INDR
:
3848 /* FIXME: we don't follow the BFD convention as this indirect symbol
3849 won't be followed by the referenced one. This looks harmless
3850 unless we start using the linker. */
3851 s
->symbol
.flags
|= BSF_INDIRECT
;
3852 s
->symbol
.section
= bfd_ind_section_ptr
;
3853 s
->symbol
.value
= 0;
3857 /* xgettext:c-format */
3858 (_("bfd_mach_o_read_symtab_symbol: "
3859 "symbol \"%s\" specified invalid type field 0x%x: "
3860 "setting to undefined"), s
->symbol
.name
, symtype
);
3861 s
->symbol
.section
= bfd_und_section_ptr
;
3870 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3872 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3873 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3875 /* Fail if there is no symtab. */
3879 /* Success if already loaded. */
3883 if (abfd
->flags
& BFD_IN_MEMORY
)
3885 struct bfd_in_memory
*b
;
3887 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3889 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3891 bfd_set_error (bfd_error_file_truncated
);
3894 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3898 /* See PR 21840 for a reproducer. */
3899 if ((sym
->strsize
+ 1) == 0)
3901 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
+ 1);
3902 if (sym
->strtab
== NULL
)
3905 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
3906 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
3908 /* PR 17512: file: 10888-1609-0.004. */
3909 bfd_release (abfd
, sym
->strtab
);
3911 bfd_set_error (bfd_error_file_truncated
);
3914 /* Zero terminate the string table. */
3915 sym
->strtab
[sym
->strsize
] = 0;
3922 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3924 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3925 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3928 if (sym
== NULL
|| sym
->symbols
)
3929 /* Return now if there are no symbols or if already loaded. */
3932 sym
->symbols
= bfd_alloc2 (abfd
, sym
->nsyms
, sizeof (bfd_mach_o_asymbol
));
3933 if (sym
->symbols
== NULL
)
3935 _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
3936 "unable to allocate memory for symbols"));
3941 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3944 for (i
= 0; i
< sym
->nsyms
; i
++)
3945 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3951 bfd_release (abfd
, sym
->symbols
);
3952 sym
->symbols
= NULL
;
3958 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3960 switch ((int) flavour
)
3962 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3963 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3964 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3965 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3966 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3967 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3968 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3969 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3970 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3971 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3972 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3973 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3974 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3975 default: return "UNKNOWN";
3980 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3982 switch ((int) flavour
)
3984 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3985 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3986 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3987 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3988 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3989 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3990 default: return "UNKNOWN";
3995 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3997 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
3998 struct mach_o_str_command_external raw
;
3999 unsigned int nameoff
;
4000 unsigned int namelen
;
4002 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4005 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
4007 cmd
->name_offset
= nameoff
;
4008 namelen
= command
->len
- nameoff
;
4009 nameoff
+= command
->offset
;
4010 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
4011 if (cmd
->name_str
== NULL
)
4013 if (bfd_seek (abfd
, nameoff
, SEEK_SET
) != 0
4014 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
4020 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4022 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4023 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
4024 struct mach_o_dylib_command_external raw
;
4025 unsigned int nameoff
;
4026 unsigned int namelen
;
4028 switch (command
->type
)
4030 case BFD_MACH_O_LC_LOAD_DYLIB
:
4031 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4032 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4033 case BFD_MACH_O_LC_ID_DYLIB
:
4034 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4035 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4042 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4045 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4046 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
4047 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
4048 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
4050 cmd
->name_offset
= command
->offset
+ nameoff
;
4051 namelen
= command
->len
- nameoff
;
4052 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
4053 if (cmd
->name_str
== NULL
)
4055 if (bfd_seek (abfd
, mdata
->hdr_offset
+ cmd
->name_offset
, SEEK_SET
) != 0
4056 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
4062 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
4063 bfd_mach_o_load_command
*command
)
4065 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
4066 struct mach_o_prebound_dylib_command_external raw
;
4067 unsigned int nameoff
;
4068 unsigned int modoff
;
4069 unsigned int str_len
;
4072 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4075 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4076 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
4077 if (nameoff
> command
->len
|| modoff
> command
->len
)
4080 str_len
= command
->len
- sizeof (raw
);
4081 str
= bfd_alloc (abfd
, str_len
);
4084 if (bfd_bread (str
, str_len
, abfd
) != str_len
)
4087 cmd
->name_offset
= command
->offset
+ nameoff
;
4088 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
4089 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
4091 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
4092 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
4097 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
4098 bfd_mach_o_load_command
*command
)
4100 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
4101 struct mach_o_prebind_cksum_command_external raw
;
4103 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4106 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
4111 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
4112 bfd_mach_o_load_command
*command
)
4114 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
4115 struct mach_o_twolevel_hints_command_external raw
;
4117 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4120 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
4121 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
4126 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4128 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
4129 struct mach_o_fvmlib_command_external raw
;
4130 unsigned int nameoff
;
4131 unsigned int namelen
;
4133 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4136 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4137 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
4138 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
4140 fvm
->name_offset
= command
->offset
+ nameoff
;
4141 namelen
= command
->len
- nameoff
;
4142 fvm
->name_str
= bfd_alloc (abfd
, namelen
);
4143 if (fvm
->name_str
== NULL
)
4145 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
4146 || bfd_bread (fvm
->name_str
, namelen
, abfd
) != namelen
)
4152 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4154 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4155 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
4156 unsigned int offset
;
4157 unsigned int nflavours
;
4160 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
4161 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
4163 /* Count the number of threads. */
4166 while (offset
!= command
->len
)
4168 struct mach_o_thread_command_external raw
;
4170 if (offset
>= command
->len
)
4173 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4174 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4177 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
4181 /* Allocate threads. */
4182 cmd
->flavours
= bfd_alloc2
4183 (abfd
, nflavours
, sizeof (bfd_mach_o_thread_flavour
));
4184 if (cmd
->flavours
== NULL
)
4186 cmd
->nflavours
= nflavours
;
4190 while (offset
!= command
->len
)
4192 struct mach_o_thread_command_external raw
;
4194 if (offset
>= command
->len
)
4197 if (nflavours
>= cmd
->nflavours
)
4200 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4201 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4204 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
4205 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
4206 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
4207 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
4211 for (i
= 0; i
< nflavours
; i
++)
4214 unsigned int snamelen
;
4216 const char *flavourstr
;
4217 const char *prefix
= "LC_THREAD";
4220 switch (mdata
->header
.cputype
)
4222 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4223 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
4225 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
4227 case BFD_MACH_O_CPU_TYPE_I386
:
4228 case BFD_MACH_O_CPU_TYPE_X86_64
:
4230 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
4233 flavourstr
= "UNKNOWN_ARCHITECTURE";
4237 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
4238 sname
= bfd_alloc (abfd
, snamelen
);
4244 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
4245 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
4250 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
4254 bfdsec
->size
= cmd
->flavours
[i
].size
;
4255 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
4256 bfdsec
->alignment_power
= 0x0;
4258 cmd
->section
= bfdsec
;
4265 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4267 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4268 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4270 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4273 struct mach_o_dysymtab_command_external raw
;
4275 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4278 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4279 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4280 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4281 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4282 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4283 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4284 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4285 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4286 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4287 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4288 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4289 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4290 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4291 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4292 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4293 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4294 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4295 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4298 if (cmd
->nmodtab
!= 0)
4301 int wide
= bfd_mach_o_wide_p (abfd
);
4302 unsigned int module_len
= wide
? 56 : 52;
4305 bfd_alloc2 (abfd
, cmd
->nmodtab
, sizeof (bfd_mach_o_dylib_module
));
4306 if (cmd
->dylib_module
== NULL
)
4309 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4312 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4314 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4316 unsigned char buf
[56];
4318 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4321 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4322 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4323 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4324 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4325 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4326 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4327 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4328 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4329 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4330 v
= bfd_h_get_32 (abfd
, buf
+36);
4331 module
->iinit
= v
& 0xffff;
4332 module
->iterm
= (v
>> 16) & 0xffff;
4333 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4334 module
->ninit
= v
& 0xffff;
4335 module
->nterm
= (v
>> 16) & 0xffff;
4338 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4339 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4343 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4344 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4353 cmd
->dylib_toc
= bfd_alloc2
4354 (abfd
, cmd
->ntoc
, sizeof (bfd_mach_o_dylib_table_of_content
));
4355 if (cmd
->dylib_toc
== NULL
)
4358 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4361 for (i
= 0; i
< cmd
->ntoc
; i
++)
4363 struct mach_o_dylib_table_of_contents_external raw
;
4364 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4366 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4369 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4370 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4374 if (cmd
->nindirectsyms
!= 0)
4378 cmd
->indirect_syms
= bfd_alloc2
4379 (abfd
, cmd
->nindirectsyms
, sizeof (unsigned int));
4380 if (cmd
->indirect_syms
== NULL
)
4383 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4386 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4388 unsigned char raw
[4];
4389 unsigned int *is
= &cmd
->indirect_syms
[i
];
4391 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4394 *is
= bfd_h_get_32 (abfd
, raw
);
4398 if (cmd
->nextrefsyms
!= 0)
4403 cmd
->ext_refs
= bfd_alloc2
4404 (abfd
, cmd
->nextrefsyms
, sizeof (bfd_mach_o_dylib_reference
));
4405 if (cmd
->ext_refs
== NULL
)
4408 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4411 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4413 unsigned char raw
[4];
4414 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4416 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4419 /* Fields isym and flags are written as bit-fields, thus we need
4420 a specific processing for endianness. */
4421 v
= bfd_h_get_32 (abfd
, raw
);
4422 if (bfd_big_endian (abfd
))
4424 ref
->isym
= (v
>> 8) & 0xffffff;
4425 ref
->flags
= v
& 0xff;
4429 ref
->isym
= v
& 0xffffff;
4430 ref
->flags
= (v
>> 24) & 0xff;
4435 if (mdata
->dysymtab
)
4437 mdata
->dysymtab
= cmd
;
4443 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4445 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4446 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4447 struct mach_o_symtab_command_external raw
;
4449 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4451 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4454 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4455 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4456 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4457 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4458 symtab
->symbols
= NULL
;
4459 symtab
->strtab
= NULL
;
4461 if (symtab
->nsyms
!= 0)
4462 abfd
->flags
|= HAS_SYMS
;
4466 mdata
->symtab
= symtab
;
4471 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4473 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4475 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4477 if (bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4484 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4486 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4487 struct mach_o_linkedit_data_command_external raw
;
4489 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4492 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4493 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4498 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4500 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4501 struct mach_o_str_command_external raw
;
4504 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4507 off
= bfd_get_32 (abfd
, raw
.str
);
4508 cmd
->stroff
= command
->offset
+ off
;
4509 cmd
->str_len
= command
->len
- off
;
4510 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
4511 if (cmd
->str
== NULL
)
4513 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
4514 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
4519 static unsigned char *
4520 bfd_mach_o_alloc_and_read (bfd
*abfd
, unsigned int off
, unsigned int size
)
4524 buf
= bfd_alloc (abfd
, size
);
4527 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4528 || bfd_bread (buf
, size
, abfd
) != size
)
4534 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4536 /* Read rebase content. */
4537 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4539 cmd
->rebase_content
=
4540 bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4541 if (cmd
->rebase_content
== NULL
)
4545 /* Read bind content. */
4546 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4549 bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4550 if (cmd
->bind_content
== NULL
)
4554 /* Read weak bind content. */
4555 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4557 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4558 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4559 if (cmd
->weak_bind_content
== NULL
)
4563 /* Read lazy bind content. */
4564 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4566 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4567 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4568 if (cmd
->lazy_bind_content
== NULL
)
4572 /* Read export content. */
4573 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4575 cmd
->export_content
= bfd_mach_o_alloc_and_read
4576 (abfd
, cmd
->export_off
, cmd
->export_size
);
4577 if (cmd
->export_content
== NULL
)
4585 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4587 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4588 struct mach_o_dyld_info_command_external raw
;
4590 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4593 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4594 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4595 cmd
->rebase_content
= NULL
;
4596 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4597 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4598 cmd
->bind_content
= NULL
;
4599 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4600 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4601 cmd
->weak_bind_content
= NULL
;
4602 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4603 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4604 cmd
->lazy_bind_content
= NULL
;
4605 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4606 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4607 cmd
->export_content
= NULL
;
4612 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4614 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4615 struct mach_o_version_min_command_external raw
;
4617 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4620 cmd
->version
= bfd_get_32 (abfd
, raw
.version
);
4621 cmd
->sdk
= bfd_get_32 (abfd
, raw
.sdk
);
4626 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4628 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4629 struct mach_o_encryption_info_command_external raw
;
4631 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4634 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4635 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4636 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4641 bfd_mach_o_read_encryption_info_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4643 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4644 struct mach_o_encryption_info_64_command_external raw
;
4646 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4649 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4650 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4651 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4656 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4658 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4659 struct mach_o_entry_point_command_external raw
;
4661 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4664 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4665 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4670 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4672 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4673 struct mach_o_source_version_command_external raw
;
4676 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4679 ver
= bfd_get_64 (abfd
, raw
.version
);
4680 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4681 generates warnings) in case of the host doesn't support 64 bit
4683 cmd
->e
= ver
& 0x3ff;
4685 cmd
->d
= ver
& 0x3ff;
4687 cmd
->c
= ver
& 0x3ff;
4689 cmd
->b
= ver
& 0x3ff;
4691 cmd
->a
= ver
& 0xffffff;
4696 bfd_mach_o_read_note (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4698 bfd_mach_o_note_command
*cmd
= &command
->command
.note
;
4699 struct mach_o_note_command_external raw
;
4701 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4704 memcpy (cmd
->data_owner
, raw
.data_owner
, 16);
4705 cmd
->offset
= bfd_get_64 (abfd
, raw
.offset
);
4706 cmd
->size
= bfd_get_64 (abfd
, raw
.size
);
4711 bfd_mach_o_read_build_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4713 bfd_mach_o_build_version_command
*cmd
= &command
->command
.build_version
;
4714 struct mach_o_build_version_command_external raw
;
4716 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4719 cmd
->platform
= bfd_get_32 (abfd
, raw
.platform
);
4720 cmd
->minos
= bfd_get_32 (abfd
, raw
.minos
);
4721 cmd
->sdk
= bfd_get_32 (abfd
, raw
.sdk
);
4722 cmd
->ntools
= bfd_get_32 (abfd
, raw
.ntools
);
4727 bfd_mach_o_read_segment (bfd
*abfd
,
4728 bfd_mach_o_load_command
*command
,
4731 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4736 struct mach_o_segment_command_64_external raw
;
4738 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4740 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4743 memcpy (seg
->segname
, raw
.segname
, 16);
4744 seg
->segname
[16] = '\0';
4746 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4747 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4748 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4749 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4750 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4751 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4752 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4753 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4757 struct mach_o_segment_command_32_external raw
;
4759 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4761 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4764 memcpy (seg
->segname
, raw
.segname
, 16);
4765 seg
->segname
[16] = '\0';
4767 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4768 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4769 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4770 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4771 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4772 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4773 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4774 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4776 seg
->sect_head
= NULL
;
4777 seg
->sect_tail
= NULL
;
4779 for (i
= 0; i
< seg
->nsects
; i
++)
4783 sec
= bfd_mach_o_read_section (abfd
, seg
->initprot
, wide
);
4787 bfd_mach_o_append_section_to_segment
4788 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4795 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4797 return bfd_mach_o_read_segment (abfd
, command
, 0);
4801 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4803 return bfd_mach_o_read_segment (abfd
, command
, 1);
4807 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4809 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4810 struct mach_o_load_command_external raw
;
4813 /* Read command type and length. */
4814 if (bfd_seek (abfd
, mdata
->hdr_offset
+ command
->offset
, SEEK_SET
) != 0
4815 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4818 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4819 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4820 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4821 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4823 switch (command
->type
)
4825 case BFD_MACH_O_LC_SEGMENT
:
4826 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4829 case BFD_MACH_O_LC_SEGMENT_64
:
4830 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4833 case BFD_MACH_O_LC_SYMTAB
:
4834 if (!bfd_mach_o_read_symtab (abfd
, command
))
4837 case BFD_MACH_O_LC_SYMSEG
:
4839 case BFD_MACH_O_LC_THREAD
:
4840 case BFD_MACH_O_LC_UNIXTHREAD
:
4841 if (!bfd_mach_o_read_thread (abfd
, command
))
4844 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4845 case BFD_MACH_O_LC_ID_DYLINKER
:
4846 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4847 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4850 case BFD_MACH_O_LC_LOAD_DYLIB
:
4851 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4852 case BFD_MACH_O_LC_ID_DYLIB
:
4853 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4854 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4855 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4856 if (!bfd_mach_o_read_dylib (abfd
, command
))
4859 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4860 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4863 case BFD_MACH_O_LC_LOADFVMLIB
:
4864 case BFD_MACH_O_LC_IDFVMLIB
:
4865 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4868 case BFD_MACH_O_LC_IDENT
:
4869 case BFD_MACH_O_LC_FVMFILE
:
4870 case BFD_MACH_O_LC_PREPAGE
:
4871 case BFD_MACH_O_LC_ROUTINES
:
4872 case BFD_MACH_O_LC_ROUTINES_64
:
4874 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4875 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4876 case BFD_MACH_O_LC_SUB_LIBRARY
:
4877 case BFD_MACH_O_LC_SUB_CLIENT
:
4878 case BFD_MACH_O_LC_RPATH
:
4879 if (!bfd_mach_o_read_str (abfd
, command
))
4882 case BFD_MACH_O_LC_DYSYMTAB
:
4883 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4886 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4887 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4890 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4891 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4894 case BFD_MACH_O_LC_UUID
:
4895 if (!bfd_mach_o_read_uuid (abfd
, command
))
4898 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4899 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4900 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4901 case BFD_MACH_O_LC_DATA_IN_CODE
:
4902 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4903 case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT
:
4904 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4907 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4908 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4911 case BFD_MACH_O_LC_ENCRYPTION_INFO_64
:
4912 if (!bfd_mach_o_read_encryption_info_64 (abfd
, command
))
4915 case BFD_MACH_O_LC_DYLD_INFO
:
4916 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
4919 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4920 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4921 case BFD_MACH_O_LC_VERSION_MIN_WATCHOS
:
4922 case BFD_MACH_O_LC_VERSION_MIN_TVOS
:
4923 if (!bfd_mach_o_read_version_min (abfd
, command
))
4926 case BFD_MACH_O_LC_MAIN
:
4927 if (!bfd_mach_o_read_main (abfd
, command
))
4930 case BFD_MACH_O_LC_SOURCE_VERSION
:
4931 if (!bfd_mach_o_read_source_version (abfd
, command
))
4934 case BFD_MACH_O_LC_LINKER_OPTIONS
:
4936 case BFD_MACH_O_LC_NOTE
:
4937 if (!bfd_mach_o_read_note (abfd
, command
))
4940 case BFD_MACH_O_LC_BUILD_VERSION
:
4941 if (!bfd_mach_o_read_build_version (abfd
, command
))
4946 _bfd_error_handler (_("%pB: unknown load command %#x"),
4947 abfd
, command
->type
);
4955 bfd_mach_o_flatten_sections (bfd
*abfd
)
4957 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4958 bfd_mach_o_load_command
*cmd
;
4961 /* Count total number of sections. */
4964 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4966 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4967 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4969 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4971 mdata
->nsects
+= seg
->nsects
;
4975 /* Allocate sections array. */
4976 mdata
->sections
= bfd_alloc2 (abfd
,
4977 mdata
->nsects
, sizeof (bfd_mach_o_section
*));
4979 /* Fill the array. */
4982 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4984 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4985 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4987 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4988 bfd_mach_o_section
*sec
;
4990 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
4992 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
4993 mdata
->sections
[csect
++] = sec
;
4999 bfd_mach_o_scan_start_address (bfd
*abfd
)
5001 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5002 bfd_mach_o_thread_command
*thr
= NULL
;
5003 bfd_mach_o_load_command
*cmd
;
5006 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5007 if (cmd
->type
== BFD_MACH_O_LC_THREAD
5008 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
5010 thr
= &cmd
->command
.thread
;
5013 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
5015 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
5016 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
5020 abfd
->start_address
= main_cmd
->entryoff
5021 + (text_sect
->addr
- text_sect
->offset
);
5026 /* An object file has no start address, so do not fail if not found. */
5030 /* FIXME: create a subtarget hook ? */
5031 for (i
= 0; i
< thr
->nflavours
; i
++)
5033 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
5034 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
5036 unsigned char buf
[4];
5038 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
5039 || bfd_bread (buf
, 4, abfd
) != 4)
5042 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
5044 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
5045 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
5047 unsigned char buf
[4];
5049 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
5050 || bfd_bread (buf
, 4, abfd
) != 4)
5053 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
5055 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
5056 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
5058 unsigned char buf
[8];
5060 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
5061 || bfd_bread (buf
, 8, abfd
) != 8)
5064 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
5066 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
5067 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
5069 unsigned char buf
[8];
5071 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
5072 || bfd_bread (buf
, 8, abfd
) != 8)
5075 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
5083 bfd_mach_o_set_arch_mach (bfd
*abfd
,
5084 enum bfd_architecture arch
,
5085 unsigned long machine
)
5087 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5089 /* If this isn't the right architecture for this backend, and this
5090 isn't the generic backend, fail. */
5091 if (arch
!= bed
->arch
5092 && arch
!= bfd_arch_unknown
5093 && bed
->arch
!= bfd_arch_unknown
)
5096 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5100 bfd_mach_o_scan (bfd
*abfd
,
5101 bfd_mach_o_header
*header
,
5102 bfd_mach_o_data_struct
*mdata
)
5105 enum bfd_architecture cputype
;
5106 unsigned long cpusubtype
;
5107 unsigned int hdrsize
;
5109 hdrsize
= mach_o_wide_p (header
) ?
5110 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
5112 mdata
->header
= *header
;
5114 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
5115 switch (header
->filetype
)
5117 case BFD_MACH_O_MH_OBJECT
:
5118 abfd
->flags
|= HAS_RELOC
;
5120 case BFD_MACH_O_MH_EXECUTE
:
5121 abfd
->flags
|= EXEC_P
;
5123 case BFD_MACH_O_MH_DYLIB
:
5124 case BFD_MACH_O_MH_BUNDLE
:
5125 abfd
->flags
|= DYNAMIC
;
5129 abfd
->tdata
.mach_o_data
= mdata
;
5131 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
5132 &cputype
, &cpusubtype
);
5133 if (cputype
== bfd_arch_unknown
)
5136 /* xgettext:c-format */
5137 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5138 header
->cputype
, header
->cpusubtype
);
5142 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
5144 if (header
->ncmds
!= 0)
5146 bfd_mach_o_load_command
*cmd
;
5148 mdata
->first_command
= NULL
;
5149 mdata
->last_command
= NULL
;
5151 cmd
= bfd_alloc2 (abfd
, header
->ncmds
, sizeof (bfd_mach_o_load_command
));
5155 for (i
= 0; i
< header
->ncmds
; i
++)
5157 bfd_mach_o_load_command
*cur
= &cmd
[i
];
5159 bfd_mach_o_append_command (abfd
, cur
);
5162 cur
->offset
= hdrsize
;
5165 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
5166 cur
->offset
= prev
->offset
+ prev
->len
;
5169 if (!bfd_mach_o_read_command (abfd
, cur
))
5174 /* Sections should be flatten before scanning start address. */
5175 bfd_mach_o_flatten_sections (abfd
);
5176 if (!bfd_mach_o_scan_start_address (abfd
))
5183 bfd_mach_o_mkobject_init (bfd
*abfd
)
5185 bfd_mach_o_data_struct
*mdata
= NULL
;
5187 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
5190 abfd
->tdata
.mach_o_data
= mdata
;
5192 mdata
->header
.magic
= 0;
5193 mdata
->header
.cputype
= 0;
5194 mdata
->header
.cpusubtype
= 0;
5195 mdata
->header
.filetype
= 0;
5196 mdata
->header
.ncmds
= 0;
5197 mdata
->header
.sizeofcmds
= 0;
5198 mdata
->header
.flags
= 0;
5199 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
5200 mdata
->first_command
= NULL
;
5201 mdata
->last_command
= NULL
;
5203 mdata
->sections
= NULL
;
5204 mdata
->dyn_reloc_cache
= NULL
;
5210 bfd_mach_o_gen_mkobject (bfd
*abfd
)
5212 bfd_mach_o_data_struct
*mdata
;
5214 if (!bfd_mach_o_mkobject_init (abfd
))
5217 mdata
= bfd_mach_o_get_data (abfd
);
5218 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
5219 mdata
->header
.cputype
= 0;
5220 mdata
->header
.cpusubtype
= 0;
5221 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
5222 mdata
->header
.version
= 1;
5228 bfd_mach_o_header_p (bfd
*abfd
,
5230 bfd_mach_o_filetype filetype
,
5231 bfd_mach_o_cpu_type cputype
)
5233 bfd_mach_o_header header
;
5234 bfd_mach_o_data_struct
*mdata
;
5236 if (!bfd_mach_o_read_header (abfd
, hdr_off
, &header
))
5239 if (! (header
.byteorder
== BFD_ENDIAN_BIG
5240 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
5242 _bfd_error_handler (_("unknown header byte-order value %#x"),
5247 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
5248 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
5249 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
5250 || (header
.byteorder
== BFD_ENDIAN_LITTLE
5251 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
5252 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
5255 /* Check cputype and filetype.
5256 In case of wildcard, do not accept magics that are handled by existing
5260 if (header
.cputype
!= cputype
)
5266 /* Do not recognize 64 architectures if not configured for 64bit targets.
5267 This could happen only for generic targets. */
5268 if (mach_o_wide_p (&header
))
5275 if (header
.filetype
!= filetype
)
5280 switch (header
.filetype
)
5282 case BFD_MACH_O_MH_CORE
:
5283 /* Handled by core_p */
5290 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
5293 mdata
->hdr_offset
= hdr_off
;
5295 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
5301 bfd_set_error (bfd_error_wrong_format
);
5307 static const bfd_target
*
5308 bfd_mach_o_gen_object_p (bfd
*abfd
)
5310 return bfd_mach_o_header_p (abfd
, 0, 0, 0);
5313 static const bfd_target
*
5314 bfd_mach_o_gen_core_p (bfd
*abfd
)
5316 return bfd_mach_o_header_p (abfd
, 0, BFD_MACH_O_MH_CORE
, 0);
5319 /* Return the base address of ABFD, ie the address at which the image is
5320 mapped. The possible initial pagezero is ignored. */
5323 bfd_mach_o_get_base_address (bfd
*abfd
)
5325 bfd_mach_o_data_struct
*mdata
;
5326 bfd_mach_o_load_command
*cmd
;
5328 /* Check for Mach-O. */
5329 if (!bfd_mach_o_valid (abfd
))
5331 mdata
= bfd_mach_o_get_data (abfd
);
5333 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5335 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5336 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5338 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5340 if (segcmd
->initprot
!= 0)
5341 return segcmd
->vmaddr
;
5347 typedef struct mach_o_fat_archentry
5349 unsigned long cputype
;
5350 unsigned long cpusubtype
;
5351 unsigned long offset
;
5353 unsigned long align
;
5354 } mach_o_fat_archentry
;
5356 typedef struct mach_o_fat_data_struct
5358 unsigned long magic
;
5359 unsigned long nfat_arch
;
5360 mach_o_fat_archentry
*archentries
;
5361 } mach_o_fat_data_struct
;
5364 bfd_mach_o_fat_archive_p (bfd
*abfd
)
5366 mach_o_fat_data_struct
*adata
= NULL
;
5367 struct mach_o_fat_header_external hdr
;
5370 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5371 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5374 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5378 adata
->magic
= bfd_getb32 (hdr
.magic
);
5379 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5380 if (adata
->magic
!= 0xcafebabe)
5382 /* Avoid matching Java bytecode files, which have the same magic number.
5383 In the Java bytecode file format this field contains the JVM version,
5384 which starts at 43.0. */
5385 if (adata
->nfat_arch
> 30)
5388 adata
->archentries
=
5389 bfd_alloc2 (abfd
, adata
->nfat_arch
, sizeof (mach_o_fat_archentry
));
5390 if (adata
->archentries
== NULL
)
5393 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5395 struct mach_o_fat_arch_external arch
;
5396 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5398 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5399 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5400 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5401 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5402 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5405 abfd
->tdata
.mach_o_fat_data
= adata
;
5411 bfd_release (abfd
, adata
);
5412 bfd_set_error (bfd_error_wrong_format
);
5416 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5417 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5418 Set arelt_data and origin fields too. */
5421 bfd_mach_o_fat_member_init (bfd
*abfd
,
5422 enum bfd_architecture arch_type
,
5423 unsigned long arch_subtype
,
5424 mach_o_fat_archentry
*entry
)
5426 struct areltdata
*areltdata
;
5427 /* Create the member filename. Use ARCH_NAME. */
5428 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5432 /* Use the architecture name if known. */
5433 abfd
->filename
= xstrdup (ap
->printable_name
);
5437 /* Forge a uniq id. */
5438 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5439 char *name
= xmalloc (namelen
);
5440 snprintf (name
, namelen
, "0x%lx-0x%lx",
5441 entry
->cputype
, entry
->cpusubtype
);
5442 abfd
->filename
= name
;
5445 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5446 areltdata
->parsed_size
= entry
->size
;
5447 abfd
->arelt_data
= areltdata
;
5448 abfd
->iostream
= NULL
;
5449 abfd
->origin
= entry
->offset
;
5453 bfd_mach_o_fat_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5455 mach_o_fat_data_struct
*adata
;
5456 mach_o_fat_archentry
*entry
= NULL
;
5459 enum bfd_architecture arch_type
;
5460 unsigned long arch_subtype
;
5462 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5463 BFD_ASSERT (adata
!= NULL
);
5465 /* Find index of previous entry. */
5468 /* Start at first one. */
5473 /* Find index of PREV. */
5474 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5476 if (adata
->archentries
[i
].offset
== prev
->origin
)
5480 if (i
== adata
->nfat_arch
)
5483 bfd_set_error (bfd_error_bad_value
);
5487 /* Get next entry. */
5491 if (i
>= adata
->nfat_arch
)
5493 bfd_set_error (bfd_error_no_more_archived_files
);
5497 entry
= &adata
->archentries
[i
];
5498 nbfd
= _bfd_new_bfd_contained_in (archive
);
5502 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5503 &arch_type
, &arch_subtype
);
5505 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
5507 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5512 /* Analogous to stat call. */
5515 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5517 if (abfd
->arelt_data
== NULL
)
5519 bfd_set_error (bfd_error_invalid_operation
);
5526 buf
->st_mode
= 0644;
5527 buf
->st_size
= arelt_size (abfd
);
5532 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5533 If ABFD is a fat image containing a member that corresponds to FORMAT
5534 and ARCH, returns it.
5535 In other case, returns NULL.
5536 This function allows transparent uses of fat images. */
5539 bfd_mach_o_fat_extract (bfd
*abfd
,
5541 const bfd_arch_info_type
*arch
)
5544 mach_o_fat_data_struct
*adata
;
5547 if (bfd_check_format (abfd
, format
))
5549 if (bfd_get_arch_info (abfd
) == arch
)
5553 if (!bfd_check_format (abfd
, bfd_archive
)
5554 || abfd
->xvec
!= &mach_o_fat_vec
)
5557 /* This is a Mach-O fat image. */
5558 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5559 BFD_ASSERT (adata
!= NULL
);
5561 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5563 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5564 enum bfd_architecture cpu_type
;
5565 unsigned long cpu_subtype
;
5567 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5568 &cpu_type
, &cpu_subtype
);
5569 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5572 /* The architecture is found. */
5573 res
= _bfd_new_bfd_contained_in (abfd
);
5577 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
5579 if (bfd_check_format (res
, format
))
5581 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5592 bfd_mach_o_fat_close_and_cleanup (bfd
*abfd
)
5594 _bfd_unlink_from_archive_parent (abfd
);
5599 bfd_mach_o_lookup_command (bfd
*abfd
,
5600 bfd_mach_o_load_command_type type
,
5601 bfd_mach_o_load_command
**mcommand
)
5603 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5604 struct bfd_mach_o_load_command
*cmd
;
5607 BFD_ASSERT (mdata
!= NULL
);
5608 BFD_ASSERT (mcommand
!= NULL
);
5611 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5613 if (cmd
->type
!= type
)
5625 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5629 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5631 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5633 case BFD_MACH_O_CPU_TYPE_I386
:
5635 case BFD_MACH_O_CPU_TYPE_SPARC
:
5637 case BFD_MACH_O_CPU_TYPE_HPPA
:
5638 return 0xc0000000 - 0x04000000;
5644 /* The following two tables should be kept, as far as possible, in order of
5645 most frequently used entries to optimize their use from gas. */
5647 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5649 { "regular", BFD_MACH_O_S_REGULAR
},
5650 { "coalesced", BFD_MACH_O_S_COALESCED
},
5651 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5652 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5653 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5654 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5655 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5656 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5657 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5658 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5659 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5660 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5661 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5662 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5663 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5664 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5665 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5669 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5671 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5672 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5673 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5674 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5675 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5676 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5677 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5678 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5679 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5680 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5681 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5685 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5688 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5690 const bfd_mach_o_xlat_name
*x
;
5691 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5693 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5694 if (strcmp (x
->name
, name
) == 0)
5696 /* We found it... does the target support it? */
5697 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5698 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5699 return x
->val
; /* OK. */
5701 break; /* Not supported. */
5703 /* Maximum section ID = 0xff. */
5707 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5710 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5712 const bfd_mach_o_xlat_name
*x
;
5714 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5715 if (strcmp (x
->name
, name
) == 0)
5717 return (unsigned int)-1;
5721 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5722 unsigned char **rbuf
,
5725 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5726 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5727 bfd_mach_o_load_command
*cmd
;
5729 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5731 bfd_mach_o_segment_command
*seg
;
5733 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5736 seg
= &cmd
->command
.segment
;
5738 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5740 unsigned long start
= seg
->fileoff
;
5741 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5742 unsigned char *buf
= bfd_malloc (1024);
5743 unsigned long size
= 1024;
5747 bfd_size_type nread
= 0;
5748 unsigned long offset
;
5749 int found_nonnull
= 0;
5751 if (size
> (end
- start
))
5752 size
= (end
- start
);
5754 buf
= bfd_realloc_or_free (buf
, size
);
5758 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5764 nread
= bfd_bread (buf
, size
, abfd
);
5772 for (offset
= 4; offset
<= size
; offset
+= 4)
5776 val
= *((unsigned long *) (buf
+ size
- offset
));
5777 if (! found_nonnull
)
5782 else if (val
== 0x0)
5784 unsigned long bottom
;
5787 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5788 top
= seg
->fileoff
+ seg
->filesize
- 4;
5789 *rbuf
= bfd_malloc (top
- bottom
);
5790 *rlen
= top
- bottom
;
5792 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5798 if (size
== (end
- start
))
5812 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5814 unsigned char *buf
= NULL
;
5815 unsigned int len
= 0;
5818 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5822 return (char *) buf
;
5826 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5831 static bfd_mach_o_uuid_command
*
5832 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5834 bfd_mach_o_load_command
*uuid_cmd
= NULL
;
5835 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5836 if (ncmd
!= 1 || uuid_cmd
== NULL
)
5838 return &uuid_cmd
->command
.uuid
;
5841 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5844 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5846 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5849 BFD_ASSERT (uuid_cmd
);
5851 if (!bfd_check_format (abfd
, bfd_object
))
5854 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5855 || bfd_mach_o_get_data (abfd
) == NULL
5856 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5859 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5860 if (dsym_uuid_cmd
== NULL
)
5863 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5864 sizeof (uuid_cmd
->uuid
)) != 0)
5870 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5871 The caller is responsible for closing the returned BFD object and
5872 its my_archive if the returned BFD is in a fat dSYM. */
5875 bfd_mach_o_find_dsym (const char *dsym_filename
,
5876 const bfd_mach_o_uuid_command
*uuid_cmd
,
5877 const bfd_arch_info_type
*arch
)
5879 bfd
*base_dsym_bfd
, *dsym_bfd
;
5881 BFD_ASSERT (uuid_cmd
);
5883 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
5884 if (base_dsym_bfd
== NULL
)
5887 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
5888 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
5891 bfd_close (dsym_bfd
);
5892 if (base_dsym_bfd
!= dsym_bfd
)
5893 bfd_close (base_dsym_bfd
);
5898 /* Return a BFD created from a dSYM file for ABFD.
5899 The caller is responsible for closing the returned BFD object, its
5900 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5903 bfd_mach_o_follow_dsym (bfd
*abfd
)
5905 char *dsym_filename
;
5906 bfd_mach_o_uuid_command
*uuid_cmd
;
5907 bfd
*dsym_bfd
, *base_bfd
= abfd
;
5908 const char *base_basename
;
5910 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
5913 if (abfd
->my_archive
&& !bfd_is_thin_archive (abfd
->my_archive
))
5914 base_bfd
= abfd
->my_archive
;
5915 /* BFD may have been opened from a stream. */
5916 if (base_bfd
->filename
== NULL
)
5918 bfd_set_error (bfd_error_invalid_operation
);
5921 base_basename
= lbasename (base_bfd
->filename
);
5923 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5924 if (uuid_cmd
== NULL
)
5927 /* TODO: We assume the DWARF file has the same as the binary's.
5928 It seems apple's GDB checks all files in the dSYM bundle directory.
5929 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5931 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
5932 + strlen (dsym_subdir
) + 1
5933 + strlen (base_basename
) + 1);
5934 sprintf (dsym_filename
, "%s%s/%s",
5935 base_bfd
->filename
, dsym_subdir
, base_basename
);
5937 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
5938 bfd_get_arch_info (abfd
));
5939 if (dsym_bfd
== NULL
)
5940 free (dsym_filename
);
5946 bfd_mach_o_find_nearest_line (bfd
*abfd
,
5950 const char **filename_ptr
,
5951 const char **functionname_ptr
,
5952 unsigned int *line_ptr
,
5953 unsigned int *discriminator_ptr
)
5955 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5958 switch (mdata
->header
.filetype
)
5960 case BFD_MACH_O_MH_OBJECT
:
5962 case BFD_MACH_O_MH_EXECUTE
:
5963 case BFD_MACH_O_MH_DYLIB
:
5964 case BFD_MACH_O_MH_BUNDLE
:
5965 case BFD_MACH_O_MH_KEXT_BUNDLE
:
5966 if (mdata
->dwarf2_find_line_info
== NULL
)
5968 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
5969 /* When we couldn't find dSYM for this binary, we look for
5970 the debug information in the binary itself. In this way,
5971 we won't try finding separated dSYM again because
5972 mdata->dwarf2_find_line_info will be filled. */
5973 if (! mdata
->dsym_bfd
)
5975 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
5976 dwarf_debug_sections
, symbols
,
5977 &mdata
->dwarf2_find_line_info
,
5985 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
5986 filename_ptr
, functionname_ptr
,
5987 line_ptr
, discriminator_ptr
,
5988 dwarf_debug_sections
,
5989 &mdata
->dwarf2_find_line_info
);
5993 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
5995 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5996 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
5998 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
5999 bfd_mach_o_free_cached_info (abfd
);
6000 if (mdata
->dsym_bfd
!= NULL
)
6002 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
6004 /* FIXME: PR 19435: This calculation to find the memory allocated by
6005 bfd_mach_o_follow_dsym for the filename does not always end up
6006 selecting the correct pointer. Unfortunately this problem is
6007 very hard to reproduce on a non Mach-O native system, so until it
6008 can be traced and fixed on such a system, this code will remain
6009 commented out. This does mean that there will be a memory leak,
6010 but it is small, and happens when we are closing down, so it
6011 should not matter too much. */
6012 char *dsym_filename
= (char *)(fat_bfd
6014 : mdata
->dsym_bfd
->filename
);
6016 bfd_close (mdata
->dsym_bfd
);
6017 mdata
->dsym_bfd
= NULL
;
6019 bfd_close (fat_bfd
);
6021 free (dsym_filename
);
6026 return _bfd_generic_close_and_cleanup (abfd
);
6030 bfd_mach_o_free_cached_info (bfd
*abfd
)
6032 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6034 free (mdata
->dyn_reloc_cache
);
6035 mdata
->dyn_reloc_cache
= NULL
;
6036 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
6038 free (asect
->relocation
);
6039 asect
->relocation
= NULL
;
6045 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
6046 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6048 #define bfd_mach_o_canonicalize_one_reloc NULL
6049 #define bfd_mach_o_swap_reloc_out NULL
6050 #define bfd_mach_o_print_thread NULL
6051 #define bfd_mach_o_tgt_seg_table NULL
6052 #define bfd_mach_o_section_type_valid_for_tgt NULL
6054 #define TARGET_NAME mach_o_be_vec
6055 #define TARGET_STRING "mach-o-be"
6056 #define TARGET_ARCHITECTURE bfd_arch_unknown
6057 #define TARGET_PAGESIZE 1
6058 #define TARGET_BIG_ENDIAN 1
6059 #define TARGET_ARCHIVE 0
6060 #define TARGET_PRIORITY 1
6061 #include "mach-o-target.c"
6064 #undef TARGET_STRING
6065 #undef TARGET_ARCHITECTURE
6066 #undef TARGET_PAGESIZE
6067 #undef TARGET_BIG_ENDIAN
6068 #undef TARGET_ARCHIVE
6069 #undef TARGET_PRIORITY
6071 #define TARGET_NAME mach_o_le_vec
6072 #define TARGET_STRING "mach-o-le"
6073 #define TARGET_ARCHITECTURE bfd_arch_unknown
6074 #define TARGET_PAGESIZE 1
6075 #define TARGET_BIG_ENDIAN 0
6076 #define TARGET_ARCHIVE 0
6077 #define TARGET_PRIORITY 1
6079 #include "mach-o-target.c"
6082 #undef TARGET_STRING
6083 #undef TARGET_ARCHITECTURE
6084 #undef TARGET_PAGESIZE
6085 #undef TARGET_BIG_ENDIAN
6086 #undef TARGET_ARCHIVE
6087 #undef TARGET_PRIORITY
6089 /* Not yet handled: creating an archive. */
6090 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
6092 #define bfd_mach_o_close_and_cleanup bfd_mach_o_fat_close_and_cleanup
6095 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
6096 #define bfd_mach_o_openr_next_archived_file bfd_mach_o_fat_openr_next_archived_file
6097 #define bfd_mach_o_archive_p bfd_mach_o_fat_archive_p
6099 #define TARGET_NAME mach_o_fat_vec
6100 #define TARGET_STRING "mach-o-fat"
6101 #define TARGET_ARCHITECTURE bfd_arch_unknown
6102 #define TARGET_PAGESIZE 1
6103 #define TARGET_BIG_ENDIAN 1
6104 #define TARGET_ARCHIVE 1
6105 #define TARGET_PRIORITY 0
6107 #include "mach-o-target.c"
6110 #undef TARGET_STRING
6111 #undef TARGET_ARCHITECTURE
6112 #undef TARGET_PAGESIZE
6113 #undef TARGET_BIG_ENDIAN
6114 #undef TARGET_ARCHIVE
6115 #undef TARGET_PRIORITY