1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2020 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_section_name (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 cpu_type
, unsigned long cpu_subtype
)
623 static char buffer
[128];
626 switch (cpu_subtype
& 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 cpu_subtype
&= ~ 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)");
687 if (cpu_subtype
!= 0)
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
)
1626 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
1628 native_relocs
= (struct mach_o_reloc_info_external
*)
1629 _bfd_malloc_and_read (abfd
, native_size
, native_size
);
1630 if (native_relocs
== NULL
)
1633 for (i
= 0; i
< count
; i
++)
1635 if (!(*bed
->_bfd_mach_o_canonicalize_one_reloc
)(abfd
, &native_relocs
[i
],
1636 &res
[i
], syms
, res
))
1639 free (native_relocs
);
1643 free (native_relocs
);
1644 if (bfd_get_error () == bfd_error_no_error
)
1645 bfd_set_error (bfd_error_invalid_operation
);
1650 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1651 arelent
**rels
, asymbol
**syms
)
1653 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1657 if (asect
->reloc_count
== 0)
1660 /* No need to go further if we don't know how to read relocs. */
1661 if (bed
->_bfd_mach_o_canonicalize_one_reloc
== NULL
)
1664 if (asect
->relocation
== NULL
)
1666 if (asect
->reloc_count
* sizeof (arelent
) < asect
->reloc_count
)
1668 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1672 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1673 asect
->reloc_count
, res
, syms
) < 0)
1678 asect
->relocation
= res
;
1681 res
= asect
->relocation
;
1682 for (i
= 0; i
< asect
->reloc_count
; i
++)
1690 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1692 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1694 if (mdata
->dysymtab
== NULL
)
1696 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1697 * sizeof (arelent
*);
1701 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1702 struct bfd_symbol
**syms
)
1704 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1705 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1706 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1710 if (dysymtab
== NULL
)
1712 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1715 /* No need to go further if we don't know how to read relocs. */
1716 if (bed
->_bfd_mach_o_canonicalize_one_reloc
== NULL
)
1719 if (mdata
->dyn_reloc_cache
== NULL
)
1721 if ((dysymtab
->nextrel
+ dysymtab
->nlocrel
) * sizeof (arelent
)
1722 < (dysymtab
->nextrel
+ dysymtab
->nlocrel
))
1725 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1726 * sizeof (arelent
));
1730 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1731 dysymtab
->nextrel
, res
, syms
) < 0)
1737 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1739 res
+ dysymtab
->nextrel
, syms
) < 0)
1745 mdata
->dyn_reloc_cache
= res
;
1748 res
= mdata
->dyn_reloc_cache
;
1749 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1755 /* In addition to the need to byte-swap the symbol number, the bit positions
1756 of the fields in the relocation information vary per target endian-ness. */
1759 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1760 bfd_mach_o_reloc_info
*rel
)
1762 unsigned char info
= 0;
1764 BFD_ASSERT (rel
->r_type
<= 15);
1765 BFD_ASSERT (rel
->r_length
<= 3);
1767 if (bfd_big_endian (abfd
))
1769 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1770 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1771 fields
[2] = rel
->r_value
& 0xff;
1772 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1773 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1774 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1775 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1779 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1780 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1781 fields
[0] = rel
->r_value
& 0xff;
1782 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1783 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1784 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1785 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1791 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1796 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1798 sec
= section
->bfdsection
;
1799 if (sec
->reloc_count
== 0)
1802 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1805 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1808 /* Convert and write. */
1809 entries
= section
->bfdsection
->orelocation
;
1810 for (i
= 0; i
< section
->nreloc
; i
++)
1812 arelent
*rel
= entries
[i
];
1813 struct mach_o_reloc_info_external raw
;
1814 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1816 /* Convert relocation to an intermediate representation. */
1817 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1820 /* Lower the relocation info. */
1821 if (pinfo
->r_scattered
)
1825 v
= BFD_MACH_O_SR_SCATTERED
1826 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1827 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1828 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1829 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1830 /* Note: scattered relocs have field in reverse order... */
1831 bfd_put_32 (abfd
, v
, raw
.r_address
);
1832 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1836 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1837 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1841 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1842 != BFD_MACH_O_RELENT_SIZE
)
1849 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1851 struct mach_o_section_32_external raw
;
1853 memcpy (raw
.sectname
, section
->sectname
, 16);
1854 memcpy (raw
.segname
, section
->segname
, 16);
1855 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1856 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1857 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1858 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1859 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1860 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1861 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1862 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1863 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1865 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1866 != BFD_MACH_O_SECTION_SIZE
)
1873 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1875 struct mach_o_section_64_external raw
;
1877 memcpy (raw
.sectname
, section
->sectname
, 16);
1878 memcpy (raw
.segname
, section
->segname
, 16);
1879 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1880 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1881 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1882 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1883 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1884 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1885 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1886 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1887 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1888 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1890 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1891 != BFD_MACH_O_SECTION_64_SIZE
)
1898 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1900 struct mach_o_segment_command_32_external raw
;
1901 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1902 bfd_mach_o_section
*sec
;
1904 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1906 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1907 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1910 memcpy (raw
.segname
, seg
->segname
, 16);
1911 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1912 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1913 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1914 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1915 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1916 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1917 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1918 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1920 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1921 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1924 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1925 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1932 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1934 struct mach_o_segment_command_64_external raw
;
1935 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1936 bfd_mach_o_section
*sec
;
1938 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1940 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1941 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1944 memcpy (raw
.segname
, seg
->segname
, 16);
1945 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1946 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1947 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1948 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1949 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1950 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1951 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1952 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1954 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1955 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1958 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1959 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1966 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1968 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1970 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1971 struct bfd_strtab_hash
*strtab
;
1972 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1975 /* Write the symbols first. */
1976 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1979 strtab
= _bfd_stringtab_init ();
1984 /* Although we don't strictly need to do this, for compatibility with
1985 Darwin system tools, actually output an empty string for the index
1987 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1989 for (i
= 0; i
< sym
->nsyms
; i
++)
1991 bfd_size_type str_index
;
1992 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1994 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1995 /* An index of 0 always means the empty string. */
1999 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
2001 if (str_index
== (bfd_size_type
) -1)
2007 struct mach_o_nlist_64_external raw
;
2009 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
2010 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
2011 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
2012 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
2013 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
2016 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2021 struct mach_o_nlist_external raw
;
2023 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
2024 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
2025 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
2026 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
2027 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
2030 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2034 sym
->strsize
= _bfd_stringtab_size (strtab
);
2035 sym
->stroff
= mdata
->filelen
;
2036 mdata
->filelen
+= sym
->strsize
;
2038 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
2041 if (!_bfd_stringtab_emit (abfd
, strtab
))
2044 /* Pad string table. */
2045 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
2048 mdata
->filelen
+= padlen
;
2049 sym
->strsize
+= padlen
;
2054 _bfd_stringtab_free (strtab
);
2060 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2062 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
2063 struct mach_o_symtab_command_external raw
;
2065 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2068 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
2069 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
2070 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
2071 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
2073 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2074 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2080 /* Count the number of indirect symbols in the image.
2081 Requires that the sections are in their final order. */
2084 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2087 unsigned int nisyms
= 0;
2089 for (i
= 0; i
< mdata
->nsects
; ++i
)
2091 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2093 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2095 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2096 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2097 case BFD_MACH_O_S_SYMBOL_STUBS
:
2098 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2107 /* Create the dysymtab. */
2110 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
2112 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2115 We are not going to try and fill these in yet and, moreover, we are
2116 going to bail if they are already set. */
2117 if (cmd
->nmodtab
!= 0
2119 || cmd
->nextrefsyms
!= 0)
2121 _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
2122 " implemented for dysymtab commands."));
2128 if (bfd_get_symcount (abfd
) > 0)
2130 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2133 /* Count the number of each kind of symbol. */
2134 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2136 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2137 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
2141 cmd
->iextdefsym
= i
;
2142 for (; i
< bfd_get_symcount (abfd
); ++i
)
2144 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2145 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
2148 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
2149 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
2150 cmd
->nundefsym
= bfd_get_symcount (abfd
)
2157 cmd
->iextdefsym
= 0;
2158 cmd
->nextdefsym
= 0;
2163 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
2164 if (cmd
->nindirectsyms
> 0)
2169 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2170 cmd
->indirectsymoff
= mdata
->filelen
;
2171 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
2173 if (cmd
->nindirectsyms
* 4 < cmd
->nindirectsyms
)
2175 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
2176 if (cmd
->indirect_syms
== NULL
)
2180 for (i
= 0; i
< mdata
->nsects
; ++i
)
2182 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2184 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2186 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2187 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2188 case BFD_MACH_O_S_SYMBOL_STUBS
:
2191 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2193 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2194 if (isyms
== NULL
|| num
== 0)
2196 /* Record the starting index in the reserved1 field. */
2198 for (j
= 0; j
< num
; j
++, n
++)
2200 if (isyms
[j
] == NULL
)
2201 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2202 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
2203 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
2204 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2205 | BFD_MACH_O_INDIRECT_SYM_ABS
;
2207 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2220 /* Write a dysymtab command.
2221 TODO: Possibly coalesce writes of smaller objects. */
2224 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2226 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2228 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2230 if (cmd
->nmodtab
!= 0)
2234 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2237 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2239 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2243 iinit
= module
->iinit
& 0xffff;
2244 iinit
|= ((module
->iterm
& 0xffff) << 16);
2246 ninit
= module
->ninit
& 0xffff;
2247 ninit
|= ((module
->nterm
& 0xffff) << 16);
2249 if (bfd_mach_o_wide_p (abfd
))
2251 struct mach_o_dylib_module_64_external w
;
2253 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2254 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2255 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2256 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2257 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2258 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2259 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2260 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2261 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2262 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2263 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2264 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2265 &w
.objc_module_info_addr
);
2266 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2267 &w
.objc_module_info_size
);
2269 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2274 struct mach_o_dylib_module_external n
;
2276 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2277 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2278 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2279 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2280 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2281 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2282 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2283 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2284 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2285 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2286 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2287 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2288 &n
.objc_module_info_addr
);
2289 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2290 &n
.objc_module_info_size
);
2292 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2302 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2305 for (i
= 0; i
< cmd
->ntoc
; i
++)
2307 struct mach_o_dylib_table_of_contents_external raw
;
2308 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2310 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2311 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2313 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2318 if (cmd
->nindirectsyms
> 0)
2322 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2325 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2327 unsigned char raw
[4];
2329 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2330 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2335 if (cmd
->nextrefsyms
!= 0)
2339 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2342 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2345 unsigned char raw
[4];
2346 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2348 /* Fields isym and flags are written as bit-fields, thus we need
2349 a specific processing for endianness. */
2351 if (bfd_big_endian (abfd
))
2353 v
= ((ref
->isym
& 0xffffff) << 8);
2354 v
|= ref
->flags
& 0xff;
2358 v
= ref
->isym
& 0xffffff;
2359 v
|= ((ref
->flags
& 0xff) << 24);
2362 bfd_h_put_32 (abfd
, v
, raw
);
2363 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2369 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2373 struct mach_o_dysymtab_command_external raw
;
2375 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2376 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2377 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2378 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2379 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2380 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2381 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2382 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2383 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2384 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2385 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2386 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2387 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2388 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2389 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2390 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2391 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2392 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2394 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2402 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2404 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2406 /* Just leave debug symbols where they are (pretend they are local, and
2407 then they will just be sorted on position). */
2408 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2411 /* Local (we should never see an undefined local AFAICT). */
2412 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2415 /* Common symbols look like undefined externs. */
2416 if (mtyp
== BFD_MACH_O_N_UNDF
)
2419 /* A defined non-local, non-debug symbol. */
2424 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2426 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2427 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2428 unsigned int soa
, sob
;
2430 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2431 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2438 /* If it's local or stab, just preserve the input order. */
2441 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2443 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2446 /* This is probably an error. */
2450 /* The second sort key is name. */
2451 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2454 /* Process the symbols.
2456 This should be OK for single-module files - but it is not likely to work
2457 for multi-module shared libraries.
2459 (a) If the application has not filled in the relevant mach-o fields, make
2462 (b) Order them, like this:
2465 ( ii) external defined
2467 (iii) external undefined/common
2474 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2477 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2479 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2482 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2484 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2486 /* We use this value, which is out-of-range as a symbol index, to signal
2487 that the mach-o-specific data are not filled in and need to be created
2488 from the bfd values. It is much preferable for the application to do
2489 this, since more meaningful diagnostics can be made that way. */
2491 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2493 /* No symbol information has been set - therefore determine
2494 it from the bfd symbol flags/info. */
2495 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2496 s
->n_type
= BFD_MACH_O_N_ABS
;
2497 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2499 s
->n_type
= BFD_MACH_O_N_UNDF
;
2500 if (s
->symbol
.flags
& BSF_WEAK
)
2501 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2502 /* mach-o automatically makes undefined symbols extern. */
2503 s
->n_type
|= BFD_MACH_O_N_EXT
;
2504 s
->symbol
.flags
|= BSF_GLOBAL
;
2506 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2508 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2509 s
->symbol
.flags
|= BSF_GLOBAL
;
2512 s
->n_type
= BFD_MACH_O_N_SECT
;
2515 /* Update external symbol bit in case objcopy changed it. */
2516 if (s
->symbol
.flags
& BSF_GLOBAL
)
2517 s
->n_type
|= BFD_MACH_O_N_EXT
;
2519 s
->n_type
&= ~BFD_MACH_O_N_EXT
;
2521 /* Put the section index in, where required. */
2522 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2523 && s
->symbol
.section
!= bfd_und_section_ptr
2524 && s
->symbol
.section
!= bfd_com_section_ptr
)
2525 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2526 && s
->symbol
.name
== NULL
))
2527 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2529 /* Number to preserve order for local and debug syms. */
2530 s
->symbol
.udata
.i
= i
;
2533 /* Sort the symbols. */
2534 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2535 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2537 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2539 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2540 s
->symbol
.udata
.i
= i
; /* renumber. */
2546 /* We build a flat table of sections, which can be re-ordered if necessary.
2547 Fill in the section number and other mach-o-specific data. */
2550 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2553 unsigned target_index
;
2557 nsect
= bfd_count_sections (abfd
);
2559 /* Don't do it if it's already set - assume the application knows what it's
2561 if (mdata
->nsects
== nsect
2562 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2565 /* We need to check that this can be done... */
2568 _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2569 " maximum is 255,\n"), nsect
);
2573 mdata
->nsects
= nsect
;
2574 if (_bfd_mul_overflow (mdata
->nsects
, sizeof (bfd_mach_o_section
*), &amt
))
2576 bfd_set_error (bfd_error_no_memory
);
2579 mdata
->sections
= bfd_alloc (abfd
, amt
);
2580 if (mdata
->sections
== NULL
)
2583 /* Create Mach-O sections.
2584 Section type, attribute and align should have been set when the
2585 section was created - either read in or specified. */
2587 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2589 unsigned bfd_align
= bfd_section_alignment (sec
);
2590 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2592 mdata
->sections
[target_index
] = msect
;
2594 msect
->addr
= bfd_section_vma (sec
);
2595 msect
->size
= bfd_section_size (sec
);
2597 /* Use the largest alignment set, in case it was bumped after the
2598 section was created. */
2599 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2602 sec
->target_index
= ++target_index
;
2609 bfd_mach_o_write_contents (bfd
*abfd
)
2611 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2612 bfd_mach_o_load_command
*cmd
;
2613 bfd_mach_o_symtab_command
*symtab
= NULL
;
2614 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2615 bfd_mach_o_segment_command
*linkedit
= NULL
;
2617 /* Make the commands, if not already present. */
2618 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2620 abfd
->output_has_begun
= TRUE
;
2622 /* Write the header. */
2623 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2626 /* First pass: allocate the linkedit segment. */
2627 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2630 case BFD_MACH_O_LC_SEGMENT_64
:
2631 case BFD_MACH_O_LC_SEGMENT
:
2632 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2633 linkedit
= &cmd
->command
.segment
;
2635 case BFD_MACH_O_LC_SYMTAB
:
2636 symtab
= &cmd
->command
.symtab
;
2638 case BFD_MACH_O_LC_DYSYMTAB
:
2639 dysymtab
= &cmd
->command
.dysymtab
;
2641 case BFD_MACH_O_LC_DYLD_INFO
:
2643 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2645 if (di
->rebase_size
!= 0)
2647 di
->rebase_off
= mdata
->filelen
;
2648 mdata
->filelen
+= di
->rebase_size
;
2650 if (di
->bind_size
!= 0)
2652 di
->bind_off
= mdata
->filelen
;
2653 mdata
->filelen
+= di
->bind_size
;
2655 if (di
->weak_bind_size
!= 0)
2657 di
->weak_bind_off
= mdata
->filelen
;
2658 mdata
->filelen
+= di
->weak_bind_size
;
2660 if (di
->lazy_bind_size
!= 0)
2662 di
->lazy_bind_off
= mdata
->filelen
;
2663 mdata
->filelen
+= di
->lazy_bind_size
;
2665 if (di
->export_size
!= 0)
2667 di
->export_off
= mdata
->filelen
;
2668 mdata
->filelen
+= di
->export_size
;
2672 case BFD_MACH_O_LC_LOAD_DYLIB
:
2673 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2674 case BFD_MACH_O_LC_MAIN
:
2675 /* Nothing to do. */
2679 (_("unable to allocate data for load command %#x"),
2684 /* Specially handle symtab and dysymtab. */
2686 /* Pre-allocate the symbol table (but not the string table). The reason
2687 is that the dysymtab is after the symbol table but before the string
2688 table (required by the native strip tool). */
2691 unsigned int symlen
;
2692 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2694 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2696 /* Align for symbols. */
2697 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2698 symtab
->symoff
= mdata
->filelen
;
2700 symtab
->nsyms
= bfd_get_symcount (abfd
);
2701 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2704 /* Build the dysymtab. */
2705 if (dysymtab
!= NULL
)
2706 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2709 /* Write symtab and strtab. */
2711 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2714 /* Adjust linkedit size. */
2715 if (linkedit
!= NULL
)
2717 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2719 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2720 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2721 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2723 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2724 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2725 | BFD_MACH_O_PROT_EXECUTE
;
2728 /* Second pass: write commands. */
2729 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2731 struct mach_o_load_command_external raw
;
2732 unsigned long typeflag
;
2734 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2736 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2737 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2739 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2740 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2745 case BFD_MACH_O_LC_SEGMENT
:
2746 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2749 case BFD_MACH_O_LC_SEGMENT_64
:
2750 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2753 case BFD_MACH_O_LC_SYMTAB
:
2754 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2757 case BFD_MACH_O_LC_DYSYMTAB
:
2758 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2761 case BFD_MACH_O_LC_THREAD
:
2762 case BFD_MACH_O_LC_UNIXTHREAD
:
2763 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2766 case BFD_MACH_O_LC_LOAD_DYLIB
:
2767 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2770 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2771 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2774 case BFD_MACH_O_LC_MAIN
:
2775 if (!bfd_mach_o_write_main (abfd
, cmd
))
2778 case BFD_MACH_O_LC_DYLD_INFO
:
2779 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2784 (_("unable to write unknown load command %#x"),
2794 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2795 bfd_mach_o_section
*s
)
2797 if (seg
->sect_head
== NULL
)
2800 seg
->sect_tail
->next
= s
;
2804 /* Create section Mach-O flags from BFD flags. */
2807 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2811 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2813 /* Create default flags. */
2814 bfd_flags
= bfd_section_flags (sec
);
2815 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2816 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2817 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2818 | BFD_MACH_O_S_REGULAR
;
2819 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2820 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2821 else if (bfd_flags
& SEC_DEBUGGING
)
2822 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2824 s
->flags
= BFD_MACH_O_S_REGULAR
;
2828 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2830 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2834 seg
->fileoff
= mdata
->filelen
;
2835 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2836 | BFD_MACH_O_PROT_EXECUTE
;
2837 seg
->maxprot
= seg
->initprot
;
2839 /* Append sections to the segment.
2841 This is a little tedious, we have to honor the need to account zerofill
2842 sections after all the rest. This forces us to do the calculation of
2843 total vmsize in three passes so that any alignment increments are
2844 properly accounted. */
2845 for (i
= 0; i
< mdata
->nsects
; ++i
)
2847 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2848 asection
*sec
= s
->bfdsection
;
2850 /* Although we account for zerofill section sizes in vm order, they are
2851 placed in the file in source sequence. */
2852 bfd_mach_o_append_section_to_segment (seg
, s
);
2855 /* Zerofill sections have zero file size & offset, the only content
2856 written to the file is the symbols. */
2857 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2858 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2859 == BFD_MACH_O_S_GB_ZEROFILL
))
2862 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2863 sections, even those with zero size. */
2866 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2867 seg
->vmsize
+= s
->size
;
2869 /* MH_OBJECT files have unaligned content. */
2872 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2873 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2875 seg
->filesize
+= s
->size
;
2877 /* The system tools write even zero-sized sections with an offset
2878 field set to the current file position. */
2879 s
->offset
= mdata
->filelen
;
2882 sec
->filepos
= s
->offset
;
2883 mdata
->filelen
+= s
->size
;
2886 /* Now pass through again, for zerofill, only now we just update the
2887 vmsize, and then for zerofill_GB. */
2888 for (j
= 0; j
< 2; j
++)
2893 stype
= BFD_MACH_O_S_ZEROFILL
;
2895 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2897 for (i
= 0; i
< mdata
->nsects
; ++i
)
2899 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2901 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2906 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2907 seg
->vmsize
+= s
->size
;
2912 /* Allocate space for the relocations. */
2913 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2915 for (i
= 0; i
< mdata
->nsects
; ++i
)
2917 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2918 asection
*sec
= ms
->bfdsection
;
2920 ms
->nreloc
= sec
->reloc_count
;
2921 if (ms
->nreloc
== 0)
2923 /* Clear nreloc and reloff if there is no relocs. */
2927 sec
->rel_filepos
= mdata
->filelen
;
2928 ms
->reloff
= sec
->rel_filepos
;
2929 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2936 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2938 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2940 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2942 bfd_mach_o_section
*s
;
2946 seg
->fileoff
= mdata
->filelen
;
2951 /* Append sections to the segment. We assume they are properly ordered
2952 by vma (but we check that). */
2954 for (i
= 0; i
< mdata
->nsects
; ++i
)
2956 s
= mdata
->sections
[i
];
2958 /* Consider only sections for this segment. */
2959 if (strcmp (seg
->segname
, s
->segname
) != 0)
2962 bfd_mach_o_append_section_to_segment (seg
, s
);
2967 /* xgettext:c-format */
2968 (_("section address (%#" PRIx64
") "
2969 "below start of segment (%#" PRIx64
")"),
2970 (uint64_t) s
->addr
, (uint64_t) vma
);
2974 vma
= s
->addr
+ s
->size
;
2977 /* Set segment file offset: make it page aligned. */
2978 vma
= seg
->sect_head
->addr
;
2979 seg
->vmaddr
= vma
& ~pagemask
;
2980 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2981 mdata
->filelen
+= pagemask
+ 1;
2982 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2983 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2985 /* Set section file offset. */
2986 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2988 asection
*sec
= s
->bfdsection
;
2989 flagword flags
= bfd_section_flags (sec
);
2991 /* Adjust segment size. */
2992 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2993 seg
->vmsize
+= s
->size
;
2995 /* File offset and length. */
2996 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2998 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
2999 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3000 != BFD_MACH_O_S_GB_ZEROFILL
))
3002 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
3004 s
->offset
= mdata
->filelen
;
3005 s
->bfdsection
->filepos
= s
->offset
;
3007 seg
->filesize
+= s
->size
;
3008 mdata
->filelen
+= s
->size
;
3013 s
->bfdsection
->filepos
= 0;
3016 /* Set protection. */
3017 if (flags
& SEC_LOAD
)
3019 if (flags
& SEC_CODE
)
3020 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
3021 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
3022 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
3025 /* Relocs shouldn't appear in non-object files. */
3026 if (s
->bfdsection
->reloc_count
!= 0)
3031 if (seg
->initprot
!= 0)
3032 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
3033 | BFD_MACH_O_PROT_EXECUTE
;
3037 /* Round segment size (and file size). */
3038 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
3039 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
3040 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
3045 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3046 fields in header. */
3049 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
3051 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3052 unsigned int hdrlen
;
3054 bfd_mach_o_load_command
*cmd
;
3056 bfd_boolean ret
= TRUE
;
3058 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3059 align
= wide
? 8 - 1 : 4 - 1;
3061 mdata
->header
.ncmds
= 0;
3063 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
3065 mdata
->header
.ncmds
++;
3066 cmd
->offset
= offset
;
3070 case BFD_MACH_O_LC_SEGMENT_64
:
3071 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
3072 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
3074 case BFD_MACH_O_LC_SEGMENT
:
3075 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
3076 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
3078 case BFD_MACH_O_LC_SYMTAB
:
3079 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
3080 + BFD_MACH_O_LC_SIZE
;
3082 case BFD_MACH_O_LC_DYSYMTAB
:
3083 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
3084 + BFD_MACH_O_LC_SIZE
;
3086 case BFD_MACH_O_LC_LOAD_DYLIB
:
3087 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
3088 + BFD_MACH_O_LC_SIZE
;
3089 cmd
->command
.dylib
.name_offset
= cmd
->len
;
3090 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
3091 cmd
->len
= (cmd
->len
+ align
) & ~align
;
3093 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3094 cmd
->len
= sizeof (struct mach_o_str_command_external
)
3095 + BFD_MACH_O_LC_SIZE
;
3096 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
3097 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
3098 cmd
->len
= (cmd
->len
+ align
) & ~align
;
3100 case BFD_MACH_O_LC_MAIN
:
3101 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
3102 + BFD_MACH_O_LC_SIZE
;
3104 case BFD_MACH_O_LC_DYLD_INFO
:
3105 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
3106 + BFD_MACH_O_LC_SIZE
;
3110 (_("unable to layout unknown load command %#x"),
3116 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
3119 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
3120 mdata
->filelen
= offset
;
3125 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3129 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
3130 bfd_mach_o_load_command
*cmd
,
3131 const char *segname
, unsigned int nbr_sect
)
3133 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3134 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3136 /* Init segment command. */
3137 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
3138 cmd
->type_required
= FALSE
;
3140 strcpy (seg
->segname
, segname
);
3141 seg
->nsects
= nbr_sect
;
3151 seg
->sect_head
= NULL
;
3152 seg
->sect_tail
= NULL
;
3155 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3156 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3157 and copy functionality. */
3160 bfd_mach_o_build_commands (bfd
*abfd
)
3162 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3163 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3164 unsigned int nbr_segcmd
= 0;
3165 bfd_mach_o_load_command
*commands
;
3166 unsigned int nbr_commands
;
3167 int symtab_idx
= -1;
3168 int dysymtab_idx
= -1;
3172 /* Return now if already built. */
3173 if (mdata
->header
.ncmds
!= 0)
3176 /* Fill in the file type, if not already set. */
3177 if (mdata
->header
.filetype
== 0)
3179 if (abfd
->flags
& EXEC_P
)
3180 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
3181 else if (abfd
->flags
& DYNAMIC
)
3182 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
3184 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
3187 /* If hasn't already been done, flatten sections list, and sort
3188 if/when required. Must be done before the symbol table is adjusted,
3189 since that depends on properly numbered sections. */
3190 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
3191 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
3194 /* Order the symbol table, fill-in/check mach-o specific fields and
3195 partition out any indirect symbols. */
3196 if (!bfd_mach_o_mangle_symbols (abfd
))
3199 /* Segment commands. */
3200 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3202 /* Only one segment for all the sections. But the segment is
3203 optional if there is no sections. */
3204 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
3208 bfd_mach_o_section
*prev_sect
= NULL
;
3210 /* One pagezero segment and one linkedit segment. */
3213 /* Create one segment for associated segment name in sections.
3214 Assume that sections with the same segment name are consecutive. */
3215 for (i
= 0; i
< mdata
->nsects
; i
++)
3217 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
3219 if (prev_sect
== NULL
3220 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
3223 prev_sect
= this_sect
;
3228 nbr_commands
= nbr_segcmd
;
3230 /* One command for the symbol table (only if there are symbols. */
3231 if (bfd_get_symcount (abfd
) > 0)
3232 symtab_idx
= nbr_commands
++;
3235 This is a rather crude test for whether we should build a dysymtab. */
3236 if (bfd_mach_o_should_emit_dysymtab ()
3237 && bfd_get_symcount (abfd
))
3239 /* If there should be a case where a dysymtab could be emitted without
3240 a symtab (seems improbable), this would need amending. */
3241 dysymtab_idx
= nbr_commands
++;
3244 /* Add an entry point command. */
3245 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3246 && bfd_get_start_address (abfd
) != 0)
3247 main_idx
= nbr_commands
++;
3249 /* Well, we must have a header, at least. */
3250 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3252 /* A bit unusual, but no content is valid;
3253 as -n empty.s -o empty.o */
3254 if (nbr_commands
== 0)
3256 /* Layout commands (well none...) and set headers command fields. */
3257 return bfd_mach_o_layout_commands (mdata
);
3260 /* Create commands for segments (and symtabs), prepend them. */
3261 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3262 if (commands
== NULL
)
3264 for (i
= 0; i
< nbr_commands
- 1; i
++)
3265 commands
[i
].next
= &commands
[i
+ 1];
3266 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3267 if (mdata
->first_command
== NULL
)
3268 mdata
->last_command
= &commands
[nbr_commands
- 1];
3269 mdata
->first_command
= &commands
[0];
3271 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3273 /* For object file, there is only one segment. */
3274 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3276 else if (nbr_segcmd
!= 0)
3278 bfd_mach_o_load_command
*cmd
;
3280 BFD_ASSERT (nbr_segcmd
>= 2);
3284 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3286 /* Segments from sections. */
3288 for (i
= 0; i
< mdata
->nsects
;)
3290 const char *segname
= mdata
->sections
[i
]->segname
;
3291 unsigned int nbr_sect
= 1;
3293 /* Count number of sections for this segment. */
3294 for (i
++; i
< mdata
->nsects
; i
++)
3295 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3300 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3305 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3308 if (symtab_idx
>= 0)
3310 /* Init symtab command. */
3311 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3313 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3314 cmd
->type_required
= FALSE
;
3317 /* If required, setup symtab command, see comment above about the quality
3319 if (dysymtab_idx
>= 0)
3321 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3323 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3324 cmd
->type_required
= FALSE
;
3327 /* Create the main command. */
3330 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3332 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3333 cmd
->type_required
= TRUE
;
3335 cmd
->command
.main
.entryoff
= 0;
3336 cmd
->command
.main
.stacksize
= 0;
3339 /* Layout commands. */
3340 if (! bfd_mach_o_layout_commands (mdata
))
3343 /* So, now we have sized the commands and the filelen set to that.
3344 Now we can build the segment command and set the section file offsets. */
3345 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3347 for (i
= 0; i
< nbr_segcmd
; i
++)
3348 if (!bfd_mach_o_build_obj_seg_command
3349 (abfd
, &commands
[i
].command
.segment
))
3356 /* Skip pagezero and linkedit segments. */
3357 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3359 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3361 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3364 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3365 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3368 /* Set the size of __PAGEZERO. */
3369 commands
[0].command
.segment
.vmsize
=
3370 commands
[1].command
.segment
.vmaddr
;
3372 /* Set the vma and fileoff of __LINKEDIT. */
3373 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3374 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3376 /* Set entry point (once segments have been laid out). */
3378 commands
[main_idx
].command
.main
.entryoff
=
3379 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3385 /* Set the contents of a section. */
3388 bfd_mach_o_set_section_contents (bfd
*abfd
,
3390 const void * location
,
3392 bfd_size_type count
)
3396 /* Trying to write the first section contents will trigger the creation of
3397 the load commands if they are not already present. */
3398 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3404 pos
= section
->filepos
+ offset
;
3405 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3406 || bfd_bwrite (location
, count
, abfd
) != count
)
3413 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3414 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3419 /* Make an empty symbol. This is required only because
3420 bfd_make_section_anyway wants to create a symbol for the section. */
3423 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3425 asymbol
*new_symbol
;
3427 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3428 if (new_symbol
== NULL
)
3430 new_symbol
->the_bfd
= abfd
;
3431 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3436 bfd_mach_o_read_header (bfd
*abfd
, file_ptr hdr_off
, bfd_mach_o_header
*header
)
3438 struct mach_o_header_external raw
;
3440 bfd_vma (*get32
) (const void *) = NULL
;
3442 /* Just read the magic number. */
3443 if (bfd_seek (abfd
, hdr_off
, SEEK_SET
) != 0
3444 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3447 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3449 header
->byteorder
= BFD_ENDIAN_BIG
;
3450 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3451 header
->version
= 1;
3454 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3456 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3457 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3458 header
->version
= 1;
3461 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3463 header
->byteorder
= BFD_ENDIAN_BIG
;
3464 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3465 header
->version
= 2;
3468 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3470 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3471 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3472 header
->version
= 2;
3477 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3481 /* Once the size of the header is known, read the full header. */
3482 size
= mach_o_wide_p (header
) ?
3483 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3485 if (bfd_seek (abfd
, hdr_off
, SEEK_SET
) != 0
3486 || bfd_bread (&raw
, size
, abfd
) != size
)
3489 header
->cputype
= (*get32
) (raw
.cputype
);
3490 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3491 header
->filetype
= (*get32
) (raw
.filetype
);
3492 header
->ncmds
= (*get32
) (raw
.ncmds
);
3493 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3494 header
->flags
= (*get32
) (raw
.flags
);
3496 if (mach_o_wide_p (header
))
3497 header
->reserved
= (*get32
) (raw
.reserved
);
3499 header
->reserved
= 0;
3505 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3507 bfd_mach_o_section
*s
;
3508 unsigned bfdalign
= bfd_section_alignment (sec
);
3510 s
= bfd_mach_o_get_mach_o_section (sec
);
3514 static const mach_o_section_name_xlat
* xlat
;
3516 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3519 sec
->used_by_bfd
= s
;
3520 s
->bfdsection
= sec
;
3522 /* Create the Darwin seg/sect name pair from the bfd name.
3523 If this is a canonical name for which a specific paiting exists
3524 there will also be defined flags, type, attribute and alignment
3526 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3529 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3530 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3532 bfd_set_section_alignment (sec
, s
->align
);
3533 bfd_flags
= bfd_section_flags (sec
);
3534 if (bfd_flags
== SEC_NO_FLAGS
)
3535 bfd_set_section_flags (sec
, xlat
->bfd_flags
);
3538 /* Create default flags. */
3539 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3542 return _bfd_generic_new_section_hook (abfd
, sec
);
3546 bfd_mach_o_init_section_from_mach_o (asection
*sec
, unsigned long prot
)
3549 bfd_mach_o_section
*section
;
3551 flags
= bfd_section_flags (sec
);
3552 section
= bfd_mach_o_get_mach_o_section (sec
);
3554 /* TODO: see if we should use the xlat system for doing this by
3555 preference and fall back to this for unknown sections. */
3557 if (flags
== SEC_NO_FLAGS
)
3559 /* Try to guess flags. */
3560 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3561 flags
= SEC_DEBUGGING
;
3565 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3566 != BFD_MACH_O_S_ZEROFILL
)
3569 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3571 if (prot
& BFD_MACH_O_PROT_WRITE
)
3573 else if (prot
& BFD_MACH_O_PROT_READ
)
3574 flags
|= SEC_READONLY
;
3580 if ((flags
& SEC_DEBUGGING
) == 0)
3584 if (section
->offset
!= 0)
3585 flags
|= SEC_HAS_CONTENTS
;
3586 if (section
->nreloc
!= 0)
3589 bfd_set_section_flags (sec
, flags
);
3591 sec
->vma
= section
->addr
;
3592 sec
->lma
= section
->addr
;
3593 sec
->size
= section
->size
;
3594 sec
->filepos
= section
->offset
;
3595 sec
->alignment_power
= section
->align
;
3596 sec
->segment_mark
= 0;
3597 sec
->reloc_count
= section
->nreloc
;
3598 sec
->rel_filepos
= section
->reloff
;
3602 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3603 const unsigned char *segname
,
3604 const unsigned char *sectname
)
3609 bfd_mach_o_convert_section_name_to_bfd
3610 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3614 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3618 bfd_mach_o_read_section_32 (bfd
*abfd
, unsigned long prot
)
3620 struct mach_o_section_32_external raw
;
3622 bfd_mach_o_section
*section
;
3624 if (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3625 != BFD_MACH_O_SECTION_SIZE
)
3628 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3632 section
= bfd_mach_o_get_mach_o_section (sec
);
3633 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3634 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3635 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3636 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3637 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3638 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3639 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3640 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3641 /* PR 17512: file: 0017eb76. */
3642 if (section
->align
> 64)
3645 (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx, "
3646 "using 32 instead"), section
->align
);
3647 section
->align
= 32;
3649 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3650 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3651 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3652 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3653 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3654 section
->reserved3
= 0;
3656 bfd_mach_o_init_section_from_mach_o (sec
, prot
);
3662 bfd_mach_o_read_section_64 (bfd
*abfd
, unsigned long prot
)
3664 struct mach_o_section_64_external raw
;
3666 bfd_mach_o_section
*section
;
3668 if (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3669 != BFD_MACH_O_SECTION_64_SIZE
)
3672 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3676 section
= bfd_mach_o_get_mach_o_section (sec
);
3677 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3678 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3679 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3680 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3681 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3682 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3683 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3684 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3685 if (section
->align
> 64)
3688 (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx, "
3689 "using 32 instead"), section
->align
);
3690 section
->align
= 32;
3692 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3693 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3694 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3695 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3696 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3697 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3699 bfd_mach_o_init_section_from_mach_o (sec
, prot
);
3705 bfd_mach_o_read_section (bfd
*abfd
, unsigned long prot
, unsigned int wide
)
3708 return bfd_mach_o_read_section_64 (abfd
, prot
);
3710 return bfd_mach_o_read_section_32 (abfd
, prot
);
3714 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3715 bfd_mach_o_symtab_command
*sym
,
3716 bfd_mach_o_asymbol
*s
,
3719 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3720 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3721 unsigned int symwidth
=
3722 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3723 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3724 struct mach_o_nlist_64_external raw
;
3725 unsigned char type
= -1;
3726 unsigned char section
= -1;
3728 symvalue value
= -1;
3729 unsigned long stroff
= -1;
3730 unsigned int symtype
= -1;
3732 BFD_ASSERT (sym
->strtab
!= NULL
);
3734 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3735 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3738 /* xgettext:c-format */
3739 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3744 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3745 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3746 symtype
= type
& BFD_MACH_O_N_TYPE
;
3747 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3748 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3750 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3752 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3754 if (stroff
>= sym
->strsize
)
3757 /* xgettext:c-format */
3758 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3764 s
->symbol
.the_bfd
= abfd
;
3765 s
->symbol
.name
= sym
->strtab
+ stroff
;
3766 s
->symbol
.value
= value
;
3767 s
->symbol
.flags
= 0x0;
3768 s
->symbol
.udata
.i
= i
;
3770 s
->n_sect
= section
;
3773 if (type
& BFD_MACH_O_N_STAB
)
3775 s
->symbol
.flags
|= BSF_DEBUGGING
;
3776 s
->symbol
.section
= bfd_und_section_ptr
;
3788 if ((section
> 0) && (section
<= mdata
->nsects
))
3790 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3792 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3799 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3800 s
->symbol
.flags
|= BSF_GLOBAL
;
3802 s
->symbol
.flags
|= BSF_LOCAL
;
3806 case BFD_MACH_O_N_UNDF
:
3807 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3808 && s
->symbol
.value
!= 0)
3810 /* A common symbol. */
3811 s
->symbol
.section
= bfd_com_section_ptr
;
3812 s
->symbol
.flags
= BSF_NO_FLAGS
;
3816 s
->symbol
.section
= bfd_und_section_ptr
;
3817 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3818 s
->symbol
.flags
|= BSF_WEAK
;
3821 case BFD_MACH_O_N_PBUD
:
3822 s
->symbol
.section
= bfd_und_section_ptr
;
3824 case BFD_MACH_O_N_ABS
:
3825 s
->symbol
.section
= bfd_abs_section_ptr
;
3827 case BFD_MACH_O_N_SECT
:
3828 if ((section
> 0) && (section
<= mdata
->nsects
))
3830 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3832 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3836 /* Mach-O uses 0 to mean "no section"; not an error. */
3840 /* xgettext:c-format */
3841 (_("bfd_mach_o_read_symtab_symbol: "
3842 "symbol \"%s\" specified invalid section %d (max %lu): "
3843 "setting to undefined"),
3844 s
->symbol
.name
, section
, mdata
->nsects
);
3846 s
->symbol
.section
= bfd_und_section_ptr
;
3849 case BFD_MACH_O_N_INDR
:
3850 /* FIXME: we don't follow the BFD convention as this indirect symbol
3851 won't be followed by the referenced one. This looks harmless
3852 unless we start using the linker. */
3853 s
->symbol
.flags
|= BSF_INDIRECT
;
3854 s
->symbol
.section
= bfd_ind_section_ptr
;
3855 s
->symbol
.value
= 0;
3859 /* xgettext:c-format */
3860 (_("bfd_mach_o_read_symtab_symbol: "
3861 "symbol \"%s\" specified invalid type field 0x%x: "
3862 "setting to undefined"), s
->symbol
.name
, symtype
);
3863 s
->symbol
.section
= bfd_und_section_ptr
;
3872 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3874 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3875 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3877 /* Fail if there is no symtab. */
3881 /* Success if already loaded. */
3885 if (abfd
->flags
& BFD_IN_MEMORY
)
3887 struct bfd_in_memory
*b
;
3889 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3891 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3893 bfd_set_error (bfd_error_file_truncated
);
3896 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3900 /* See PR 21840 for a reproducer. */
3901 if ((sym
->strsize
+ 1) == 0)
3903 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
3905 sym
->strtab
= (char *) _bfd_alloc_and_read (abfd
, sym
->strsize
+ 1,
3907 if (sym
->strtab
== NULL
)
3910 /* Zero terminate the string table. */
3911 sym
->strtab
[sym
->strsize
] = 0;
3918 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3920 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3921 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3925 if (sym
== NULL
|| sym
->symbols
)
3926 /* Return now if there are no symbols or if already loaded. */
3929 if (_bfd_mul_overflow (sym
->nsyms
, sizeof (bfd_mach_o_asymbol
), &amt
)
3930 || (sym
->symbols
= bfd_alloc (abfd
, amt
)) == NULL
)
3932 bfd_set_error (bfd_error_no_memory
);
3933 _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
3934 "unable to allocate memory for symbols"));
3939 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3942 for (i
= 0; i
< sym
->nsyms
; i
++)
3943 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3949 bfd_release (abfd
, sym
->symbols
);
3950 sym
->symbols
= NULL
;
3956 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3958 switch ((int) flavour
)
3960 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3961 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3962 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3963 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3964 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3965 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3966 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3967 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3968 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3969 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3970 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3971 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3972 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3973 default: return "UNKNOWN";
3978 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3980 switch ((int) flavour
)
3982 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3983 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3984 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3985 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3986 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3987 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3988 default: return "UNKNOWN";
3992 static unsigned char *
3993 bfd_mach_o_alloc_and_read (bfd
*abfd
, file_ptr filepos
, size_t size
)
3995 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3997 return _bfd_alloc_and_read (abfd
, size
, size
);
4001 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4003 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
4004 struct mach_o_str_command_external raw
;
4005 unsigned int nameoff
;
4006 unsigned int namelen
;
4008 if (command
->len
< sizeof (raw
) + 8)
4010 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4013 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
4014 if (nameoff
> command
->len
)
4017 cmd
->name_offset
= nameoff
;
4018 namelen
= command
->len
- nameoff
;
4019 nameoff
+= command
->offset
;
4020 cmd
->name_str
= (char *) bfd_mach_o_alloc_and_read (abfd
, nameoff
, namelen
);
4021 return cmd
->name_str
!= NULL
;
4025 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4027 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4028 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
4029 struct mach_o_dylib_command_external raw
;
4030 unsigned int nameoff
;
4031 unsigned int namelen
;
4034 if (command
->len
< sizeof (raw
) + 8)
4036 switch (command
->type
)
4038 case BFD_MACH_O_LC_LOAD_DYLIB
:
4039 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4040 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4041 case BFD_MACH_O_LC_ID_DYLIB
:
4042 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4043 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4050 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4053 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4054 if (nameoff
> command
->len
)
4056 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
4057 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
4058 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
4060 cmd
->name_offset
= command
->offset
+ nameoff
;
4061 namelen
= command
->len
- nameoff
;
4062 pos
= mdata
->hdr_offset
+ cmd
->name_offset
;
4063 cmd
->name_str
= (char *) bfd_mach_o_alloc_and_read (abfd
, pos
, namelen
);
4064 return cmd
->name_str
!= NULL
;
4068 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
4069 bfd_mach_o_load_command
*command
)
4071 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
4072 struct mach_o_prebound_dylib_command_external raw
;
4073 unsigned int nameoff
;
4074 unsigned int modoff
;
4075 unsigned int str_len
;
4078 if (command
->len
< sizeof (raw
) + 8)
4080 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4083 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4084 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
4085 if (nameoff
> command
->len
|| modoff
> command
->len
)
4088 str_len
= command
->len
- sizeof (raw
);
4089 str
= _bfd_alloc_and_read (abfd
, str_len
, str_len
);
4093 cmd
->name_offset
= command
->offset
+ nameoff
;
4094 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
4095 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
4097 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
4098 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
4103 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
4104 bfd_mach_o_load_command
*command
)
4106 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
4107 struct mach_o_prebind_cksum_command_external raw
;
4109 if (command
->len
< sizeof (raw
) + 8)
4111 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4114 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
4119 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
4120 bfd_mach_o_load_command
*command
)
4122 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
4123 struct mach_o_twolevel_hints_command_external raw
;
4125 if (command
->len
< sizeof (raw
) + 8)
4127 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4130 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
4131 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
4136 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4138 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
4139 struct mach_o_fvmlib_command_external raw
;
4140 unsigned int nameoff
;
4141 unsigned int namelen
;
4143 if (command
->len
< sizeof (raw
) + 8)
4145 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4148 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4149 if (nameoff
> command
->len
)
4151 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
4152 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
4154 fvm
->name_offset
= command
->offset
+ nameoff
;
4155 namelen
= command
->len
- nameoff
;
4156 fvm
->name_str
= (char *) bfd_mach_o_alloc_and_read (abfd
, fvm
->name_offset
,
4158 return fvm
->name_str
!= NULL
;
4162 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4164 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4165 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
4166 unsigned int offset
;
4167 unsigned int nflavours
;
4169 struct mach_o_thread_command_external raw
;
4172 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
4173 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
4175 /* Count the number of threads. */
4178 while (offset
+ sizeof (raw
) <= command
->len
)
4182 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4183 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4186 count
= bfd_h_get_32 (abfd
, raw
.count
);
4187 if (count
> (unsigned) -1 / 4
4188 || command
->len
- (offset
+ sizeof (raw
)) < count
* 4)
4190 offset
+= sizeof (raw
) + count
* 4;
4193 if (nflavours
== 0 || offset
!= command
->len
)
4196 /* Allocate threads. */
4197 if (_bfd_mul_overflow (nflavours
, sizeof (bfd_mach_o_thread_flavour
), &amt
))
4199 bfd_set_error (bfd_error_file_too_big
);
4202 cmd
->flavours
= bfd_alloc (abfd
, amt
);
4203 if (cmd
->flavours
== NULL
)
4205 cmd
->nflavours
= nflavours
;
4209 while (offset
!= command
->len
)
4211 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4212 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4215 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
4216 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
4217 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
4218 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
4222 for (i
= 0; i
< nflavours
; i
++)
4225 unsigned int snamelen
;
4227 const char *flavourstr
;
4228 const char *prefix
= "LC_THREAD";
4231 switch (mdata
->header
.cputype
)
4233 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4234 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
4236 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
4238 case BFD_MACH_O_CPU_TYPE_I386
:
4239 case BFD_MACH_O_CPU_TYPE_X86_64
:
4241 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
4244 flavourstr
= "UNKNOWN_ARCHITECTURE";
4248 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
4249 sname
= bfd_alloc (abfd
, snamelen
);
4255 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
4256 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
4261 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
4265 bfdsec
->size
= cmd
->flavours
[i
].size
;
4266 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
4267 bfdsec
->alignment_power
= 0x0;
4269 cmd
->section
= bfdsec
;
4276 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4278 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4279 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4281 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4284 struct mach_o_dysymtab_command_external raw
;
4286 if (command
->len
< sizeof (raw
) + 8)
4288 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4291 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4292 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4293 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4294 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4295 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4296 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4297 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4298 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4299 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4300 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4301 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4302 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4303 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4304 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4305 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4306 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4307 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4308 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4311 if (cmd
->nmodtab
!= 0)
4314 int wide
= bfd_mach_o_wide_p (abfd
);
4315 unsigned int module_len
= wide
? 56 : 52;
4318 if (_bfd_mul_overflow (cmd
->nmodtab
,
4319 sizeof (bfd_mach_o_dylib_module
), &amt
))
4321 bfd_set_error (bfd_error_file_too_big
);
4324 cmd
->dylib_module
= bfd_alloc (abfd
, amt
);
4325 if (cmd
->dylib_module
== NULL
)
4328 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4331 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4333 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4335 unsigned char buf
[56];
4337 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4340 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4341 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4342 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4343 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4344 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4345 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4346 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4347 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4348 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4349 v
= bfd_h_get_32 (abfd
, buf
+36);
4350 module
->iinit
= v
& 0xffff;
4351 module
->iterm
= (v
>> 16) & 0xffff;
4352 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4353 module
->ninit
= v
& 0xffff;
4354 module
->nterm
= (v
>> 16) & 0xffff;
4357 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4358 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4362 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4363 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4373 if (_bfd_mul_overflow (cmd
->ntoc
,
4374 sizeof (bfd_mach_o_dylib_table_of_content
), &amt
))
4376 bfd_set_error (bfd_error_file_too_big
);
4379 cmd
->dylib_toc
= bfd_alloc (abfd
, amt
);
4380 if (cmd
->dylib_toc
== NULL
)
4383 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4386 for (i
= 0; i
< cmd
->ntoc
; i
++)
4388 struct mach_o_dylib_table_of_contents_external raw
;
4389 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4391 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4394 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4395 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4399 if (cmd
->nindirectsyms
!= 0)
4404 if (_bfd_mul_overflow (cmd
->nindirectsyms
, sizeof (unsigned int), &amt
))
4406 bfd_set_error (bfd_error_file_too_big
);
4409 cmd
->indirect_syms
= bfd_alloc (abfd
, amt
);
4410 if (cmd
->indirect_syms
== NULL
)
4413 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4416 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4418 unsigned char raw
[4];
4419 unsigned int *is
= &cmd
->indirect_syms
[i
];
4421 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4424 *is
= bfd_h_get_32 (abfd
, raw
);
4428 if (cmd
->nextrefsyms
!= 0)
4434 if (_bfd_mul_overflow (cmd
->nextrefsyms
,
4435 sizeof (bfd_mach_o_dylib_reference
), &amt
))
4437 bfd_set_error (bfd_error_file_too_big
);
4440 cmd
->ext_refs
= bfd_alloc (abfd
, amt
);
4441 if (cmd
->ext_refs
== NULL
)
4444 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4447 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4449 unsigned char raw
[4];
4450 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4452 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4455 /* Fields isym and flags are written as bit-fields, thus we need
4456 a specific processing for endianness. */
4457 v
= bfd_h_get_32 (abfd
, raw
);
4458 if (bfd_big_endian (abfd
))
4460 ref
->isym
= (v
>> 8) & 0xffffff;
4461 ref
->flags
= v
& 0xff;
4465 ref
->isym
= v
& 0xffffff;
4466 ref
->flags
= (v
>> 24) & 0xff;
4471 if (mdata
->dysymtab
)
4473 mdata
->dysymtab
= cmd
;
4479 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4481 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4482 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4483 struct mach_o_symtab_command_external raw
;
4485 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4487 if (command
->len
< sizeof (raw
) + 8)
4489 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4492 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4493 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4494 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4495 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4496 symtab
->symbols
= NULL
;
4497 symtab
->strtab
= NULL
;
4499 if (symtab
->nsyms
!= 0)
4500 abfd
->flags
|= HAS_SYMS
;
4504 mdata
->symtab
= symtab
;
4509 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4511 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4513 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4515 if (command
->len
< 16 + 8)
4517 if (bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4524 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4526 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4527 struct mach_o_linkedit_data_command_external raw
;
4529 if (command
->len
< sizeof (raw
) + 8)
4531 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4534 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4535 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4540 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4542 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4543 struct mach_o_str_command_external raw
;
4546 if (command
->len
< sizeof (raw
) + 8)
4548 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4551 off
= bfd_get_32 (abfd
, raw
.str
);
4552 if (off
> command
->len
)
4555 cmd
->stroff
= command
->offset
+ off
;
4556 cmd
->str_len
= command
->len
- off
;
4557 cmd
->str
= (char *) bfd_mach_o_alloc_and_read (abfd
, cmd
->stroff
,
4559 return cmd
->str
!= NULL
;
4563 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4565 /* Read rebase content. */
4566 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4569 = bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4570 if (cmd
->rebase_content
== NULL
)
4574 /* Read bind content. */
4575 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4578 = bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4579 if (cmd
->bind_content
== NULL
)
4583 /* Read weak bind content. */
4584 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4586 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4587 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4588 if (cmd
->weak_bind_content
== NULL
)
4592 /* Read lazy bind content. */
4593 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4595 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4596 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4597 if (cmd
->lazy_bind_content
== NULL
)
4601 /* Read export content. */
4602 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4604 cmd
->export_content
= bfd_mach_o_alloc_and_read
4605 (abfd
, cmd
->export_off
, cmd
->export_size
);
4606 if (cmd
->export_content
== NULL
)
4614 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4616 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4617 struct mach_o_dyld_info_command_external raw
;
4619 if (command
->len
< sizeof (raw
) + 8)
4621 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4624 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4625 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4626 cmd
->rebase_content
= NULL
;
4627 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4628 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4629 cmd
->bind_content
= NULL
;
4630 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4631 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4632 cmd
->weak_bind_content
= NULL
;
4633 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4634 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4635 cmd
->lazy_bind_content
= NULL
;
4636 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4637 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4638 cmd
->export_content
= NULL
;
4643 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4645 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4646 struct mach_o_version_min_command_external raw
;
4648 if (command
->len
< sizeof (raw
) + 8)
4650 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4653 cmd
->version
= bfd_get_32 (abfd
, raw
.version
);
4654 cmd
->sdk
= bfd_get_32 (abfd
, raw
.sdk
);
4659 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4661 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4662 struct mach_o_encryption_info_command_external raw
;
4664 if (command
->len
< sizeof (raw
) + 8)
4666 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4669 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4670 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4671 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4676 bfd_mach_o_read_encryption_info_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4678 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4679 struct mach_o_encryption_info_64_command_external raw
;
4681 if (command
->len
< sizeof (raw
) + 8)
4683 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4686 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4687 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4688 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4693 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4695 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4696 struct mach_o_entry_point_command_external raw
;
4698 if (command
->len
< sizeof (raw
) + 8)
4700 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4703 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4704 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4709 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4711 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4712 struct mach_o_source_version_command_external raw
;
4715 if (command
->len
< sizeof (raw
) + 8)
4717 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4720 ver
= bfd_get_64 (abfd
, raw
.version
);
4721 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4722 generates warnings) in case of the host doesn't support 64 bit
4724 cmd
->e
= ver
& 0x3ff;
4726 cmd
->d
= ver
& 0x3ff;
4728 cmd
->c
= ver
& 0x3ff;
4730 cmd
->b
= ver
& 0x3ff;
4732 cmd
->a
= ver
& 0xffffff;
4737 bfd_mach_o_read_note (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4739 bfd_mach_o_note_command
*cmd
= &command
->command
.note
;
4740 struct mach_o_note_command_external raw
;
4742 if (command
->len
< sizeof (raw
) + 8)
4744 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4747 memcpy (cmd
->data_owner
, raw
.data_owner
, 16);
4748 cmd
->offset
= bfd_get_64 (abfd
, raw
.offset
);
4749 cmd
->size
= bfd_get_64 (abfd
, raw
.size
);
4754 bfd_mach_o_read_build_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4756 bfd_mach_o_build_version_command
*cmd
= &command
->command
.build_version
;
4757 struct mach_o_build_version_command_external raw
;
4759 if (command
->len
< sizeof (raw
) + 8)
4761 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4764 cmd
->platform
= bfd_get_32 (abfd
, raw
.platform
);
4765 cmd
->minos
= bfd_get_32 (abfd
, raw
.minos
);
4766 cmd
->sdk
= bfd_get_32 (abfd
, raw
.sdk
);
4767 cmd
->ntools
= bfd_get_32 (abfd
, raw
.ntools
);
4772 bfd_mach_o_read_segment (bfd
*abfd
,
4773 bfd_mach_o_load_command
*command
,
4776 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4781 struct mach_o_segment_command_64_external raw
;
4783 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4785 if (command
->len
< sizeof (raw
) + 8)
4787 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4790 memcpy (seg
->segname
, raw
.segname
, 16);
4791 seg
->segname
[16] = '\0';
4793 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4794 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4795 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4796 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4797 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4798 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4799 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4800 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4804 struct mach_o_segment_command_32_external raw
;
4806 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4808 if (command
->len
< sizeof (raw
) + 8)
4810 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4813 memcpy (seg
->segname
, raw
.segname
, 16);
4814 seg
->segname
[16] = '\0';
4816 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4817 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4818 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4819 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4820 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4821 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4822 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4823 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4825 seg
->sect_head
= NULL
;
4826 seg
->sect_tail
= NULL
;
4828 for (i
= 0; i
< seg
->nsects
; i
++)
4832 sec
= bfd_mach_o_read_section (abfd
, seg
->initprot
, wide
);
4836 bfd_mach_o_append_section_to_segment
4837 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4844 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4846 return bfd_mach_o_read_segment (abfd
, command
, 0);
4850 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4852 return bfd_mach_o_read_segment (abfd
, command
, 1);
4856 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4858 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4859 struct mach_o_load_command_external raw
;
4862 /* Read command type and length. */
4863 if (bfd_seek (abfd
, mdata
->hdr_offset
+ command
->offset
, SEEK_SET
) != 0
4864 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4867 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4868 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4869 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4870 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4871 if (command
->len
< 8 || command
->len
% 4 != 0)
4874 switch (command
->type
)
4876 case BFD_MACH_O_LC_SEGMENT
:
4877 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4880 case BFD_MACH_O_LC_SEGMENT_64
:
4881 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4884 case BFD_MACH_O_LC_SYMTAB
:
4885 if (!bfd_mach_o_read_symtab (abfd
, command
))
4888 case BFD_MACH_O_LC_SYMSEG
:
4890 case BFD_MACH_O_LC_THREAD
:
4891 case BFD_MACH_O_LC_UNIXTHREAD
:
4892 if (!bfd_mach_o_read_thread (abfd
, command
))
4895 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4896 case BFD_MACH_O_LC_ID_DYLINKER
:
4897 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4898 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4901 case BFD_MACH_O_LC_LOAD_DYLIB
:
4902 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4903 case BFD_MACH_O_LC_ID_DYLIB
:
4904 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4905 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4906 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4907 if (!bfd_mach_o_read_dylib (abfd
, command
))
4910 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4911 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4914 case BFD_MACH_O_LC_LOADFVMLIB
:
4915 case BFD_MACH_O_LC_IDFVMLIB
:
4916 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4919 case BFD_MACH_O_LC_IDENT
:
4920 case BFD_MACH_O_LC_FVMFILE
:
4921 case BFD_MACH_O_LC_PREPAGE
:
4922 case BFD_MACH_O_LC_ROUTINES
:
4923 case BFD_MACH_O_LC_ROUTINES_64
:
4925 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4926 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4927 case BFD_MACH_O_LC_SUB_LIBRARY
:
4928 case BFD_MACH_O_LC_SUB_CLIENT
:
4929 case BFD_MACH_O_LC_RPATH
:
4930 if (!bfd_mach_o_read_str (abfd
, command
))
4933 case BFD_MACH_O_LC_DYSYMTAB
:
4934 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4937 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4938 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4941 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4942 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4945 case BFD_MACH_O_LC_UUID
:
4946 if (!bfd_mach_o_read_uuid (abfd
, command
))
4949 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4950 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4951 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4952 case BFD_MACH_O_LC_DATA_IN_CODE
:
4953 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4954 case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT
:
4955 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4958 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4959 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4962 case BFD_MACH_O_LC_ENCRYPTION_INFO_64
:
4963 if (!bfd_mach_o_read_encryption_info_64 (abfd
, command
))
4966 case BFD_MACH_O_LC_DYLD_INFO
:
4967 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
4970 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4971 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4972 case BFD_MACH_O_LC_VERSION_MIN_WATCHOS
:
4973 case BFD_MACH_O_LC_VERSION_MIN_TVOS
:
4974 if (!bfd_mach_o_read_version_min (abfd
, command
))
4977 case BFD_MACH_O_LC_MAIN
:
4978 if (!bfd_mach_o_read_main (abfd
, command
))
4981 case BFD_MACH_O_LC_SOURCE_VERSION
:
4982 if (!bfd_mach_o_read_source_version (abfd
, command
))
4985 case BFD_MACH_O_LC_LINKER_OPTIONS
:
4987 case BFD_MACH_O_LC_NOTE
:
4988 if (!bfd_mach_o_read_note (abfd
, command
))
4991 case BFD_MACH_O_LC_BUILD_VERSION
:
4992 if (!bfd_mach_o_read_build_version (abfd
, command
))
4997 _bfd_error_handler (_("%pB: unknown load command %#x"),
4998 abfd
, command
->type
);
5006 bfd_mach_o_flatten_sections (bfd
*abfd
)
5008 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5009 bfd_mach_o_load_command
*cmd
;
5013 /* Count total number of sections. */
5016 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5018 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
5019 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
5021 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
5023 mdata
->nsects
+= seg
->nsects
;
5027 /* Allocate sections array. */
5028 if (_bfd_mul_overflow (mdata
->nsects
, sizeof (bfd_mach_o_section
*), &amt
))
5030 bfd_set_error (bfd_error_file_too_big
);
5033 mdata
->sections
= bfd_alloc (abfd
, amt
);
5034 if (mdata
->sections
== NULL
&& mdata
->nsects
!= 0)
5037 /* Fill the array. */
5040 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5042 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
5043 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
5045 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
5046 bfd_mach_o_section
*sec
;
5048 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
5050 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
5051 mdata
->sections
[csect
++] = sec
;
5058 bfd_mach_o_scan_start_address (bfd
*abfd
)
5060 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5061 bfd_mach_o_thread_command
*thr
= NULL
;
5062 bfd_mach_o_load_command
*cmd
;
5065 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5066 if (cmd
->type
== BFD_MACH_O_LC_THREAD
5067 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
5069 thr
= &cmd
->command
.thread
;
5072 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
5074 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
5075 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
5079 abfd
->start_address
= main_cmd
->entryoff
5080 + (text_sect
->addr
- text_sect
->offset
);
5085 /* An object file has no start address, so do not fail if not found. */
5089 /* FIXME: create a subtarget hook ? */
5090 for (i
= 0; i
< thr
->nflavours
; i
++)
5092 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
5093 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
5095 unsigned char buf
[4];
5097 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
5098 || bfd_bread (buf
, 4, abfd
) != 4)
5101 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
5103 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
5104 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
5106 unsigned char buf
[4];
5108 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
5109 || bfd_bread (buf
, 4, abfd
) != 4)
5112 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
5114 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
5115 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
5117 unsigned char buf
[8];
5119 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
5120 || bfd_bread (buf
, 8, abfd
) != 8)
5123 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
5125 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
5126 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
5128 unsigned char buf
[8];
5130 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
5131 || bfd_bread (buf
, 8, abfd
) != 8)
5134 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
5142 bfd_mach_o_set_arch_mach (bfd
*abfd
,
5143 enum bfd_architecture arch
,
5144 unsigned long machine
)
5146 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5148 /* If this isn't the right architecture for this backend, and this
5149 isn't the generic backend, fail. */
5150 if (arch
!= bed
->arch
5151 && arch
!= bfd_arch_unknown
5152 && bed
->arch
!= bfd_arch_unknown
)
5155 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5159 bfd_mach_o_scan (bfd
*abfd
,
5160 bfd_mach_o_header
*header
,
5161 bfd_mach_o_data_struct
*mdata
)
5164 enum bfd_architecture cpu_type
;
5165 unsigned long cpu_subtype
;
5166 unsigned int hdrsize
;
5168 hdrsize
= mach_o_wide_p (header
) ?
5169 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
5171 mdata
->header
= *header
;
5173 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
5174 switch (header
->filetype
)
5176 case BFD_MACH_O_MH_OBJECT
:
5177 abfd
->flags
|= HAS_RELOC
;
5179 case BFD_MACH_O_MH_EXECUTE
:
5180 abfd
->flags
|= EXEC_P
;
5182 case BFD_MACH_O_MH_DYLIB
:
5183 case BFD_MACH_O_MH_BUNDLE
:
5184 abfd
->flags
|= DYNAMIC
;
5188 abfd
->tdata
.mach_o_data
= mdata
;
5190 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
5191 &cpu_type
, &cpu_subtype
);
5192 if (cpu_type
== bfd_arch_unknown
)
5195 /* xgettext:c-format */
5196 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5197 header
->cputype
, header
->cpusubtype
);
5201 bfd_set_arch_mach (abfd
, cpu_type
, cpu_subtype
);
5203 if (header
->ncmds
!= 0)
5205 bfd_mach_o_load_command
*cmd
;
5208 mdata
->first_command
= NULL
;
5209 mdata
->last_command
= NULL
;
5211 if (_bfd_mul_overflow (header
->ncmds
,
5212 sizeof (bfd_mach_o_load_command
), &amt
))
5214 bfd_set_error (bfd_error_file_too_big
);
5217 cmd
= bfd_alloc (abfd
, amt
);
5221 for (i
= 0; i
< header
->ncmds
; i
++)
5223 bfd_mach_o_load_command
*cur
= &cmd
[i
];
5225 bfd_mach_o_append_command (abfd
, cur
);
5228 cur
->offset
= hdrsize
;
5231 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
5232 cur
->offset
= prev
->offset
+ prev
->len
;
5235 if (!bfd_mach_o_read_command (abfd
, cur
))
5240 /* Sections should be flatten before scanning start address. */
5241 if (!bfd_mach_o_flatten_sections (abfd
))
5243 if (!bfd_mach_o_scan_start_address (abfd
))
5250 bfd_mach_o_mkobject_init (bfd
*abfd
)
5252 bfd_mach_o_data_struct
*mdata
= NULL
;
5254 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
5257 abfd
->tdata
.mach_o_data
= mdata
;
5259 mdata
->header
.magic
= 0;
5260 mdata
->header
.cputype
= 0;
5261 mdata
->header
.cpusubtype
= 0;
5262 mdata
->header
.filetype
= 0;
5263 mdata
->header
.ncmds
= 0;
5264 mdata
->header
.sizeofcmds
= 0;
5265 mdata
->header
.flags
= 0;
5266 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
5267 mdata
->first_command
= NULL
;
5268 mdata
->last_command
= NULL
;
5270 mdata
->sections
= NULL
;
5271 mdata
->dyn_reloc_cache
= NULL
;
5277 bfd_mach_o_gen_mkobject (bfd
*abfd
)
5279 bfd_mach_o_data_struct
*mdata
;
5281 if (!bfd_mach_o_mkobject_init (abfd
))
5284 mdata
= bfd_mach_o_get_data (abfd
);
5285 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
5286 mdata
->header
.cputype
= 0;
5287 mdata
->header
.cpusubtype
= 0;
5288 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
5289 mdata
->header
.version
= 1;
5295 bfd_mach_o_header_p (bfd
*abfd
,
5297 bfd_mach_o_filetype file_type
,
5298 bfd_mach_o_cpu_type cpu_type
)
5300 bfd_mach_o_header header
;
5301 bfd_mach_o_data_struct
*mdata
;
5303 if (!bfd_mach_o_read_header (abfd
, hdr_off
, &header
))
5306 if (! (header
.byteorder
== BFD_ENDIAN_BIG
5307 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
5309 _bfd_error_handler (_("unknown header byte-order value %#x"),
5314 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
5315 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
5316 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
5317 || (header
.byteorder
== BFD_ENDIAN_LITTLE
5318 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
5319 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
5322 /* Check cputype and filetype.
5323 In case of wildcard, do not accept magics that are handled by existing
5327 if (header
.cputype
!= cpu_type
)
5333 /* Do not recognize 64 architectures if not configured for 64bit targets.
5334 This could happen only for generic targets. */
5335 if (mach_o_wide_p (&header
))
5342 if (header
.filetype
!= file_type
)
5347 switch (header
.filetype
)
5349 case BFD_MACH_O_MH_CORE
:
5350 /* Handled by core_p */
5357 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
5360 mdata
->hdr_offset
= hdr_off
;
5362 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
5368 bfd_set_error (bfd_error_wrong_format
);
5374 static const bfd_target
*
5375 bfd_mach_o_gen_object_p (bfd
*abfd
)
5377 return bfd_mach_o_header_p (abfd
, 0, 0, 0);
5380 static const bfd_target
*
5381 bfd_mach_o_gen_core_p (bfd
*abfd
)
5383 return bfd_mach_o_header_p (abfd
, 0, BFD_MACH_O_MH_CORE
, 0);
5386 /* Return the base address of ABFD, ie the address at which the image is
5387 mapped. The possible initial pagezero is ignored. */
5390 bfd_mach_o_get_base_address (bfd
*abfd
)
5392 bfd_mach_o_data_struct
*mdata
;
5393 bfd_mach_o_load_command
*cmd
;
5395 /* Check for Mach-O. */
5396 if (!bfd_mach_o_valid (abfd
))
5398 mdata
= bfd_mach_o_get_data (abfd
);
5400 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5402 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5403 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5405 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5407 if (segcmd
->initprot
!= 0)
5408 return segcmd
->vmaddr
;
5414 typedef struct mach_o_fat_archentry
5416 unsigned long cputype
;
5417 unsigned long cpusubtype
;
5418 unsigned long offset
;
5420 unsigned long align
;
5421 } mach_o_fat_archentry
;
5423 typedef struct mach_o_fat_data_struct
5425 unsigned long magic
;
5426 unsigned long nfat_arch
;
5427 mach_o_fat_archentry
*archentries
;
5428 } mach_o_fat_data_struct
;
5431 bfd_mach_o_fat_archive_p (bfd
*abfd
)
5433 mach_o_fat_data_struct
*adata
= NULL
;
5434 struct mach_o_fat_header_external hdr
;
5438 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5439 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5442 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5446 adata
->magic
= bfd_getb32 (hdr
.magic
);
5447 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5448 if (adata
->magic
!= 0xcafebabe)
5450 /* Avoid matching Java bytecode files, which have the same magic number.
5451 In the Java bytecode file format this field contains the JVM version,
5452 which starts at 43.0. */
5453 if (adata
->nfat_arch
> 30)
5456 if (_bfd_mul_overflow (adata
->nfat_arch
,
5457 sizeof (mach_o_fat_archentry
), &amt
))
5459 bfd_set_error (bfd_error_file_too_big
);
5462 adata
->archentries
= bfd_alloc (abfd
, amt
);
5463 if (adata
->archentries
== NULL
)
5466 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5468 struct mach_o_fat_arch_external arch
;
5469 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5471 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5472 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5473 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5474 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5475 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5478 abfd
->tdata
.mach_o_fat_data
= adata
;
5484 bfd_release (abfd
, adata
);
5485 bfd_set_error (bfd_error_wrong_format
);
5489 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5490 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5491 Set arelt_data and origin fields too. */
5494 bfd_mach_o_fat_member_init (bfd
*abfd
,
5495 enum bfd_architecture arch_type
,
5496 unsigned long arch_subtype
,
5497 mach_o_fat_archentry
*entry
)
5499 struct areltdata
*areltdata
;
5500 /* Create the member filename. Use ARCH_NAME. */
5501 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5506 /* Use the architecture name if known. */
5507 filename
= bfd_strdup (ap
->printable_name
);
5508 if (filename
== NULL
)
5513 /* Forge a uniq id. */
5514 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5515 filename
= bfd_malloc (namelen
);
5516 if (filename
== NULL
)
5518 snprintf (filename
, namelen
, "0x%lx-0x%lx",
5519 entry
->cputype
, entry
->cpusubtype
);
5521 bfd_set_filename (abfd
, filename
);
5523 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5524 if (areltdata
== NULL
)
5526 areltdata
->parsed_size
= entry
->size
;
5527 abfd
->arelt_data
= areltdata
;
5528 abfd
->iostream
= NULL
;
5529 abfd
->origin
= entry
->offset
;
5534 bfd_mach_o_fat_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5536 mach_o_fat_data_struct
*adata
;
5537 mach_o_fat_archentry
*entry
= NULL
;
5540 enum bfd_architecture arch_type
;
5541 unsigned long arch_subtype
;
5543 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5544 BFD_ASSERT (adata
!= NULL
);
5546 /* Find index of previous entry. */
5549 /* Start at first one. */
5554 /* Find index of PREV. */
5555 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5557 if (adata
->archentries
[i
].offset
== prev
->origin
)
5561 if (i
== adata
->nfat_arch
)
5564 bfd_set_error (bfd_error_bad_value
);
5568 /* Get next entry. */
5572 if (i
>= adata
->nfat_arch
)
5574 bfd_set_error (bfd_error_no_more_archived_files
);
5578 entry
= &adata
->archentries
[i
];
5579 nbfd
= _bfd_new_bfd_contained_in (archive
);
5583 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5584 &arch_type
, &arch_subtype
);
5586 if (!bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
))
5592 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5597 /* Analogous to stat call. */
5600 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5602 if (abfd
->arelt_data
== NULL
)
5604 bfd_set_error (bfd_error_invalid_operation
);
5611 buf
->st_mode
= 0644;
5612 buf
->st_size
= arelt_size (abfd
);
5617 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5618 If ABFD is a fat image containing a member that corresponds to FORMAT
5619 and ARCH, returns it.
5620 In other case, returns NULL.
5621 This function allows transparent uses of fat images. */
5624 bfd_mach_o_fat_extract (bfd
*abfd
,
5626 const bfd_arch_info_type
*arch
)
5629 mach_o_fat_data_struct
*adata
;
5632 if (bfd_check_format (abfd
, format
))
5634 if (bfd_get_arch_info (abfd
) == arch
)
5638 if (!bfd_check_format (abfd
, bfd_archive
)
5639 || abfd
->xvec
!= &mach_o_fat_vec
)
5642 /* This is a Mach-O fat image. */
5643 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5644 BFD_ASSERT (adata
!= NULL
);
5646 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5648 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5649 enum bfd_architecture cpu_type
;
5650 unsigned long cpu_subtype
;
5652 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5653 &cpu_type
, &cpu_subtype
);
5654 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5657 /* The architecture is found. */
5658 res
= _bfd_new_bfd_contained_in (abfd
);
5662 if (bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
)
5663 && bfd_check_format (res
, format
))
5665 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5676 bfd_mach_o_fat_close_and_cleanup (bfd
*abfd
)
5678 _bfd_unlink_from_archive_parent (abfd
);
5683 bfd_mach_o_lookup_command (bfd
*abfd
,
5684 bfd_mach_o_load_command_type type
,
5685 bfd_mach_o_load_command
**mcommand
)
5687 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5688 struct bfd_mach_o_load_command
*cmd
;
5691 BFD_ASSERT (mdata
!= NULL
);
5692 BFD_ASSERT (mcommand
!= NULL
);
5695 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5697 if (cmd
->type
!= type
)
5709 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5713 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5715 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5717 case BFD_MACH_O_CPU_TYPE_I386
:
5719 case BFD_MACH_O_CPU_TYPE_SPARC
:
5721 case BFD_MACH_O_CPU_TYPE_HPPA
:
5722 return 0xc0000000 - 0x04000000;
5728 /* The following two tables should be kept, as far as possible, in order of
5729 most frequently used entries to optimize their use from gas. */
5731 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5733 { "regular", BFD_MACH_O_S_REGULAR
},
5734 { "coalesced", BFD_MACH_O_S_COALESCED
},
5735 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5736 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5737 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5738 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5739 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5740 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5741 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5742 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5743 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5744 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5745 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5746 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5747 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5748 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5749 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5753 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5755 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5756 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5757 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5758 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5759 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5760 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5761 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5762 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5763 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5764 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5765 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5769 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5772 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5774 const bfd_mach_o_xlat_name
*x
;
5775 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5777 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5778 if (strcmp (x
->name
, name
) == 0)
5780 /* We found it... does the target support it? */
5781 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5782 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5783 return x
->val
; /* OK. */
5785 break; /* Not supported. */
5787 /* Maximum section ID = 0xff. */
5791 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5794 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5796 const bfd_mach_o_xlat_name
*x
;
5798 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5799 if (strcmp (x
->name
, name
) == 0)
5801 return (unsigned int)-1;
5805 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5806 unsigned char **rbuf
,
5809 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5810 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5811 bfd_mach_o_load_command
*cmd
;
5813 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5815 bfd_mach_o_segment_command
*seg
;
5817 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5820 seg
= &cmd
->command
.segment
;
5822 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5824 unsigned long start
= seg
->fileoff
;
5825 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5826 unsigned char *buf
= bfd_malloc (1024);
5827 unsigned long size
= 1024;
5833 bfd_size_type nread
= 0;
5834 unsigned long offset
;
5835 int found_nonnull
= 0;
5837 if (size
> (end
- start
))
5838 size
= (end
- start
);
5840 buf
= bfd_realloc_or_free (buf
, size
);
5844 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5850 nread
= bfd_bread (buf
, size
, abfd
);
5858 for (offset
= 4; offset
<= size
; offset
+= 4)
5862 val
= *((unsigned long *) (buf
+ size
- offset
));
5863 if (! found_nonnull
)
5868 else if (val
== 0x0)
5870 unsigned long bottom
;
5873 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5874 top
= seg
->fileoff
+ seg
->filesize
- 4;
5875 *rbuf
= bfd_malloc (top
- bottom
);
5878 *rlen
= top
- bottom
;
5880 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5886 if (size
== (end
- start
))
5900 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5902 unsigned char *buf
= NULL
;
5903 unsigned int len
= 0;
5906 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5910 return (char *) buf
;
5914 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5919 static bfd_mach_o_uuid_command
*
5920 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5922 bfd_mach_o_load_command
*uuid_cmd
= NULL
;
5923 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5924 if (ncmd
!= 1 || uuid_cmd
== NULL
)
5926 return &uuid_cmd
->command
.uuid
;
5929 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5932 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5934 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5937 BFD_ASSERT (uuid_cmd
);
5939 if (!bfd_check_format (abfd
, bfd_object
))
5942 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5943 || bfd_mach_o_get_data (abfd
) == NULL
5944 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5947 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5948 if (dsym_uuid_cmd
== NULL
)
5951 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5952 sizeof (uuid_cmd
->uuid
)) != 0)
5958 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5959 The caller is responsible for closing the returned BFD object and
5960 its my_archive if the returned BFD is in a fat dSYM. */
5963 bfd_mach_o_find_dsym (const char *dsym_filename
,
5964 const bfd_mach_o_uuid_command
*uuid_cmd
,
5965 const bfd_arch_info_type
*arch
)
5967 bfd
*base_dsym_bfd
, *dsym_bfd
;
5969 BFD_ASSERT (uuid_cmd
);
5971 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
5972 if (base_dsym_bfd
== NULL
)
5975 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
5976 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
5979 bfd_close (dsym_bfd
);
5980 if (base_dsym_bfd
!= dsym_bfd
)
5981 bfd_close (base_dsym_bfd
);
5986 /* Return a BFD created from a dSYM file for ABFD.
5987 The caller is responsible for closing the returned BFD object, its
5988 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5991 bfd_mach_o_follow_dsym (bfd
*abfd
)
5993 char *dsym_filename
;
5994 bfd_mach_o_uuid_command
*uuid_cmd
;
5995 bfd
*dsym_bfd
, *base_bfd
= abfd
;
5996 const char *base_basename
;
5998 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
6001 if (abfd
->my_archive
&& !bfd_is_thin_archive (abfd
->my_archive
))
6002 base_bfd
= abfd
->my_archive
;
6003 /* BFD may have been opened from a stream. */
6004 if (base_bfd
->filename
== NULL
)
6006 bfd_set_error (bfd_error_invalid_operation
);
6009 base_basename
= lbasename (base_bfd
->filename
);
6011 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
6012 if (uuid_cmd
== NULL
)
6015 /* TODO: We assume the DWARF file has the same as the binary's.
6016 It seems apple's GDB checks all files in the dSYM bundle directory.
6017 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
6019 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
6020 + strlen (dsym_subdir
) + 1
6021 + strlen (base_basename
) + 1);
6022 if (dsym_filename
== NULL
)
6025 sprintf (dsym_filename
, "%s%s/%s",
6026 base_bfd
->filename
, dsym_subdir
, base_basename
);
6028 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
6029 bfd_get_arch_info (abfd
));
6030 if (dsym_bfd
== NULL
)
6031 free (dsym_filename
);
6037 bfd_mach_o_find_nearest_line (bfd
*abfd
,
6041 const char **filename_ptr
,
6042 const char **functionname_ptr
,
6043 unsigned int *line_ptr
,
6044 unsigned int *discriminator_ptr
)
6046 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6049 switch (mdata
->header
.filetype
)
6051 case BFD_MACH_O_MH_OBJECT
:
6053 case BFD_MACH_O_MH_EXECUTE
:
6054 case BFD_MACH_O_MH_DYLIB
:
6055 case BFD_MACH_O_MH_BUNDLE
:
6056 case BFD_MACH_O_MH_KEXT_BUNDLE
:
6057 if (mdata
->dwarf2_find_line_info
== NULL
)
6059 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
6060 /* When we couldn't find dSYM for this binary, we look for
6061 the debug information in the binary itself. In this way,
6062 we won't try finding separated dSYM again because
6063 mdata->dwarf2_find_line_info will be filled. */
6064 if (! mdata
->dsym_bfd
)
6066 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
6067 dwarf_debug_sections
, symbols
,
6068 &mdata
->dwarf2_find_line_info
,
6076 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
6077 filename_ptr
, functionname_ptr
,
6078 line_ptr
, discriminator_ptr
,
6079 dwarf_debug_sections
,
6080 &mdata
->dwarf2_find_line_info
);
6084 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
6086 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6087 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
6089 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
6090 bfd_mach_o_free_cached_info (abfd
);
6091 if (mdata
->dsym_bfd
!= NULL
)
6093 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
6095 /* FIXME: PR 19435: This calculation to find the memory allocated by
6096 bfd_mach_o_follow_dsym for the filename does not always end up
6097 selecting the correct pointer. Unfortunately this problem is
6098 very hard to reproduce on a non Mach-O native system, so until it
6099 can be traced and fixed on such a system, this code will remain
6100 commented out. This does mean that there will be a memory leak,
6101 but it is small, and happens when we are closing down, so it
6102 should not matter too much. */
6103 char *dsym_filename
= (char *)(fat_bfd
6105 : mdata
->dsym_bfd
->filename
);
6107 bfd_close (mdata
->dsym_bfd
);
6108 mdata
->dsym_bfd
= NULL
;
6110 bfd_close (fat_bfd
);
6112 free (dsym_filename
);
6117 return _bfd_generic_close_and_cleanup (abfd
);
6121 bfd_mach_o_free_cached_info (bfd
*abfd
)
6123 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6125 free (mdata
->dyn_reloc_cache
);
6126 mdata
->dyn_reloc_cache
= NULL
;
6127 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
6129 free (asect
->relocation
);
6130 asect
->relocation
= NULL
;
6136 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
6137 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6139 #define bfd_mach_o_canonicalize_one_reloc NULL
6140 #define bfd_mach_o_swap_reloc_out NULL
6141 #define bfd_mach_o_print_thread NULL
6142 #define bfd_mach_o_tgt_seg_table NULL
6143 #define bfd_mach_o_section_type_valid_for_tgt NULL
6145 #define TARGET_NAME mach_o_be_vec
6146 #define TARGET_STRING "mach-o-be"
6147 #define TARGET_ARCHITECTURE bfd_arch_unknown
6148 #define TARGET_PAGESIZE 1
6149 #define TARGET_BIG_ENDIAN 1
6150 #define TARGET_ARCHIVE 0
6151 #define TARGET_PRIORITY 1
6152 #include "mach-o-target.c"
6155 #undef TARGET_STRING
6156 #undef TARGET_ARCHITECTURE
6157 #undef TARGET_PAGESIZE
6158 #undef TARGET_BIG_ENDIAN
6159 #undef TARGET_ARCHIVE
6160 #undef TARGET_PRIORITY
6162 #define TARGET_NAME mach_o_le_vec
6163 #define TARGET_STRING "mach-o-le"
6164 #define TARGET_ARCHITECTURE bfd_arch_unknown
6165 #define TARGET_PAGESIZE 1
6166 #define TARGET_BIG_ENDIAN 0
6167 #define TARGET_ARCHIVE 0
6168 #define TARGET_PRIORITY 1
6170 #include "mach-o-target.c"
6173 #undef TARGET_STRING
6174 #undef TARGET_ARCHITECTURE
6175 #undef TARGET_PAGESIZE
6176 #undef TARGET_BIG_ENDIAN
6177 #undef TARGET_ARCHIVE
6178 #undef TARGET_PRIORITY
6180 /* Not yet handled: creating an archive. */
6181 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
6183 #define bfd_mach_o_close_and_cleanup bfd_mach_o_fat_close_and_cleanup
6186 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
6187 #define bfd_mach_o_openr_next_archived_file bfd_mach_o_fat_openr_next_archived_file
6188 #define bfd_mach_o_archive_p bfd_mach_o_fat_archive_p
6190 #define TARGET_NAME mach_o_fat_vec
6191 #define TARGET_STRING "mach-o-fat"
6192 #define TARGET_ARCHITECTURE bfd_arch_unknown
6193 #define TARGET_PAGESIZE 1
6194 #define TARGET_BIG_ENDIAN 1
6195 #define TARGET_ARCHIVE 1
6196 #define TARGET_PRIORITY 0
6198 #include "mach-o-target.c"
6201 #undef TARGET_STRING
6202 #undef TARGET_ARCHITECTURE
6203 #undef TARGET_PAGESIZE
6204 #undef TARGET_BIG_ENDIAN
6205 #undef TARGET_ARCHIVE
6206 #undef TARGET_PRIORITY