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
)
1627 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1628 if (native_relocs
== NULL
)
1631 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1632 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1635 for (i
= 0; i
< count
; i
++)
1637 if (!(*bed
->_bfd_mach_o_canonicalize_one_reloc
)(abfd
, &native_relocs
[i
],
1638 &res
[i
], syms
, res
))
1641 free (native_relocs
);
1645 free (native_relocs
);
1646 if (bfd_get_error () == bfd_error_no_error
)
1647 bfd_set_error (bfd_error_invalid_operation
);
1652 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1653 arelent
**rels
, asymbol
**syms
)
1655 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1659 if (asect
->reloc_count
== 0)
1662 /* No need to go further if we don't know how to read relocs. */
1663 if (bed
->_bfd_mach_o_canonicalize_one_reloc
== NULL
)
1666 if (asect
->relocation
== NULL
)
1668 if (asect
->reloc_count
* sizeof (arelent
) < asect
->reloc_count
)
1670 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1674 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1675 asect
->reloc_count
, res
, syms
) < 0)
1680 asect
->relocation
= res
;
1683 res
= asect
->relocation
;
1684 for (i
= 0; i
< asect
->reloc_count
; i
++)
1692 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1694 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1696 if (mdata
->dysymtab
== NULL
)
1698 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1699 * sizeof (arelent
*);
1703 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1704 struct bfd_symbol
**syms
)
1706 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1707 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1708 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1712 if (dysymtab
== NULL
)
1714 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1717 /* No need to go further if we don't know how to read relocs. */
1718 if (bed
->_bfd_mach_o_canonicalize_one_reloc
== NULL
)
1721 if (mdata
->dyn_reloc_cache
== NULL
)
1723 if ((dysymtab
->nextrel
+ dysymtab
->nlocrel
) * sizeof (arelent
)
1724 < (dysymtab
->nextrel
+ dysymtab
->nlocrel
))
1727 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1728 * sizeof (arelent
));
1732 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1733 dysymtab
->nextrel
, res
, syms
) < 0)
1739 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1741 res
+ dysymtab
->nextrel
, syms
) < 0)
1747 mdata
->dyn_reloc_cache
= res
;
1750 res
= mdata
->dyn_reloc_cache
;
1751 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1757 /* In addition to the need to byte-swap the symbol number, the bit positions
1758 of the fields in the relocation information vary per target endian-ness. */
1761 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1762 bfd_mach_o_reloc_info
*rel
)
1764 unsigned char info
= 0;
1766 BFD_ASSERT (rel
->r_type
<= 15);
1767 BFD_ASSERT (rel
->r_length
<= 3);
1769 if (bfd_big_endian (abfd
))
1771 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1772 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1773 fields
[2] = rel
->r_value
& 0xff;
1774 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1775 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1776 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1777 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1781 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1782 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1783 fields
[0] = rel
->r_value
& 0xff;
1784 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1785 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1786 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1787 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1793 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1798 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1800 sec
= section
->bfdsection
;
1801 if (sec
->reloc_count
== 0)
1804 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1807 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1810 /* Convert and write. */
1811 entries
= section
->bfdsection
->orelocation
;
1812 for (i
= 0; i
< section
->nreloc
; i
++)
1814 arelent
*rel
= entries
[i
];
1815 struct mach_o_reloc_info_external raw
;
1816 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1818 /* Convert relocation to an intermediate representation. */
1819 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1822 /* Lower the relocation info. */
1823 if (pinfo
->r_scattered
)
1827 v
= BFD_MACH_O_SR_SCATTERED
1828 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1829 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1830 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1831 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1832 /* Note: scattered relocs have field in reverse order... */
1833 bfd_put_32 (abfd
, v
, raw
.r_address
);
1834 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1838 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1839 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1843 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1844 != BFD_MACH_O_RELENT_SIZE
)
1851 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1853 struct mach_o_section_32_external raw
;
1855 memcpy (raw
.sectname
, section
->sectname
, 16);
1856 memcpy (raw
.segname
, section
->segname
, 16);
1857 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1858 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1859 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1860 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1861 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1862 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1863 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1864 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1865 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1867 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1868 != BFD_MACH_O_SECTION_SIZE
)
1875 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1877 struct mach_o_section_64_external raw
;
1879 memcpy (raw
.sectname
, section
->sectname
, 16);
1880 memcpy (raw
.segname
, section
->segname
, 16);
1881 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1882 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1883 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1884 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1885 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1886 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1887 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1888 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1889 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1890 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1892 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1893 != BFD_MACH_O_SECTION_64_SIZE
)
1900 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1902 struct mach_o_segment_command_32_external raw
;
1903 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1904 bfd_mach_o_section
*sec
;
1906 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1908 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1909 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1912 memcpy (raw
.segname
, seg
->segname
, 16);
1913 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1914 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1915 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1916 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1917 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1918 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1919 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1920 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1922 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1923 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1926 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1927 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1934 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1936 struct mach_o_segment_command_64_external raw
;
1937 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1938 bfd_mach_o_section
*sec
;
1940 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1942 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1943 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1946 memcpy (raw
.segname
, seg
->segname
, 16);
1947 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1948 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1949 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1950 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1951 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1952 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1953 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1954 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1956 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1957 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1960 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1961 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1968 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1970 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1972 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1973 struct bfd_strtab_hash
*strtab
;
1974 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1977 /* Write the symbols first. */
1978 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1981 strtab
= _bfd_stringtab_init ();
1986 /* Although we don't strictly need to do this, for compatibility with
1987 Darwin system tools, actually output an empty string for the index
1989 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1991 for (i
= 0; i
< sym
->nsyms
; i
++)
1993 bfd_size_type str_index
;
1994 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1996 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1997 /* An index of 0 always means the empty string. */
2001 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
2003 if (str_index
== (bfd_size_type
) -1)
2009 struct mach_o_nlist_64_external raw
;
2011 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
2012 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
2013 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
2014 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
2015 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
2018 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2023 struct mach_o_nlist_external raw
;
2025 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
2026 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
2027 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
2028 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
2029 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
2032 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2036 sym
->strsize
= _bfd_stringtab_size (strtab
);
2037 sym
->stroff
= mdata
->filelen
;
2038 mdata
->filelen
+= sym
->strsize
;
2040 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
2043 if (!_bfd_stringtab_emit (abfd
, strtab
))
2046 /* Pad string table. */
2047 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
2050 mdata
->filelen
+= padlen
;
2051 sym
->strsize
+= padlen
;
2056 _bfd_stringtab_free (strtab
);
2062 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2064 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
2065 struct mach_o_symtab_command_external raw
;
2067 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2070 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
2071 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
2072 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
2073 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
2075 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2076 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2082 /* Count the number of indirect symbols in the image.
2083 Requires that the sections are in their final order. */
2086 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2089 unsigned int nisyms
= 0;
2091 for (i
= 0; i
< mdata
->nsects
; ++i
)
2093 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2095 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2097 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2098 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2099 case BFD_MACH_O_S_SYMBOL_STUBS
:
2100 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2109 /* Create the dysymtab. */
2112 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
2114 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2117 We are not going to try and fill these in yet and, moreover, we are
2118 going to bail if they are already set. */
2119 if (cmd
->nmodtab
!= 0
2121 || cmd
->nextrefsyms
!= 0)
2123 _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
2124 " implemented for dysymtab commands."));
2130 if (bfd_get_symcount (abfd
) > 0)
2132 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2135 /* Count the number of each kind of symbol. */
2136 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2138 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2139 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
2143 cmd
->iextdefsym
= i
;
2144 for (; i
< bfd_get_symcount (abfd
); ++i
)
2146 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2147 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
2150 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
2151 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
2152 cmd
->nundefsym
= bfd_get_symcount (abfd
)
2159 cmd
->iextdefsym
= 0;
2160 cmd
->nextdefsym
= 0;
2165 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
2166 if (cmd
->nindirectsyms
> 0)
2171 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2172 cmd
->indirectsymoff
= mdata
->filelen
;
2173 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
2175 if (cmd
->nindirectsyms
* 4 < cmd
->nindirectsyms
)
2177 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
2178 if (cmd
->indirect_syms
== NULL
)
2182 for (i
= 0; i
< mdata
->nsects
; ++i
)
2184 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2186 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2188 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2189 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2190 case BFD_MACH_O_S_SYMBOL_STUBS
:
2193 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2195 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2196 if (isyms
== NULL
|| num
== 0)
2198 /* Record the starting index in the reserved1 field. */
2200 for (j
= 0; j
< num
; j
++, n
++)
2202 if (isyms
[j
] == NULL
)
2203 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2204 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
2205 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
2206 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2207 | BFD_MACH_O_INDIRECT_SYM_ABS
;
2209 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2222 /* Write a dysymtab command.
2223 TODO: Possibly coalesce writes of smaller objects. */
2226 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2228 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2230 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2232 if (cmd
->nmodtab
!= 0)
2236 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2239 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2241 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2245 iinit
= module
->iinit
& 0xffff;
2246 iinit
|= ((module
->iterm
& 0xffff) << 16);
2248 ninit
= module
->ninit
& 0xffff;
2249 ninit
|= ((module
->nterm
& 0xffff) << 16);
2251 if (bfd_mach_o_wide_p (abfd
))
2253 struct mach_o_dylib_module_64_external w
;
2255 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2256 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2257 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2258 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2259 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2260 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2261 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2262 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2263 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2264 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2265 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2266 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2267 &w
.objc_module_info_addr
);
2268 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2269 &w
.objc_module_info_size
);
2271 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2276 struct mach_o_dylib_module_external n
;
2278 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2279 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2280 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2281 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2282 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2283 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2284 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2285 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2286 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2287 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2288 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2289 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2290 &n
.objc_module_info_addr
);
2291 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2292 &n
.objc_module_info_size
);
2294 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2304 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2307 for (i
= 0; i
< cmd
->ntoc
; i
++)
2309 struct mach_o_dylib_table_of_contents_external raw
;
2310 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2312 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2313 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2315 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2320 if (cmd
->nindirectsyms
> 0)
2324 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2327 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2329 unsigned char raw
[4];
2331 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2332 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2337 if (cmd
->nextrefsyms
!= 0)
2341 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2344 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2347 unsigned char raw
[4];
2348 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2350 /* Fields isym and flags are written as bit-fields, thus we need
2351 a specific processing for endianness. */
2353 if (bfd_big_endian (abfd
))
2355 v
= ((ref
->isym
& 0xffffff) << 8);
2356 v
|= ref
->flags
& 0xff;
2360 v
= ref
->isym
& 0xffffff;
2361 v
|= ((ref
->flags
& 0xff) << 24);
2364 bfd_h_put_32 (abfd
, v
, raw
);
2365 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2371 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2375 struct mach_o_dysymtab_command_external raw
;
2377 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2378 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2379 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2380 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2381 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2382 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2383 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2384 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2385 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2386 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2387 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2388 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2389 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2390 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2391 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2392 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2393 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2394 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2396 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2404 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2406 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2408 /* Just leave debug symbols where they are (pretend they are local, and
2409 then they will just be sorted on position). */
2410 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2413 /* Local (we should never see an undefined local AFAICT). */
2414 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2417 /* Common symbols look like undefined externs. */
2418 if (mtyp
== BFD_MACH_O_N_UNDF
)
2421 /* A defined non-local, non-debug symbol. */
2426 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2428 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2429 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2430 unsigned int soa
, sob
;
2432 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2433 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2440 /* If it's local or stab, just preserve the input order. */
2443 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2445 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2448 /* This is probably an error. */
2452 /* The second sort key is name. */
2453 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2456 /* Process the symbols.
2458 This should be OK for single-module files - but it is not likely to work
2459 for multi-module shared libraries.
2461 (a) If the application has not filled in the relevant mach-o fields, make
2464 (b) Order them, like this:
2467 ( ii) external defined
2469 (iii) external undefined/common
2476 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2479 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2481 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2484 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2486 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2488 /* We use this value, which is out-of-range as a symbol index, to signal
2489 that the mach-o-specific data are not filled in and need to be created
2490 from the bfd values. It is much preferable for the application to do
2491 this, since more meaningful diagnostics can be made that way. */
2493 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2495 /* No symbol information has been set - therefore determine
2496 it from the bfd symbol flags/info. */
2497 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2498 s
->n_type
= BFD_MACH_O_N_ABS
;
2499 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2501 s
->n_type
= BFD_MACH_O_N_UNDF
;
2502 if (s
->symbol
.flags
& BSF_WEAK
)
2503 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2504 /* mach-o automatically makes undefined symbols extern. */
2505 s
->n_type
|= BFD_MACH_O_N_EXT
;
2506 s
->symbol
.flags
|= BSF_GLOBAL
;
2508 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2510 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2511 s
->symbol
.flags
|= BSF_GLOBAL
;
2514 s
->n_type
= BFD_MACH_O_N_SECT
;
2517 /* Update external symbol bit in case objcopy changed it. */
2518 if (s
->symbol
.flags
& BSF_GLOBAL
)
2519 s
->n_type
|= BFD_MACH_O_N_EXT
;
2521 s
->n_type
&= ~BFD_MACH_O_N_EXT
;
2523 /* Put the section index in, where required. */
2524 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2525 && s
->symbol
.section
!= bfd_und_section_ptr
2526 && s
->symbol
.section
!= bfd_com_section_ptr
)
2527 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2528 && s
->symbol
.name
== NULL
))
2529 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2531 /* Number to preserve order for local and debug syms. */
2532 s
->symbol
.udata
.i
= i
;
2535 /* Sort the symbols. */
2536 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2537 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2539 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2541 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2542 s
->symbol
.udata
.i
= i
; /* renumber. */
2548 /* We build a flat table of sections, which can be re-ordered if necessary.
2549 Fill in the section number and other mach-o-specific data. */
2552 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2555 unsigned target_index
;
2559 nsect
= bfd_count_sections (abfd
);
2561 /* Don't do it if it's already set - assume the application knows what it's
2563 if (mdata
->nsects
== nsect
2564 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2567 /* We need to check that this can be done... */
2570 _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2571 " maximum is 255,\n"), nsect
);
2575 mdata
->nsects
= nsect
;
2576 if (_bfd_mul_overflow (mdata
->nsects
, sizeof (bfd_mach_o_section
*), &amt
))
2578 bfd_set_error (bfd_error_no_memory
);
2581 mdata
->sections
= bfd_alloc (abfd
, amt
);
2582 if (mdata
->sections
== NULL
)
2585 /* Create Mach-O sections.
2586 Section type, attribute and align should have been set when the
2587 section was created - either read in or specified. */
2589 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2591 unsigned bfd_align
= bfd_section_alignment (sec
);
2592 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2594 mdata
->sections
[target_index
] = msect
;
2596 msect
->addr
= bfd_section_vma (sec
);
2597 msect
->size
= bfd_section_size (sec
);
2599 /* Use the largest alignment set, in case it was bumped after the
2600 section was created. */
2601 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2604 sec
->target_index
= ++target_index
;
2611 bfd_mach_o_write_contents (bfd
*abfd
)
2613 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2614 bfd_mach_o_load_command
*cmd
;
2615 bfd_mach_o_symtab_command
*symtab
= NULL
;
2616 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2617 bfd_mach_o_segment_command
*linkedit
= NULL
;
2619 /* Make the commands, if not already present. */
2620 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2622 abfd
->output_has_begun
= TRUE
;
2624 /* Write the header. */
2625 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2628 /* First pass: allocate the linkedit segment. */
2629 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2632 case BFD_MACH_O_LC_SEGMENT_64
:
2633 case BFD_MACH_O_LC_SEGMENT
:
2634 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2635 linkedit
= &cmd
->command
.segment
;
2637 case BFD_MACH_O_LC_SYMTAB
:
2638 symtab
= &cmd
->command
.symtab
;
2640 case BFD_MACH_O_LC_DYSYMTAB
:
2641 dysymtab
= &cmd
->command
.dysymtab
;
2643 case BFD_MACH_O_LC_DYLD_INFO
:
2645 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2647 if (di
->rebase_size
!= 0)
2649 di
->rebase_off
= mdata
->filelen
;
2650 mdata
->filelen
+= di
->rebase_size
;
2652 if (di
->bind_size
!= 0)
2654 di
->bind_off
= mdata
->filelen
;
2655 mdata
->filelen
+= di
->bind_size
;
2657 if (di
->weak_bind_size
!= 0)
2659 di
->weak_bind_off
= mdata
->filelen
;
2660 mdata
->filelen
+= di
->weak_bind_size
;
2662 if (di
->lazy_bind_size
!= 0)
2664 di
->lazy_bind_off
= mdata
->filelen
;
2665 mdata
->filelen
+= di
->lazy_bind_size
;
2667 if (di
->export_size
!= 0)
2669 di
->export_off
= mdata
->filelen
;
2670 mdata
->filelen
+= di
->export_size
;
2674 case BFD_MACH_O_LC_LOAD_DYLIB
:
2675 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2676 case BFD_MACH_O_LC_MAIN
:
2677 /* Nothing to do. */
2681 (_("unable to allocate data for load command %#x"),
2686 /* Specially handle symtab and dysymtab. */
2688 /* Pre-allocate the symbol table (but not the string table). The reason
2689 is that the dysymtab is after the symbol table but before the string
2690 table (required by the native strip tool). */
2693 unsigned int symlen
;
2694 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2696 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2698 /* Align for symbols. */
2699 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2700 symtab
->symoff
= mdata
->filelen
;
2702 symtab
->nsyms
= bfd_get_symcount (abfd
);
2703 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2706 /* Build the dysymtab. */
2707 if (dysymtab
!= NULL
)
2708 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2711 /* Write symtab and strtab. */
2713 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2716 /* Adjust linkedit size. */
2717 if (linkedit
!= NULL
)
2719 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2721 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2722 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2723 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2725 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2726 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2727 | BFD_MACH_O_PROT_EXECUTE
;
2730 /* Second pass: write commands. */
2731 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2733 struct mach_o_load_command_external raw
;
2734 unsigned long typeflag
;
2736 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2738 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2739 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2741 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2742 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2747 case BFD_MACH_O_LC_SEGMENT
:
2748 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2751 case BFD_MACH_O_LC_SEGMENT_64
:
2752 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2755 case BFD_MACH_O_LC_SYMTAB
:
2756 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2759 case BFD_MACH_O_LC_DYSYMTAB
:
2760 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2763 case BFD_MACH_O_LC_THREAD
:
2764 case BFD_MACH_O_LC_UNIXTHREAD
:
2765 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2768 case BFD_MACH_O_LC_LOAD_DYLIB
:
2769 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2772 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2773 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2776 case BFD_MACH_O_LC_MAIN
:
2777 if (!bfd_mach_o_write_main (abfd
, cmd
))
2780 case BFD_MACH_O_LC_DYLD_INFO
:
2781 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2786 (_("unable to write unknown load command %#x"),
2796 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2797 bfd_mach_o_section
*s
)
2799 if (seg
->sect_head
== NULL
)
2802 seg
->sect_tail
->next
= s
;
2806 /* Create section Mach-O flags from BFD flags. */
2809 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2813 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2815 /* Create default flags. */
2816 bfd_flags
= bfd_section_flags (sec
);
2817 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2818 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2819 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2820 | BFD_MACH_O_S_REGULAR
;
2821 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2822 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2823 else if (bfd_flags
& SEC_DEBUGGING
)
2824 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2826 s
->flags
= BFD_MACH_O_S_REGULAR
;
2830 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2832 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2836 seg
->fileoff
= mdata
->filelen
;
2837 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2838 | BFD_MACH_O_PROT_EXECUTE
;
2839 seg
->maxprot
= seg
->initprot
;
2841 /* Append sections to the segment.
2843 This is a little tedious, we have to honor the need to account zerofill
2844 sections after all the rest. This forces us to do the calculation of
2845 total vmsize in three passes so that any alignment increments are
2846 properly accounted. */
2847 for (i
= 0; i
< mdata
->nsects
; ++i
)
2849 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2850 asection
*sec
= s
->bfdsection
;
2852 /* Although we account for zerofill section sizes in vm order, they are
2853 placed in the file in source sequence. */
2854 bfd_mach_o_append_section_to_segment (seg
, s
);
2857 /* Zerofill sections have zero file size & offset, the only content
2858 written to the file is the symbols. */
2859 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2860 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2861 == BFD_MACH_O_S_GB_ZEROFILL
))
2864 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2865 sections, even those with zero size. */
2868 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2869 seg
->vmsize
+= s
->size
;
2871 /* MH_OBJECT files have unaligned content. */
2874 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2875 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2877 seg
->filesize
+= s
->size
;
2879 /* The system tools write even zero-sized sections with an offset
2880 field set to the current file position. */
2881 s
->offset
= mdata
->filelen
;
2884 sec
->filepos
= s
->offset
;
2885 mdata
->filelen
+= s
->size
;
2888 /* Now pass through again, for zerofill, only now we just update the
2889 vmsize, and then for zerofill_GB. */
2890 for (j
= 0; j
< 2; j
++)
2895 stype
= BFD_MACH_O_S_ZEROFILL
;
2897 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2899 for (i
= 0; i
< mdata
->nsects
; ++i
)
2901 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2903 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2908 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2909 seg
->vmsize
+= s
->size
;
2914 /* Allocate space for the relocations. */
2915 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2917 for (i
= 0; i
< mdata
->nsects
; ++i
)
2919 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2920 asection
*sec
= ms
->bfdsection
;
2922 ms
->nreloc
= sec
->reloc_count
;
2923 if (ms
->nreloc
== 0)
2925 /* Clear nreloc and reloff if there is no relocs. */
2929 sec
->rel_filepos
= mdata
->filelen
;
2930 ms
->reloff
= sec
->rel_filepos
;
2931 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2938 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2940 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2942 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2944 bfd_mach_o_section
*s
;
2948 seg
->fileoff
= mdata
->filelen
;
2953 /* Append sections to the segment. We assume they are properly ordered
2954 by vma (but we check that). */
2956 for (i
= 0; i
< mdata
->nsects
; ++i
)
2958 s
= mdata
->sections
[i
];
2960 /* Consider only sections for this segment. */
2961 if (strcmp (seg
->segname
, s
->segname
) != 0)
2964 bfd_mach_o_append_section_to_segment (seg
, s
);
2969 /* xgettext:c-format */
2970 (_("section address (%#" PRIx64
") "
2971 "below start of segment (%#" PRIx64
")"),
2972 (uint64_t) s
->addr
, (uint64_t) vma
);
2976 vma
= s
->addr
+ s
->size
;
2979 /* Set segment file offset: make it page aligned. */
2980 vma
= seg
->sect_head
->addr
;
2981 seg
->vmaddr
= vma
& ~pagemask
;
2982 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2983 mdata
->filelen
+= pagemask
+ 1;
2984 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2985 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2987 /* Set section file offset. */
2988 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2990 asection
*sec
= s
->bfdsection
;
2991 flagword flags
= bfd_section_flags (sec
);
2993 /* Adjust segment size. */
2994 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2995 seg
->vmsize
+= s
->size
;
2997 /* File offset and length. */
2998 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
3000 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
3001 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3002 != BFD_MACH_O_S_GB_ZEROFILL
))
3004 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
3006 s
->offset
= mdata
->filelen
;
3007 s
->bfdsection
->filepos
= s
->offset
;
3009 seg
->filesize
+= s
->size
;
3010 mdata
->filelen
+= s
->size
;
3015 s
->bfdsection
->filepos
= 0;
3018 /* Set protection. */
3019 if (flags
& SEC_LOAD
)
3021 if (flags
& SEC_CODE
)
3022 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
3023 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
3024 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
3027 /* Relocs shouldn't appear in non-object files. */
3028 if (s
->bfdsection
->reloc_count
!= 0)
3033 if (seg
->initprot
!= 0)
3034 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
3035 | BFD_MACH_O_PROT_EXECUTE
;
3039 /* Round segment size (and file size). */
3040 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
3041 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
3042 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
3047 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3048 fields in header. */
3051 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
3053 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3054 unsigned int hdrlen
;
3056 bfd_mach_o_load_command
*cmd
;
3058 bfd_boolean ret
= TRUE
;
3060 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3061 align
= wide
? 8 - 1 : 4 - 1;
3063 mdata
->header
.ncmds
= 0;
3065 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
3067 mdata
->header
.ncmds
++;
3068 cmd
->offset
= offset
;
3072 case BFD_MACH_O_LC_SEGMENT_64
:
3073 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
3074 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
3076 case BFD_MACH_O_LC_SEGMENT
:
3077 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
3078 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
3080 case BFD_MACH_O_LC_SYMTAB
:
3081 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
3082 + BFD_MACH_O_LC_SIZE
;
3084 case BFD_MACH_O_LC_DYSYMTAB
:
3085 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
3086 + BFD_MACH_O_LC_SIZE
;
3088 case BFD_MACH_O_LC_LOAD_DYLIB
:
3089 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
3090 + BFD_MACH_O_LC_SIZE
;
3091 cmd
->command
.dylib
.name_offset
= cmd
->len
;
3092 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
3093 cmd
->len
= (cmd
->len
+ align
) & ~align
;
3095 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3096 cmd
->len
= sizeof (struct mach_o_str_command_external
)
3097 + BFD_MACH_O_LC_SIZE
;
3098 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
3099 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
3100 cmd
->len
= (cmd
->len
+ align
) & ~align
;
3102 case BFD_MACH_O_LC_MAIN
:
3103 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
3104 + BFD_MACH_O_LC_SIZE
;
3106 case BFD_MACH_O_LC_DYLD_INFO
:
3107 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
3108 + BFD_MACH_O_LC_SIZE
;
3112 (_("unable to layout unknown load command %#x"),
3118 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
3121 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
3122 mdata
->filelen
= offset
;
3127 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3131 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
3132 bfd_mach_o_load_command
*cmd
,
3133 const char *segname
, unsigned int nbr_sect
)
3135 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3136 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3138 /* Init segment command. */
3139 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
3140 cmd
->type_required
= FALSE
;
3142 strcpy (seg
->segname
, segname
);
3143 seg
->nsects
= nbr_sect
;
3153 seg
->sect_head
= NULL
;
3154 seg
->sect_tail
= NULL
;
3157 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3158 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3159 and copy functionality. */
3162 bfd_mach_o_build_commands (bfd
*abfd
)
3164 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3165 unsigned wide
= mach_o_wide_p (&mdata
->header
);
3166 unsigned int nbr_segcmd
= 0;
3167 bfd_mach_o_load_command
*commands
;
3168 unsigned int nbr_commands
;
3169 int symtab_idx
= -1;
3170 int dysymtab_idx
= -1;
3174 /* Return now if already built. */
3175 if (mdata
->header
.ncmds
!= 0)
3178 /* Fill in the file type, if not already set. */
3179 if (mdata
->header
.filetype
== 0)
3181 if (abfd
->flags
& EXEC_P
)
3182 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
3183 else if (abfd
->flags
& DYNAMIC
)
3184 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
3186 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
3189 /* If hasn't already been done, flatten sections list, and sort
3190 if/when required. Must be done before the symbol table is adjusted,
3191 since that depends on properly numbered sections. */
3192 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
3193 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
3196 /* Order the symbol table, fill-in/check mach-o specific fields and
3197 partition out any indirect symbols. */
3198 if (!bfd_mach_o_mangle_symbols (abfd
))
3201 /* Segment commands. */
3202 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3204 /* Only one segment for all the sections. But the segment is
3205 optional if there is no sections. */
3206 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
3210 bfd_mach_o_section
*prev_sect
= NULL
;
3212 /* One pagezero segment and one linkedit segment. */
3215 /* Create one segment for associated segment name in sections.
3216 Assume that sections with the same segment name are consecutive. */
3217 for (i
= 0; i
< mdata
->nsects
; i
++)
3219 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
3221 if (prev_sect
== NULL
3222 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
3225 prev_sect
= this_sect
;
3230 nbr_commands
= nbr_segcmd
;
3232 /* One command for the symbol table (only if there are symbols. */
3233 if (bfd_get_symcount (abfd
) > 0)
3234 symtab_idx
= nbr_commands
++;
3237 This is a rather crude test for whether we should build a dysymtab. */
3238 if (bfd_mach_o_should_emit_dysymtab ()
3239 && bfd_get_symcount (abfd
))
3241 /* If there should be a case where a dysymtab could be emitted without
3242 a symtab (seems improbable), this would need amending. */
3243 dysymtab_idx
= nbr_commands
++;
3246 /* Add an entry point command. */
3247 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3248 && bfd_get_start_address (abfd
) != 0)
3249 main_idx
= nbr_commands
++;
3251 /* Well, we must have a header, at least. */
3252 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3254 /* A bit unusual, but no content is valid;
3255 as -n empty.s -o empty.o */
3256 if (nbr_commands
== 0)
3258 /* Layout commands (well none...) and set headers command fields. */
3259 return bfd_mach_o_layout_commands (mdata
);
3262 /* Create commands for segments (and symtabs), prepend them. */
3263 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3264 if (commands
== NULL
)
3266 for (i
= 0; i
< nbr_commands
- 1; i
++)
3267 commands
[i
].next
= &commands
[i
+ 1];
3268 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3269 if (mdata
->first_command
== NULL
)
3270 mdata
->last_command
= &commands
[nbr_commands
- 1];
3271 mdata
->first_command
= &commands
[0];
3273 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3275 /* For object file, there is only one segment. */
3276 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3278 else if (nbr_segcmd
!= 0)
3280 bfd_mach_o_load_command
*cmd
;
3282 BFD_ASSERT (nbr_segcmd
>= 2);
3286 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3288 /* Segments from sections. */
3290 for (i
= 0; i
< mdata
->nsects
;)
3292 const char *segname
= mdata
->sections
[i
]->segname
;
3293 unsigned int nbr_sect
= 1;
3295 /* Count number of sections for this segment. */
3296 for (i
++; i
< mdata
->nsects
; i
++)
3297 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3302 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3307 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3310 if (symtab_idx
>= 0)
3312 /* Init symtab command. */
3313 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3315 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3316 cmd
->type_required
= FALSE
;
3319 /* If required, setup symtab command, see comment above about the quality
3321 if (dysymtab_idx
>= 0)
3323 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3325 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3326 cmd
->type_required
= FALSE
;
3329 /* Create the main command. */
3332 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3334 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3335 cmd
->type_required
= TRUE
;
3337 cmd
->command
.main
.entryoff
= 0;
3338 cmd
->command
.main
.stacksize
= 0;
3341 /* Layout commands. */
3342 if (! bfd_mach_o_layout_commands (mdata
))
3345 /* So, now we have sized the commands and the filelen set to that.
3346 Now we can build the segment command and set the section file offsets. */
3347 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3349 for (i
= 0; i
< nbr_segcmd
; i
++)
3350 if (!bfd_mach_o_build_obj_seg_command
3351 (abfd
, &commands
[i
].command
.segment
))
3358 /* Skip pagezero and linkedit segments. */
3359 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3361 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3363 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3366 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3367 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3370 /* Set the size of __PAGEZERO. */
3371 commands
[0].command
.segment
.vmsize
=
3372 commands
[1].command
.segment
.vmaddr
;
3374 /* Set the vma and fileoff of __LINKEDIT. */
3375 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3376 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3378 /* Set entry point (once segments have been laid out). */
3380 commands
[main_idx
].command
.main
.entryoff
=
3381 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3387 /* Set the contents of a section. */
3390 bfd_mach_o_set_section_contents (bfd
*abfd
,
3392 const void * location
,
3394 bfd_size_type count
)
3398 /* Trying to write the first section contents will trigger the creation of
3399 the load commands if they are not already present. */
3400 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3406 pos
= section
->filepos
+ offset
;
3407 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3408 || bfd_bwrite (location
, count
, abfd
) != count
)
3415 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3416 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3421 /* Make an empty symbol. This is required only because
3422 bfd_make_section_anyway wants to create a symbol for the section. */
3425 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3427 asymbol
*new_symbol
;
3429 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3430 if (new_symbol
== NULL
)
3432 new_symbol
->the_bfd
= abfd
;
3433 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3438 bfd_mach_o_read_header (bfd
*abfd
, file_ptr hdr_off
, bfd_mach_o_header
*header
)
3440 struct mach_o_header_external raw
;
3442 bfd_vma (*get32
) (const void *) = NULL
;
3444 /* Just read the magic number. */
3445 if (bfd_seek (abfd
, hdr_off
, SEEK_SET
) != 0
3446 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3449 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3451 header
->byteorder
= BFD_ENDIAN_BIG
;
3452 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3453 header
->version
= 1;
3456 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3458 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3459 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3460 header
->version
= 1;
3463 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3465 header
->byteorder
= BFD_ENDIAN_BIG
;
3466 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3467 header
->version
= 2;
3470 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3472 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3473 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3474 header
->version
= 2;
3479 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3483 /* Once the size of the header is known, read the full header. */
3484 size
= mach_o_wide_p (header
) ?
3485 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3487 if (bfd_seek (abfd
, hdr_off
, SEEK_SET
) != 0
3488 || bfd_bread (&raw
, size
, abfd
) != size
)
3491 header
->cputype
= (*get32
) (raw
.cputype
);
3492 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3493 header
->filetype
= (*get32
) (raw
.filetype
);
3494 header
->ncmds
= (*get32
) (raw
.ncmds
);
3495 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3496 header
->flags
= (*get32
) (raw
.flags
);
3498 if (mach_o_wide_p (header
))
3499 header
->reserved
= (*get32
) (raw
.reserved
);
3501 header
->reserved
= 0;
3507 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3509 bfd_mach_o_section
*s
;
3510 unsigned bfdalign
= bfd_section_alignment (sec
);
3512 s
= bfd_mach_o_get_mach_o_section (sec
);
3516 static const mach_o_section_name_xlat
* xlat
;
3518 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3521 sec
->used_by_bfd
= s
;
3522 s
->bfdsection
= sec
;
3524 /* Create the Darwin seg/sect name pair from the bfd name.
3525 If this is a canonical name for which a specific paiting exists
3526 there will also be defined flags, type, attribute and alignment
3528 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3531 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3532 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3534 bfd_set_section_alignment (sec
, s
->align
);
3535 bfd_flags
= bfd_section_flags (sec
);
3536 if (bfd_flags
== SEC_NO_FLAGS
)
3537 bfd_set_section_flags (sec
, xlat
->bfd_flags
);
3540 /* Create default flags. */
3541 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3544 return _bfd_generic_new_section_hook (abfd
, sec
);
3548 bfd_mach_o_init_section_from_mach_o (asection
*sec
, unsigned long prot
)
3551 bfd_mach_o_section
*section
;
3553 flags
= bfd_section_flags (sec
);
3554 section
= bfd_mach_o_get_mach_o_section (sec
);
3556 /* TODO: see if we should use the xlat system for doing this by
3557 preference and fall back to this for unknown sections. */
3559 if (flags
== SEC_NO_FLAGS
)
3561 /* Try to guess flags. */
3562 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3563 flags
= SEC_DEBUGGING
;
3567 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3568 != BFD_MACH_O_S_ZEROFILL
)
3571 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3573 if (prot
& BFD_MACH_O_PROT_WRITE
)
3575 else if (prot
& BFD_MACH_O_PROT_READ
)
3576 flags
|= SEC_READONLY
;
3582 if ((flags
& SEC_DEBUGGING
) == 0)
3586 if (section
->offset
!= 0)
3587 flags
|= SEC_HAS_CONTENTS
;
3588 if (section
->nreloc
!= 0)
3591 bfd_set_section_flags (sec
, flags
);
3593 sec
->vma
= section
->addr
;
3594 sec
->lma
= section
->addr
;
3595 sec
->size
= section
->size
;
3596 sec
->filepos
= section
->offset
;
3597 sec
->alignment_power
= section
->align
;
3598 sec
->segment_mark
= 0;
3599 sec
->reloc_count
= section
->nreloc
;
3600 sec
->rel_filepos
= section
->reloff
;
3604 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3605 const unsigned char *segname
,
3606 const unsigned char *sectname
)
3611 bfd_mach_o_convert_section_name_to_bfd
3612 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3616 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3620 bfd_mach_o_read_section_32 (bfd
*abfd
, unsigned long prot
)
3622 struct mach_o_section_32_external raw
;
3624 bfd_mach_o_section
*section
;
3626 if (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3627 != BFD_MACH_O_SECTION_SIZE
)
3630 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3634 section
= bfd_mach_o_get_mach_o_section (sec
);
3635 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3636 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3637 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3638 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3639 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3640 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3641 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3642 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3643 /* PR 17512: file: 0017eb76. */
3644 if (section
->align
> 64)
3647 (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx, "
3648 "using 32 instead"), section
->align
);
3649 section
->align
= 32;
3651 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3652 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3653 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3654 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3655 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3656 section
->reserved3
= 0;
3658 bfd_mach_o_init_section_from_mach_o (sec
, prot
);
3664 bfd_mach_o_read_section_64 (bfd
*abfd
, unsigned long prot
)
3666 struct mach_o_section_64_external raw
;
3668 bfd_mach_o_section
*section
;
3670 if (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3671 != BFD_MACH_O_SECTION_64_SIZE
)
3674 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3678 section
= bfd_mach_o_get_mach_o_section (sec
);
3679 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3680 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3681 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3682 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3683 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3684 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3685 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3686 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3687 if (section
->align
> 64)
3690 (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx, "
3691 "using 32 instead"), section
->align
);
3692 section
->align
= 32;
3694 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3695 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3696 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3697 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3698 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3699 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3701 bfd_mach_o_init_section_from_mach_o (sec
, prot
);
3707 bfd_mach_o_read_section (bfd
*abfd
, unsigned long prot
, unsigned int wide
)
3710 return bfd_mach_o_read_section_64 (abfd
, prot
);
3712 return bfd_mach_o_read_section_32 (abfd
, prot
);
3716 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3717 bfd_mach_o_symtab_command
*sym
,
3718 bfd_mach_o_asymbol
*s
,
3721 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3722 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3723 unsigned int symwidth
=
3724 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3725 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3726 struct mach_o_nlist_64_external raw
;
3727 unsigned char type
= -1;
3728 unsigned char section
= -1;
3730 symvalue value
= -1;
3731 unsigned long stroff
= -1;
3732 unsigned int symtype
= -1;
3734 BFD_ASSERT (sym
->strtab
!= NULL
);
3736 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3737 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3740 /* xgettext:c-format */
3741 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3746 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3747 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3748 symtype
= type
& BFD_MACH_O_N_TYPE
;
3749 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3750 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3752 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3754 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3756 if (stroff
>= sym
->strsize
)
3759 /* xgettext:c-format */
3760 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3766 s
->symbol
.the_bfd
= abfd
;
3767 s
->symbol
.name
= sym
->strtab
+ stroff
;
3768 s
->symbol
.value
= value
;
3769 s
->symbol
.flags
= 0x0;
3770 s
->symbol
.udata
.i
= i
;
3772 s
->n_sect
= section
;
3775 if (type
& BFD_MACH_O_N_STAB
)
3777 s
->symbol
.flags
|= BSF_DEBUGGING
;
3778 s
->symbol
.section
= bfd_und_section_ptr
;
3790 if ((section
> 0) && (section
<= mdata
->nsects
))
3792 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3794 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3801 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3802 s
->symbol
.flags
|= BSF_GLOBAL
;
3804 s
->symbol
.flags
|= BSF_LOCAL
;
3808 case BFD_MACH_O_N_UNDF
:
3809 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3810 && s
->symbol
.value
!= 0)
3812 /* A common symbol. */
3813 s
->symbol
.section
= bfd_com_section_ptr
;
3814 s
->symbol
.flags
= BSF_NO_FLAGS
;
3818 s
->symbol
.section
= bfd_und_section_ptr
;
3819 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3820 s
->symbol
.flags
|= BSF_WEAK
;
3823 case BFD_MACH_O_N_PBUD
:
3824 s
->symbol
.section
= bfd_und_section_ptr
;
3826 case BFD_MACH_O_N_ABS
:
3827 s
->symbol
.section
= bfd_abs_section_ptr
;
3829 case BFD_MACH_O_N_SECT
:
3830 if ((section
> 0) && (section
<= mdata
->nsects
))
3832 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3834 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3838 /* Mach-O uses 0 to mean "no section"; not an error. */
3842 /* xgettext:c-format */
3843 (_("bfd_mach_o_read_symtab_symbol: "
3844 "symbol \"%s\" specified invalid section %d (max %lu): "
3845 "setting to undefined"),
3846 s
->symbol
.name
, section
, mdata
->nsects
);
3848 s
->symbol
.section
= bfd_und_section_ptr
;
3851 case BFD_MACH_O_N_INDR
:
3852 /* FIXME: we don't follow the BFD convention as this indirect symbol
3853 won't be followed by the referenced one. This looks harmless
3854 unless we start using the linker. */
3855 s
->symbol
.flags
|= BSF_INDIRECT
;
3856 s
->symbol
.section
= bfd_ind_section_ptr
;
3857 s
->symbol
.value
= 0;
3861 /* xgettext:c-format */
3862 (_("bfd_mach_o_read_symtab_symbol: "
3863 "symbol \"%s\" specified invalid type field 0x%x: "
3864 "setting to undefined"), s
->symbol
.name
, symtype
);
3865 s
->symbol
.section
= bfd_und_section_ptr
;
3874 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3876 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3877 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3879 /* Fail if there is no symtab. */
3883 /* Success if already loaded. */
3887 if (abfd
->flags
& BFD_IN_MEMORY
)
3889 struct bfd_in_memory
*b
;
3891 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3893 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3895 bfd_set_error (bfd_error_file_truncated
);
3898 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3902 /* See PR 21840 for a reproducer. */
3903 if ((sym
->strsize
+ 1) == 0)
3905 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
+ 1);
3906 if (sym
->strtab
== NULL
)
3909 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
3910 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
3912 /* PR 17512: file: 10888-1609-0.004. */
3913 bfd_release (abfd
, sym
->strtab
);
3915 bfd_set_error (bfd_error_file_truncated
);
3918 /* Zero terminate the string table. */
3919 sym
->strtab
[sym
->strsize
] = 0;
3926 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3928 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3929 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3933 if (sym
== NULL
|| sym
->symbols
)
3934 /* Return now if there are no symbols or if already loaded. */
3937 if (_bfd_mul_overflow (sym
->nsyms
, sizeof (bfd_mach_o_asymbol
), &amt
)
3938 || (sym
->symbols
= bfd_alloc (abfd
, amt
)) == NULL
)
3940 bfd_set_error (bfd_error_no_memory
);
3941 _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
3942 "unable to allocate memory for symbols"));
3947 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3950 for (i
= 0; i
< sym
->nsyms
; i
++)
3951 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3957 bfd_release (abfd
, sym
->symbols
);
3958 sym
->symbols
= NULL
;
3964 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3966 switch ((int) flavour
)
3968 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3969 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3970 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3971 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3972 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3973 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3974 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3975 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3976 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3977 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3978 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3979 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3980 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3981 default: return "UNKNOWN";
3986 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3988 switch ((int) flavour
)
3990 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3991 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3992 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3993 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3994 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3995 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3996 default: return "UNKNOWN";
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
= bfd_alloc (abfd
, namelen
);
4021 if (cmd
->name_str
== NULL
)
4023 if (bfd_seek (abfd
, nameoff
, SEEK_SET
) != 0
4024 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
4030 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4032 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4033 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
4034 struct mach_o_dylib_command_external raw
;
4035 unsigned int nameoff
;
4036 unsigned int namelen
;
4038 if (command
->len
< sizeof (raw
) + 8)
4040 switch (command
->type
)
4042 case BFD_MACH_O_LC_LOAD_DYLIB
:
4043 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4044 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4045 case BFD_MACH_O_LC_ID_DYLIB
:
4046 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4047 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4054 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4057 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4058 if (nameoff
> command
->len
)
4060 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
4061 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
4062 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
4064 cmd
->name_offset
= command
->offset
+ nameoff
;
4065 namelen
= command
->len
- nameoff
;
4066 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
4067 if (cmd
->name_str
== NULL
)
4069 if (bfd_seek (abfd
, mdata
->hdr_offset
+ cmd
->name_offset
, SEEK_SET
) != 0
4070 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
4076 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
4077 bfd_mach_o_load_command
*command
)
4079 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
4080 struct mach_o_prebound_dylib_command_external raw
;
4081 unsigned int nameoff
;
4082 unsigned int modoff
;
4083 unsigned int str_len
;
4086 if (command
->len
< sizeof (raw
) + 8)
4088 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4091 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4092 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
4093 if (nameoff
> command
->len
|| modoff
> command
->len
)
4096 str_len
= command
->len
- sizeof (raw
);
4097 str
= bfd_alloc (abfd
, str_len
);
4100 if (bfd_bread (str
, str_len
, abfd
) != str_len
)
4103 cmd
->name_offset
= command
->offset
+ nameoff
;
4104 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
4105 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
4107 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
4108 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
4113 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
4114 bfd_mach_o_load_command
*command
)
4116 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
4117 struct mach_o_prebind_cksum_command_external raw
;
4119 if (command
->len
< sizeof (raw
) + 8)
4121 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4124 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
4129 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
4130 bfd_mach_o_load_command
*command
)
4132 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
4133 struct mach_o_twolevel_hints_command_external raw
;
4135 if (command
->len
< sizeof (raw
) + 8)
4137 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4140 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
4141 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
4146 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4148 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
4149 struct mach_o_fvmlib_command_external raw
;
4150 unsigned int nameoff
;
4151 unsigned int namelen
;
4153 if (command
->len
< sizeof (raw
) + 8)
4155 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4158 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
4159 if (nameoff
> command
->len
)
4161 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
4162 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
4164 fvm
->name_offset
= command
->offset
+ nameoff
;
4165 namelen
= command
->len
- nameoff
;
4166 fvm
->name_str
= bfd_alloc (abfd
, namelen
);
4167 if (fvm
->name_str
== NULL
)
4169 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
4170 || bfd_bread (fvm
->name_str
, namelen
, abfd
) != namelen
)
4176 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4178 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4179 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
4180 unsigned int offset
;
4181 unsigned int nflavours
;
4183 struct mach_o_thread_command_external raw
;
4186 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
4187 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
4189 /* Count the number of threads. */
4192 while (offset
+ sizeof (raw
) <= command
->len
)
4196 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4197 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4200 count
= bfd_h_get_32 (abfd
, raw
.count
);
4201 if (count
> (unsigned) -1 / 4
4202 || command
->len
- (offset
+ sizeof (raw
)) < count
* 4)
4204 offset
+= sizeof (raw
) + count
* 4;
4207 if (nflavours
== 0 || offset
!= command
->len
)
4210 /* Allocate threads. */
4211 if (_bfd_mul_overflow (nflavours
, sizeof (bfd_mach_o_thread_flavour
), &amt
))
4213 bfd_set_error (bfd_error_file_too_big
);
4216 cmd
->flavours
= bfd_alloc (abfd
, amt
);
4217 if (cmd
->flavours
== NULL
)
4219 cmd
->nflavours
= nflavours
;
4223 while (offset
!= command
->len
)
4225 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4226 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4229 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
4230 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
4231 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
4232 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
4236 for (i
= 0; i
< nflavours
; i
++)
4239 unsigned int snamelen
;
4241 const char *flavourstr
;
4242 const char *prefix
= "LC_THREAD";
4245 switch (mdata
->header
.cputype
)
4247 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4248 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
4250 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
4252 case BFD_MACH_O_CPU_TYPE_I386
:
4253 case BFD_MACH_O_CPU_TYPE_X86_64
:
4255 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
4258 flavourstr
= "UNKNOWN_ARCHITECTURE";
4262 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
4263 sname
= bfd_alloc (abfd
, snamelen
);
4269 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
4270 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
4275 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
4279 bfdsec
->size
= cmd
->flavours
[i
].size
;
4280 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
4281 bfdsec
->alignment_power
= 0x0;
4283 cmd
->section
= bfdsec
;
4290 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4292 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4293 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4295 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4298 struct mach_o_dysymtab_command_external raw
;
4300 if (command
->len
< sizeof (raw
) + 8)
4302 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4305 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4306 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4307 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4308 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4309 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4310 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4311 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4312 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4313 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4314 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4315 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4316 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4317 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4318 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4319 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4320 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4321 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4322 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4325 if (cmd
->nmodtab
!= 0)
4328 int wide
= bfd_mach_o_wide_p (abfd
);
4329 unsigned int module_len
= wide
? 56 : 52;
4332 if (_bfd_mul_overflow (cmd
->nmodtab
,
4333 sizeof (bfd_mach_o_dylib_module
), &amt
))
4335 bfd_set_error (bfd_error_file_too_big
);
4338 cmd
->dylib_module
= bfd_alloc (abfd
, amt
);
4339 if (cmd
->dylib_module
== NULL
)
4342 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4345 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4347 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4349 unsigned char buf
[56];
4351 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4354 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4355 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4356 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4357 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4358 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4359 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4360 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4361 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4362 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4363 v
= bfd_h_get_32 (abfd
, buf
+36);
4364 module
->iinit
= v
& 0xffff;
4365 module
->iterm
= (v
>> 16) & 0xffff;
4366 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4367 module
->ninit
= v
& 0xffff;
4368 module
->nterm
= (v
>> 16) & 0xffff;
4371 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4372 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4376 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4377 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4387 if (_bfd_mul_overflow (cmd
->ntoc
,
4388 sizeof (bfd_mach_o_dylib_table_of_content
), &amt
))
4390 bfd_set_error (bfd_error_file_too_big
);
4393 cmd
->dylib_toc
= bfd_alloc (abfd
, amt
);
4394 if (cmd
->dylib_toc
== NULL
)
4397 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4400 for (i
= 0; i
< cmd
->ntoc
; i
++)
4402 struct mach_o_dylib_table_of_contents_external raw
;
4403 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4405 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4408 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4409 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4413 if (cmd
->nindirectsyms
!= 0)
4418 if (_bfd_mul_overflow (cmd
->nindirectsyms
, sizeof (unsigned int), &amt
))
4420 bfd_set_error (bfd_error_file_too_big
);
4423 cmd
->indirect_syms
= bfd_alloc (abfd
, amt
);
4424 if (cmd
->indirect_syms
== NULL
)
4427 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4430 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4432 unsigned char raw
[4];
4433 unsigned int *is
= &cmd
->indirect_syms
[i
];
4435 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4438 *is
= bfd_h_get_32 (abfd
, raw
);
4442 if (cmd
->nextrefsyms
!= 0)
4448 if (_bfd_mul_overflow (cmd
->nextrefsyms
,
4449 sizeof (bfd_mach_o_dylib_reference
), &amt
))
4451 bfd_set_error (bfd_error_file_too_big
);
4454 cmd
->ext_refs
= bfd_alloc (abfd
, amt
);
4455 if (cmd
->ext_refs
== NULL
)
4458 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4461 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4463 unsigned char raw
[4];
4464 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4466 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4469 /* Fields isym and flags are written as bit-fields, thus we need
4470 a specific processing for endianness. */
4471 v
= bfd_h_get_32 (abfd
, raw
);
4472 if (bfd_big_endian (abfd
))
4474 ref
->isym
= (v
>> 8) & 0xffffff;
4475 ref
->flags
= v
& 0xff;
4479 ref
->isym
= v
& 0xffffff;
4480 ref
->flags
= (v
>> 24) & 0xff;
4485 if (mdata
->dysymtab
)
4487 mdata
->dysymtab
= cmd
;
4493 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4495 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4496 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4497 struct mach_o_symtab_command_external raw
;
4499 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4501 if (command
->len
< sizeof (raw
) + 8)
4503 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4506 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4507 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4508 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4509 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4510 symtab
->symbols
= NULL
;
4511 symtab
->strtab
= NULL
;
4513 if (symtab
->nsyms
!= 0)
4514 abfd
->flags
|= HAS_SYMS
;
4518 mdata
->symtab
= symtab
;
4523 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4525 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4527 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4529 if (command
->len
< 16 + 8)
4531 if (bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4538 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4540 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4541 struct mach_o_linkedit_data_command_external raw
;
4543 if (command
->len
< sizeof (raw
) + 8)
4545 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4548 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4549 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4554 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4556 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4557 struct mach_o_str_command_external raw
;
4560 if (command
->len
< sizeof (raw
) + 8)
4562 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4565 off
= bfd_get_32 (abfd
, raw
.str
);
4566 if (off
> command
->len
)
4569 cmd
->stroff
= command
->offset
+ off
;
4570 cmd
->str_len
= command
->len
- off
;
4571 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
4572 if (cmd
->str
== NULL
)
4574 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
4575 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
4580 static unsigned char *
4581 bfd_mach_o_alloc_and_read (bfd
*abfd
, unsigned int off
, unsigned int size
)
4585 buf
= bfd_alloc (abfd
, size
);
4588 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4589 || bfd_bread (buf
, size
, abfd
) != size
)
4595 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4597 /* Read rebase content. */
4598 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4600 cmd
->rebase_content
=
4601 bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4602 if (cmd
->rebase_content
== NULL
)
4606 /* Read bind content. */
4607 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4610 bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4611 if (cmd
->bind_content
== NULL
)
4615 /* Read weak bind content. */
4616 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4618 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4619 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4620 if (cmd
->weak_bind_content
== NULL
)
4624 /* Read lazy bind content. */
4625 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4627 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4628 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4629 if (cmd
->lazy_bind_content
== NULL
)
4633 /* Read export content. */
4634 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4636 cmd
->export_content
= bfd_mach_o_alloc_and_read
4637 (abfd
, cmd
->export_off
, cmd
->export_size
);
4638 if (cmd
->export_content
== NULL
)
4646 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4648 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4649 struct mach_o_dyld_info_command_external raw
;
4651 if (command
->len
< sizeof (raw
) + 8)
4653 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4656 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4657 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4658 cmd
->rebase_content
= NULL
;
4659 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4660 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4661 cmd
->bind_content
= NULL
;
4662 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4663 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4664 cmd
->weak_bind_content
= NULL
;
4665 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4666 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4667 cmd
->lazy_bind_content
= NULL
;
4668 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4669 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4670 cmd
->export_content
= NULL
;
4675 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4677 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4678 struct mach_o_version_min_command_external raw
;
4680 if (command
->len
< sizeof (raw
) + 8)
4682 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4685 cmd
->version
= bfd_get_32 (abfd
, raw
.version
);
4686 cmd
->sdk
= bfd_get_32 (abfd
, raw
.sdk
);
4691 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4693 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4694 struct mach_o_encryption_info_command_external raw
;
4696 if (command
->len
< sizeof (raw
) + 8)
4698 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4701 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4702 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4703 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4708 bfd_mach_o_read_encryption_info_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4710 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4711 struct mach_o_encryption_info_64_command_external raw
;
4713 if (command
->len
< sizeof (raw
) + 8)
4715 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4718 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4719 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4720 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4725 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4727 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4728 struct mach_o_entry_point_command_external raw
;
4730 if (command
->len
< sizeof (raw
) + 8)
4732 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4735 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4736 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4741 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4743 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4744 struct mach_o_source_version_command_external raw
;
4747 if (command
->len
< sizeof (raw
) + 8)
4749 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4752 ver
= bfd_get_64 (abfd
, raw
.version
);
4753 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4754 generates warnings) in case of the host doesn't support 64 bit
4756 cmd
->e
= ver
& 0x3ff;
4758 cmd
->d
= ver
& 0x3ff;
4760 cmd
->c
= ver
& 0x3ff;
4762 cmd
->b
= ver
& 0x3ff;
4764 cmd
->a
= ver
& 0xffffff;
4769 bfd_mach_o_read_note (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4771 bfd_mach_o_note_command
*cmd
= &command
->command
.note
;
4772 struct mach_o_note_command_external raw
;
4774 if (command
->len
< sizeof (raw
) + 8)
4776 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4779 memcpy (cmd
->data_owner
, raw
.data_owner
, 16);
4780 cmd
->offset
= bfd_get_64 (abfd
, raw
.offset
);
4781 cmd
->size
= bfd_get_64 (abfd
, raw
.size
);
4786 bfd_mach_o_read_build_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4788 bfd_mach_o_build_version_command
*cmd
= &command
->command
.build_version
;
4789 struct mach_o_build_version_command_external raw
;
4791 if (command
->len
< sizeof (raw
) + 8)
4793 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4796 cmd
->platform
= bfd_get_32 (abfd
, raw
.platform
);
4797 cmd
->minos
= bfd_get_32 (abfd
, raw
.minos
);
4798 cmd
->sdk
= bfd_get_32 (abfd
, raw
.sdk
);
4799 cmd
->ntools
= bfd_get_32 (abfd
, raw
.ntools
);
4804 bfd_mach_o_read_segment (bfd
*abfd
,
4805 bfd_mach_o_load_command
*command
,
4808 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4813 struct mach_o_segment_command_64_external raw
;
4815 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4817 if (command
->len
< sizeof (raw
) + 8)
4819 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4822 memcpy (seg
->segname
, raw
.segname
, 16);
4823 seg
->segname
[16] = '\0';
4825 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4826 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4827 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4828 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4829 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4830 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4831 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4832 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4836 struct mach_o_segment_command_32_external raw
;
4838 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4840 if (command
->len
< sizeof (raw
) + 8)
4842 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4845 memcpy (seg
->segname
, raw
.segname
, 16);
4846 seg
->segname
[16] = '\0';
4848 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4849 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4850 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4851 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4852 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4853 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4854 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4855 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4857 seg
->sect_head
= NULL
;
4858 seg
->sect_tail
= NULL
;
4860 for (i
= 0; i
< seg
->nsects
; i
++)
4864 sec
= bfd_mach_o_read_section (abfd
, seg
->initprot
, wide
);
4868 bfd_mach_o_append_section_to_segment
4869 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4876 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4878 return bfd_mach_o_read_segment (abfd
, command
, 0);
4882 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4884 return bfd_mach_o_read_segment (abfd
, command
, 1);
4888 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4890 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4891 struct mach_o_load_command_external raw
;
4894 /* Read command type and length. */
4895 if (bfd_seek (abfd
, mdata
->hdr_offset
+ command
->offset
, SEEK_SET
) != 0
4896 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4899 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4900 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4901 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4902 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4903 if (command
->len
< 8 || command
->len
% 4 != 0)
4906 switch (command
->type
)
4908 case BFD_MACH_O_LC_SEGMENT
:
4909 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4912 case BFD_MACH_O_LC_SEGMENT_64
:
4913 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4916 case BFD_MACH_O_LC_SYMTAB
:
4917 if (!bfd_mach_o_read_symtab (abfd
, command
))
4920 case BFD_MACH_O_LC_SYMSEG
:
4922 case BFD_MACH_O_LC_THREAD
:
4923 case BFD_MACH_O_LC_UNIXTHREAD
:
4924 if (!bfd_mach_o_read_thread (abfd
, command
))
4927 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4928 case BFD_MACH_O_LC_ID_DYLINKER
:
4929 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4930 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4933 case BFD_MACH_O_LC_LOAD_DYLIB
:
4934 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4935 case BFD_MACH_O_LC_ID_DYLIB
:
4936 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4937 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4938 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4939 if (!bfd_mach_o_read_dylib (abfd
, command
))
4942 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4943 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4946 case BFD_MACH_O_LC_LOADFVMLIB
:
4947 case BFD_MACH_O_LC_IDFVMLIB
:
4948 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4951 case BFD_MACH_O_LC_IDENT
:
4952 case BFD_MACH_O_LC_FVMFILE
:
4953 case BFD_MACH_O_LC_PREPAGE
:
4954 case BFD_MACH_O_LC_ROUTINES
:
4955 case BFD_MACH_O_LC_ROUTINES_64
:
4957 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4958 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4959 case BFD_MACH_O_LC_SUB_LIBRARY
:
4960 case BFD_MACH_O_LC_SUB_CLIENT
:
4961 case BFD_MACH_O_LC_RPATH
:
4962 if (!bfd_mach_o_read_str (abfd
, command
))
4965 case BFD_MACH_O_LC_DYSYMTAB
:
4966 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4969 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4970 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4973 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4974 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4977 case BFD_MACH_O_LC_UUID
:
4978 if (!bfd_mach_o_read_uuid (abfd
, command
))
4981 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4982 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4983 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4984 case BFD_MACH_O_LC_DATA_IN_CODE
:
4985 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4986 case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT
:
4987 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4990 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4991 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4994 case BFD_MACH_O_LC_ENCRYPTION_INFO_64
:
4995 if (!bfd_mach_o_read_encryption_info_64 (abfd
, command
))
4998 case BFD_MACH_O_LC_DYLD_INFO
:
4999 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
5002 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
5003 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
5004 case BFD_MACH_O_LC_VERSION_MIN_WATCHOS
:
5005 case BFD_MACH_O_LC_VERSION_MIN_TVOS
:
5006 if (!bfd_mach_o_read_version_min (abfd
, command
))
5009 case BFD_MACH_O_LC_MAIN
:
5010 if (!bfd_mach_o_read_main (abfd
, command
))
5013 case BFD_MACH_O_LC_SOURCE_VERSION
:
5014 if (!bfd_mach_o_read_source_version (abfd
, command
))
5017 case BFD_MACH_O_LC_LINKER_OPTIONS
:
5019 case BFD_MACH_O_LC_NOTE
:
5020 if (!bfd_mach_o_read_note (abfd
, command
))
5023 case BFD_MACH_O_LC_BUILD_VERSION
:
5024 if (!bfd_mach_o_read_build_version (abfd
, command
))
5029 _bfd_error_handler (_("%pB: unknown load command %#x"),
5030 abfd
, command
->type
);
5038 bfd_mach_o_flatten_sections (bfd
*abfd
)
5040 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5041 bfd_mach_o_load_command
*cmd
;
5045 /* Count total number of sections. */
5048 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5050 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
5051 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
5053 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
5055 mdata
->nsects
+= seg
->nsects
;
5059 /* Allocate sections array. */
5060 if (_bfd_mul_overflow (mdata
->nsects
, sizeof (bfd_mach_o_section
*), &amt
))
5062 bfd_set_error (bfd_error_file_too_big
);
5065 mdata
->sections
= bfd_alloc (abfd
, amt
);
5066 if (mdata
->sections
== NULL
&& mdata
->nsects
!= 0)
5069 /* Fill the array. */
5072 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5074 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
5075 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
5077 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
5078 bfd_mach_o_section
*sec
;
5080 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
5082 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
5083 mdata
->sections
[csect
++] = sec
;
5090 bfd_mach_o_scan_start_address (bfd
*abfd
)
5092 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5093 bfd_mach_o_thread_command
*thr
= NULL
;
5094 bfd_mach_o_load_command
*cmd
;
5097 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5098 if (cmd
->type
== BFD_MACH_O_LC_THREAD
5099 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
5101 thr
= &cmd
->command
.thread
;
5104 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
5106 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
5107 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
5111 abfd
->start_address
= main_cmd
->entryoff
5112 + (text_sect
->addr
- text_sect
->offset
);
5117 /* An object file has no start address, so do not fail if not found. */
5121 /* FIXME: create a subtarget hook ? */
5122 for (i
= 0; i
< thr
->nflavours
; i
++)
5124 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
5125 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
5127 unsigned char buf
[4];
5129 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
5130 || bfd_bread (buf
, 4, abfd
) != 4)
5133 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
5135 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
5136 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
5138 unsigned char buf
[4];
5140 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
5141 || bfd_bread (buf
, 4, abfd
) != 4)
5144 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
5146 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
5147 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
5149 unsigned char buf
[8];
5151 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
5152 || bfd_bread (buf
, 8, abfd
) != 8)
5155 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
5157 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
5158 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
5160 unsigned char buf
[8];
5162 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
5163 || bfd_bread (buf
, 8, abfd
) != 8)
5166 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
5174 bfd_mach_o_set_arch_mach (bfd
*abfd
,
5175 enum bfd_architecture arch
,
5176 unsigned long machine
)
5178 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5180 /* If this isn't the right architecture for this backend, and this
5181 isn't the generic backend, fail. */
5182 if (arch
!= bed
->arch
5183 && arch
!= bfd_arch_unknown
5184 && bed
->arch
!= bfd_arch_unknown
)
5187 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5191 bfd_mach_o_scan (bfd
*abfd
,
5192 bfd_mach_o_header
*header
,
5193 bfd_mach_o_data_struct
*mdata
)
5196 enum bfd_architecture cpu_type
;
5197 unsigned long cpu_subtype
;
5198 unsigned int hdrsize
;
5200 hdrsize
= mach_o_wide_p (header
) ?
5201 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
5203 mdata
->header
= *header
;
5205 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
5206 switch (header
->filetype
)
5208 case BFD_MACH_O_MH_OBJECT
:
5209 abfd
->flags
|= HAS_RELOC
;
5211 case BFD_MACH_O_MH_EXECUTE
:
5212 abfd
->flags
|= EXEC_P
;
5214 case BFD_MACH_O_MH_DYLIB
:
5215 case BFD_MACH_O_MH_BUNDLE
:
5216 abfd
->flags
|= DYNAMIC
;
5220 abfd
->tdata
.mach_o_data
= mdata
;
5222 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
5223 &cpu_type
, &cpu_subtype
);
5224 if (cpu_type
== bfd_arch_unknown
)
5227 /* xgettext:c-format */
5228 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5229 header
->cputype
, header
->cpusubtype
);
5233 bfd_set_arch_mach (abfd
, cpu_type
, cpu_subtype
);
5235 if (header
->ncmds
!= 0)
5237 bfd_mach_o_load_command
*cmd
;
5240 mdata
->first_command
= NULL
;
5241 mdata
->last_command
= NULL
;
5243 if (_bfd_mul_overflow (header
->ncmds
,
5244 sizeof (bfd_mach_o_load_command
), &amt
))
5246 bfd_set_error (bfd_error_file_too_big
);
5249 cmd
= bfd_alloc (abfd
, amt
);
5253 for (i
= 0; i
< header
->ncmds
; i
++)
5255 bfd_mach_o_load_command
*cur
= &cmd
[i
];
5257 bfd_mach_o_append_command (abfd
, cur
);
5260 cur
->offset
= hdrsize
;
5263 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
5264 cur
->offset
= prev
->offset
+ prev
->len
;
5267 if (!bfd_mach_o_read_command (abfd
, cur
))
5272 /* Sections should be flatten before scanning start address. */
5273 if (!bfd_mach_o_flatten_sections (abfd
))
5275 if (!bfd_mach_o_scan_start_address (abfd
))
5282 bfd_mach_o_mkobject_init (bfd
*abfd
)
5284 bfd_mach_o_data_struct
*mdata
= NULL
;
5286 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
5289 abfd
->tdata
.mach_o_data
= mdata
;
5291 mdata
->header
.magic
= 0;
5292 mdata
->header
.cputype
= 0;
5293 mdata
->header
.cpusubtype
= 0;
5294 mdata
->header
.filetype
= 0;
5295 mdata
->header
.ncmds
= 0;
5296 mdata
->header
.sizeofcmds
= 0;
5297 mdata
->header
.flags
= 0;
5298 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
5299 mdata
->first_command
= NULL
;
5300 mdata
->last_command
= NULL
;
5302 mdata
->sections
= NULL
;
5303 mdata
->dyn_reloc_cache
= NULL
;
5309 bfd_mach_o_gen_mkobject (bfd
*abfd
)
5311 bfd_mach_o_data_struct
*mdata
;
5313 if (!bfd_mach_o_mkobject_init (abfd
))
5316 mdata
= bfd_mach_o_get_data (abfd
);
5317 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
5318 mdata
->header
.cputype
= 0;
5319 mdata
->header
.cpusubtype
= 0;
5320 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
5321 mdata
->header
.version
= 1;
5327 bfd_mach_o_header_p (bfd
*abfd
,
5329 bfd_mach_o_filetype file_type
,
5330 bfd_mach_o_cpu_type cpu_type
)
5332 bfd_mach_o_header header
;
5333 bfd_mach_o_data_struct
*mdata
;
5335 if (!bfd_mach_o_read_header (abfd
, hdr_off
, &header
))
5338 if (! (header
.byteorder
== BFD_ENDIAN_BIG
5339 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
5341 _bfd_error_handler (_("unknown header byte-order value %#x"),
5346 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
5347 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
5348 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
5349 || (header
.byteorder
== BFD_ENDIAN_LITTLE
5350 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
5351 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
5354 /* Check cputype and filetype.
5355 In case of wildcard, do not accept magics that are handled by existing
5359 if (header
.cputype
!= cpu_type
)
5365 /* Do not recognize 64 architectures if not configured for 64bit targets.
5366 This could happen only for generic targets. */
5367 if (mach_o_wide_p (&header
))
5374 if (header
.filetype
!= file_type
)
5379 switch (header
.filetype
)
5381 case BFD_MACH_O_MH_CORE
:
5382 /* Handled by core_p */
5389 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
5392 mdata
->hdr_offset
= hdr_off
;
5394 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
5400 bfd_set_error (bfd_error_wrong_format
);
5406 static const bfd_target
*
5407 bfd_mach_o_gen_object_p (bfd
*abfd
)
5409 return bfd_mach_o_header_p (abfd
, 0, 0, 0);
5412 static const bfd_target
*
5413 bfd_mach_o_gen_core_p (bfd
*abfd
)
5415 return bfd_mach_o_header_p (abfd
, 0, BFD_MACH_O_MH_CORE
, 0);
5418 /* Return the base address of ABFD, ie the address at which the image is
5419 mapped. The possible initial pagezero is ignored. */
5422 bfd_mach_o_get_base_address (bfd
*abfd
)
5424 bfd_mach_o_data_struct
*mdata
;
5425 bfd_mach_o_load_command
*cmd
;
5427 /* Check for Mach-O. */
5428 if (!bfd_mach_o_valid (abfd
))
5430 mdata
= bfd_mach_o_get_data (abfd
);
5432 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5434 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5435 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5437 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5439 if (segcmd
->initprot
!= 0)
5440 return segcmd
->vmaddr
;
5446 typedef struct mach_o_fat_archentry
5448 unsigned long cputype
;
5449 unsigned long cpusubtype
;
5450 unsigned long offset
;
5452 unsigned long align
;
5453 } mach_o_fat_archentry
;
5455 typedef struct mach_o_fat_data_struct
5457 unsigned long magic
;
5458 unsigned long nfat_arch
;
5459 mach_o_fat_archentry
*archentries
;
5460 } mach_o_fat_data_struct
;
5463 bfd_mach_o_fat_archive_p (bfd
*abfd
)
5465 mach_o_fat_data_struct
*adata
= NULL
;
5466 struct mach_o_fat_header_external hdr
;
5470 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5471 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5474 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5478 adata
->magic
= bfd_getb32 (hdr
.magic
);
5479 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5480 if (adata
->magic
!= 0xcafebabe)
5482 /* Avoid matching Java bytecode files, which have the same magic number.
5483 In the Java bytecode file format this field contains the JVM version,
5484 which starts at 43.0. */
5485 if (adata
->nfat_arch
> 30)
5488 if (_bfd_mul_overflow (adata
->nfat_arch
,
5489 sizeof (mach_o_fat_archentry
), &amt
))
5491 bfd_set_error (bfd_error_file_too_big
);
5494 adata
->archentries
= bfd_alloc (abfd
, amt
);
5495 if (adata
->archentries
== NULL
)
5498 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5500 struct mach_o_fat_arch_external arch
;
5501 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5503 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5504 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5505 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5506 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5507 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5510 abfd
->tdata
.mach_o_fat_data
= adata
;
5516 bfd_release (abfd
, adata
);
5517 bfd_set_error (bfd_error_wrong_format
);
5521 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5522 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5523 Set arelt_data and origin fields too. */
5526 bfd_mach_o_fat_member_init (bfd
*abfd
,
5527 enum bfd_architecture arch_type
,
5528 unsigned long arch_subtype
,
5529 mach_o_fat_archentry
*entry
)
5531 struct areltdata
*areltdata
;
5532 /* Create the member filename. Use ARCH_NAME. */
5533 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5538 /* Use the architecture name if known. */
5539 filename
= bfd_strdup (ap
->printable_name
);
5540 if (filename
== NULL
)
5545 /* Forge a uniq id. */
5546 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5547 filename
= bfd_malloc (namelen
);
5548 if (filename
== NULL
)
5550 snprintf (filename
, namelen
, "0x%lx-0x%lx",
5551 entry
->cputype
, entry
->cpusubtype
);
5553 bfd_set_filename (abfd
, filename
);
5555 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5556 if (areltdata
== NULL
)
5558 areltdata
->parsed_size
= entry
->size
;
5559 abfd
->arelt_data
= areltdata
;
5560 abfd
->iostream
= NULL
;
5561 abfd
->origin
= entry
->offset
;
5566 bfd_mach_o_fat_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5568 mach_o_fat_data_struct
*adata
;
5569 mach_o_fat_archentry
*entry
= NULL
;
5572 enum bfd_architecture arch_type
;
5573 unsigned long arch_subtype
;
5575 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5576 BFD_ASSERT (adata
!= NULL
);
5578 /* Find index of previous entry. */
5581 /* Start at first one. */
5586 /* Find index of PREV. */
5587 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5589 if (adata
->archentries
[i
].offset
== prev
->origin
)
5593 if (i
== adata
->nfat_arch
)
5596 bfd_set_error (bfd_error_bad_value
);
5600 /* Get next entry. */
5604 if (i
>= adata
->nfat_arch
)
5606 bfd_set_error (bfd_error_no_more_archived_files
);
5610 entry
= &adata
->archentries
[i
];
5611 nbfd
= _bfd_new_bfd_contained_in (archive
);
5615 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5616 &arch_type
, &arch_subtype
);
5618 if (!bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
))
5624 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5629 /* Analogous to stat call. */
5632 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5634 if (abfd
->arelt_data
== NULL
)
5636 bfd_set_error (bfd_error_invalid_operation
);
5643 buf
->st_mode
= 0644;
5644 buf
->st_size
= arelt_size (abfd
);
5649 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5650 If ABFD is a fat image containing a member that corresponds to FORMAT
5651 and ARCH, returns it.
5652 In other case, returns NULL.
5653 This function allows transparent uses of fat images. */
5656 bfd_mach_o_fat_extract (bfd
*abfd
,
5658 const bfd_arch_info_type
*arch
)
5661 mach_o_fat_data_struct
*adata
;
5664 if (bfd_check_format (abfd
, format
))
5666 if (bfd_get_arch_info (abfd
) == arch
)
5670 if (!bfd_check_format (abfd
, bfd_archive
)
5671 || abfd
->xvec
!= &mach_o_fat_vec
)
5674 /* This is a Mach-O fat image. */
5675 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5676 BFD_ASSERT (adata
!= NULL
);
5678 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5680 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5681 enum bfd_architecture cpu_type
;
5682 unsigned long cpu_subtype
;
5684 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5685 &cpu_type
, &cpu_subtype
);
5686 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5689 /* The architecture is found. */
5690 res
= _bfd_new_bfd_contained_in (abfd
);
5694 if (bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
)
5695 && bfd_check_format (res
, format
))
5697 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5708 bfd_mach_o_fat_close_and_cleanup (bfd
*abfd
)
5710 _bfd_unlink_from_archive_parent (abfd
);
5715 bfd_mach_o_lookup_command (bfd
*abfd
,
5716 bfd_mach_o_load_command_type type
,
5717 bfd_mach_o_load_command
**mcommand
)
5719 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5720 struct bfd_mach_o_load_command
*cmd
;
5723 BFD_ASSERT (mdata
!= NULL
);
5724 BFD_ASSERT (mcommand
!= NULL
);
5727 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5729 if (cmd
->type
!= type
)
5741 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5745 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5747 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5749 case BFD_MACH_O_CPU_TYPE_I386
:
5751 case BFD_MACH_O_CPU_TYPE_SPARC
:
5753 case BFD_MACH_O_CPU_TYPE_HPPA
:
5754 return 0xc0000000 - 0x04000000;
5760 /* The following two tables should be kept, as far as possible, in order of
5761 most frequently used entries to optimize their use from gas. */
5763 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5765 { "regular", BFD_MACH_O_S_REGULAR
},
5766 { "coalesced", BFD_MACH_O_S_COALESCED
},
5767 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5768 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5769 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5770 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5771 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5772 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5773 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5774 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5775 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5776 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5777 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5778 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5779 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5780 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5781 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5785 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5787 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5788 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5789 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5790 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5791 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5792 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5793 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5794 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5795 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5796 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5797 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5801 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5804 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5806 const bfd_mach_o_xlat_name
*x
;
5807 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5809 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5810 if (strcmp (x
->name
, name
) == 0)
5812 /* We found it... does the target support it? */
5813 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5814 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5815 return x
->val
; /* OK. */
5817 break; /* Not supported. */
5819 /* Maximum section ID = 0xff. */
5823 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5826 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5828 const bfd_mach_o_xlat_name
*x
;
5830 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5831 if (strcmp (x
->name
, name
) == 0)
5833 return (unsigned int)-1;
5837 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5838 unsigned char **rbuf
,
5841 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5842 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5843 bfd_mach_o_load_command
*cmd
;
5845 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5847 bfd_mach_o_segment_command
*seg
;
5849 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5852 seg
= &cmd
->command
.segment
;
5854 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5856 unsigned long start
= seg
->fileoff
;
5857 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5858 unsigned char *buf
= bfd_malloc (1024);
5859 unsigned long size
= 1024;
5865 bfd_size_type nread
= 0;
5866 unsigned long offset
;
5867 int found_nonnull
= 0;
5869 if (size
> (end
- start
))
5870 size
= (end
- start
);
5872 buf
= bfd_realloc_or_free (buf
, size
);
5876 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5882 nread
= bfd_bread (buf
, size
, abfd
);
5890 for (offset
= 4; offset
<= size
; offset
+= 4)
5894 val
= *((unsigned long *) (buf
+ size
- offset
));
5895 if (! found_nonnull
)
5900 else if (val
== 0x0)
5902 unsigned long bottom
;
5905 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5906 top
= seg
->fileoff
+ seg
->filesize
- 4;
5907 *rbuf
= bfd_malloc (top
- bottom
);
5910 *rlen
= top
- bottom
;
5912 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5918 if (size
== (end
- start
))
5932 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5934 unsigned char *buf
= NULL
;
5935 unsigned int len
= 0;
5938 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5942 return (char *) buf
;
5946 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5951 static bfd_mach_o_uuid_command
*
5952 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5954 bfd_mach_o_load_command
*uuid_cmd
= NULL
;
5955 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5956 if (ncmd
!= 1 || uuid_cmd
== NULL
)
5958 return &uuid_cmd
->command
.uuid
;
5961 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5964 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5966 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5969 BFD_ASSERT (uuid_cmd
);
5971 if (!bfd_check_format (abfd
, bfd_object
))
5974 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5975 || bfd_mach_o_get_data (abfd
) == NULL
5976 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5979 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5980 if (dsym_uuid_cmd
== NULL
)
5983 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5984 sizeof (uuid_cmd
->uuid
)) != 0)
5990 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5991 The caller is responsible for closing the returned BFD object and
5992 its my_archive if the returned BFD is in a fat dSYM. */
5995 bfd_mach_o_find_dsym (const char *dsym_filename
,
5996 const bfd_mach_o_uuid_command
*uuid_cmd
,
5997 const bfd_arch_info_type
*arch
)
5999 bfd
*base_dsym_bfd
, *dsym_bfd
;
6001 BFD_ASSERT (uuid_cmd
);
6003 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
6004 if (base_dsym_bfd
== NULL
)
6007 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
6008 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
6011 bfd_close (dsym_bfd
);
6012 if (base_dsym_bfd
!= dsym_bfd
)
6013 bfd_close (base_dsym_bfd
);
6018 /* Return a BFD created from a dSYM file for ABFD.
6019 The caller is responsible for closing the returned BFD object, its
6020 filename, and its my_archive if the returned BFD is in a fat dSYM. */
6023 bfd_mach_o_follow_dsym (bfd
*abfd
)
6025 char *dsym_filename
;
6026 bfd_mach_o_uuid_command
*uuid_cmd
;
6027 bfd
*dsym_bfd
, *base_bfd
= abfd
;
6028 const char *base_basename
;
6030 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
6033 if (abfd
->my_archive
&& !bfd_is_thin_archive (abfd
->my_archive
))
6034 base_bfd
= abfd
->my_archive
;
6035 /* BFD may have been opened from a stream. */
6036 if (base_bfd
->filename
== NULL
)
6038 bfd_set_error (bfd_error_invalid_operation
);
6041 base_basename
= lbasename (base_bfd
->filename
);
6043 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
6044 if (uuid_cmd
== NULL
)
6047 /* TODO: We assume the DWARF file has the same as the binary's.
6048 It seems apple's GDB checks all files in the dSYM bundle directory.
6049 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
6051 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
6052 + strlen (dsym_subdir
) + 1
6053 + strlen (base_basename
) + 1);
6054 if (dsym_filename
== NULL
)
6057 sprintf (dsym_filename
, "%s%s/%s",
6058 base_bfd
->filename
, dsym_subdir
, base_basename
);
6060 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
6061 bfd_get_arch_info (abfd
));
6062 if (dsym_bfd
== NULL
)
6063 free (dsym_filename
);
6069 bfd_mach_o_find_nearest_line (bfd
*abfd
,
6073 const char **filename_ptr
,
6074 const char **functionname_ptr
,
6075 unsigned int *line_ptr
,
6076 unsigned int *discriminator_ptr
)
6078 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6081 switch (mdata
->header
.filetype
)
6083 case BFD_MACH_O_MH_OBJECT
:
6085 case BFD_MACH_O_MH_EXECUTE
:
6086 case BFD_MACH_O_MH_DYLIB
:
6087 case BFD_MACH_O_MH_BUNDLE
:
6088 case BFD_MACH_O_MH_KEXT_BUNDLE
:
6089 if (mdata
->dwarf2_find_line_info
== NULL
)
6091 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
6092 /* When we couldn't find dSYM for this binary, we look for
6093 the debug information in the binary itself. In this way,
6094 we won't try finding separated dSYM again because
6095 mdata->dwarf2_find_line_info will be filled. */
6096 if (! mdata
->dsym_bfd
)
6098 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
6099 dwarf_debug_sections
, symbols
,
6100 &mdata
->dwarf2_find_line_info
,
6108 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
6109 filename_ptr
, functionname_ptr
,
6110 line_ptr
, discriminator_ptr
,
6111 dwarf_debug_sections
,
6112 &mdata
->dwarf2_find_line_info
);
6116 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
6118 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6119 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
6121 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
6122 bfd_mach_o_free_cached_info (abfd
);
6123 if (mdata
->dsym_bfd
!= NULL
)
6125 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
6127 /* FIXME: PR 19435: This calculation to find the memory allocated by
6128 bfd_mach_o_follow_dsym for the filename does not always end up
6129 selecting the correct pointer. Unfortunately this problem is
6130 very hard to reproduce on a non Mach-O native system, so until it
6131 can be traced and fixed on such a system, this code will remain
6132 commented out. This does mean that there will be a memory leak,
6133 but it is small, and happens when we are closing down, so it
6134 should not matter too much. */
6135 char *dsym_filename
= (char *)(fat_bfd
6137 : mdata
->dsym_bfd
->filename
);
6139 bfd_close (mdata
->dsym_bfd
);
6140 mdata
->dsym_bfd
= NULL
;
6142 bfd_close (fat_bfd
);
6144 free (dsym_filename
);
6149 return _bfd_generic_close_and_cleanup (abfd
);
6153 bfd_mach_o_free_cached_info (bfd
*abfd
)
6155 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
6157 free (mdata
->dyn_reloc_cache
);
6158 mdata
->dyn_reloc_cache
= NULL
;
6159 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
6161 free (asect
->relocation
);
6162 asect
->relocation
= NULL
;
6168 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
6169 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6171 #define bfd_mach_o_canonicalize_one_reloc NULL
6172 #define bfd_mach_o_swap_reloc_out NULL
6173 #define bfd_mach_o_print_thread NULL
6174 #define bfd_mach_o_tgt_seg_table NULL
6175 #define bfd_mach_o_section_type_valid_for_tgt NULL
6177 #define TARGET_NAME mach_o_be_vec
6178 #define TARGET_STRING "mach-o-be"
6179 #define TARGET_ARCHITECTURE bfd_arch_unknown
6180 #define TARGET_PAGESIZE 1
6181 #define TARGET_BIG_ENDIAN 1
6182 #define TARGET_ARCHIVE 0
6183 #define TARGET_PRIORITY 1
6184 #include "mach-o-target.c"
6187 #undef TARGET_STRING
6188 #undef TARGET_ARCHITECTURE
6189 #undef TARGET_PAGESIZE
6190 #undef TARGET_BIG_ENDIAN
6191 #undef TARGET_ARCHIVE
6192 #undef TARGET_PRIORITY
6194 #define TARGET_NAME mach_o_le_vec
6195 #define TARGET_STRING "mach-o-le"
6196 #define TARGET_ARCHITECTURE bfd_arch_unknown
6197 #define TARGET_PAGESIZE 1
6198 #define TARGET_BIG_ENDIAN 0
6199 #define TARGET_ARCHIVE 0
6200 #define TARGET_PRIORITY 1
6202 #include "mach-o-target.c"
6205 #undef TARGET_STRING
6206 #undef TARGET_ARCHITECTURE
6207 #undef TARGET_PAGESIZE
6208 #undef TARGET_BIG_ENDIAN
6209 #undef TARGET_ARCHIVE
6210 #undef TARGET_PRIORITY
6212 /* Not yet handled: creating an archive. */
6213 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
6215 #define bfd_mach_o_close_and_cleanup bfd_mach_o_fat_close_and_cleanup
6218 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
6219 #define bfd_mach_o_openr_next_archived_file bfd_mach_o_fat_openr_next_archived_file
6220 #define bfd_mach_o_archive_p bfd_mach_o_fat_archive_p
6222 #define TARGET_NAME mach_o_fat_vec
6223 #define TARGET_STRING "mach-o-fat"
6224 #define TARGET_ARCHITECTURE bfd_arch_unknown
6225 #define TARGET_PAGESIZE 1
6226 #define TARGET_BIG_ENDIAN 1
6227 #define TARGET_ARCHIVE 1
6228 #define TARGET_PRIORITY 0
6230 #include "mach-o-target.c"
6233 #undef TARGET_STRING
6234 #undef TARGET_ARCHITECTURE
6235 #undef TARGET_PAGESIZE
6236 #undef TARGET_BIG_ENDIAN
6237 #undef TARGET_ARCHIVE
6238 #undef TARGET_PRIORITY