1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2015 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "libiberty.h"
26 #include "aout/stab_gnu.h"
27 #include "mach-o/reloc.h"
28 #include "mach-o/external.h"
33 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
34 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
35 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
37 #define FILE_ALIGN(off, algn) \
38 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
41 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
);
44 bfd_mach_o_version (bfd
*abfd
)
46 bfd_mach_o_data_struct
*mdata
= NULL
;
48 BFD_ASSERT (bfd_mach_o_valid (abfd
));
49 mdata
= bfd_mach_o_get_data (abfd
);
51 return mdata
->header
.version
;
55 bfd_mach_o_valid (bfd
*abfd
)
57 if (abfd
== NULL
|| abfd
->xvec
== NULL
)
60 if (abfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
63 if (bfd_mach_o_get_data (abfd
) == NULL
)
68 static INLINE bfd_boolean
69 mach_o_wide_p (bfd_mach_o_header
*header
)
71 switch (header
->version
)
83 static INLINE bfd_boolean
84 bfd_mach_o_wide_p (bfd
*abfd
)
86 return mach_o_wide_p (&bfd_mach_o_get_data (abfd
)->header
);
89 /* Tables to translate well known Mach-O segment/section names to bfd
90 names. Use of canonical names (such as .text or .debug_frame) is required
94 static const mach_o_section_name_xlat text_section_names_xlat
[] =
97 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
98 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
, 0},
99 { ".const", "__const",
100 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
101 BFD_MACH_O_S_ATTR_NONE
, 0},
102 { ".static_const", "__static_const",
103 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
104 BFD_MACH_O_S_ATTR_NONE
, 0},
105 { ".cstring", "__cstring",
106 SEC_READONLY
| SEC_DATA
| SEC_LOAD
| SEC_MERGE
| SEC_STRINGS
,
107 BFD_MACH_O_S_CSTRING_LITERALS
,
108 BFD_MACH_O_S_ATTR_NONE
, 0},
109 { ".literal4", "__literal4",
110 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_4BYTE_LITERALS
,
111 BFD_MACH_O_S_ATTR_NONE
, 2},
112 { ".literal8", "__literal8",
113 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_8BYTE_LITERALS
,
114 BFD_MACH_O_S_ATTR_NONE
, 3},
115 { ".literal16", "__literal16",
116 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_16BYTE_LITERALS
,
117 BFD_MACH_O_S_ATTR_NONE
, 4},
118 { ".constructor", "__constructor",
119 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
120 BFD_MACH_O_S_ATTR_NONE
, 0},
121 { ".destructor", "__destructor",
122 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
123 BFD_MACH_O_S_ATTR_NONE
, 0},
124 { ".eh_frame", "__eh_frame",
125 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_COALESCED
,
126 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
127 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
128 | BFD_MACH_O_S_ATTR_NO_TOC
, 2},
129 { NULL
, NULL
, 0, 0, 0, 0}
132 /* __DATA Segment. */
133 static const mach_o_section_name_xlat data_section_names_xlat
[] =
136 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
137 BFD_MACH_O_S_ATTR_NONE
, 0},
139 SEC_NO_FLAGS
, BFD_MACH_O_S_ZEROFILL
,
140 BFD_MACH_O_S_ATTR_NONE
, 0},
141 { ".const_data", "__const",
142 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
143 BFD_MACH_O_S_ATTR_NONE
, 0},
144 { ".static_data", "__static_data",
145 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
146 BFD_MACH_O_S_ATTR_NONE
, 0},
147 { ".mod_init_func", "__mod_init_func",
148 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
,
149 BFD_MACH_O_S_ATTR_NONE
, 2},
150 { ".mod_term_func", "__mod_term_func",
151 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
,
152 BFD_MACH_O_S_ATTR_NONE
, 2},
154 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
155 BFD_MACH_O_S_ATTR_NONE
, 0},
156 { ".cfstring", "__cfstring",
157 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
158 BFD_MACH_O_S_ATTR_NONE
, 2},
159 { NULL
, NULL
, 0, 0, 0, 0}
162 /* __DWARF Segment. */
163 static const mach_o_section_name_xlat dwarf_section_names_xlat
[] =
165 { ".debug_frame", "__debug_frame",
166 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
167 BFD_MACH_O_S_ATTR_DEBUG
, 0},
168 { ".debug_info", "__debug_info",
169 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
170 BFD_MACH_O_S_ATTR_DEBUG
, 0},
171 { ".debug_abbrev", "__debug_abbrev",
172 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
173 BFD_MACH_O_S_ATTR_DEBUG
, 0},
174 { ".debug_aranges", "__debug_aranges",
175 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
176 BFD_MACH_O_S_ATTR_DEBUG
, 0},
177 { ".debug_macinfo", "__debug_macinfo",
178 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
179 BFD_MACH_O_S_ATTR_DEBUG
, 0},
180 { ".debug_line", "__debug_line",
181 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
182 BFD_MACH_O_S_ATTR_DEBUG
, 0},
183 { ".debug_loc", "__debug_loc",
184 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
185 BFD_MACH_O_S_ATTR_DEBUG
, 0},
186 { ".debug_pubnames", "__debug_pubnames",
187 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
188 BFD_MACH_O_S_ATTR_DEBUG
, 0},
189 { ".debug_pubtypes", "__debug_pubtypes",
190 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
191 BFD_MACH_O_S_ATTR_DEBUG
, 0},
192 { ".debug_str", "__debug_str",
193 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
194 BFD_MACH_O_S_ATTR_DEBUG
, 0},
195 { ".debug_ranges", "__debug_ranges",
196 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
197 BFD_MACH_O_S_ATTR_DEBUG
, 0},
198 { ".debug_macro", "__debug_macro",
199 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
200 BFD_MACH_O_S_ATTR_DEBUG
, 0},
201 { ".debug_gdb_scripts", "__debug_gdb_scri",
202 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
203 BFD_MACH_O_S_ATTR_DEBUG
, 0},
204 { NULL
, NULL
, 0, 0, 0, 0}
207 /* __OBJC Segment. */
208 static const mach_o_section_name_xlat objc_section_names_xlat
[] =
210 { ".objc_class", "__class",
211 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
212 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
213 { ".objc_meta_class", "__meta_class",
214 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
215 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
216 { ".objc_cat_cls_meth", "__cat_cls_meth",
217 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
218 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
219 { ".objc_cat_inst_meth", "__cat_inst_meth",
220 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
221 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
222 { ".objc_protocol", "__protocol",
223 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
224 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
225 { ".objc_string_object", "__string_object",
226 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
227 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
228 { ".objc_cls_meth", "__cls_meth",
229 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
230 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
231 { ".objc_inst_meth", "__inst_meth",
232 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
233 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
234 { ".objc_cls_refs", "__cls_refs",
235 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
236 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
237 { ".objc_message_refs", "__message_refs",
238 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
239 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
240 { ".objc_symbols", "__symbols",
241 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
242 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
243 { ".objc_category", "__category",
244 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
245 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
246 { ".objc_class_vars", "__class_vars",
247 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
248 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
249 { ".objc_instance_vars", "__instance_vars",
250 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
251 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
252 { ".objc_module_info", "__module_info",
253 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
254 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
255 { ".objc_selector_strs", "__selector_strs",
256 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_CSTRING_LITERALS
,
257 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
258 { ".objc_image_info", "__image_info",
259 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
260 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
261 { ".objc_selector_fixup", "__sel_fixup",
262 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
263 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
265 { ".objc1_class_ext", "__class_ext",
266 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
267 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
268 { ".objc1_property_list", "__property",
269 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
270 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
271 { ".objc1_protocol_ext", "__protocol_ext",
272 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
273 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
274 { NULL
, NULL
, 0, 0, 0, 0}
277 static const mach_o_segment_name_xlat segsec_names_xlat
[] =
279 { "__TEXT", text_section_names_xlat
},
280 { "__DATA", data_section_names_xlat
},
281 { "__DWARF", dwarf_section_names_xlat
},
282 { "__OBJC", objc_section_names_xlat
},
286 static const char dsym_subdir
[] = ".dSYM/Contents/Resources/DWARF";
288 /* For both cases bfd-name => mach-o name and vice versa, the specific target
289 is checked before the generic. This allows a target (e.g. ppc for cstring)
290 to override the generic definition with a more specific one. */
292 /* Fetch the translation from a Mach-O section designation (segment, section)
293 as a bfd short name, if one exists. Otherwise return NULL.
295 Allow the segment and section names to be unterminated 16 byte arrays. */
297 const mach_o_section_name_xlat
*
298 bfd_mach_o_section_data_for_mach_sect (bfd
*abfd
, const char *segname
,
299 const char *sectname
)
301 const struct mach_o_segment_name_xlat
*seg
;
302 const mach_o_section_name_xlat
*sec
;
303 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
305 /* First try any target-specific translations defined... */
306 if (bed
->segsec_names_xlat
)
307 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
308 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
309 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
310 if (strncmp (sec
->mach_o_name
, sectname
,
311 BFD_MACH_O_SECTNAME_SIZE
) == 0)
314 /* ... and then the Mach-O generic ones. */
315 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
316 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
317 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
318 if (strncmp (sec
->mach_o_name
, sectname
,
319 BFD_MACH_O_SECTNAME_SIZE
) == 0)
325 /* If the bfd_name for this section is a 'canonical' form for which we
326 know the Mach-O data, return the segment name and the data for the
327 Mach-O equivalent. Otherwise return NULL. */
329 const mach_o_section_name_xlat
*
330 bfd_mach_o_section_data_for_bfd_name (bfd
*abfd
, const char *bfd_name
,
331 const char **segname
)
333 const struct mach_o_segment_name_xlat
*seg
;
334 const mach_o_section_name_xlat
*sec
;
335 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
338 if (bfd_name
[0] != '.')
341 /* First try any target-specific translations defined... */
342 if (bed
->segsec_names_xlat
)
343 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
344 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
345 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
347 *segname
= seg
->segname
;
351 /* ... and then the Mach-O generic ones. */
352 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
353 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
354 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
356 *segname
= seg
->segname
;
363 /* Convert Mach-O section name to BFD.
365 Try to use standard/canonical names, for which we have tables including
366 default flag settings - which are returned. Otherwise forge a new name
367 in the form "<segmentname>.<sectionname>" this will be prefixed with
368 LC_SEGMENT. if the segment name does not begin with an underscore.
370 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
371 terminated if the name length is exactly 16 bytes - but must be if the name
372 length is less than 16 characters). */
375 bfd_mach_o_convert_section_name_to_bfd (bfd
*abfd
, const char *segname
,
376 const char *secname
, const char **name
,
379 const mach_o_section_name_xlat
*xlat
;
382 const char *pfx
= "";
385 *flags
= SEC_NO_FLAGS
;
387 /* First search for a canonical name...
388 xlat will be non-null if there is an entry for segname, secname. */
389 xlat
= bfd_mach_o_section_data_for_mach_sect (abfd
, segname
, secname
);
392 len
= strlen (xlat
->bfd_name
);
393 res
= bfd_alloc (abfd
, len
+1);
396 memcpy (res
, xlat
->bfd_name
, len
+1);
398 *flags
= xlat
->bfd_flags
;
402 /* ... else we make up a bfd name from the segment concatenated with the
405 len
= 16 + 1 + 16 + 1;
407 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
408 with an underscore. */
409 if (segname
[0] != '_')
411 static const char seg_pfx
[] = "LC_SEGMENT.";
414 len
+= sizeof (seg_pfx
) - 1;
417 res
= bfd_alloc (abfd
, len
);
420 snprintf (res
, len
, "%s%.16s.%.16s", pfx
, segname
, secname
);
424 /* Convert a bfd section name to a Mach-O segment + section name.
426 If the name is a canonical one for which we have a Darwin match
427 return the translation table - which contains defaults for flags,
428 type, attribute and default alignment data.
430 Otherwise, expand the bfd_name (assumed to be in the form
431 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
433 static const mach_o_section_name_xlat
*
434 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
436 bfd_mach_o_section
*section
)
438 const mach_o_section_name_xlat
*xlat
;
439 const char *name
= bfd_get_section_name (abfd
, sect
);
446 memset (section
->segname
, 0, BFD_MACH_O_SEGNAME_SIZE
+ 1);
447 memset (section
->sectname
, 0, BFD_MACH_O_SECTNAME_SIZE
+ 1);
449 /* See if is a canonical name ... */
450 xlat
= bfd_mach_o_section_data_for_bfd_name (abfd
, name
, &segname
);
453 strcpy (section
->segname
, segname
);
454 strcpy (section
->sectname
, xlat
->mach_o_name
);
458 /* .. else we convert our constructed one back to Mach-O.
459 Strip LC_SEGMENT. prefix, if present. */
460 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
464 dot
= strchr (name
, '.');
467 /* Try to split name into segment and section names. */
468 if (dot
&& dot
!= name
)
471 seclen
= len
- (dot
+ 1 - name
);
473 if (seglen
<= BFD_MACH_O_SEGNAME_SIZE
474 && seclen
<= BFD_MACH_O_SECTNAME_SIZE
)
476 memcpy (section
->segname
, name
, seglen
);
477 section
->segname
[seglen
] = 0;
478 memcpy (section
->sectname
, dot
+ 1, seclen
);
479 section
->sectname
[seclen
] = 0;
484 /* The segment and section names are both missing - don't make them
486 if (dot
&& dot
== name
)
489 /* Just duplicate the name into both segment and section. */
492 memcpy (section
->segname
, name
, len
);
493 section
->segname
[len
] = 0;
494 memcpy (section
->sectname
, name
, len
);
495 section
->sectname
[len
] = 0;
499 /* Return the size of an entry for section SEC.
500 Must be called only for symbol pointer section and symbol stubs
504 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
506 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
508 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
509 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
510 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
511 case BFD_MACH_O_S_SYMBOL_STUBS
:
512 return sec
->reserved2
;
519 /* Return the number of indirect symbols for a section.
520 Must be called only for symbol pointer section and symbol stubs
524 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
528 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
532 return sec
->size
/ elsz
;
535 /* Append command CMD to ABFD. Note that header.ncmds is not updated. */
538 bfd_mach_o_append_command (bfd
*abfd
, bfd_mach_o_load_command
*cmd
)
540 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
542 if (mdata
->last_command
!= NULL
)
543 mdata
->last_command
->next
= cmd
;
545 mdata
->first_command
= cmd
;
546 mdata
->last_command
= cmd
;
550 /* Copy any private info we understand from the input symbol
551 to the output symbol. */
554 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
556 bfd
*obfd ATTRIBUTE_UNUSED
,
559 bfd_mach_o_asymbol
*os
, *is
;
561 os
= (bfd_mach_o_asymbol
*)osymbol
;
562 is
= (bfd_mach_o_asymbol
*)isymbol
;
563 os
->n_type
= is
->n_type
;
564 os
->n_sect
= is
->n_sect
;
565 os
->n_desc
= is
->n_desc
;
566 os
->symbol
.udata
.i
= is
->symbol
.udata
.i
;
571 /* Copy any private info we understand from the input section
572 to the output section. */
575 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd
, asection
*isection
,
576 bfd
*obfd
, asection
*osection
)
578 bfd_mach_o_section
*os
= bfd_mach_o_get_mach_o_section (osection
);
579 bfd_mach_o_section
*is
= bfd_mach_o_get_mach_o_section (isection
);
581 if (ibfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
582 || obfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
585 BFD_ASSERT (is
!= NULL
&& os
!= NULL
);
587 os
->flags
= is
->flags
;
588 os
->reserved1
= is
->reserved1
;
589 os
->reserved2
= is
->reserved2
;
590 os
->reserved3
= is
->reserved3
;
595 /* Copy any private info we understand from the input bfd
596 to the output bfd. */
599 bfd_mach_o_bfd_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
601 bfd_mach_o_data_struct
*imdata
;
602 bfd_mach_o_data_struct
*omdata
;
603 bfd_mach_o_load_command
*icmd
;
605 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
606 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
609 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
610 BFD_ASSERT (bfd_mach_o_valid (obfd
));
612 imdata
= bfd_mach_o_get_data (ibfd
);
613 omdata
= bfd_mach_o_get_data (obfd
);
615 /* Copy header flags. */
616 omdata
->header
.flags
= imdata
->header
.flags
;
619 for (icmd
= imdata
->first_command
; icmd
!= NULL
; icmd
= icmd
->next
)
621 bfd_mach_o_load_command
*ocmd
;
625 case BFD_MACH_O_LC_LOAD_DYLIB
:
626 case BFD_MACH_O_LC_LOAD_DYLINKER
:
627 case BFD_MACH_O_LC_DYLD_INFO
:
628 /* Command is copied. */
629 ocmd
= bfd_alloc (obfd
, sizeof (bfd_mach_o_load_command
));
633 /* Copy common fields. */
634 ocmd
->type
= icmd
->type
;
635 ocmd
->type_required
= icmd
->type_required
;
637 ocmd
->len
= icmd
->len
;
641 /* Command is not copied. */
648 case BFD_MACH_O_LC_LOAD_DYLIB
:
650 bfd_mach_o_dylib_command
*idy
= &icmd
->command
.dylib
;
651 bfd_mach_o_dylib_command
*ody
= &ocmd
->command
.dylib
;
653 ody
->name_offset
= idy
->name_offset
;
654 ody
->timestamp
= idy
->timestamp
;
655 ody
->current_version
= idy
->current_version
;
656 ody
->compatibility_version
= idy
->compatibility_version
;
657 ody
->name_str
= idy
->name_str
;
661 case BFD_MACH_O_LC_LOAD_DYLINKER
:
663 bfd_mach_o_dylinker_command
*idy
= &icmd
->command
.dylinker
;
664 bfd_mach_o_dylinker_command
*ody
= &ocmd
->command
.dylinker
;
666 ody
->name_offset
= idy
->name_offset
;
667 ody
->name_str
= idy
->name_str
;
671 case BFD_MACH_O_LC_DYLD_INFO
:
673 bfd_mach_o_dyld_info_command
*idy
= &icmd
->command
.dyld_info
;
674 bfd_mach_o_dyld_info_command
*ody
= &ocmd
->command
.dyld_info
;
676 if (bfd_mach_o_read_dyld_content (ibfd
, idy
))
678 ody
->rebase_size
= idy
->rebase_size
;
679 ody
->rebase_content
= idy
->rebase_content
;
681 ody
->bind_size
= idy
->bind_size
;
682 ody
->bind_content
= idy
->bind_content
;
684 ody
->weak_bind_size
= idy
->weak_bind_size
;
685 ody
->weak_bind_content
= idy
->weak_bind_content
;
687 ody
->lazy_bind_size
= idy
->lazy_bind_size
;
688 ody
->lazy_bind_content
= idy
->lazy_bind_content
;
690 ody
->export_size
= idy
->export_size
;
691 ody
->export_content
= idy
->export_content
;
693 /* PR 17512L: file: 730e492d. */
698 ody
->weak_bind_size
=
699 ody
->lazy_bind_size
=
700 ody
->export_size
= 0;
701 ody
->rebase_content
=
703 ody
->weak_bind_content
=
704 ody
->lazy_bind_content
=
705 ody
->export_content
= NULL
;
711 /* That command should be handled. */
715 /* Insert command. */
716 bfd_mach_o_append_command (obfd
, ocmd
);
722 /* This allows us to set up to 32 bits of flags (unless we invent some
723 fiendish scheme to subdivide). For now, we'll just set the file flags
724 without error checking - just overwrite. */
727 bfd_mach_o_bfd_set_private_flags (bfd
*abfd
, flagword flags
)
729 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
734 mdata
->header
.flags
= flags
;
738 /* Count the total number of symbols. */
741 bfd_mach_o_count_symbols (bfd
*abfd
)
743 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
745 if (mdata
->symtab
== NULL
)
747 return mdata
->symtab
->nsyms
;
751 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
753 long nsyms
= bfd_mach_o_count_symbols (abfd
);
755 return ((nsyms
+ 1) * sizeof (asymbol
*));
759 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
761 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
762 long nsyms
= bfd_mach_o_count_symbols (abfd
);
763 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
771 /* Do not try to read symbols if there are none. */
776 if (!bfd_mach_o_read_symtab_symbols (abfd
))
778 (*_bfd_error_handler
)
779 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
783 BFD_ASSERT (sym
->symbols
!= NULL
);
785 for (j
= 0; j
< sym
->nsyms
; j
++)
786 alocation
[j
] = &sym
->symbols
[j
].symbol
;
793 /* Create synthetic symbols for indirect symbols. */
796 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
797 long symcount ATTRIBUTE_UNUSED
,
798 asymbol
**syms ATTRIBUTE_UNUSED
,
799 long dynsymcount ATTRIBUTE_UNUSED
,
800 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
803 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
804 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
805 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
809 unsigned long count
, i
, j
, n
;
813 const char stub
[] = "$stub";
817 /* Stop now if no symbols or no indirect symbols. */
818 if (dysymtab
== NULL
|| dysymtab
->nindirectsyms
== 0
819 || symtab
== NULL
|| symtab
->symbols
== NULL
)
822 /* We need to allocate a bfd symbol for every indirect symbol and to
823 allocate the memory for its name. */
824 count
= dysymtab
->nindirectsyms
;
825 size
= count
* sizeof (asymbol
) + 1;
827 for (j
= 0; j
< count
; j
++)
830 unsigned int isym
= dysymtab
->indirect_syms
[j
];
832 /* Some indirect symbols are anonymous. */
833 if (isym
< symtab
->nsyms
&& (strng
= symtab
->symbols
[isym
].symbol
.name
))
834 /* PR 17512: file: f5b8eeba. */
835 size
+= strnlen (strng
, symtab
->strsize
- (strng
- symtab
->strtab
)) + sizeof (stub
);
838 s_start
= bfd_malloc (size
);
839 s
= *ret
= (asymbol
*) s_start
;
842 names
= (char *) (s
+ count
);
845 s_end
= s_start
+ size
;
848 for (i
= 0; i
< mdata
->nsects
; i
++)
850 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
851 unsigned int first
, last
;
855 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
857 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
858 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
859 case BFD_MACH_O_S_SYMBOL_STUBS
:
860 /* Only these sections have indirect symbols. */
861 first
= sec
->reserved1
;
862 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
864 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
866 /* PR 17512: file: 08e15eec. */
867 if (first
>= count
|| last
>= count
|| first
> last
)
870 for (j
= first
; j
< last
; j
++)
872 unsigned int isym
= dysymtab
->indirect_syms
[j
];
874 /* PR 17512: file: 04d64d9b. */
875 if (((char *) s
) + sizeof (* s
) > s_end
)
878 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
879 s
->section
= sec
->bfdsection
;
880 s
->value
= addr
- sec
->addr
;
883 if (isym
< symtab
->nsyms
884 && symtab
->symbols
[isym
].symbol
.name
)
886 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
891 /* PR 17512: file: 47dfd4d2. */
892 if (names
+ len
>= s_end
)
894 memcpy (names
, sym
, len
);
896 /* PR 17512: file: 18f340a4. */
897 if (names
+ sizeof (stub
) >= s_end
)
899 memcpy (names
, stub
, sizeof (stub
));
900 names
+= sizeof (stub
);
924 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
928 bfd_symbol_info (symbol
, ret
);
932 bfd_mach_o_print_symbol (bfd
*abfd
,
935 bfd_print_symbol_type how
)
937 FILE *file
= (FILE *) afile
;
939 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
943 case bfd_print_symbol_name
:
944 fprintf (file
, "%s", symbol
->name
);
947 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
948 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
949 name
= bfd_get_stab_name (asym
->n_type
);
951 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
953 case BFD_MACH_O_N_UNDF
:
954 if (symbol
->value
== 0)
959 case BFD_MACH_O_N_ABS
:
962 case BFD_MACH_O_N_INDR
:
965 case BFD_MACH_O_N_PBUD
:
968 case BFD_MACH_O_N_SECT
:
977 fprintf (file
, " %02x %-6s %02x %04x",
978 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
979 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
980 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
981 fprintf (file
, " [%s]", symbol
->section
->name
);
982 fprintf (file
, " %s", symbol
->name
);
987 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
988 bfd_mach_o_cpu_subtype msubtype
,
989 enum bfd_architecture
*type
,
990 unsigned long *subtype
)
992 *subtype
= bfd_arch_unknown
;
996 case BFD_MACH_O_CPU_TYPE_VAX
:
997 *type
= bfd_arch_vax
;
999 case BFD_MACH_O_CPU_TYPE_MC680x0
:
1000 *type
= bfd_arch_m68k
;
1002 case BFD_MACH_O_CPU_TYPE_I386
:
1003 *type
= bfd_arch_i386
;
1004 *subtype
= bfd_mach_i386_i386
;
1006 case BFD_MACH_O_CPU_TYPE_X86_64
:
1007 *type
= bfd_arch_i386
;
1008 *subtype
= bfd_mach_x86_64
;
1010 case BFD_MACH_O_CPU_TYPE_MIPS
:
1011 *type
= bfd_arch_mips
;
1013 case BFD_MACH_O_CPU_TYPE_MC98000
:
1014 *type
= bfd_arch_m98k
;
1016 case BFD_MACH_O_CPU_TYPE_HPPA
:
1017 *type
= bfd_arch_hppa
;
1019 case BFD_MACH_O_CPU_TYPE_ARM
:
1020 *type
= bfd_arch_arm
;
1023 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
1024 *subtype
= bfd_mach_arm_4T
;
1026 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
1027 *subtype
= bfd_mach_arm_4T
; /* Best fit ? */
1029 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
1030 *subtype
= bfd_mach_arm_5TE
;
1032 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
1033 *subtype
= bfd_mach_arm_XScale
;
1035 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
1036 *subtype
= bfd_mach_arm_5TE
; /* Best fit ? */
1038 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
1043 case BFD_MACH_O_CPU_TYPE_MC88000
:
1044 *type
= bfd_arch_m88k
;
1046 case BFD_MACH_O_CPU_TYPE_SPARC
:
1047 *type
= bfd_arch_sparc
;
1048 *subtype
= bfd_mach_sparc
;
1050 case BFD_MACH_O_CPU_TYPE_I860
:
1051 *type
= bfd_arch_i860
;
1053 case BFD_MACH_O_CPU_TYPE_ALPHA
:
1054 *type
= bfd_arch_alpha
;
1056 case BFD_MACH_O_CPU_TYPE_POWERPC
:
1057 *type
= bfd_arch_powerpc
;
1058 *subtype
= bfd_mach_ppc
;
1060 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
1061 *type
= bfd_arch_powerpc
;
1062 *subtype
= bfd_mach_ppc64
;
1064 case BFD_MACH_O_CPU_TYPE_ARM64
:
1065 *type
= bfd_arch_aarch64
;
1066 *subtype
= bfd_mach_aarch64
;
1069 *type
= bfd_arch_unknown
;
1074 /* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4. Return the
1075 number of bytes written or -1 in case of error. */
1078 bfd_mach_o_pad4 (bfd
*abfd
, unsigned int len
)
1082 char pad
[4] = {0,0,0,0};
1083 unsigned int padlen
= 4 - (len
% 4);
1085 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1094 /* Likewise, but for a command. */
1097 bfd_mach_o_pad_command (bfd
*abfd
, unsigned int len
)
1099 unsigned int align
= bfd_mach_o_wide_p (abfd
) ? 8 : 4;
1101 if (len
% align
!= 0)
1104 unsigned int padlen
= align
- (len
% align
);
1106 if (bfd_bwrite (pad
, padlen
, abfd
) != padlen
)
1116 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1118 struct mach_o_header_external raw
;
1121 size
= mach_o_wide_p (header
) ?
1122 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1124 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
1125 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
1126 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
1127 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
1128 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
1129 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
1130 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
1132 if (mach_o_wide_p (header
))
1133 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
1135 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1136 || bfd_bwrite (&raw
, size
, abfd
) != size
)
1143 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1145 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
1147 struct mach_o_thread_command_external raw
;
1148 unsigned int offset
;
1150 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
1151 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
1153 offset
= BFD_MACH_O_LC_SIZE
;
1154 for (i
= 0; i
< cmd
->nflavours
; i
++)
1156 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
1157 BFD_ASSERT (cmd
->flavours
[i
].offset
==
1158 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
1160 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
1161 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
1163 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
1164 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1167 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
1174 bfd_mach_o_write_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1176 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
1177 struct mach_o_str_command_external raw
;
1178 unsigned int namelen
;
1180 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.str
);
1182 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1183 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1186 namelen
= strlen (cmd
->name_str
) + 1;
1187 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1190 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1197 bfd_mach_o_write_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1199 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
1200 struct mach_o_dylib_command_external raw
;
1201 unsigned int namelen
;
1203 bfd_h_put_32 (abfd
, cmd
->name_offset
, raw
.name
);
1204 bfd_h_put_32 (abfd
, cmd
->timestamp
, raw
.timestamp
);
1205 bfd_h_put_32 (abfd
, cmd
->current_version
, raw
.current_version
);
1206 bfd_h_put_32 (abfd
, cmd
->compatibility_version
, raw
.compatibility_version
);
1208 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1209 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1212 namelen
= strlen (cmd
->name_str
) + 1;
1213 if (bfd_bwrite (cmd
->name_str
, namelen
, abfd
) != namelen
)
1216 if (bfd_mach_o_pad_command (abfd
, namelen
) < 0)
1223 bfd_mach_o_write_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1225 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
1226 struct mach_o_entry_point_command_external raw
;
1228 bfd_h_put_64 (abfd
, cmd
->entryoff
, raw
.entryoff
);
1229 bfd_h_put_64 (abfd
, cmd
->stacksize
, raw
.stacksize
);
1231 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1232 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1239 bfd_mach_o_write_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1241 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
1242 struct mach_o_dyld_info_command_external raw
;
1244 bfd_h_put_32 (abfd
, cmd
->rebase_off
, raw
.rebase_off
);
1245 bfd_h_put_32 (abfd
, cmd
->rebase_size
, raw
.rebase_size
);
1246 bfd_h_put_32 (abfd
, cmd
->bind_off
, raw
.bind_off
);
1247 bfd_h_put_32 (abfd
, cmd
->bind_size
, raw
.bind_size
);
1248 bfd_h_put_32 (abfd
, cmd
->weak_bind_off
, raw
.weak_bind_off
);
1249 bfd_h_put_32 (abfd
, cmd
->weak_bind_size
, raw
.weak_bind_size
);
1250 bfd_h_put_32 (abfd
, cmd
->lazy_bind_off
, raw
.lazy_bind_off
);
1251 bfd_h_put_32 (abfd
, cmd
->lazy_bind_size
, raw
.lazy_bind_size
);
1252 bfd_h_put_32 (abfd
, cmd
->export_off
, raw
.export_off
);
1253 bfd_h_put_32 (abfd
, cmd
->export_size
, raw
.export_size
);
1255 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1256 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1259 if (cmd
->rebase_size
!= 0)
1260 if (bfd_seek (abfd
, cmd
->rebase_off
, SEEK_SET
) != 0
1261 || (bfd_bwrite (cmd
->rebase_content
, cmd
->rebase_size
, abfd
) !=
1265 if (cmd
->bind_size
!= 0)
1266 if (bfd_seek (abfd
, cmd
->bind_off
, SEEK_SET
) != 0
1267 || (bfd_bwrite (cmd
->bind_content
, cmd
->bind_size
, abfd
) !=
1271 if (cmd
->weak_bind_size
!= 0)
1272 if (bfd_seek (abfd
, cmd
->weak_bind_off
, SEEK_SET
) != 0
1273 || (bfd_bwrite (cmd
->weak_bind_content
, cmd
->weak_bind_size
, abfd
) !=
1274 cmd
->weak_bind_size
))
1277 if (cmd
->lazy_bind_size
!= 0)
1278 if (bfd_seek (abfd
, cmd
->lazy_bind_off
, SEEK_SET
) != 0
1279 || (bfd_bwrite (cmd
->lazy_bind_content
, cmd
->lazy_bind_size
, abfd
) !=
1280 cmd
->lazy_bind_size
))
1283 if (cmd
->export_size
!= 0)
1284 if (bfd_seek (abfd
, cmd
->export_off
, SEEK_SET
) != 0
1285 || (bfd_bwrite (cmd
->export_content
, cmd
->export_size
, abfd
) !=
1293 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
1296 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1299 /* In addition to the need to byte-swap the symbol number, the bit positions
1300 of the fields in the relocation information vary per target endian-ness. */
1303 bfd_mach_o_swap_in_non_scattered_reloc (bfd
*abfd
, bfd_mach_o_reloc_info
*rel
,
1304 unsigned char *fields
)
1306 unsigned char info
= fields
[3];
1308 if (bfd_big_endian (abfd
))
1310 rel
->r_value
= (fields
[0] << 16) | (fields
[1] << 8) | fields
[2];
1311 rel
->r_type
= (info
>> BFD_MACH_O_BE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1312 rel
->r_pcrel
= (info
& BFD_MACH_O_BE_PCREL
) ? 1 : 0;
1313 rel
->r_length
= (info
>> BFD_MACH_O_BE_LENGTH_SHIFT
)
1314 & BFD_MACH_O_LENGTH_MASK
;
1315 rel
->r_extern
= (info
& BFD_MACH_O_BE_EXTERN
) ? 1 : 0;
1319 rel
->r_value
= (fields
[2] << 16) | (fields
[1] << 8) | fields
[0];
1320 rel
->r_type
= (info
>> BFD_MACH_O_LE_TYPE_SHIFT
) & BFD_MACH_O_TYPE_MASK
;
1321 rel
->r_pcrel
= (info
& BFD_MACH_O_LE_PCREL
) ? 1 : 0;
1322 rel
->r_length
= (info
>> BFD_MACH_O_LE_LENGTH_SHIFT
)
1323 & BFD_MACH_O_LENGTH_MASK
;
1324 rel
->r_extern
= (info
& BFD_MACH_O_LE_EXTERN
) ? 1 : 0;
1329 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
1330 struct mach_o_reloc_info_external
*raw
,
1331 arelent
*res
, asymbol
**syms
)
1333 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1334 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1335 bfd_mach_o_reloc_info reloc
;
1339 addr
= bfd_get_32 (abfd
, raw
->r_address
);
1340 res
->sym_ptr_ptr
= NULL
;
1343 if (addr
& BFD_MACH_O_SR_SCATTERED
)
1346 bfd_vma symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
1348 /* Scattered relocation, can't be extern. */
1349 reloc
.r_scattered
= 1;
1352 /* Extract section and offset from r_value (symnum). */
1353 reloc
.r_value
= symnum
;
1354 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1355 end of the data for the section (e.g. in a calculation of section
1356 data length). At present, the symbol will end up associated with
1357 the following section or, if it falls within alignment padding, as
1358 null - which will assert later. */
1359 for (j
= 0; j
< mdata
->nsects
; j
++)
1361 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
1362 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
1364 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
1365 res
->addend
= symnum
- sect
->addr
;
1370 /* Extract the info and address fields from r_address. */
1371 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
1372 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
1373 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
1374 reloc
.r_address
= BFD_MACH_O_GET_SR_TYPE (addr
);
1375 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
1381 /* Non-scattered relocation. */
1382 reloc
.r_scattered
= 0;
1384 /* The value and info fields have to be extracted dependent on target
1386 bfd_mach_o_swap_in_non_scattered_reloc (abfd
, &reloc
, raw
->r_symbolnum
);
1387 num
= reloc
.r_value
;
1391 /* PR 17512: file: 8396-1185-0.004. */
1392 if (bfd_get_symcount (abfd
) > 0 && num
> bfd_get_symcount (abfd
))
1393 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1394 else if (syms
== NULL
)
1395 sym
= bfd_und_section_ptr
->symbol_ptr_ptr
;
1397 /* An external symbol number. */
1400 else if (num
== 0x00ffffff || num
== 0)
1402 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1403 is generic code, we don't know wether this is really a PAIR.
1404 This value is almost certainly not a valid section number, hence
1405 this specific case to avoid an assertion failure.
1406 Target specific swap_reloc_in routine should adjust that. */
1407 sym
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1411 /* PR 17512: file: 006-2964-0.004. */
1412 if (num
> mdata
->nsects
)
1415 /* A section number. */
1416 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1417 /* For a symbol defined in section S, the addend (stored in the
1418 binary) contains the address of the section. To comply with
1419 bfd convention, subtract the section address.
1420 Use the address from the header, so that the user can modify
1421 the vma of the section. */
1422 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1424 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1425 in the lower 16bits of the address value. So we have to find the
1426 'symbol' from the preceding reloc. We do this even though the
1427 section symbol is probably not needed here, because NULL symbol
1428 values cause an assert in generic BFD code. This must be done in
1429 the PPC swap_reloc_in routine. */
1430 res
->sym_ptr_ptr
= sym
;
1432 /* The 'address' is just r_address.
1433 ??? maybe this should be masked with 0xffffff for safety. */
1434 res
->address
= addr
;
1435 reloc
.r_address
= addr
;
1438 /* We have set up a reloc with all the information present, so the swapper
1439 can modify address, value and addend fields, if necessary, to convey
1440 information in the generic BFD reloc that is mach-o specific. */
1442 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
1449 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1450 unsigned long count
,
1451 arelent
*res
, asymbol
**syms
)
1454 struct mach_o_reloc_info_external
*native_relocs
;
1455 bfd_size_type native_size
;
1457 /* Allocate and read relocs. */
1458 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1461 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1462 if (native_relocs
== NULL
)
1465 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1466 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1469 for (i
= 0; i
< count
; i
++)
1471 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
1475 free (native_relocs
);
1478 free (native_relocs
);
1483 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1484 arelent
**rels
, asymbol
**syms
)
1486 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1490 if (asect
->reloc_count
== 0)
1493 /* No need to go further if we don't know how to read relocs. */
1494 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1497 if (asect
->relocation
== NULL
)
1499 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1503 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1504 asect
->reloc_count
, res
, syms
) < 0)
1509 asect
->relocation
= res
;
1512 res
= asect
->relocation
;
1513 for (i
= 0; i
< asect
->reloc_count
; i
++)
1521 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1523 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1525 if (mdata
->dysymtab
== NULL
)
1527 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1528 * sizeof (arelent
*);
1532 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1533 struct bfd_symbol
**syms
)
1535 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1536 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1537 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1541 if (dysymtab
== NULL
)
1543 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1546 /* No need to go further if we don't know how to read relocs. */
1547 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1550 if (mdata
->dyn_reloc_cache
== NULL
)
1552 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1553 * sizeof (arelent
));
1557 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1558 dysymtab
->nextrel
, res
, syms
) < 0)
1564 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1566 res
+ dysymtab
->nextrel
, syms
) < 0)
1572 mdata
->dyn_reloc_cache
= res
;
1575 res
= mdata
->dyn_reloc_cache
;
1576 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1582 /* In addition to the need to byte-swap the symbol number, the bit positions
1583 of the fields in the relocation information vary per target endian-ness. */
1586 bfd_mach_o_swap_out_non_scattered_reloc (bfd
*abfd
, unsigned char *fields
,
1587 bfd_mach_o_reloc_info
*rel
)
1589 unsigned char info
= 0;
1591 BFD_ASSERT (rel
->r_type
<= 15);
1592 BFD_ASSERT (rel
->r_length
<= 3);
1594 if (bfd_big_endian (abfd
))
1596 fields
[0] = (rel
->r_value
>> 16) & 0xff;
1597 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1598 fields
[2] = rel
->r_value
& 0xff;
1599 info
|= rel
->r_type
<< BFD_MACH_O_BE_TYPE_SHIFT
;
1600 info
|= rel
->r_pcrel
? BFD_MACH_O_BE_PCREL
: 0;
1601 info
|= rel
->r_length
<< BFD_MACH_O_BE_LENGTH_SHIFT
;
1602 info
|= rel
->r_extern
? BFD_MACH_O_BE_EXTERN
: 0;
1606 fields
[2] = (rel
->r_value
>> 16) & 0xff;
1607 fields
[1] = (rel
->r_value
>> 8) & 0xff;
1608 fields
[0] = rel
->r_value
& 0xff;
1609 info
|= rel
->r_type
<< BFD_MACH_O_LE_TYPE_SHIFT
;
1610 info
|= rel
->r_pcrel
? BFD_MACH_O_LE_PCREL
: 0;
1611 info
|= rel
->r_length
<< BFD_MACH_O_LE_LENGTH_SHIFT
;
1612 info
|= rel
->r_extern
? BFD_MACH_O_LE_EXTERN
: 0;
1618 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1623 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1625 sec
= section
->bfdsection
;
1626 if (sec
->reloc_count
== 0)
1629 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1632 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1635 /* Convert and write. */
1636 entries
= section
->bfdsection
->orelocation
;
1637 for (i
= 0; i
< section
->nreloc
; i
++)
1639 arelent
*rel
= entries
[i
];
1640 struct mach_o_reloc_info_external raw
;
1641 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1643 /* Convert relocation to an intermediate representation. */
1644 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1647 /* Lower the relocation info. */
1648 if (pinfo
->r_scattered
)
1652 v
= BFD_MACH_O_SR_SCATTERED
1653 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1654 | BFD_MACH_O_SET_SR_LENGTH (pinfo
->r_length
)
1655 | BFD_MACH_O_SET_SR_TYPE (pinfo
->r_type
)
1656 | BFD_MACH_O_SET_SR_ADDRESS (pinfo
->r_address
);
1657 /* Note: scattered relocs have field in reverse order... */
1658 bfd_put_32 (abfd
, v
, raw
.r_address
);
1659 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1663 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1664 bfd_mach_o_swap_out_non_scattered_reloc (abfd
, raw
.r_symbolnum
,
1668 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1669 != BFD_MACH_O_RELENT_SIZE
)
1676 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1678 struct mach_o_section_32_external raw
;
1680 memcpy (raw
.sectname
, section
->sectname
, 16);
1681 memcpy (raw
.segname
, section
->segname
, 16);
1682 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1683 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1684 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1685 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1686 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1687 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1688 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1689 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1690 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1692 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1693 != BFD_MACH_O_SECTION_SIZE
)
1700 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1702 struct mach_o_section_64_external raw
;
1704 memcpy (raw
.sectname
, section
->sectname
, 16);
1705 memcpy (raw
.segname
, section
->segname
, 16);
1706 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1707 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1708 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1709 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1710 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1711 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1712 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1713 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1714 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1715 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1717 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1718 != BFD_MACH_O_SECTION_64_SIZE
)
1725 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1727 struct mach_o_segment_command_32_external raw
;
1728 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1729 bfd_mach_o_section
*sec
;
1731 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1733 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1734 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1737 memcpy (raw
.segname
, seg
->segname
, 16);
1738 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1739 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1740 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1741 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1742 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1743 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1744 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1745 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1747 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1748 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1751 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1752 if (!bfd_mach_o_write_section_32 (abfd
, sec
))
1759 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1761 struct mach_o_segment_command_64_external raw
;
1762 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1763 bfd_mach_o_section
*sec
;
1765 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1767 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1768 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1771 memcpy (raw
.segname
, seg
->segname
, 16);
1772 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1773 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1774 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1775 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1776 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1777 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1778 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1779 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1781 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1782 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1785 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1786 if (!bfd_mach_o_write_section_64 (abfd
, sec
))
1793 bfd_mach_o_write_symtab_content (bfd
*abfd
, bfd_mach_o_symtab_command
*sym
)
1795 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1797 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1798 struct bfd_strtab_hash
*strtab
;
1799 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1802 /* Write the symbols first. */
1803 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1806 strtab
= _bfd_stringtab_init ();
1811 /* Although we don't strictly need to do this, for compatibility with
1812 Darwin system tools, actually output an empty string for the index
1814 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1816 for (i
= 0; i
< sym
->nsyms
; i
++)
1818 bfd_size_type str_index
;
1819 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1821 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1822 /* An index of 0 always means the empty string. */
1826 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1828 if (str_index
== (bfd_size_type
) -1)
1834 struct mach_o_nlist_64_external raw
;
1836 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1837 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1838 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1839 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1840 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1843 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1848 struct mach_o_nlist_external raw
;
1850 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1851 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1852 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1853 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1854 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1857 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1861 sym
->strsize
= _bfd_stringtab_size (strtab
);
1862 sym
->stroff
= mdata
->filelen
;
1863 mdata
->filelen
+= sym
->strsize
;
1865 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0)
1868 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1870 _bfd_stringtab_free (strtab
);
1872 /* Pad string table. */
1873 padlen
= bfd_mach_o_pad4 (abfd
, sym
->strsize
);
1876 mdata
->filelen
+= padlen
;
1877 sym
->strsize
+= padlen
;
1882 _bfd_stringtab_free (strtab
);
1887 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1889 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1890 struct mach_o_symtab_command_external raw
;
1892 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1895 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1896 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1897 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1898 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1900 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1901 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1907 /* Count the number of indirect symbols in the image.
1908 Requires that the sections are in their final order. */
1911 bfd_mach_o_count_indirect_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1914 unsigned int nisyms
= 0;
1916 for (i
= 0; i
< mdata
->nsects
; ++i
)
1918 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
1920 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1922 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
1923 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
1924 case BFD_MACH_O_S_SYMBOL_STUBS
:
1925 nisyms
+= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
1934 /* Create the dysymtab. */
1937 bfd_mach_o_build_dysymtab (bfd
*abfd
, bfd_mach_o_dysymtab_command
*cmd
)
1939 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1942 We are not going to try and fill these in yet and, moreover, we are
1943 going to bail if they are already set. */
1944 if (cmd
->nmodtab
!= 0
1946 || cmd
->nextrefsyms
!= 0)
1948 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
1949 " implemented for dysymtab commands."));
1955 if (bfd_get_symcount (abfd
) > 0)
1957 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1960 /* Count the number of each kind of symbol. */
1961 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1963 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1964 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
1968 cmd
->iextdefsym
= i
;
1969 for (; i
< bfd_get_symcount (abfd
); ++i
)
1971 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1972 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
1975 cmd
->nextdefsym
= i
- cmd
->nlocalsym
;
1976 cmd
->iundefsym
= cmd
->nextdefsym
+ cmd
->iextdefsym
;
1977 cmd
->nundefsym
= bfd_get_symcount (abfd
)
1984 cmd
->iextdefsym
= 0;
1985 cmd
->nextdefsym
= 0;
1990 cmd
->nindirectsyms
= bfd_mach_o_count_indirect_symbols (abfd
, mdata
);
1991 if (cmd
->nindirectsyms
> 0)
1996 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
1997 cmd
->indirectsymoff
= mdata
->filelen
;
1998 mdata
->filelen
+= cmd
->nindirectsyms
* 4;
2000 cmd
->indirect_syms
= bfd_zalloc (abfd
, cmd
->nindirectsyms
* 4);
2001 if (cmd
->indirect_syms
== NULL
)
2005 for (i
= 0; i
< mdata
->nsects
; ++i
)
2007 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
2009 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2011 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
2012 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
2013 case BFD_MACH_O_S_SYMBOL_STUBS
:
2016 bfd_mach_o_asymbol
**isyms
= sec
->indirect_syms
;
2018 num
= bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
2019 if (isyms
== NULL
|| num
== 0)
2021 /* Record the starting index in the reserved1 field. */
2023 for (j
= 0; j
< num
; j
++, n
++)
2025 if (isyms
[j
] == NULL
)
2026 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
;
2027 else if (isyms
[j
]->symbol
.section
== bfd_abs_section_ptr
2028 && ! (isyms
[j
]->n_type
& BFD_MACH_O_N_EXT
))
2029 cmd
->indirect_syms
[n
] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2030 | BFD_MACH_O_INDIRECT_SYM_ABS
;
2032 cmd
->indirect_syms
[n
] = isyms
[j
]->symbol
.udata
.i
;
2045 /* Write a dysymtab command.
2046 TODO: Possibly coalesce writes of smaller objects. */
2049 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2051 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2053 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2055 if (cmd
->nmodtab
!= 0)
2059 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2062 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2064 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2068 iinit
= module
->iinit
& 0xffff;
2069 iinit
|= ((module
->iterm
& 0xffff) << 16);
2071 ninit
= module
->ninit
& 0xffff;
2072 ninit
|= ((module
->nterm
& 0xffff) << 16);
2074 if (bfd_mach_o_wide_p (abfd
))
2076 struct mach_o_dylib_module_64_external w
;
2078 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
2079 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
2080 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
2081 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
2082 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
2083 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
2084 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
2085 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
2086 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
2087 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
2088 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
2089 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
2090 &w
.objc_module_info_addr
);
2091 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2092 &w
.objc_module_info_size
);
2094 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
2099 struct mach_o_dylib_module_external n
;
2101 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
2102 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
2103 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
2104 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
2105 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
2106 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
2107 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
2108 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
2109 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
2110 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
2111 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
2112 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
2113 &n
.objc_module_info_addr
);
2114 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
2115 &n
.objc_module_info_size
);
2117 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
2127 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2130 for (i
= 0; i
< cmd
->ntoc
; i
++)
2132 struct mach_o_dylib_table_of_contents_external raw
;
2133 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2135 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
2136 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
2138 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2143 if (cmd
->nindirectsyms
> 0)
2147 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2150 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
2152 unsigned char raw
[4];
2154 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
2155 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2160 if (cmd
->nextrefsyms
!= 0)
2164 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2167 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2170 unsigned char raw
[4];
2171 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2173 /* Fields isym and flags are written as bit-fields, thus we need
2174 a specific processing for endianness. */
2176 if (bfd_big_endian (abfd
))
2178 v
= ((ref
->isym
& 0xffffff) << 8);
2179 v
|= ref
->flags
& 0xff;
2183 v
= ref
->isym
& 0xffffff;
2184 v
|= ((ref
->flags
& 0xff) << 24);
2187 bfd_h_put_32 (abfd
, v
, raw
);
2188 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2194 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
2198 struct mach_o_dysymtab_command_external raw
;
2200 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
2201 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
2202 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
2203 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
2204 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
2205 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
2206 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
2207 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
2208 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
2209 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
2210 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
2211 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
2212 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
2213 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
2214 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
2215 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
2216 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
2217 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
2219 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2227 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol
*s
)
2229 unsigned mtyp
= s
->n_type
& BFD_MACH_O_N_TYPE
;
2231 /* Just leave debug symbols where they are (pretend they are local, and
2232 then they will just be sorted on position). */
2233 if (s
->n_type
& BFD_MACH_O_N_STAB
)
2236 /* Local (we should never see an undefined local AFAICT). */
2237 if (! (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
2240 /* Common symbols look like undefined externs. */
2241 if (mtyp
== BFD_MACH_O_N_UNDF
)
2244 /* A defined non-local, non-debug symbol. */
2249 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
2251 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
2252 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
2253 unsigned int soa
, sob
;
2255 soa
= bfd_mach_o_primary_symbol_sort_key (sa
);
2256 sob
= bfd_mach_o_primary_symbol_sort_key (sb
);
2263 /* If it's local or stab, just preserve the input order. */
2266 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
2268 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
2271 /* This is probably an error. */
2275 /* The second sort key is name. */
2276 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
2279 /* Process the symbols.
2281 This should be OK for single-module files - but it is not likely to work
2282 for multi-module shared libraries.
2284 (a) If the application has not filled in the relevant mach-o fields, make
2287 (b) Order them, like this:
2290 ( ii) external defined
2292 (iii) external undefined/common
2299 bfd_mach_o_mangle_symbols (bfd
*abfd
)
2302 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
2304 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
2307 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
2309 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2311 /* We use this value, which is out-of-range as a symbol index, to signal
2312 that the mach-o-specific data are not filled in and need to be created
2313 from the bfd values. It is much preferable for the application to do
2314 this, since more meaningful diagnostics can be made that way. */
2316 if (s
->symbol
.udata
.i
== SYM_MACHO_FIELDS_UNSET
)
2318 /* No symbol information has been set - therefore determine
2319 it from the bfd symbol flags/info. */
2320 if (s
->symbol
.section
== bfd_abs_section_ptr
)
2321 s
->n_type
= BFD_MACH_O_N_ABS
;
2322 else if (s
->symbol
.section
== bfd_und_section_ptr
)
2324 s
->n_type
= BFD_MACH_O_N_UNDF
;
2325 if (s
->symbol
.flags
& BSF_WEAK
)
2326 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
2327 /* mach-o automatically makes undefined symbols extern. */
2328 s
->n_type
|= BFD_MACH_O_N_EXT
;
2329 s
->symbol
.flags
|= BSF_GLOBAL
;
2331 else if (s
->symbol
.section
== bfd_com_section_ptr
)
2333 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
2334 s
->symbol
.flags
|= BSF_GLOBAL
;
2337 s
->n_type
= BFD_MACH_O_N_SECT
;
2339 if (s
->symbol
.flags
& BSF_GLOBAL
)
2340 s
->n_type
|= BFD_MACH_O_N_EXT
;
2343 /* Put the section index in, where required. */
2344 if ((s
->symbol
.section
!= bfd_abs_section_ptr
2345 && s
->symbol
.section
!= bfd_und_section_ptr
2346 && s
->symbol
.section
!= bfd_com_section_ptr
)
2347 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
2348 && s
->symbol
.name
== NULL
))
2349 s
->n_sect
= s
->symbol
.section
->output_section
->target_index
;
2351 /* Number to preserve order for local and debug syms. */
2352 s
->symbol
.udata
.i
= i
;
2355 /* Sort the symbols. */
2356 qsort ((void *) symbols
, (size_t) bfd_get_symcount (abfd
),
2357 sizeof (asymbol
*), bfd_mach_o_cf_symbols
);
2359 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
2361 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
2362 s
->symbol
.udata
.i
= i
; /* renumber. */
2368 /* We build a flat table of sections, which can be re-ordered if necessary.
2369 Fill in the section number and other mach-o-specific data. */
2372 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
2375 unsigned target_index
;
2378 nsect
= bfd_count_sections (abfd
);
2380 /* Don't do it if it's already set - assume the application knows what it's
2382 if (mdata
->nsects
== nsect
2383 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
2386 /* We need to check that this can be done... */
2389 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%u)"
2390 " maximum is 255,\n"), nsect
);
2394 mdata
->nsects
= nsect
;
2395 mdata
->sections
= bfd_alloc (abfd
,
2396 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2397 if (mdata
->sections
== NULL
)
2400 /* Create Mach-O sections.
2401 Section type, attribute and align should have been set when the
2402 section was created - either read in or specified. */
2404 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2406 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
2407 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
2409 mdata
->sections
[target_index
] = msect
;
2411 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
2412 msect
->size
= bfd_get_section_size (sec
);
2414 /* Use the largest alignment set, in case it was bumped after the
2415 section was created. */
2416 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
2419 sec
->target_index
= ++target_index
;
2426 bfd_mach_o_write_contents (bfd
*abfd
)
2428 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2429 bfd_mach_o_load_command
*cmd
;
2430 bfd_mach_o_symtab_command
*symtab
= NULL
;
2431 bfd_mach_o_dysymtab_command
*dysymtab
= NULL
;
2432 bfd_mach_o_segment_command
*linkedit
= NULL
;
2434 /* Make the commands, if not already present. */
2435 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
2437 abfd
->output_has_begun
= TRUE
;
2439 /* Write the header. */
2440 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
2443 /* First pass: allocate the linkedit segment. */
2444 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2447 case BFD_MACH_O_LC_SEGMENT_64
:
2448 case BFD_MACH_O_LC_SEGMENT
:
2449 if (strcmp (cmd
->command
.segment
.segname
, "__LINKEDIT") == 0)
2450 linkedit
= &cmd
->command
.segment
;
2452 case BFD_MACH_O_LC_SYMTAB
:
2453 symtab
= &cmd
->command
.symtab
;
2455 case BFD_MACH_O_LC_DYSYMTAB
:
2456 dysymtab
= &cmd
->command
.dysymtab
;
2458 case BFD_MACH_O_LC_DYLD_INFO
:
2460 bfd_mach_o_dyld_info_command
*di
= &cmd
->command
.dyld_info
;
2462 if (di
->rebase_size
!= 0)
2464 di
->rebase_off
= mdata
->filelen
;
2465 mdata
->filelen
+= di
->rebase_size
;
2467 if (di
->bind_size
!= 0)
2469 di
->bind_off
= mdata
->filelen
;
2470 mdata
->filelen
+= di
->bind_size
;
2472 if (di
->weak_bind_size
!= 0)
2474 di
->weak_bind_off
= mdata
->filelen
;
2475 mdata
->filelen
+= di
->weak_bind_size
;
2477 if (di
->lazy_bind_size
!= 0)
2479 di
->lazy_bind_off
= mdata
->filelen
;
2480 mdata
->filelen
+= di
->lazy_bind_size
;
2482 if (di
->export_size
!= 0)
2484 di
->export_off
= mdata
->filelen
;
2485 mdata
->filelen
+= di
->export_size
;
2489 case BFD_MACH_O_LC_LOAD_DYLIB
:
2490 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2491 case BFD_MACH_O_LC_MAIN
:
2492 /* Nothing to do. */
2495 (*_bfd_error_handler
)
2496 (_("unable to allocate data for load command 0x%lx"),
2497 (unsigned long) cmd
->type
);
2501 /* Specially handle symtab and dysymtab. */
2503 /* Pre-allocate the symbol table (but not the string table). The reason
2504 is that the dysymtab is after the symbol table but before the string
2505 table (required by the native strip tool). */
2508 unsigned int symlen
;
2509 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
2511 symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2513 /* Align for symbols. */
2514 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, wide
? 3 : 2);
2515 symtab
->symoff
= mdata
->filelen
;
2517 symtab
->nsyms
= bfd_get_symcount (abfd
);
2518 mdata
->filelen
+= symtab
->nsyms
* symlen
;
2521 /* Build the dysymtab. */
2522 if (dysymtab
!= NULL
)
2523 if (!bfd_mach_o_build_dysymtab (abfd
, dysymtab
))
2526 /* Write symtab and strtab. */
2528 if (!bfd_mach_o_write_symtab_content (abfd
, symtab
))
2531 /* Adjust linkedit size. */
2532 if (linkedit
!= NULL
)
2534 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2536 linkedit
->vmsize
= mdata
->filelen
- linkedit
->fileoff
;
2537 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2538 linkedit
->filesize
= mdata
->filelen
- linkedit
->fileoff
;
2540 linkedit
->initprot
= BFD_MACH_O_PROT_READ
;
2541 linkedit
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2542 | BFD_MACH_O_PROT_EXECUTE
;
2545 /* Second pass: write commands. */
2546 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
2548 struct mach_o_load_command_external raw
;
2549 unsigned long typeflag
;
2551 typeflag
= cmd
->type
| (cmd
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
2553 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
2554 bfd_h_put_32 (abfd
, cmd
->len
, raw
.cmdsize
);
2556 if (bfd_seek (abfd
, cmd
->offset
, SEEK_SET
) != 0
2557 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
2562 case BFD_MACH_O_LC_SEGMENT
:
2563 if (!bfd_mach_o_write_segment_32 (abfd
, cmd
))
2566 case BFD_MACH_O_LC_SEGMENT_64
:
2567 if (!bfd_mach_o_write_segment_64 (abfd
, cmd
))
2570 case BFD_MACH_O_LC_SYMTAB
:
2571 if (!bfd_mach_o_write_symtab (abfd
, cmd
))
2574 case BFD_MACH_O_LC_DYSYMTAB
:
2575 if (!bfd_mach_o_write_dysymtab (abfd
, cmd
))
2578 case BFD_MACH_O_LC_THREAD
:
2579 case BFD_MACH_O_LC_UNIXTHREAD
:
2580 if (!bfd_mach_o_write_thread (abfd
, cmd
))
2583 case BFD_MACH_O_LC_LOAD_DYLIB
:
2584 if (!bfd_mach_o_write_dylib (abfd
, cmd
))
2587 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2588 if (!bfd_mach_o_write_dylinker (abfd
, cmd
))
2591 case BFD_MACH_O_LC_MAIN
:
2592 if (!bfd_mach_o_write_main (abfd
, cmd
))
2595 case BFD_MACH_O_LC_DYLD_INFO
:
2596 if (!bfd_mach_o_write_dyld_info (abfd
, cmd
))
2600 (*_bfd_error_handler
)
2601 (_("unable to write unknown load command 0x%lx"),
2602 (unsigned long) cmd
->type
);
2611 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2612 bfd_mach_o_section
*s
)
2614 if (seg
->sect_head
== NULL
)
2617 seg
->sect_tail
->next
= s
;
2621 /* Create section Mach-O flags from BFD flags. */
2624 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
,
2628 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2630 /* Create default flags. */
2631 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2632 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2633 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2634 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2635 | BFD_MACH_O_S_REGULAR
;
2636 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2637 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2638 else if (bfd_flags
& SEC_DEBUGGING
)
2639 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2641 s
->flags
= BFD_MACH_O_S_REGULAR
;
2645 bfd_mach_o_build_obj_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2647 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2651 seg
->fileoff
= mdata
->filelen
;
2652 seg
->initprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2653 | BFD_MACH_O_PROT_EXECUTE
;
2654 seg
->maxprot
= seg
->initprot
;
2656 /* Append sections to the segment.
2658 This is a little tedious, we have to honor the need to account zerofill
2659 sections after all the rest. This forces us to do the calculation of
2660 total vmsize in three passes so that any alignment increments are
2661 properly accounted. */
2662 for (i
= 0; i
< mdata
->nsects
; ++i
)
2664 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2665 asection
*sec
= s
->bfdsection
;
2667 /* Although we account for zerofill section sizes in vm order, they are
2668 placed in the file in source sequence. */
2669 bfd_mach_o_append_section_to_segment (seg
, s
);
2672 /* Zerofill sections have zero file size & offset, the only content
2673 written to the file is the symbols. */
2674 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) == BFD_MACH_O_S_ZEROFILL
2675 || ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2676 == BFD_MACH_O_S_GB_ZEROFILL
))
2679 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2680 sections, even those with zero size. */
2683 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2684 seg
->vmsize
+= s
->size
;
2686 /* MH_OBJECT files have unaligned content. */
2689 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2690 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2692 seg
->filesize
+= s
->size
;
2694 /* The system tools write even zero-sized sections with an offset
2695 field set to the current file position. */
2696 s
->offset
= mdata
->filelen
;
2699 sec
->filepos
= s
->offset
;
2700 mdata
->filelen
+= s
->size
;
2703 /* Now pass through again, for zerofill, only now we just update the
2704 vmsize, and then for zerofill_GB. */
2705 for (j
= 0; j
< 2; j
++)
2710 stype
= BFD_MACH_O_S_ZEROFILL
;
2712 stype
= BFD_MACH_O_S_GB_ZEROFILL
;
2714 for (i
= 0; i
< mdata
->nsects
; ++i
)
2716 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2718 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != stype
)
2723 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2724 seg
->vmsize
+= s
->size
;
2729 /* Allocate space for the relocations. */
2730 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2732 for (i
= 0; i
< mdata
->nsects
; ++i
)
2734 bfd_mach_o_section
*ms
= mdata
->sections
[i
];
2735 asection
*sec
= ms
->bfdsection
;
2737 ms
->nreloc
= sec
->reloc_count
;
2738 if (ms
->nreloc
== 0)
2740 /* Clear nreloc and reloff if there is no relocs. */
2744 sec
->rel_filepos
= mdata
->filelen
;
2745 ms
->reloff
= sec
->rel_filepos
;
2746 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
2753 bfd_mach_o_build_exec_seg_command (bfd
*abfd
, bfd_mach_o_segment_command
*seg
)
2755 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2757 bfd_vma pagemask
= bfd_mach_o_get_backend_data (abfd
)->page_size
- 1;
2759 bfd_mach_o_section
*s
;
2763 seg
->fileoff
= mdata
->filelen
;
2768 /* Append sections to the segment. We assume they are properly ordered
2769 by vma (but we check that). */
2771 for (i
= 0; i
< mdata
->nsects
; ++i
)
2773 s
= mdata
->sections
[i
];
2775 /* Consider only sections for this segment. */
2776 if (strcmp (seg
->segname
, s
->segname
) != 0)
2779 bfd_mach_o_append_section_to_segment (seg
, s
);
2783 (*_bfd_error_handler
)
2784 (_("section address (%lx) below start of segment (%lx)"),
2785 (unsigned long) s
->addr
, (unsigned long) vma
);
2789 vma
= s
->addr
+ s
->size
;
2792 /* Set segment file offset: make it page aligned. */
2793 vma
= seg
->sect_head
->addr
;
2794 seg
->vmaddr
= vma
& ~pagemask
;
2795 if ((mdata
->filelen
& pagemask
) > (vma
& pagemask
))
2796 mdata
->filelen
+= pagemask
+ 1;
2797 seg
->fileoff
= mdata
->filelen
& ~pagemask
;
2798 mdata
->filelen
= seg
->fileoff
+ (vma
& pagemask
);
2800 /* Set section file offset. */
2801 for (s
= seg
->sect_head
; s
!= NULL
; s
= s
->next
)
2803 asection
*sec
= s
->bfdsection
;
2804 flagword flags
= bfd_get_section_flags (abfd
, sec
);
2806 /* Adjust segment size. */
2807 seg
->vmsize
= FILE_ALIGN (seg
->vmsize
, s
->align
);
2808 seg
->vmsize
+= s
->size
;
2810 /* File offset and length. */
2811 seg
->filesize
= FILE_ALIGN (seg
->filesize
, s
->align
);
2813 if ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
) != BFD_MACH_O_S_ZEROFILL
2814 && ((s
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2815 != BFD_MACH_O_S_GB_ZEROFILL
))
2817 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2819 s
->offset
= mdata
->filelen
;
2820 s
->bfdsection
->filepos
= s
->offset
;
2822 seg
->filesize
+= s
->size
;
2823 mdata
->filelen
+= s
->size
;
2828 s
->bfdsection
->filepos
= 0;
2831 /* Set protection. */
2832 if (flags
& SEC_LOAD
)
2834 if (flags
& SEC_CODE
)
2835 seg
->initprot
|= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_EXECUTE
;
2836 if ((flags
& (SEC_DATA
| SEC_READONLY
)) == SEC_DATA
)
2837 seg
->initprot
|= BFD_MACH_O_PROT_WRITE
| BFD_MACH_O_PROT_READ
;
2840 /* Relocs shouldn't appear in non-object files. */
2841 if (s
->bfdsection
->reloc_count
!= 0)
2846 if (seg
->initprot
!= 0)
2847 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2848 | BFD_MACH_O_PROT_EXECUTE
;
2852 /* Round segment size (and file size). */
2853 seg
->vmsize
= (seg
->vmsize
+ pagemask
) & ~pagemask
;
2854 seg
->filesize
= (seg
->filesize
+ pagemask
) & ~pagemask
;
2855 mdata
->filelen
= (mdata
->filelen
+ pagemask
) & ~pagemask
;
2860 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2861 fields in header. */
2864 bfd_mach_o_layout_commands (bfd_mach_o_data_struct
*mdata
)
2866 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2867 unsigned int hdrlen
;
2869 bfd_mach_o_load_command
*cmd
;
2871 bfd_boolean ret
= TRUE
;
2873 hdrlen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2874 align
= wide
? 8 - 1 : 4 - 1;
2876 mdata
->header
.ncmds
= 0;
2878 for (cmd
= mdata
->first_command
; cmd
; cmd
= cmd
->next
)
2880 mdata
->header
.ncmds
++;
2881 cmd
->offset
= offset
;
2885 case BFD_MACH_O_LC_SEGMENT_64
:
2886 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2887 + BFD_MACH_O_SECTION_64_SIZE
* cmd
->command
.segment
.nsects
;
2889 case BFD_MACH_O_LC_SEGMENT
:
2890 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2891 + BFD_MACH_O_SECTION_SIZE
* cmd
->command
.segment
.nsects
;
2893 case BFD_MACH_O_LC_SYMTAB
:
2894 cmd
->len
= sizeof (struct mach_o_symtab_command_external
)
2895 + BFD_MACH_O_LC_SIZE
;
2897 case BFD_MACH_O_LC_DYSYMTAB
:
2898 cmd
->len
= sizeof (struct mach_o_dysymtab_command_external
)
2899 + BFD_MACH_O_LC_SIZE
;
2901 case BFD_MACH_O_LC_LOAD_DYLIB
:
2902 cmd
->len
= sizeof (struct mach_o_dylib_command_external
)
2903 + BFD_MACH_O_LC_SIZE
;
2904 cmd
->command
.dylib
.name_offset
= cmd
->len
;
2905 cmd
->len
+= strlen (cmd
->command
.dylib
.name_str
);
2906 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2908 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2909 cmd
->len
= sizeof (struct mach_o_str_command_external
)
2910 + BFD_MACH_O_LC_SIZE
;
2911 cmd
->command
.dylinker
.name_offset
= cmd
->len
;
2912 cmd
->len
+= strlen (cmd
->command
.dylinker
.name_str
);
2913 cmd
->len
= (cmd
->len
+ align
) & ~align
;
2915 case BFD_MACH_O_LC_MAIN
:
2916 cmd
->len
= sizeof (struct mach_o_entry_point_command_external
)
2917 + BFD_MACH_O_LC_SIZE
;
2919 case BFD_MACH_O_LC_DYLD_INFO
:
2920 cmd
->len
= sizeof (struct mach_o_dyld_info_command_external
)
2921 + BFD_MACH_O_LC_SIZE
;
2924 (*_bfd_error_handler
)
2925 (_("unable to layout unknown load command 0x%lx"),
2926 (unsigned long) cmd
->type
);
2931 BFD_ASSERT (cmd
->len
% (align
+ 1) == 0);
2934 mdata
->header
.sizeofcmds
= offset
- hdrlen
;
2935 mdata
->filelen
= offset
;
2940 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2944 bfd_mach_o_init_segment (bfd_mach_o_data_struct
*mdata
,
2945 bfd_mach_o_load_command
*cmd
,
2946 const char *segname
, unsigned int nbr_sect
)
2948 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
2949 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2951 /* Init segment command. */
2952 cmd
->type
= wide
? BFD_MACH_O_LC_SEGMENT_64
: BFD_MACH_O_LC_SEGMENT
;
2953 cmd
->type_required
= FALSE
;
2955 strcpy (seg
->segname
, segname
);
2956 seg
->nsects
= nbr_sect
;
2966 seg
->sect_head
= NULL
;
2967 seg
->sect_tail
= NULL
;
2970 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2971 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2972 and copy functionality. */
2975 bfd_mach_o_build_commands (bfd
*abfd
)
2977 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2978 unsigned wide
= mach_o_wide_p (&mdata
->header
);
2979 unsigned int nbr_segcmd
= 0;
2980 bfd_mach_o_load_command
*commands
;
2981 unsigned int nbr_commands
;
2982 int symtab_idx
= -1;
2983 int dysymtab_idx
= -1;
2987 /* Return now if already built. */
2988 if (mdata
->header
.ncmds
!= 0)
2991 /* Fill in the file type, if not already set. */
2992 if (mdata
->header
.filetype
== 0)
2994 if (abfd
->flags
& EXEC_P
)
2995 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2996 else if (abfd
->flags
& DYNAMIC
)
2997 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2999 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
3002 /* If hasn't already been done, flatten sections list, and sort
3003 if/when required. Must be done before the symbol table is adjusted,
3004 since that depends on properly numbered sections. */
3005 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
3006 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
3009 /* Order the symbol table, fill-in/check mach-o specific fields and
3010 partition out any indirect symbols. */
3011 if (!bfd_mach_o_mangle_symbols (abfd
))
3014 /* Segment commands. */
3015 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3017 /* Only one segment for all the sections. But the segment is
3018 optional if there is no sections. */
3019 nbr_segcmd
= (mdata
->nsects
> 0) ? 1 : 0;
3023 bfd_mach_o_section
*prev_sect
= NULL
;
3025 /* One pagezero segment and one linkedit segment. */
3028 /* Create one segment for associated segment name in sections.
3029 Assume that sections with the same segment name are consecutive. */
3030 for (i
= 0; i
< mdata
->nsects
; i
++)
3032 bfd_mach_o_section
*this_sect
= mdata
->sections
[i
];
3034 if (prev_sect
== NULL
3035 || strcmp (prev_sect
->segname
, this_sect
->segname
) != 0)
3038 prev_sect
= this_sect
;
3043 nbr_commands
= nbr_segcmd
;
3045 /* One command for the symbol table (only if there are symbols. */
3046 if (bfd_get_symcount (abfd
) > 0)
3047 symtab_idx
= nbr_commands
++;
3050 This is a rather crude test for whether we should build a dysymtab. */
3051 if (bfd_mach_o_should_emit_dysymtab ()
3052 && bfd_get_symcount (abfd
))
3054 /* If there should be a case where a dysymtab could be emitted without
3055 a symtab (seems improbable), this would need amending. */
3056 dysymtab_idx
= nbr_commands
++;
3059 /* Add an entry point command. */
3060 if (mdata
->header
.filetype
== BFD_MACH_O_MH_EXECUTE
3061 && bfd_get_start_address (abfd
) != 0)
3062 main_idx
= nbr_commands
++;
3064 /* Well, we must have a header, at least. */
3065 mdata
->filelen
= wide
? BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3067 /* A bit unusual, but no content is valid;
3068 as -n empty.s -o empty.o */
3069 if (nbr_commands
== 0)
3071 /* Layout commands (well none...) and set headers command fields. */
3072 return bfd_mach_o_layout_commands (mdata
);
3075 /* Create commands for segments (and symtabs), prepend them. */
3076 commands
= bfd_zalloc (abfd
, nbr_commands
* sizeof (bfd_mach_o_load_command
));
3077 if (commands
== NULL
)
3079 for (i
= 0; i
< nbr_commands
- 1; i
++)
3080 commands
[i
].next
= &commands
[i
+ 1];
3081 commands
[nbr_commands
- 1].next
= mdata
->first_command
;
3082 if (mdata
->first_command
== NULL
)
3083 mdata
->last_command
= &commands
[nbr_commands
- 1];
3084 mdata
->first_command
= &commands
[0];
3086 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
&& nbr_segcmd
!= 0)
3088 /* For object file, there is only one segment. */
3089 bfd_mach_o_init_segment (mdata
, &commands
[0], "", mdata
->nsects
);
3091 else if (nbr_segcmd
!= 0)
3093 bfd_mach_o_load_command
*cmd
;
3095 BFD_ASSERT (nbr_segcmd
>= 2);
3099 bfd_mach_o_init_segment (mdata
, cmd
, "__PAGEZERO", 0);
3101 /* Segments from sections. */
3103 for (i
= 0; i
< mdata
->nsects
;)
3105 const char *segname
= mdata
->sections
[i
]->segname
;
3106 unsigned int nbr_sect
= 1;
3108 /* Count number of sections for this segment. */
3109 for (i
++; i
< mdata
->nsects
; i
++)
3110 if (strcmp (mdata
->sections
[i
]->segname
, segname
) == 0)
3115 bfd_mach_o_init_segment (mdata
, cmd
, segname
, nbr_sect
);
3120 bfd_mach_o_init_segment (mdata
, cmd
, "__LINKEDIT", 0);
3123 if (symtab_idx
>= 0)
3125 /* Init symtab command. */
3126 bfd_mach_o_load_command
*cmd
= &commands
[symtab_idx
];
3128 cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
3129 cmd
->type_required
= FALSE
;
3132 /* If required, setup symtab command, see comment above about the quality
3134 if (dysymtab_idx
>= 0)
3136 bfd_mach_o_load_command
*cmd
= &commands
[dysymtab_idx
];
3138 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
3139 cmd
->type_required
= FALSE
;
3142 /* Create the main command. */
3145 bfd_mach_o_load_command
*cmd
= &commands
[main_idx
];
3147 cmd
->type
= BFD_MACH_O_LC_MAIN
;
3148 cmd
->type_required
= TRUE
;
3150 cmd
->command
.main
.entryoff
= 0;
3151 cmd
->command
.main
.stacksize
= 0;
3154 /* Layout commands. */
3155 if (! bfd_mach_o_layout_commands (mdata
))
3158 /* So, now we have sized the commands and the filelen set to that.
3159 Now we can build the segment command and set the section file offsets. */
3160 if (mdata
->header
.filetype
== BFD_MACH_O_MH_OBJECT
)
3162 for (i
= 0; i
< nbr_segcmd
; i
++)
3163 if (!bfd_mach_o_build_obj_seg_command
3164 (abfd
, &commands
[i
].command
.segment
))
3171 /* Skip pagezero and linkedit segments. */
3172 for (i
= 1; i
< nbr_segcmd
- 1; i
++)
3174 bfd_mach_o_segment_command
*seg
= &commands
[i
].command
.segment
;
3176 if (!bfd_mach_o_build_exec_seg_command (abfd
, seg
))
3179 if (seg
->vmaddr
+ seg
->vmsize
> maxvma
)
3180 maxvma
= seg
->vmaddr
+ seg
->vmsize
;
3183 /* Set the size of __PAGEZERO. */
3184 commands
[0].command
.segment
.vmsize
=
3185 commands
[1].command
.segment
.vmaddr
;
3187 /* Set the vma and fileoff of __LINKEDIT. */
3188 commands
[nbr_segcmd
- 1].command
.segment
.vmaddr
= maxvma
;
3189 commands
[nbr_segcmd
- 1].command
.segment
.fileoff
= mdata
->filelen
;
3191 /* Set entry point (once segments have been laid out). */
3193 commands
[main_idx
].command
.main
.entryoff
=
3194 bfd_get_start_address (abfd
) - commands
[1].command
.segment
.vmaddr
;
3200 /* Set the contents of a section. */
3203 bfd_mach_o_set_section_contents (bfd
*abfd
,
3205 const void * location
,
3207 bfd_size_type count
)
3211 /* Trying to write the first section contents will trigger the creation of
3212 the load commands if they are not already present. */
3213 if (!abfd
->output_has_begun
&& !bfd_mach_o_build_commands (abfd
))
3219 pos
= section
->filepos
+ offset
;
3220 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
3221 || bfd_bwrite (location
, count
, abfd
) != count
)
3228 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
3229 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
3234 /* Make an empty symbol. This is required only because
3235 bfd_make_section_anyway wants to create a symbol for the section. */
3238 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
3240 asymbol
*new_symbol
;
3242 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
3243 if (new_symbol
== NULL
)
3245 new_symbol
->the_bfd
= abfd
;
3246 new_symbol
->udata
.i
= SYM_MACHO_FIELDS_UNSET
;
3251 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
3253 struct mach_o_header_external raw
;
3255 bfd_vma (*get32
) (const void *) = NULL
;
3257 /* Just read the magic number. */
3258 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3259 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
3262 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3264 header
->byteorder
= BFD_ENDIAN_BIG
;
3265 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3266 header
->version
= 1;
3269 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
3271 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3272 header
->magic
= BFD_MACH_O_MH_MAGIC
;
3273 header
->version
= 1;
3276 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3278 header
->byteorder
= BFD_ENDIAN_BIG
;
3279 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3280 header
->version
= 2;
3283 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
3285 header
->byteorder
= BFD_ENDIAN_LITTLE
;
3286 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
3287 header
->version
= 2;
3292 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
3296 /* Once the size of the header is known, read the full header. */
3297 size
= mach_o_wide_p (header
) ?
3298 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3300 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3301 || bfd_bread (&raw
, size
, abfd
) != size
)
3304 header
->cputype
= (*get32
) (raw
.cputype
);
3305 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
3306 header
->filetype
= (*get32
) (raw
.filetype
);
3307 header
->ncmds
= (*get32
) (raw
.ncmds
);
3308 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
3309 header
->flags
= (*get32
) (raw
.flags
);
3311 if (mach_o_wide_p (header
))
3312 header
->reserved
= (*get32
) (raw
.reserved
);
3314 header
->reserved
= 0;
3320 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
3322 bfd_mach_o_section
*s
;
3323 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
3325 s
= bfd_mach_o_get_mach_o_section (sec
);
3329 static const mach_o_section_name_xlat
* xlat
;
3331 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
3334 sec
->used_by_bfd
= s
;
3335 s
->bfdsection
= sec
;
3337 /* Create the Darwin seg/sect name pair from the bfd name.
3338 If this is a canonical name for which a specific paiting exists
3339 there will also be defined flags, type, attribute and alignment
3341 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
3344 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
3345 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
3347 (void) bfd_set_section_alignment (abfd
, sec
, s
->align
);
3348 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
3349 if (bfd_flags
== SEC_NO_FLAGS
)
3350 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
3353 /* Create default flags. */
3354 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
3357 return _bfd_generic_new_section_hook (abfd
, sec
);
3361 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
3365 bfd_mach_o_section
*section
;
3367 flags
= bfd_get_section_flags (abfd
, sec
);
3368 section
= bfd_mach_o_get_mach_o_section (sec
);
3370 /* TODO: see if we should use the xlat system for doing this by
3371 preference and fall back to this for unknown sections. */
3373 if (flags
== SEC_NO_FLAGS
)
3375 /* Try to guess flags. */
3376 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
3377 flags
= SEC_DEBUGGING
;
3381 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3382 != BFD_MACH_O_S_ZEROFILL
)
3385 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
3387 if (prot
& BFD_MACH_O_PROT_WRITE
)
3389 else if (prot
& BFD_MACH_O_PROT_READ
)
3390 flags
|= SEC_READONLY
;
3396 if ((flags
& SEC_DEBUGGING
) == 0)
3400 if (section
->offset
!= 0)
3401 flags
|= SEC_HAS_CONTENTS
;
3402 if (section
->nreloc
!= 0)
3405 bfd_set_section_flags (abfd
, sec
, flags
);
3407 sec
->vma
= section
->addr
;
3408 sec
->lma
= section
->addr
;
3409 sec
->size
= section
->size
;
3410 sec
->filepos
= section
->offset
;
3411 sec
->alignment_power
= section
->align
;
3412 sec
->segment_mark
= 0;
3413 sec
->reloc_count
= section
->nreloc
;
3414 sec
->rel_filepos
= section
->reloff
;
3418 bfd_mach_o_make_bfd_section (bfd
*abfd
,
3419 const unsigned char *segname
,
3420 const unsigned char *sectname
)
3425 bfd_mach_o_convert_section_name_to_bfd
3426 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
3430 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
3434 bfd_mach_o_read_section_32 (bfd
*abfd
,
3435 unsigned int offset
,
3438 struct mach_o_section_32_external raw
;
3440 bfd_mach_o_section
*section
;
3442 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3443 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
3444 != BFD_MACH_O_SECTION_SIZE
))
3447 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3451 section
= bfd_mach_o_get_mach_o_section (sec
);
3452 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3453 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3454 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3455 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3456 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
3457 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
3458 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3459 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3460 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3461 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3462 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3463 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3464 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3465 section
->reserved3
= 0;
3467 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3473 bfd_mach_o_read_section_64 (bfd
*abfd
,
3474 unsigned int offset
,
3477 struct mach_o_section_64_external raw
;
3479 bfd_mach_o_section
*section
;
3481 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
3482 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
3483 != BFD_MACH_O_SECTION_64_SIZE
))
3486 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
3490 section
= bfd_mach_o_get_mach_o_section (sec
);
3491 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
3492 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
3493 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
3494 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
3495 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
3496 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
3497 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
3498 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
3499 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
3500 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
3501 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3502 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
3503 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
3504 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
3506 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
3512 bfd_mach_o_read_section (bfd
*abfd
,
3513 unsigned int offset
,
3518 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
3520 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
3524 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
3525 bfd_mach_o_symtab_command
*sym
,
3526 bfd_mach_o_asymbol
*s
,
3529 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3530 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
3531 unsigned int symwidth
=
3532 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
3533 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
3534 struct mach_o_nlist_64_external raw
;
3535 unsigned char type
= -1;
3536 unsigned char section
= -1;
3538 symvalue value
= -1;
3539 unsigned long stroff
= -1;
3540 unsigned int symtype
= -1;
3542 BFD_ASSERT (sym
->strtab
!= NULL
);
3544 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
3545 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
3547 (*_bfd_error_handler
)
3548 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3549 symwidth
, (unsigned long) symoff
);
3553 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
3554 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
3555 symtype
= type
& BFD_MACH_O_N_TYPE
;
3556 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
3557 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
3559 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
3561 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
3563 if (stroff
>= sym
->strsize
)
3565 (*_bfd_error_handler
)
3566 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3567 (unsigned long) stroff
,
3568 (unsigned long) sym
->strsize
);
3572 s
->symbol
.the_bfd
= abfd
;
3573 s
->symbol
.name
= sym
->strtab
+ stroff
;
3574 s
->symbol
.value
= value
;
3575 s
->symbol
.flags
= 0x0;
3576 s
->symbol
.udata
.i
= i
;
3578 s
->n_sect
= section
;
3581 if (type
& BFD_MACH_O_N_STAB
)
3583 s
->symbol
.flags
|= BSF_DEBUGGING
;
3584 s
->symbol
.section
= bfd_und_section_ptr
;
3596 if ((section
> 0) && (section
<= mdata
->nsects
))
3598 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3600 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3607 if (type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
))
3608 s
->symbol
.flags
|= BSF_GLOBAL
;
3610 s
->symbol
.flags
|= BSF_LOCAL
;
3614 case BFD_MACH_O_N_UNDF
:
3615 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
3616 && s
->symbol
.value
!= 0)
3618 /* A common symbol. */
3619 s
->symbol
.section
= bfd_com_section_ptr
;
3620 s
->symbol
.flags
= BSF_NO_FLAGS
;
3624 s
->symbol
.section
= bfd_und_section_ptr
;
3625 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
3626 s
->symbol
.flags
|= BSF_WEAK
;
3629 case BFD_MACH_O_N_PBUD
:
3630 s
->symbol
.section
= bfd_und_section_ptr
;
3632 case BFD_MACH_O_N_ABS
:
3633 s
->symbol
.section
= bfd_abs_section_ptr
;
3635 case BFD_MACH_O_N_SECT
:
3636 if ((section
> 0) && (section
<= mdata
->nsects
))
3638 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
3640 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
3644 /* Mach-O uses 0 to mean "no section"; not an error. */
3647 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3648 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3649 s
->symbol
.name
, section
, mdata
->nsects
);
3651 s
->symbol
.section
= bfd_und_section_ptr
;
3654 case BFD_MACH_O_N_INDR
:
3655 /* FIXME: we don't follow the BFD convention as this indirect symbol
3656 won't be followed by the referenced one. This looks harmless
3657 unless we start using the linker. */
3658 s
->symbol
.flags
|= BSF_INDIRECT
;
3659 s
->symbol
.section
= bfd_ind_section_ptr
;
3660 s
->symbol
.value
= 0;
3663 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
3664 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3665 s
->symbol
.name
, symtype
);
3666 s
->symbol
.section
= bfd_und_section_ptr
;
3675 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
3677 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3678 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3680 /* Fail if there is no symtab. */
3684 /* Success if already loaded. */
3688 if (abfd
->flags
& BFD_IN_MEMORY
)
3690 struct bfd_in_memory
*b
;
3692 b
= (struct bfd_in_memory
*) abfd
->iostream
;
3694 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
3696 bfd_set_error (bfd_error_file_truncated
);
3699 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
3703 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
+ 1);
3704 if (sym
->strtab
== NULL
)
3707 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
3708 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
3710 /* PR 17512: file: 10888-1609-0.004. */
3711 bfd_release (abfd
, sym
->strtab
);
3713 bfd_set_error (bfd_error_file_truncated
);
3716 /* Zero terminate the string table. */
3717 sym
->strtab
[sym
->strsize
] = 0;
3724 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
3726 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3727 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
3730 if (sym
== NULL
|| sym
->symbols
)
3731 /* Return now if there are no symbols or if already loaded. */
3734 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
3736 if (sym
->symbols
== NULL
)
3738 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3742 if (!bfd_mach_o_read_symtab_strtab (abfd
))
3744 bfd_release (abfd
, sym
->symbols
);
3745 sym
->symbols
= NULL
;
3749 for (i
= 0; i
< sym
->nsyms
; i
++)
3751 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
3753 bfd_release (abfd
, sym
->symbols
);
3754 sym
->symbols
= NULL
;
3763 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
3765 switch ((int) flavour
)
3767 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
3768 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
3769 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
3770 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
3771 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
3772 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
3773 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
3774 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
3775 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
3776 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
3777 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
3778 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
3779 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
3780 default: return "UNKNOWN";
3785 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
3787 switch ((int) flavour
)
3789 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
3790 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
3791 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
3792 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
3793 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
3794 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
3795 default: return "UNKNOWN";
3800 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3802 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
3803 struct mach_o_str_command_external raw
;
3804 unsigned int nameoff
;
3805 unsigned int namelen
;
3807 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3808 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3811 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
3813 cmd
->name_offset
= nameoff
;
3814 namelen
= command
->len
- nameoff
;
3815 nameoff
+= command
->offset
;
3816 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3817 if (cmd
->name_str
== NULL
)
3819 if (bfd_seek (abfd
, nameoff
, SEEK_SET
) != 0
3820 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3826 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3828 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3829 struct mach_o_dylib_command_external raw
;
3830 unsigned int nameoff
;
3831 unsigned int namelen
;
3833 switch (command
->type
)
3835 case BFD_MACH_O_LC_LOAD_DYLIB
:
3836 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
3837 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3838 case BFD_MACH_O_LC_ID_DYLIB
:
3839 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3840 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3847 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3848 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3851 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3852 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3853 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3854 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3856 cmd
->name_offset
= command
->offset
+ nameoff
;
3857 namelen
= command
->len
- nameoff
;
3858 cmd
->name_str
= bfd_alloc (abfd
, namelen
);
3859 if (cmd
->name_str
== NULL
)
3861 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3862 || bfd_bread (cmd
->name_str
, namelen
, abfd
) != namelen
)
3868 bfd_mach_o_read_prebound_dylib (bfd
*abfd
,
3869 bfd_mach_o_load_command
*command
)
3871 bfd_mach_o_prebound_dylib_command
*cmd
= &command
->command
.prebound_dylib
;
3872 struct mach_o_prebound_dylib_command_external raw
;
3873 unsigned int nameoff
;
3874 unsigned int modoff
;
3875 unsigned int str_len
;
3878 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3879 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3882 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3883 modoff
= bfd_h_get_32 (abfd
, raw
.linked_modules
);
3884 if (nameoff
> command
->len
|| modoff
> command
->len
)
3887 str_len
= command
->len
- sizeof (raw
);
3888 str
= bfd_alloc (abfd
, str_len
);
3891 if (bfd_bread (str
, str_len
, abfd
) != str_len
)
3894 cmd
->name_offset
= command
->offset
+ nameoff
;
3895 cmd
->nmodules
= bfd_h_get_32 (abfd
, raw
.nmodules
);
3896 cmd
->linked_modules_offset
= command
->offset
+ modoff
;
3898 cmd
->name_str
= (char *)str
+ nameoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3899 cmd
->linked_modules
= str
+ modoff
- (sizeof (raw
) + BFD_MACH_O_LC_SIZE
);
3904 bfd_mach_o_read_prebind_cksum (bfd
*abfd
,
3905 bfd_mach_o_load_command
*command
)
3907 bfd_mach_o_prebind_cksum_command
*cmd
= &command
->command
.prebind_cksum
;
3908 struct mach_o_prebind_cksum_command_external raw
;
3910 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3911 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3914 cmd
->cksum
= bfd_get_32 (abfd
, raw
.cksum
);
3919 bfd_mach_o_read_twolevel_hints (bfd
*abfd
,
3920 bfd_mach_o_load_command
*command
)
3922 bfd_mach_o_twolevel_hints_command
*cmd
= &command
->command
.twolevel_hints
;
3923 struct mach_o_twolevel_hints_command_external raw
;
3925 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3926 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3929 cmd
->offset
= bfd_get_32 (abfd
, raw
.offset
);
3930 cmd
->nhints
= bfd_get_32 (abfd
, raw
.nhints
);
3935 bfd_mach_o_read_fvmlib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3937 bfd_mach_o_fvmlib_command
*fvm
= &command
->command
.fvmlib
;
3938 struct mach_o_fvmlib_command_external raw
;
3939 unsigned int nameoff
;
3940 unsigned int namelen
;
3942 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3943 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3946 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3947 fvm
->minor_version
= bfd_h_get_32 (abfd
, raw
.minor_version
);
3948 fvm
->header_addr
= bfd_h_get_32 (abfd
, raw
.header_addr
);
3950 fvm
->name_offset
= command
->offset
+ nameoff
;
3951 namelen
= command
->len
- nameoff
;
3952 fvm
->name_str
= bfd_alloc (abfd
, namelen
);
3953 if (fvm
->name_str
== NULL
)
3955 if (bfd_seek (abfd
, fvm
->name_offset
, SEEK_SET
) != 0
3956 || bfd_bread (fvm
->name_str
, namelen
, abfd
) != namelen
)
3962 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3964 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3965 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3966 unsigned int offset
;
3967 unsigned int nflavours
;
3970 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3971 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3973 /* Count the number of threads. */
3976 while (offset
!= command
->len
)
3978 struct mach_o_thread_command_external raw
;
3980 if (offset
>= command
->len
)
3983 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3984 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3987 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3991 /* Allocate threads. */
3992 cmd
->flavours
= bfd_alloc
3993 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3994 if (cmd
->flavours
== NULL
)
3996 cmd
->nflavours
= nflavours
;
4000 while (offset
!= command
->len
)
4002 struct mach_o_thread_command_external raw
;
4004 if (offset
>= command
->len
)
4007 if (nflavours
>= cmd
->nflavours
)
4010 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
4011 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4014 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
4015 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
4016 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
4017 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
4021 for (i
= 0; i
< nflavours
; i
++)
4024 unsigned int snamelen
;
4026 const char *flavourstr
;
4027 const char *prefix
= "LC_THREAD";
4030 switch (mdata
->header
.cputype
)
4032 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4033 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
4035 bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
4037 case BFD_MACH_O_CPU_TYPE_I386
:
4038 case BFD_MACH_O_CPU_TYPE_X86_64
:
4040 bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
4043 flavourstr
= "UNKNOWN_ARCHITECTURE";
4047 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
4048 sname
= bfd_alloc (abfd
, snamelen
);
4054 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
4055 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
4060 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
4064 bfdsec
->size
= cmd
->flavours
[i
].size
;
4065 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
4066 bfdsec
->alignment_power
= 0x0;
4068 cmd
->section
= bfdsec
;
4075 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4077 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
4078 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4080 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
4083 struct mach_o_dysymtab_command_external raw
;
4085 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4086 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4089 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
4090 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
4091 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
4092 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
4093 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
4094 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
4095 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
4096 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
4097 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
4098 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
4099 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
4100 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
4101 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
4102 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
4103 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
4104 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
4105 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
4106 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
4109 if (cmd
->nmodtab
!= 0)
4112 int wide
= bfd_mach_o_wide_p (abfd
);
4113 unsigned int module_len
= wide
? 56 : 52;
4116 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
4117 if (cmd
->dylib_module
== NULL
)
4120 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
4123 for (i
= 0; i
< cmd
->nmodtab
; i
++)
4125 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
4127 unsigned char buf
[56];
4129 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
4132 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
4133 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
4134 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
4135 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
4136 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
4137 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
4138 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
4139 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
4140 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
4141 v
= bfd_h_get_32 (abfd
, buf
+36);
4142 module
->iinit
= v
& 0xffff;
4143 module
->iterm
= (v
>> 16) & 0xffff;
4144 v
= bfd_h_get_32 (abfd
, buf
+ 40);
4145 module
->ninit
= v
& 0xffff;
4146 module
->nterm
= (v
>> 16) & 0xffff;
4149 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
4150 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
4154 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
4155 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
4164 cmd
->dylib_toc
= bfd_alloc
4165 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
4166 if (cmd
->dylib_toc
== NULL
)
4169 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
4172 for (i
= 0; i
< cmd
->ntoc
; i
++)
4174 struct mach_o_dylib_table_of_contents_external raw
;
4175 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
4177 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4180 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
4181 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
4185 if (cmd
->nindirectsyms
!= 0)
4189 cmd
->indirect_syms
= bfd_alloc
4190 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
4191 if (cmd
->indirect_syms
== NULL
)
4194 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
4197 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
4199 unsigned char raw
[4];
4200 unsigned int *is
= &cmd
->indirect_syms
[i
];
4202 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4205 *is
= bfd_h_get_32 (abfd
, raw
);
4209 if (cmd
->nextrefsyms
!= 0)
4214 cmd
->ext_refs
= bfd_alloc
4215 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
4216 if (cmd
->ext_refs
== NULL
)
4219 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
4222 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
4224 unsigned char raw
[4];
4225 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
4227 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4230 /* Fields isym and flags are written as bit-fields, thus we need
4231 a specific processing for endianness. */
4232 v
= bfd_h_get_32 (abfd
, raw
);
4233 if (bfd_big_endian (abfd
))
4235 ref
->isym
= (v
>> 8) & 0xffffff;
4236 ref
->flags
= v
& 0xff;
4240 ref
->isym
= v
& 0xffffff;
4241 ref
->flags
= (v
>> 24) & 0xff;
4246 if (mdata
->dysymtab
)
4248 mdata
->dysymtab
= cmd
;
4254 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4256 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
4257 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4258 struct mach_o_symtab_command_external raw
;
4260 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
4262 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4263 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4266 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
4267 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
4268 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
4269 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
4270 symtab
->symbols
= NULL
;
4271 symtab
->strtab
= NULL
;
4273 if (symtab
->nsyms
!= 0)
4274 abfd
->flags
|= HAS_SYMS
;
4278 mdata
->symtab
= symtab
;
4283 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4285 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
4287 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
4289 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4290 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
4297 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4299 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
4300 struct mach_o_linkedit_data_command_external raw
;
4302 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4303 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4306 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
4307 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
4312 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4314 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
4315 struct mach_o_str_command_external raw
;
4318 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4319 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4322 off
= bfd_get_32 (abfd
, raw
.str
);
4323 cmd
->stroff
= command
->offset
+ off
;
4324 cmd
->str_len
= command
->len
- off
;
4325 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
4326 if (cmd
->str
== NULL
)
4328 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
4329 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
4334 static unsigned char *
4335 bfd_mach_o_alloc_and_read (bfd
*abfd
, unsigned int off
, unsigned int size
)
4339 buf
= bfd_alloc (abfd
, size
);
4342 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
4343 || bfd_bread (buf
, size
, abfd
) != size
)
4349 bfd_mach_o_read_dyld_content (bfd
*abfd
, bfd_mach_o_dyld_info_command
*cmd
)
4351 /* Read rebase content. */
4352 if (cmd
->rebase_content
== NULL
&& cmd
->rebase_size
!= 0)
4354 cmd
->rebase_content
=
4355 bfd_mach_o_alloc_and_read (abfd
, cmd
->rebase_off
, cmd
->rebase_size
);
4356 if (cmd
->rebase_content
== NULL
)
4360 /* Read bind content. */
4361 if (cmd
->bind_content
== NULL
&& cmd
->bind_size
!= 0)
4364 bfd_mach_o_alloc_and_read (abfd
, cmd
->bind_off
, cmd
->bind_size
);
4365 if (cmd
->bind_content
== NULL
)
4369 /* Read weak bind content. */
4370 if (cmd
->weak_bind_content
== NULL
&& cmd
->weak_bind_size
!= 0)
4372 cmd
->weak_bind_content
= bfd_mach_o_alloc_and_read
4373 (abfd
, cmd
->weak_bind_off
, cmd
->weak_bind_size
);
4374 if (cmd
->weak_bind_content
== NULL
)
4378 /* Read lazy bind content. */
4379 if (cmd
->lazy_bind_content
== NULL
&& cmd
->lazy_bind_size
!= 0)
4381 cmd
->lazy_bind_content
= bfd_mach_o_alloc_and_read
4382 (abfd
, cmd
->lazy_bind_off
, cmd
->lazy_bind_size
);
4383 if (cmd
->lazy_bind_content
== NULL
)
4387 /* Read export content. */
4388 if (cmd
->export_content
== NULL
&& cmd
->export_size
!= 0)
4390 cmd
->export_content
= bfd_mach_o_alloc_and_read
4391 (abfd
, cmd
->export_off
, cmd
->export_size
);
4392 if (cmd
->export_content
== NULL
)
4400 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4402 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
4403 struct mach_o_dyld_info_command_external raw
;
4405 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4406 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4409 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
4410 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
4411 cmd
->rebase_content
= NULL
;
4412 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
4413 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
4414 cmd
->bind_content
= NULL
;
4415 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
4416 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
4417 cmd
->weak_bind_content
= NULL
;
4418 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
4419 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
4420 cmd
->lazy_bind_content
= NULL
;
4421 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
4422 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
4423 cmd
->export_content
= NULL
;
4428 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4430 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
4431 struct mach_o_version_min_command_external raw
;
4434 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4435 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4438 ver
= bfd_get_32 (abfd
, raw
.version
);
4439 cmd
->rel
= ver
>> 16;
4440 cmd
->maj
= ver
>> 8;
4442 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
4447 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4449 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
4450 struct mach_o_encryption_info_command_external raw
;
4452 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4453 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4456 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
4457 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
4458 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
4463 bfd_mach_o_read_main (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4465 bfd_mach_o_main_command
*cmd
= &command
->command
.main
;
4466 struct mach_o_entry_point_command_external raw
;
4468 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4469 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4472 cmd
->entryoff
= bfd_get_64 (abfd
, raw
.entryoff
);
4473 cmd
->stacksize
= bfd_get_64 (abfd
, raw
.stacksize
);
4478 bfd_mach_o_read_source_version (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4480 bfd_mach_o_source_version_command
*cmd
= &command
->command
.source_version
;
4481 struct mach_o_source_version_command_external raw
;
4484 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4485 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4488 ver
= bfd_get_64 (abfd
, raw
.version
);
4489 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4490 generates warnings) in case of the host doesn't support 64 bit
4492 cmd
->e
= ver
& 0x3ff;
4494 cmd
->d
= ver
& 0x3ff;
4496 cmd
->c
= ver
& 0x3ff;
4498 cmd
->b
= ver
& 0x3ff;
4500 cmd
->a
= ver
& 0xffffff;
4505 bfd_mach_o_read_segment (bfd
*abfd
,
4506 bfd_mach_o_load_command
*command
,
4509 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
4514 struct mach_o_segment_command_64_external raw
;
4516 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
4518 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4519 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4522 memcpy (seg
->segname
, raw
.segname
, 16);
4523 seg
->segname
[16] = '\0';
4525 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
4526 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
4527 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
4528 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
4529 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4530 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4531 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4532 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4536 struct mach_o_segment_command_32_external raw
;
4538 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
4540 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
4541 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
4544 memcpy (seg
->segname
, raw
.segname
, 16);
4545 seg
->segname
[16] = '\0';
4547 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
4548 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
4549 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
4550 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
4551 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
4552 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
4553 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
4554 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
4556 seg
->sect_head
= NULL
;
4557 seg
->sect_tail
= NULL
;
4559 for (i
= 0; i
< seg
->nsects
; i
++)
4565 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
4566 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
4568 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
4569 + (i
* BFD_MACH_O_SECTION_SIZE
);
4571 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
4575 bfd_mach_o_append_section_to_segment
4576 (seg
, bfd_mach_o_get_mach_o_section (sec
));
4583 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4585 return bfd_mach_o_read_segment (abfd
, command
, 0);
4589 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4591 return bfd_mach_o_read_segment (abfd
, command
, 1);
4595 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
4597 struct mach_o_load_command_external raw
;
4600 /* Read command type and length. */
4601 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
4602 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
4605 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
4606 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
4607 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
4608 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
4610 switch (command
->type
)
4612 case BFD_MACH_O_LC_SEGMENT
:
4613 if (!bfd_mach_o_read_segment_32 (abfd
, command
))
4616 case BFD_MACH_O_LC_SEGMENT_64
:
4617 if (!bfd_mach_o_read_segment_64 (abfd
, command
))
4620 case BFD_MACH_O_LC_SYMTAB
:
4621 if (!bfd_mach_o_read_symtab (abfd
, command
))
4624 case BFD_MACH_O_LC_SYMSEG
:
4626 case BFD_MACH_O_LC_THREAD
:
4627 case BFD_MACH_O_LC_UNIXTHREAD
:
4628 if (!bfd_mach_o_read_thread (abfd
, command
))
4631 case BFD_MACH_O_LC_LOAD_DYLINKER
:
4632 case BFD_MACH_O_LC_ID_DYLINKER
:
4633 case BFD_MACH_O_LC_DYLD_ENVIRONMENT
:
4634 if (!bfd_mach_o_read_dylinker (abfd
, command
))
4637 case BFD_MACH_O_LC_LOAD_DYLIB
:
4638 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB
:
4639 case BFD_MACH_O_LC_ID_DYLIB
:
4640 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
4641 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
4642 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
4643 if (!bfd_mach_o_read_dylib (abfd
, command
))
4646 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
4647 if (!bfd_mach_o_read_prebound_dylib (abfd
, command
))
4650 case BFD_MACH_O_LC_LOADFVMLIB
:
4651 case BFD_MACH_O_LC_IDFVMLIB
:
4652 if (!bfd_mach_o_read_fvmlib (abfd
, command
))
4655 case BFD_MACH_O_LC_IDENT
:
4656 case BFD_MACH_O_LC_FVMFILE
:
4657 case BFD_MACH_O_LC_PREPAGE
:
4658 case BFD_MACH_O_LC_ROUTINES
:
4659 case BFD_MACH_O_LC_ROUTINES_64
:
4661 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4662 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4663 case BFD_MACH_O_LC_SUB_LIBRARY
:
4664 case BFD_MACH_O_LC_SUB_CLIENT
:
4665 case BFD_MACH_O_LC_RPATH
:
4666 if (!bfd_mach_o_read_str (abfd
, command
))
4669 case BFD_MACH_O_LC_DYSYMTAB
:
4670 if (!bfd_mach_o_read_dysymtab (abfd
, command
))
4673 case BFD_MACH_O_LC_PREBIND_CKSUM
:
4674 if (!bfd_mach_o_read_prebind_cksum (abfd
, command
))
4677 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
4678 if (!bfd_mach_o_read_twolevel_hints (abfd
, command
))
4681 case BFD_MACH_O_LC_UUID
:
4682 if (!bfd_mach_o_read_uuid (abfd
, command
))
4685 case BFD_MACH_O_LC_CODE_SIGNATURE
:
4686 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
4687 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4688 case BFD_MACH_O_LC_DATA_IN_CODE
:
4689 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS
:
4690 if (!bfd_mach_o_read_linkedit (abfd
, command
))
4693 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
4694 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
4697 case BFD_MACH_O_LC_DYLD_INFO
:
4698 if (!bfd_mach_o_read_dyld_info (abfd
, command
))
4701 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4702 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4703 if (!bfd_mach_o_read_version_min (abfd
, command
))
4706 case BFD_MACH_O_LC_MAIN
:
4707 if (!bfd_mach_o_read_main (abfd
, command
))
4710 case BFD_MACH_O_LC_SOURCE_VERSION
:
4711 if (!bfd_mach_o_read_source_version (abfd
, command
))
4716 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
4717 abfd
, (unsigned long) command
->type
);
4725 bfd_mach_o_flatten_sections (bfd
*abfd
)
4727 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4728 bfd_mach_o_load_command
*cmd
;
4731 /* Count total number of sections. */
4734 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4736 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4737 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4739 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4741 mdata
->nsects
+= seg
->nsects
;
4745 /* Allocate sections array. */
4746 mdata
->sections
= bfd_alloc (abfd
,
4747 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
4749 /* Fill the array. */
4752 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4754 if (cmd
->type
== BFD_MACH_O_LC_SEGMENT
4755 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
)
4757 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
4758 bfd_mach_o_section
*sec
;
4760 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
4762 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
4763 mdata
->sections
[csect
++] = sec
;
4769 bfd_mach_o_scan_start_address (bfd
*abfd
)
4771 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4772 bfd_mach_o_thread_command
*thr
= NULL
;
4773 bfd_mach_o_load_command
*cmd
;
4776 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
4777 if (cmd
->type
== BFD_MACH_O_LC_THREAD
4778 || cmd
->type
== BFD_MACH_O_LC_UNIXTHREAD
)
4780 thr
= &cmd
->command
.thread
;
4783 else if (cmd
->type
== BFD_MACH_O_LC_MAIN
&& mdata
->nsects
> 1)
4785 bfd_mach_o_main_command
*main_cmd
= &cmd
->command
.main
;
4786 bfd_mach_o_section
*text_sect
= mdata
->sections
[0];
4790 abfd
->start_address
= main_cmd
->entryoff
4791 + (text_sect
->addr
- text_sect
->offset
);
4796 /* An object file has no start address, so do not fail if not found. */
4800 /* FIXME: create a subtarget hook ? */
4801 for (i
= 0; i
< thr
->nflavours
; i
++)
4803 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
4804 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE32
))
4806 unsigned char buf
[4];
4808 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
4809 || bfd_bread (buf
, 4, abfd
) != 4)
4812 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4814 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
4815 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
4817 unsigned char buf
[4];
4819 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4820 || bfd_bread (buf
, 4, abfd
) != 4)
4823 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
4825 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
4826 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
4828 unsigned char buf
[8];
4830 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
4831 || bfd_bread (buf
, 8, abfd
) != 8)
4834 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4836 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
4837 && (thr
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
4839 unsigned char buf
[8];
4841 if (bfd_seek (abfd
, thr
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
4842 || bfd_bread (buf
, 8, abfd
) != 8)
4845 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
4853 bfd_mach_o_set_arch_mach (bfd
*abfd
,
4854 enum bfd_architecture arch
,
4855 unsigned long machine
)
4857 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4859 /* If this isn't the right architecture for this backend, and this
4860 isn't the generic backend, fail. */
4861 if (arch
!= bed
->arch
4862 && arch
!= bfd_arch_unknown
4863 && bed
->arch
!= bfd_arch_unknown
)
4866 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4870 bfd_mach_o_scan (bfd
*abfd
,
4871 bfd_mach_o_header
*header
,
4872 bfd_mach_o_data_struct
*mdata
)
4875 enum bfd_architecture cputype
;
4876 unsigned long cpusubtype
;
4877 unsigned int hdrsize
;
4879 hdrsize
= mach_o_wide_p (header
) ?
4880 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
4882 mdata
->header
= *header
;
4884 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
4885 switch (header
->filetype
)
4887 case BFD_MACH_O_MH_OBJECT
:
4888 abfd
->flags
|= HAS_RELOC
;
4890 case BFD_MACH_O_MH_EXECUTE
:
4891 abfd
->flags
|= EXEC_P
;
4893 case BFD_MACH_O_MH_DYLIB
:
4894 case BFD_MACH_O_MH_BUNDLE
:
4895 abfd
->flags
|= DYNAMIC
;
4899 abfd
->tdata
.mach_o_data
= mdata
;
4901 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
4902 &cputype
, &cpusubtype
);
4903 if (cputype
== bfd_arch_unknown
)
4905 (*_bfd_error_handler
)
4906 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4907 header
->cputype
, header
->cpusubtype
);
4911 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
4913 if (header
->ncmds
!= 0)
4915 bfd_mach_o_load_command
*cmd
;
4917 mdata
->first_command
= NULL
;
4918 mdata
->last_command
= NULL
;
4919 cmd
= bfd_alloc (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
4923 for (i
= 0; i
< header
->ncmds
; i
++)
4925 bfd_mach_o_load_command
*cur
= &cmd
[i
];
4927 bfd_mach_o_append_command (abfd
, cur
);
4930 cur
->offset
= hdrsize
;
4933 bfd_mach_o_load_command
*prev
= &cmd
[i
- 1];
4934 cur
->offset
= prev
->offset
+ prev
->len
;
4937 if (!bfd_mach_o_read_command (abfd
, cur
))
4942 /* Sections should be flatten before scanning start address. */
4943 bfd_mach_o_flatten_sections (abfd
);
4944 if (!bfd_mach_o_scan_start_address (abfd
))
4951 bfd_mach_o_mkobject_init (bfd
*abfd
)
4953 bfd_mach_o_data_struct
*mdata
= NULL
;
4955 mdata
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
4958 abfd
->tdata
.mach_o_data
= mdata
;
4960 mdata
->header
.magic
= 0;
4961 mdata
->header
.cputype
= 0;
4962 mdata
->header
.cpusubtype
= 0;
4963 mdata
->header
.filetype
= 0;
4964 mdata
->header
.ncmds
= 0;
4965 mdata
->header
.sizeofcmds
= 0;
4966 mdata
->header
.flags
= 0;
4967 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
4968 mdata
->first_command
= NULL
;
4969 mdata
->last_command
= NULL
;
4971 mdata
->sections
= NULL
;
4972 mdata
->dyn_reloc_cache
= NULL
;
4978 bfd_mach_o_gen_mkobject (bfd
*abfd
)
4980 bfd_mach_o_data_struct
*mdata
;
4982 if (!bfd_mach_o_mkobject_init (abfd
))
4985 mdata
= bfd_mach_o_get_data (abfd
);
4986 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
4987 mdata
->header
.cputype
= 0;
4988 mdata
->header
.cpusubtype
= 0;
4989 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
4990 mdata
->header
.version
= 1;
4996 bfd_mach_o_header_p (bfd
*abfd
,
4997 bfd_mach_o_filetype filetype
,
4998 bfd_mach_o_cpu_type cputype
)
5000 bfd_mach_o_header header
;
5001 bfd_mach_o_data_struct
*mdata
;
5003 if (!bfd_mach_o_read_header (abfd
, &header
))
5006 if (! (header
.byteorder
== BFD_ENDIAN_BIG
5007 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
5009 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
5010 (unsigned long) header
.byteorder
);
5014 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
5015 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
5016 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
5017 || (header
.byteorder
== BFD_ENDIAN_LITTLE
5018 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
5019 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
5022 /* Check cputype and filetype.
5023 In case of wildcard, do not accept magics that are handled by existing
5027 if (header
.cputype
!= cputype
)
5033 /* Do not recognize 64 architectures if not configured for 64bit targets.
5034 This could happen only for generic targets. */
5035 if (mach_o_wide_p (&header
))
5042 if (header
.filetype
!= filetype
)
5047 switch (header
.filetype
)
5049 case BFD_MACH_O_MH_CORE
:
5050 /* Handled by core_p */
5057 mdata
= (bfd_mach_o_data_struct
*) bfd_zalloc (abfd
, sizeof (*mdata
));
5061 if (!bfd_mach_o_scan (abfd
, &header
, mdata
))
5067 bfd_set_error (bfd_error_wrong_format
);
5073 static const bfd_target
*
5074 bfd_mach_o_gen_object_p (bfd
*abfd
)
5076 return bfd_mach_o_header_p (abfd
, 0, 0);
5079 static const bfd_target
*
5080 bfd_mach_o_gen_core_p (bfd
*abfd
)
5082 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
5085 /* Return the base address of ABFD, ie the address at which the image is
5086 mapped. The possible initial pagezero is ignored. */
5089 bfd_mach_o_get_base_address (bfd
*abfd
)
5091 bfd_mach_o_data_struct
*mdata
;
5092 bfd_mach_o_load_command
*cmd
;
5094 /* Check for Mach-O. */
5095 if (!bfd_mach_o_valid (abfd
))
5097 mdata
= bfd_mach_o_get_data (abfd
);
5099 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5101 if ((cmd
->type
== BFD_MACH_O_LC_SEGMENT
5102 || cmd
->type
== BFD_MACH_O_LC_SEGMENT_64
))
5104 struct bfd_mach_o_segment_command
*segcmd
= &cmd
->command
.segment
;
5106 if (segcmd
->initprot
!= 0)
5107 return segcmd
->vmaddr
;
5113 typedef struct mach_o_fat_archentry
5115 unsigned long cputype
;
5116 unsigned long cpusubtype
;
5117 unsigned long offset
;
5119 unsigned long align
;
5120 } mach_o_fat_archentry
;
5122 typedef struct mach_o_fat_data_struct
5124 unsigned long magic
;
5125 unsigned long nfat_arch
;
5126 mach_o_fat_archentry
*archentries
;
5127 } mach_o_fat_data_struct
;
5130 bfd_mach_o_archive_p (bfd
*abfd
)
5132 mach_o_fat_data_struct
*adata
= NULL
;
5133 struct mach_o_fat_header_external hdr
;
5136 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
5137 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
5140 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
5144 adata
->magic
= bfd_getb32 (hdr
.magic
);
5145 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
5146 if (adata
->magic
!= 0xcafebabe)
5148 /* Avoid matching Java bytecode files, which have the same magic number.
5149 In the Java bytecode file format this field contains the JVM version,
5150 which starts at 43.0. */
5151 if (adata
->nfat_arch
> 30)
5154 adata
->archentries
=
5155 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
5156 if (adata
->archentries
== NULL
)
5159 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5161 struct mach_o_fat_arch_external arch
;
5162 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
5164 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
5165 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
5166 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
5167 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
5168 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
5171 abfd
->tdata
.mach_o_fat_data
= adata
;
5176 bfd_release (abfd
, adata
);
5177 bfd_set_error (bfd_error_wrong_format
);
5181 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5182 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5183 Set arelt_data and origin fields too. */
5186 bfd_mach_o_fat_member_init (bfd
*abfd
,
5187 enum bfd_architecture arch_type
,
5188 unsigned long arch_subtype
,
5189 mach_o_fat_archentry
*entry
)
5191 struct areltdata
*areltdata
;
5192 /* Create the member filename. Use ARCH_NAME. */
5193 const bfd_arch_info_type
*ap
= bfd_lookup_arch (arch_type
, arch_subtype
);
5197 /* Use the architecture name if known. */
5198 abfd
->filename
= xstrdup (ap
->printable_name
);
5202 /* Forge a uniq id. */
5203 const size_t namelen
= 2 + 8 + 1 + 2 + 8 + 1;
5204 char *name
= xmalloc (namelen
);
5205 snprintf (name
, namelen
, "0x%lx-0x%lx",
5206 entry
->cputype
, entry
->cpusubtype
);
5207 abfd
->filename
= name
;
5210 areltdata
= bfd_zmalloc (sizeof (struct areltdata
));
5211 areltdata
->parsed_size
= entry
->size
;
5212 abfd
->arelt_data
= areltdata
;
5213 abfd
->iostream
= NULL
;
5214 abfd
->origin
= entry
->offset
;
5218 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
5220 mach_o_fat_data_struct
*adata
;
5221 mach_o_fat_archentry
*entry
= NULL
;
5224 enum bfd_architecture arch_type
;
5225 unsigned long arch_subtype
;
5227 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
5228 BFD_ASSERT (adata
!= NULL
);
5230 /* Find index of previous entry. */
5233 /* Start at first one. */
5238 /* Find index of PREV. */
5239 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5241 if (adata
->archentries
[i
].offset
== prev
->origin
)
5245 if (i
== adata
->nfat_arch
)
5248 bfd_set_error (bfd_error_bad_value
);
5252 /* Get next entry. */
5256 if (i
>= adata
->nfat_arch
)
5258 bfd_set_error (bfd_error_no_more_archived_files
);
5262 entry
= &adata
->archentries
[i
];
5263 nbfd
= _bfd_new_bfd_contained_in (archive
);
5267 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
5268 &arch_type
, &arch_subtype
);
5270 bfd_mach_o_fat_member_init (nbfd
, arch_type
, arch_subtype
, entry
);
5272 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
5277 /* Analogous to stat call. */
5280 bfd_mach_o_fat_stat_arch_elt (bfd
*abfd
, struct stat
*buf
)
5282 if (abfd
->arelt_data
== NULL
)
5284 bfd_set_error (bfd_error_invalid_operation
);
5291 buf
->st_mode
= 0644;
5292 buf
->st_size
= arelt_size (abfd
);
5297 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5298 If ABFD is a fat image containing a member that corresponds to FORMAT
5299 and ARCH, returns it.
5300 In other case, returns NULL.
5301 This function allows transparent uses of fat images. */
5304 bfd_mach_o_fat_extract (bfd
*abfd
,
5306 const bfd_arch_info_type
*arch
)
5309 mach_o_fat_data_struct
*adata
;
5312 if (bfd_check_format (abfd
, format
))
5314 if (bfd_get_arch_info (abfd
) == arch
)
5318 if (!bfd_check_format (abfd
, bfd_archive
)
5319 || abfd
->xvec
!= &mach_o_fat_vec
)
5322 /* This is a Mach-O fat image. */
5323 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
5324 BFD_ASSERT (adata
!= NULL
);
5326 for (i
= 0; i
< adata
->nfat_arch
; i
++)
5328 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
5329 enum bfd_architecture cpu_type
;
5330 unsigned long cpu_subtype
;
5332 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
5333 &cpu_type
, &cpu_subtype
);
5334 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
5337 /* The architecture is found. */
5338 res
= _bfd_new_bfd_contained_in (abfd
);
5342 bfd_mach_o_fat_member_init (res
, cpu_type
, cpu_subtype
, e
);
5344 if (bfd_check_format (res
, format
))
5346 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
5357 bfd_mach_o_lookup_command (bfd
*abfd
,
5358 bfd_mach_o_load_command_type type
,
5359 bfd_mach_o_load_command
**mcommand
)
5361 struct mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5362 struct bfd_mach_o_load_command
*cmd
;
5365 BFD_ASSERT (mdata
!= NULL
);
5366 BFD_ASSERT (mcommand
!= NULL
);
5369 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5371 if (cmd
->type
!= type
)
5383 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
5387 case BFD_MACH_O_CPU_TYPE_MC680x0
:
5389 case BFD_MACH_O_CPU_TYPE_MC88000
:
5391 case BFD_MACH_O_CPU_TYPE_POWERPC
:
5393 case BFD_MACH_O_CPU_TYPE_I386
:
5395 case BFD_MACH_O_CPU_TYPE_SPARC
:
5397 case BFD_MACH_O_CPU_TYPE_I860
:
5399 case BFD_MACH_O_CPU_TYPE_HPPA
:
5400 return 0xc0000000 - 0x04000000;
5406 /* The following two tables should be kept, as far as possible, in order of
5407 most frequently used entries to optimize their use from gas. */
5409 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
5411 { "regular", BFD_MACH_O_S_REGULAR
},
5412 { "coalesced", BFD_MACH_O_S_COALESCED
},
5413 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
5414 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
5415 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
5416 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
5417 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
5418 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
5419 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
5420 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
5421 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
5422 { "interposing", BFD_MACH_O_S_INTERPOSING
},
5423 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
5424 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
5425 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
5426 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
5427 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
5431 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
5433 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
5434 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
5435 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
5436 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
5437 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
5438 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
5439 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
5440 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
5441 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
5442 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5443 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
5447 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5450 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
5452 const bfd_mach_o_xlat_name
*x
;
5453 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
5455 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
5456 if (strcmp (x
->name
, name
) == 0)
5458 /* We found it... does the target support it? */
5459 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
5460 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
5461 return x
->val
; /* OK. */
5463 break; /* Not supported. */
5465 /* Maximum section ID = 0xff. */
5469 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5472 bfd_mach_o_get_section_attribute_from_name (const char *name
)
5474 const bfd_mach_o_xlat_name
*x
;
5476 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
5477 if (strcmp (x
->name
, name
) == 0)
5479 return (unsigned int)-1;
5483 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
5484 unsigned char **rbuf
,
5487 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5488 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
5489 bfd_mach_o_load_command
*cmd
;
5491 for (cmd
= mdata
->first_command
; cmd
!= NULL
; cmd
= cmd
->next
)
5493 bfd_mach_o_segment_command
*seg
;
5495 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
)
5498 seg
= &cmd
->command
.segment
;
5500 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
5502 unsigned long start
= seg
->fileoff
;
5503 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
5504 unsigned char *buf
= bfd_malloc (1024);
5505 unsigned long size
= 1024;
5509 bfd_size_type nread
= 0;
5510 unsigned long offset
;
5511 int found_nonnull
= 0;
5513 if (size
> (end
- start
))
5514 size
= (end
- start
);
5516 buf
= bfd_realloc_or_free (buf
, size
);
5520 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
5526 nread
= bfd_bread (buf
, size
, abfd
);
5534 for (offset
= 4; offset
<= size
; offset
+= 4)
5538 val
= *((unsigned long *) (buf
+ size
- offset
));
5539 if (! found_nonnull
)
5544 else if (val
== 0x0)
5546 unsigned long bottom
;
5549 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
5550 top
= seg
->fileoff
+ seg
->filesize
- 4;
5551 *rbuf
= bfd_malloc (top
- bottom
);
5552 *rlen
= top
- bottom
;
5554 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
5560 if (size
== (end
- start
))
5574 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
5576 unsigned char *buf
= NULL
;
5577 unsigned int len
= 0;
5580 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
5584 return (char *) buf
;
5588 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
5593 static bfd_mach_o_uuid_command
*
5594 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
5596 bfd_mach_o_load_command
*uuid_cmd
;
5597 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
5600 return &uuid_cmd
->command
.uuid
;
5603 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5606 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
5608 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
5611 BFD_ASSERT (uuid_cmd
);
5613 if (!bfd_check_format (abfd
, bfd_object
))
5616 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
5617 || bfd_mach_o_get_data (abfd
) == NULL
5618 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
5621 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5622 if (dsym_uuid_cmd
== NULL
)
5625 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
5626 sizeof (uuid_cmd
->uuid
)) != 0)
5632 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5633 The caller is responsible for closing the returned BFD object and
5634 its my_archive if the returned BFD is in a fat dSYM. */
5637 bfd_mach_o_find_dsym (const char *dsym_filename
,
5638 const bfd_mach_o_uuid_command
*uuid_cmd
,
5639 const bfd_arch_info_type
*arch
)
5641 bfd
*base_dsym_bfd
, *dsym_bfd
;
5643 BFD_ASSERT (uuid_cmd
);
5645 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
5646 if (base_dsym_bfd
== NULL
)
5649 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
5650 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
5653 bfd_close (dsym_bfd
);
5654 if (base_dsym_bfd
!= dsym_bfd
)
5655 bfd_close (base_dsym_bfd
);
5660 /* Return a BFD created from a dSYM file for ABFD.
5661 The caller is responsible for closing the returned BFD object, its
5662 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5665 bfd_mach_o_follow_dsym (bfd
*abfd
)
5667 char *dsym_filename
;
5668 bfd_mach_o_uuid_command
*uuid_cmd
;
5669 bfd
*dsym_bfd
, *base_bfd
= abfd
;
5670 const char *base_basename
;
5672 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
5675 if (abfd
->my_archive
)
5676 base_bfd
= abfd
->my_archive
;
5677 /* BFD may have been opened from a stream. */
5678 if (base_bfd
->filename
== NULL
)
5680 bfd_set_error (bfd_error_invalid_operation
);
5683 base_basename
= lbasename (base_bfd
->filename
);
5685 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
5686 if (uuid_cmd
== NULL
)
5689 /* TODO: We assume the DWARF file has the same as the binary's.
5690 It seems apple's GDB checks all files in the dSYM bundle directory.
5691 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5693 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
5694 + strlen (dsym_subdir
) + 1
5695 + strlen (base_basename
) + 1);
5696 sprintf (dsym_filename
, "%s%s/%s",
5697 base_bfd
->filename
, dsym_subdir
, base_basename
);
5699 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
5700 bfd_get_arch_info (abfd
));
5701 if (dsym_bfd
== NULL
)
5702 free (dsym_filename
);
5708 bfd_mach_o_find_nearest_line (bfd
*abfd
,
5712 const char **filename_ptr
,
5713 const char **functionname_ptr
,
5714 unsigned int *line_ptr
,
5715 unsigned int *discriminator_ptr
)
5717 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5720 switch (mdata
->header
.filetype
)
5722 case BFD_MACH_O_MH_OBJECT
:
5724 case BFD_MACH_O_MH_EXECUTE
:
5725 case BFD_MACH_O_MH_DYLIB
:
5726 case BFD_MACH_O_MH_BUNDLE
:
5727 case BFD_MACH_O_MH_KEXT_BUNDLE
:
5728 if (mdata
->dwarf2_find_line_info
== NULL
)
5730 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
5731 /* When we couldn't find dSYM for this binary, we look for
5732 the debug information in the binary itself. In this way,
5733 we won't try finding separated dSYM again because
5734 mdata->dwarf2_find_line_info will be filled. */
5735 if (! mdata
->dsym_bfd
)
5737 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
5738 dwarf_debug_sections
, symbols
,
5739 &mdata
->dwarf2_find_line_info
,
5747 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
5748 filename_ptr
, functionname_ptr
,
5749 line_ptr
, discriminator_ptr
,
5750 dwarf_debug_sections
, 0,
5751 &mdata
->dwarf2_find_line_info
);
5755 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
5757 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5758 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
5760 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
5761 bfd_mach_o_free_cached_info (abfd
);
5762 if (mdata
->dsym_bfd
!= NULL
)
5764 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
5765 char *dsym_filename
= (char *)(fat_bfd
5767 : mdata
->dsym_bfd
->filename
);
5768 bfd_close (mdata
->dsym_bfd
);
5769 mdata
->dsym_bfd
= NULL
;
5771 bfd_close (fat_bfd
);
5772 free (dsym_filename
);
5776 if (bfd_get_format (abfd
) == bfd_archive
5777 && abfd
->xvec
== &mach_o_fat_vec
)
5779 return _bfd_generic_close_and_cleanup (abfd
);
5782 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
5784 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
5786 free (mdata
->dyn_reloc_cache
);
5787 mdata
->dyn_reloc_cache
= NULL
;
5788 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
5790 free (asect
->relocation
);
5791 asect
->relocation
= NULL
;
5797 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5798 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5800 #define bfd_mach_o_swap_reloc_in NULL
5801 #define bfd_mach_o_swap_reloc_out NULL
5802 #define bfd_mach_o_print_thread NULL
5803 #define bfd_mach_o_tgt_seg_table NULL
5804 #define bfd_mach_o_section_type_valid_for_tgt NULL
5806 #define TARGET_NAME mach_o_be_vec
5807 #define TARGET_STRING "mach-o-be"
5808 #define TARGET_ARCHITECTURE bfd_arch_unknown
5809 #define TARGET_PAGESIZE 1
5810 #define TARGET_BIG_ENDIAN 1
5811 #define TARGET_ARCHIVE 0
5812 #define TARGET_PRIORITY 1
5813 #include "mach-o-target.c"
5816 #undef TARGET_STRING
5817 #undef TARGET_ARCHITECTURE
5818 #undef TARGET_PAGESIZE
5819 #undef TARGET_BIG_ENDIAN
5820 #undef TARGET_ARCHIVE
5821 #undef TARGET_PRIORITY
5823 #define TARGET_NAME mach_o_le_vec
5824 #define TARGET_STRING "mach-o-le"
5825 #define TARGET_ARCHITECTURE bfd_arch_unknown
5826 #define TARGET_PAGESIZE 1
5827 #define TARGET_BIG_ENDIAN 0
5828 #define TARGET_ARCHIVE 0
5829 #define TARGET_PRIORITY 1
5831 #include "mach-o-target.c"
5834 #undef TARGET_STRING
5835 #undef TARGET_ARCHITECTURE
5836 #undef TARGET_PAGESIZE
5837 #undef TARGET_BIG_ENDIAN
5838 #undef TARGET_ARCHIVE
5839 #undef TARGET_PRIORITY
5841 /* Not yet handled: creating an archive. */
5842 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5845 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5846 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5847 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5848 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5849 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5850 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5851 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5852 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5853 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5854 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5856 #define TARGET_NAME mach_o_fat_vec
5857 #define TARGET_STRING "mach-o-fat"
5858 #define TARGET_ARCHITECTURE bfd_arch_unknown
5859 #define TARGET_PAGESIZE 1
5860 #define TARGET_BIG_ENDIAN 1
5861 #define TARGET_ARCHIVE 1
5862 #define TARGET_PRIORITY 0
5864 #include "mach-o-target.c"
5867 #undef TARGET_STRING
5868 #undef TARGET_ARCHITECTURE
5869 #undef TARGET_PAGESIZE
5870 #undef TARGET_BIG_ENDIAN
5871 #undef TARGET_ARCHIVE
5872 #undef TARGET_PRIORITY