1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
28 #include "aout/stab_gnu.h"
29 #include "mach-o/reloc.h"
30 #include "mach-o/external.h"
35 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
36 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
37 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
39 #define FILE_ALIGN(off, algn) \
40 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
43 bfd_mach_o_version (bfd
*abfd
)
45 bfd_mach_o_data_struct
*mdata
= NULL
;
47 BFD_ASSERT (bfd_mach_o_valid (abfd
));
48 mdata
= bfd_mach_o_get_data (abfd
);
50 return mdata
->header
.version
;
54 bfd_mach_o_valid (bfd
*abfd
)
56 if (abfd
== NULL
|| abfd
->xvec
== NULL
)
59 if (abfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
62 if (bfd_mach_o_get_data (abfd
) == NULL
)
67 static INLINE bfd_boolean
68 mach_o_wide_p (bfd_mach_o_header
*header
)
70 switch (header
->version
)
82 static INLINE bfd_boolean
83 bfd_mach_o_wide_p (bfd
*abfd
)
85 return mach_o_wide_p (&bfd_mach_o_get_data (abfd
)->header
);
88 /* Tables to translate well known Mach-O segment/section names to bfd
89 names. Use of canonical names (such as .text or .debug_frame) is required
93 static const mach_o_section_name_xlat text_section_names_xlat
[] =
96 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
97 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
, 0},
98 { ".const", "__const",
99 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
100 BFD_MACH_O_S_ATTR_NONE
, 0},
101 { ".static_const", "__static_const",
102 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
103 BFD_MACH_O_S_ATTR_NONE
, 0},
104 { ".cstring", "__cstring",
105 SEC_READONLY
| SEC_DATA
| SEC_LOAD
| SEC_MERGE
| SEC_STRINGS
,
106 BFD_MACH_O_S_CSTRING_LITERALS
,
107 BFD_MACH_O_S_ATTR_NONE
, 0},
108 { ".literal4", "__literal4",
109 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_4BYTE_LITERALS
,
110 BFD_MACH_O_S_ATTR_NONE
, 2},
111 { ".literal8", "__literal8",
112 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_8BYTE_LITERALS
,
113 BFD_MACH_O_S_ATTR_NONE
, 3},
114 { ".literal16", "__literal16",
115 SEC_READONLY
| SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_16BYTE_LITERALS
,
116 BFD_MACH_O_S_ATTR_NONE
, 4},
117 { ".constructor", "__constructor",
118 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
119 BFD_MACH_O_S_ATTR_NONE
, 0},
120 { ".destructor", "__destructor",
121 SEC_CODE
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
122 BFD_MACH_O_S_ATTR_NONE
, 0},
123 { ".eh_frame", "__eh_frame",
124 SEC_READONLY
| SEC_LOAD
, BFD_MACH_O_S_COALESCED
,
125 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
126 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
127 | BFD_MACH_O_S_ATTR_NO_TOC
, 3},
128 { NULL
, NULL
, 0, 0, 0, 0}
131 /* __DATA Segment. */
132 static const mach_o_section_name_xlat data_section_names_xlat
[] =
135 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
136 BFD_MACH_O_S_ATTR_NONE
, 0},
138 SEC_NO_FLAGS
, BFD_MACH_O_S_ZEROFILL
,
139 BFD_MACH_O_S_ATTR_NONE
, 0},
140 { ".const_data", "__const",
141 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
142 BFD_MACH_O_S_ATTR_NONE
, 0},
143 { ".static_data", "__static_data",
144 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
145 BFD_MACH_O_S_ATTR_NONE
, 0},
146 { ".mod_init_func", "__mod_init_func",
147 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
,
148 BFD_MACH_O_S_ATTR_NONE
, 2},
149 { ".mod_term_func", "__mod_term_func",
150 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
,
151 BFD_MACH_O_S_ATTR_NONE
, 2},
153 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
154 BFD_MACH_O_S_ATTR_NONE
, 0},
155 { ".cfstring", "__cfstring",
156 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
157 BFD_MACH_O_S_ATTR_NONE
, 2},
158 { NULL
, NULL
, 0, 0, 0, 0}
161 /* __DWARF Segment. */
162 static const mach_o_section_name_xlat dwarf_section_names_xlat
[] =
164 { ".debug_frame", "__debug_frame",
165 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
166 BFD_MACH_O_S_ATTR_DEBUG
, 0},
167 { ".debug_info", "__debug_info",
168 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
169 BFD_MACH_O_S_ATTR_DEBUG
, 0},
170 { ".debug_abbrev", "__debug_abbrev",
171 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
172 BFD_MACH_O_S_ATTR_DEBUG
, 0},
173 { ".debug_aranges", "__debug_aranges",
174 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
175 BFD_MACH_O_S_ATTR_DEBUG
, 0},
176 { ".debug_macinfo", "__debug_macinfo",
177 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
178 BFD_MACH_O_S_ATTR_DEBUG
, 0},
179 { ".debug_line", "__debug_line",
180 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
181 BFD_MACH_O_S_ATTR_DEBUG
, 0},
182 { ".debug_loc", "__debug_loc",
183 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
184 BFD_MACH_O_S_ATTR_DEBUG
, 0},
185 { ".debug_pubnames", "__debug_pubnames",
186 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
187 BFD_MACH_O_S_ATTR_DEBUG
, 0},
188 { ".debug_pubtypes", "__debug_pubtypes",
189 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
190 BFD_MACH_O_S_ATTR_DEBUG
, 0},
191 { ".debug_str", "__debug_str",
192 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
193 BFD_MACH_O_S_ATTR_DEBUG
, 0},
194 { ".debug_ranges", "__debug_ranges",
195 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
196 BFD_MACH_O_S_ATTR_DEBUG
, 0},
197 { ".debug_macro", "__debug_macro",
198 SEC_DEBUGGING
, BFD_MACH_O_S_REGULAR
,
199 BFD_MACH_O_S_ATTR_DEBUG
, 0},
200 { NULL
, NULL
, 0, 0, 0, 0}
203 /* __OBJC Segment. */
204 static const mach_o_section_name_xlat objc_section_names_xlat
[] =
206 { ".objc_class", "__class",
207 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
208 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
209 { ".objc_meta_class", "__meta_class",
210 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
211 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
212 { ".objc_cat_cls_meth", "__cat_cls_meth",
213 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
214 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
215 { ".objc_cat_inst_meth", "__cat_inst_meth",
216 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
217 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
218 { ".objc_protocol", "__protocol",
219 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
220 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
221 { ".objc_string_object", "__string_object",
222 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
223 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
224 { ".objc_cls_meth", "__cls_meth",
225 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
226 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
227 { ".objc_inst_meth", "__inst_meth",
228 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
229 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
230 { ".objc_cls_refs", "__cls_refs",
231 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
232 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
233 { ".objc_message_refs", "__message_refs",
234 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_LITERAL_POINTERS
,
235 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
236 { ".objc_symbols", "__symbols",
237 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
238 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
239 { ".objc_category", "__category",
240 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
241 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
242 { ".objc_class_vars", "__class_vars",
243 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
244 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
245 { ".objc_instance_vars", "__instance_vars",
246 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
247 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
248 { ".objc_module_info", "__module_info",
249 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
250 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
251 { ".objc_selector_strs", "__selector_strs",
252 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_CSTRING_LITERALS
,
253 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
254 { ".objc_image_info", "__image_info",
255 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
256 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
257 { ".objc_selector_fixup", "__sel_fixup",
258 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
259 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
261 { ".objc1_class_ext", "__class_ext",
262 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
263 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
264 { ".objc1_property_list", "__property",
265 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
266 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
267 { ".objc1_protocol_ext", "__protocol_ext",
268 SEC_DATA
| SEC_LOAD
, BFD_MACH_O_S_REGULAR
,
269 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
, 0},
270 { NULL
, NULL
, 0, 0, 0, 0}
273 static const mach_o_segment_name_xlat segsec_names_xlat
[] =
275 { "__TEXT", text_section_names_xlat
},
276 { "__DATA", data_section_names_xlat
},
277 { "__DWARF", dwarf_section_names_xlat
},
278 { "__OBJC", objc_section_names_xlat
},
282 static const char dsym_subdir
[] = ".dSYM/Contents/Resources/DWARF";
284 /* For both cases bfd-name => mach-o name and vice versa, the specific target
285 is checked before the generic. This allows a target (e.g. ppc for cstring)
286 to override the generic definition with a more specific one. */
288 /* Fetch the translation from a Mach-O section designation (segment, section)
289 as a bfd short name, if one exists. Otherwise return NULL.
291 Allow the segment and section names to be unterminated 16 byte arrays. */
293 const mach_o_section_name_xlat
*
294 bfd_mach_o_section_data_for_mach_sect (bfd
*abfd
, const char *segname
,
295 const char *sectname
)
297 const struct mach_o_segment_name_xlat
*seg
;
298 const mach_o_section_name_xlat
*sec
;
299 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
301 /* First try any target-specific translations defined... */
302 if (bed
->segsec_names_xlat
)
303 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
304 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
305 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
306 if (strncmp (sec
->mach_o_name
, sectname
,
307 BFD_MACH_O_SECTNAME_SIZE
) == 0)
310 /* ... and then the Mach-O generic ones. */
311 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
312 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
313 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
314 if (strncmp (sec
->mach_o_name
, sectname
,
315 BFD_MACH_O_SECTNAME_SIZE
) == 0)
321 /* If the bfd_name for this section is a 'canonical' form for which we
322 know the Mach-O data, return the segment name and the data for the
323 Mach-O equivalent. Otherwise return NULL. */
325 const mach_o_section_name_xlat
*
326 bfd_mach_o_section_data_for_bfd_name (bfd
*abfd
, const char *bfd_name
,
327 const char **segname
)
329 const struct mach_o_segment_name_xlat
*seg
;
330 const mach_o_section_name_xlat
*sec
;
331 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
334 if (bfd_name
[0] != '.')
337 /* First try any target-specific translations defined... */
338 if (bed
->segsec_names_xlat
)
339 for (seg
= bed
->segsec_names_xlat
; seg
->segname
; seg
++)
340 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
341 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
343 *segname
= seg
->segname
;
347 /* ... and then the Mach-O generic ones. */
348 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
349 for (sec
= seg
->sections
; sec
->bfd_name
; sec
++)
350 if (strcmp (bfd_name
, sec
->bfd_name
) == 0)
352 *segname
= seg
->segname
;
359 /* Convert Mach-O section name to BFD.
361 Try to use standard/canonical names, for which we have tables including
362 default flag settings - which are returned. Otherwise forge a new name
363 in the form "<segmentname>.<sectionname>" this will be prefixed with
364 LC_SEGMENT. if the segment name does not begin with an underscore.
366 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
367 terminated if the name length is exactly 16 bytes - but must be if the name
368 length is less than 16 characters). */
371 bfd_mach_o_convert_section_name_to_bfd (bfd
*abfd
, const char *segname
,
372 const char *secname
, const char **name
,
375 const mach_o_section_name_xlat
*xlat
;
378 const char *pfx
= "";
381 *flags
= SEC_NO_FLAGS
;
383 /* First search for a canonical name...
384 xlat will be non-null if there is an entry for segname, secname. */
385 xlat
= bfd_mach_o_section_data_for_mach_sect (abfd
, segname
, secname
);
388 len
= strlen (xlat
->bfd_name
);
389 res
= bfd_alloc (abfd
, len
+1);
392 memcpy (res
, xlat
->bfd_name
, len
+1);
394 *flags
= xlat
->bfd_flags
;
398 /* ... else we make up a bfd name from the segment concatenated with the
401 len
= 16 + 1 + 16 + 1;
403 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
404 with an underscore. */
405 if (segname
[0] != '_')
407 static const char seg_pfx
[] = "LC_SEGMENT.";
410 len
+= sizeof (seg_pfx
) - 1;
413 res
= bfd_alloc (abfd
, len
);
416 snprintf (res
, len
, "%s%.16s.%.16s", pfx
, segname
, secname
);
420 /* Convert a bfd section name to a Mach-O segment + section name.
422 If the name is a canonical one for which we have a Darwin match
423 return the translation table - which contains defaults for flags,
424 type, attribute and default alignment data.
426 Otherwise, expand the bfd_name (assumed to be in the form
427 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
429 static const mach_o_section_name_xlat
*
430 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
432 bfd_mach_o_section
*section
)
434 const mach_o_section_name_xlat
*xlat
;
435 const char *name
= bfd_get_section_name (abfd
, sect
);
442 memset (section
->segname
, 0, BFD_MACH_O_SEGNAME_SIZE
+ 1);
443 memset (section
->sectname
, 0, BFD_MACH_O_SECTNAME_SIZE
+ 1);
445 /* See if is a canonical name ... */
446 xlat
= bfd_mach_o_section_data_for_bfd_name (abfd
, name
, &segname
);
449 strcpy (section
->segname
, segname
);
450 strcpy (section
->sectname
, xlat
->mach_o_name
);
454 /* .. else we convert our constructed one back to Mach-O.
455 Strip LC_SEGMENT. prefix, if present. */
456 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
460 dot
= strchr (name
, '.');
463 /* Try to split name into segment and section names. */
464 if (dot
&& dot
!= name
)
467 seclen
= len
- (dot
+ 1 - name
);
469 if (seglen
< 16 && seclen
< 16)
471 memcpy (section
->segname
, name
, seglen
);
472 section
->segname
[seglen
] = 0;
473 memcpy (section
->sectname
, dot
+ 1, seclen
);
474 section
->sectname
[seclen
] = 0;
479 /* The segment and section names are both missing - don't make them
481 if (dot
&& dot
== name
)
484 /* Just duplicate the name into both segment and section. */
487 memcpy (section
->segname
, name
, len
);
488 section
->segname
[len
] = 0;
489 memcpy (section
->sectname
, name
, len
);
490 section
->sectname
[len
] = 0;
494 /* Return the size of an entry for section SEC.
495 Must be called only for symbol pointer section and symbol stubs
499 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
501 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
503 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
504 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
505 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
506 case BFD_MACH_O_S_SYMBOL_STUBS
:
507 return sec
->reserved2
;
514 /* Return the number of indirect symbols for a section.
515 Must be called only for symbol pointer section and symbol stubs
519 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
523 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
527 return sec
->size
/ elsz
;
531 /* Copy any private info we understand from the input symbol
532 to the output symbol. */
535 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
536 asymbol
*isymbol ATTRIBUTE_UNUSED
,
537 bfd
*obfd ATTRIBUTE_UNUSED
,
538 asymbol
*osymbol ATTRIBUTE_UNUSED
)
543 /* Copy any private info we understand from the input section
544 to the output section. */
547 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
549 bfd
*obfd ATTRIBUTE_UNUSED
,
552 if (osection
->used_by_bfd
== NULL
)
553 osection
->used_by_bfd
= isection
->used_by_bfd
;
555 if (isection
->used_by_bfd
!= NULL
)
556 memcpy (osection
->used_by_bfd
, isection
->used_by_bfd
,
557 sizeof (bfd_mach_o_section
));
559 if (osection
->used_by_bfd
!= NULL
)
560 ((bfd_mach_o_section
*)osection
->used_by_bfd
)->bfdsection
= osection
;
565 /* Copy any private info we understand from the input bfd
566 to the output bfd. */
569 bfd_mach_o_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
571 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
572 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
575 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
576 BFD_ASSERT (bfd_mach_o_valid (obfd
));
578 /* FIXME: copy commands. */
583 /* This allows us to set up to 32 bits of flags (unless we invent some
584 fiendish scheme to subdivide). For now, we'll just set the file flags
585 without error checking - just overwrite. */
588 bfd_mach_o_bfd_set_private_flags (bfd
*abfd
, flagword flags
)
590 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
595 mdata
->header
.flags
= flags
;
599 /* Count the total number of symbols. */
602 bfd_mach_o_count_symbols (bfd
*abfd
)
604 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
606 if (mdata
->symtab
== NULL
)
608 return mdata
->symtab
->nsyms
;
612 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
614 long nsyms
= bfd_mach_o_count_symbols (abfd
);
616 return ((nsyms
+ 1) * sizeof (asymbol
*));
620 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
622 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
623 long nsyms
= bfd_mach_o_count_symbols (abfd
);
624 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
632 /* Do not try to read symbols if there are none. */
637 if (!bfd_mach_o_read_symtab_symbols (abfd
))
639 (*_bfd_error_handler
)
640 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
644 BFD_ASSERT (sym
->symbols
!= NULL
);
646 for (j
= 0; j
< sym
->nsyms
; j
++)
647 alocation
[j
] = &sym
->symbols
[j
].symbol
;
654 /* Create synthetic symbols for indirect symbols. */
657 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
658 long symcount ATTRIBUTE_UNUSED
,
659 asymbol
**syms ATTRIBUTE_UNUSED
,
660 long dynsymcount ATTRIBUTE_UNUSED
,
661 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
664 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
665 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
666 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
668 unsigned long count
, i
, j
, n
;
675 /* Stop now if no symbols or no indirect symbols. */
676 if (dysymtab
== NULL
|| symtab
== NULL
|| symtab
->symbols
== NULL
)
679 if (dysymtab
->nindirectsyms
== 0)
682 /* We need to allocate a bfd symbol for every indirect symbol and to
683 allocate the memory for its name. */
684 count
= dysymtab
->nindirectsyms
;
685 size
= count
* sizeof (asymbol
) + 1;
687 for (j
= 0; j
< count
; j
++)
689 unsigned int isym
= dysymtab
->indirect_syms
[j
];
691 /* Some indirect symbols are anonymous. */
692 if (isym
< symtab
->nsyms
&& symtab
->symbols
[isym
].symbol
.name
)
693 size
+= strlen (symtab
->symbols
[isym
].symbol
.name
) + sizeof ("$stub");
696 s
= *ret
= (asymbol
*) bfd_malloc (size
);
699 names
= (char *) (s
+ count
);
704 for (i
= 0; i
< mdata
->nsects
; i
++)
706 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
707 unsigned int first
, last
;
711 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
713 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
714 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
715 case BFD_MACH_O_S_SYMBOL_STUBS
:
716 /* Only these sections have indirect symbols. */
717 first
= sec
->reserved1
;
718 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
720 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
721 for (j
= first
; j
< last
; j
++)
723 unsigned int isym
= dysymtab
->indirect_syms
[j
];
725 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
726 s
->section
= sec
->bfdsection
;
727 s
->value
= addr
- sec
->addr
;
730 if (isym
< symtab
->nsyms
731 && symtab
->symbols
[isym
].symbol
.name
)
733 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
738 memcpy (names
, sym
, len
);
740 memcpy (names
, "$stub", sizeof ("$stub"));
741 names
+= sizeof ("$stub");
760 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
764 bfd_symbol_info (symbol
, ret
);
768 bfd_mach_o_print_symbol (bfd
*abfd
,
771 bfd_print_symbol_type how
)
773 FILE *file
= (FILE *) afile
;
775 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
779 case bfd_print_symbol_name
:
780 fprintf (file
, "%s", symbol
->name
);
783 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
784 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
785 name
= bfd_get_stab_name (asym
->n_type
);
787 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
789 case BFD_MACH_O_N_UNDF
:
790 if (symbol
->value
== 0)
795 case BFD_MACH_O_N_ABS
:
798 case BFD_MACH_O_N_INDR
:
801 case BFD_MACH_O_N_PBUD
:
804 case BFD_MACH_O_N_SECT
:
813 fprintf (file
, " %02x %-6s %02x %04x",
814 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
815 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
816 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
817 fprintf (file
, " [%s]", symbol
->section
->name
);
818 fprintf (file
, " %s", symbol
->name
);
823 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
824 bfd_mach_o_cpu_subtype msubtype
,
825 enum bfd_architecture
*type
,
826 unsigned long *subtype
)
828 *subtype
= bfd_arch_unknown
;
832 case BFD_MACH_O_CPU_TYPE_VAX
:
833 *type
= bfd_arch_vax
;
835 case BFD_MACH_O_CPU_TYPE_MC680x0
:
836 *type
= bfd_arch_m68k
;
838 case BFD_MACH_O_CPU_TYPE_I386
:
839 *type
= bfd_arch_i386
;
840 *subtype
= bfd_mach_i386_i386
;
842 case BFD_MACH_O_CPU_TYPE_X86_64
:
843 *type
= bfd_arch_i386
;
844 *subtype
= bfd_mach_x86_64
;
846 case BFD_MACH_O_CPU_TYPE_MIPS
:
847 *type
= bfd_arch_mips
;
849 case BFD_MACH_O_CPU_TYPE_MC98000
:
850 *type
= bfd_arch_m98k
;
852 case BFD_MACH_O_CPU_TYPE_HPPA
:
853 *type
= bfd_arch_hppa
;
855 case BFD_MACH_O_CPU_TYPE_ARM
:
856 *type
= bfd_arch_arm
;
859 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T
:
860 *subtype
= bfd_mach_arm_4T
;
862 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6
:
863 *subtype
= bfd_mach_arm_4T
; /* Best fit ? */
865 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ
:
866 *subtype
= bfd_mach_arm_5TE
;
868 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE
:
869 *subtype
= bfd_mach_arm_XScale
;
871 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7
:
872 *subtype
= bfd_mach_arm_5TE
; /* Best fit ? */
874 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL
:
879 case BFD_MACH_O_CPU_TYPE_MC88000
:
880 *type
= bfd_arch_m88k
;
882 case BFD_MACH_O_CPU_TYPE_SPARC
:
883 *type
= bfd_arch_sparc
;
884 *subtype
= bfd_mach_sparc
;
886 case BFD_MACH_O_CPU_TYPE_I860
:
887 *type
= bfd_arch_i860
;
889 case BFD_MACH_O_CPU_TYPE_ALPHA
:
890 *type
= bfd_arch_alpha
;
892 case BFD_MACH_O_CPU_TYPE_POWERPC
:
893 *type
= bfd_arch_powerpc
;
894 *subtype
= bfd_mach_ppc
;
896 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
897 *type
= bfd_arch_powerpc
;
898 *subtype
= bfd_mach_ppc64
;
901 *type
= bfd_arch_unknown
;
907 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
909 struct mach_o_header_external raw
;
912 size
= mach_o_wide_p (header
) ?
913 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
915 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
916 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
917 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
918 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
919 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
920 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
921 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
923 if (mach_o_wide_p (header
))
924 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
926 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
927 || bfd_bwrite (&raw
, size
, abfd
) != size
)
934 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
936 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
938 struct mach_o_thread_command_external raw
;
941 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
942 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
945 for (i
= 0; i
< cmd
->nflavours
; i
++)
947 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
948 BFD_ASSERT (cmd
->flavours
[i
].offset
==
949 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
951 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
952 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
954 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
955 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
958 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
965 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
968 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
972 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
973 struct mach_o_reloc_info_external
*raw
,
974 arelent
*res
, asymbol
**syms
)
976 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
977 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
978 bfd_mach_o_reloc_info reloc
;
983 addr
= bfd_get_32 (abfd
, raw
->r_address
);
984 symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
986 if (addr
& BFD_MACH_O_SR_SCATTERED
)
990 /* Scattered relocation.
991 Extract section and offset from r_value. */
992 res
->sym_ptr_ptr
= NULL
;
994 for (j
= 0; j
< mdata
->nsects
; j
++)
996 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
997 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
999 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
1000 res
->addend
= symnum
- sect
->addr
;
1004 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
1005 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
1006 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
1007 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
1008 reloc
.r_scattered
= 1;
1012 unsigned int num
= BFD_MACH_O_GET_R_SYMBOLNUM (symnum
);
1014 res
->address
= addr
;
1015 if (symnum
& BFD_MACH_O_R_EXTERN
)
1022 BFD_ASSERT (num
!= 0);
1023 BFD_ASSERT (num
<= mdata
->nsects
);
1024 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
1025 /* For a symbol defined in section S, the addend (stored in the
1026 binary) contains the address of the section. To comply with
1027 bfd conventio, substract the section address.
1028 Use the address from the header, so that the user can modify
1029 the vma of the section. */
1030 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
1033 res
->sym_ptr_ptr
= sym
;
1034 reloc
.r_type
= BFD_MACH_O_GET_R_TYPE (symnum
);
1035 reloc
.r_length
= BFD_MACH_O_GET_R_LENGTH (symnum
);
1036 reloc
.r_pcrel
= (symnum
& BFD_MACH_O_R_PCREL
) ? 1 : 0;
1037 reloc
.r_scattered
= 0;
1040 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
1046 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
1047 unsigned long count
,
1048 arelent
*res
, asymbol
**syms
)
1051 struct mach_o_reloc_info_external
*native_relocs
;
1052 bfd_size_type native_size
;
1054 /* Allocate and read relocs. */
1055 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
1057 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
1058 if (native_relocs
== NULL
)
1061 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
1062 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
1065 for (i
= 0; i
< count
; i
++)
1067 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
1071 free (native_relocs
);
1074 free (native_relocs
);
1079 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
1080 arelent
**rels
, asymbol
**syms
)
1082 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1086 if (asect
->reloc_count
== 0)
1089 /* No need to go further if we don't know how to read relocs. */
1090 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1093 if (asect
->relocation
== NULL
)
1095 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
1099 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
1100 asect
->reloc_count
, res
, syms
) < 0)
1105 asect
->relocation
= res
;
1108 res
= asect
->relocation
;
1109 for (i
= 0; i
< asect
->reloc_count
; i
++)
1117 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
1119 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1121 if (mdata
->dysymtab
== NULL
)
1123 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
+ 1)
1124 * sizeof (arelent
*);
1128 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
1129 struct bfd_symbol
**syms
)
1131 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1132 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
1133 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1137 if (dysymtab
== NULL
)
1139 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
1142 /* No need to go further if we don't know how to read relocs. */
1143 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
1146 if (mdata
->dyn_reloc_cache
== NULL
)
1148 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
)
1149 * sizeof (arelent
));
1153 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
1154 dysymtab
->nextrel
, res
, syms
) < 0)
1160 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
1162 res
+ dysymtab
->nextrel
, syms
) < 0)
1168 mdata
->dyn_reloc_cache
= res
;
1171 res
= mdata
->dyn_reloc_cache
;
1172 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
1179 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
1181 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1185 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
1187 sec
= section
->bfdsection
;
1188 if (sec
->reloc_count
== 0)
1191 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
1194 /* Allocate relocation room. */
1195 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, 2);
1196 section
->nreloc
= sec
->reloc_count
;
1197 sec
->rel_filepos
= mdata
->filelen
;
1198 section
->reloff
= sec
->rel_filepos
;
1199 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
1201 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
1204 /* Convert and write. */
1205 entries
= section
->bfdsection
->orelocation
;
1206 for (i
= 0; i
< section
->nreloc
; i
++)
1208 arelent
*rel
= entries
[i
];
1209 struct mach_o_reloc_info_external raw
;
1210 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
1212 /* Convert relocation to an intermediate representation. */
1213 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
1216 /* Lower the relocation info. */
1217 if (pinfo
->r_scattered
)
1221 v
= BFD_MACH_O_SR_SCATTERED
1222 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
1223 | BFD_MACH_O_SET_SR_LENGTH(pinfo
->r_length
)
1224 | BFD_MACH_O_SET_SR_TYPE(pinfo
->r_type
)
1225 | BFD_MACH_O_SET_SR_ADDRESS(pinfo
->r_address
);
1226 /* Note: scattered relocs have field in reverse order... */
1227 bfd_put_32 (abfd
, v
, raw
.r_address
);
1228 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
1234 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
1235 v
= BFD_MACH_O_SET_R_SYMBOLNUM (pinfo
->r_value
)
1236 | (pinfo
->r_pcrel
? BFD_MACH_O_R_PCREL
: 0)
1237 | BFD_MACH_O_SET_R_LENGTH (pinfo
->r_length
)
1238 | (pinfo
->r_extern
? BFD_MACH_O_R_EXTERN
: 0)
1239 | BFD_MACH_O_SET_R_TYPE (pinfo
->r_type
);
1240 bfd_put_32 (abfd
, v
, raw
.r_symbolnum
);
1243 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
1244 != BFD_MACH_O_RELENT_SIZE
)
1251 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
1253 struct mach_o_section_32_external raw
;
1255 memcpy (raw
.sectname
, section
->sectname
, 16);
1256 memcpy (raw
.segname
, section
->segname
, 16);
1257 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
1258 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
1259 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1260 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1261 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1262 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1263 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1264 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1265 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1267 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1268 != BFD_MACH_O_SECTION_SIZE
)
1275 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
1277 struct mach_o_section_64_external raw
;
1279 memcpy (raw
.sectname
, section
->sectname
, 16);
1280 memcpy (raw
.segname
, section
->segname
, 16);
1281 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
1282 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
1283 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
1284 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
1285 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
1286 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
1287 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
1288 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
1289 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1290 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1292 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1293 != BFD_MACH_O_SECTION_64_SIZE
)
1300 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1302 struct mach_o_segment_command_32_external raw
;
1303 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1304 bfd_mach_o_section
*sec
;
1306 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1308 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1309 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1312 memcpy (raw
.segname
, seg
->segname
, 16);
1313 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1314 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1315 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1316 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1317 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1318 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1319 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1320 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1322 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1323 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1326 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1327 if (bfd_mach_o_write_section_32 (abfd
, sec
))
1334 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1336 struct mach_o_segment_command_64_external raw
;
1337 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1338 bfd_mach_o_section
*sec
;
1340 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1342 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1343 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1346 memcpy (raw
.segname
, seg
->segname
, 16);
1347 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1348 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1349 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1350 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1351 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1352 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1353 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1354 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1356 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1357 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1360 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1361 if (bfd_mach_o_write_section_64 (abfd
, sec
))
1368 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1370 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1371 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1373 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1374 unsigned int symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1375 struct bfd_strtab_hash
*strtab
;
1376 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1378 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1380 /* Write the symbols first. */
1381 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, wide
? 3 : 2);
1382 sym
->symoff
= mdata
->filelen
;
1383 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1386 sym
->nsyms
= bfd_get_symcount (abfd
);
1387 mdata
->filelen
+= sym
->nsyms
* symlen
;
1389 strtab
= _bfd_stringtab_init ();
1394 /* Although we don't strictly need to do this, for compatibility with
1395 Darwin system tools, actually output an empty string for the index
1397 _bfd_stringtab_add (strtab
, "", TRUE
, FALSE
);
1399 for (i
= 0; i
< sym
->nsyms
; i
++)
1401 bfd_size_type str_index
;
1402 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1404 /* For a bare indirect symbol, the system tools expect that the symbol
1405 value will be the string table offset for its referenced counterpart.
1407 Normally, indirect syms will not be written this way, but rather as
1408 part of the dysymtab command.
1410 In either case, correct operation depends on the symbol table being
1411 sorted such that the indirect symbols are at the end (since the
1412 string table index is filled in below). */
1414 if (IS_MACHO_INDIRECT (s
->n_type
))
1415 /* A pointer to the referenced symbol will be stored in the udata
1416 field. Use that to find the string index. */
1418 ((bfd_mach_o_asymbol
*)s
->symbol
.udata
.p
)->symbol
.udata
.i
;
1420 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1421 /* An index of 0 always means the empty string. */
1425 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1426 /* Record the string index. This can be looked up by an indirect sym
1427 which retains a pointer to its referenced counterpart, until it is
1429 if (IS_MACHO_INDIRECT (s
->n_type
))
1430 s
->symbol
.udata
.i
= str_index
;
1432 if (str_index
== (bfd_size_type
) -1)
1438 struct mach_o_nlist_64_external raw
;
1440 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1441 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1442 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1443 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1444 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1447 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1452 struct mach_o_nlist_external raw
;
1454 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1455 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1456 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1457 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1458 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1461 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1465 sym
->strsize
= _bfd_stringtab_size (strtab
);
1466 sym
->stroff
= mdata
->filelen
;
1467 mdata
->filelen
+= sym
->strsize
;
1469 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1471 _bfd_stringtab_free (strtab
);
1475 struct mach_o_symtab_command_external raw
;
1477 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1478 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1479 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1480 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1482 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1483 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1490 _bfd_stringtab_free (strtab
);
1494 /* Write a dysymtab command.
1495 TODO: Possibly coalesce writes of smaller objects. */
1498 bfd_mach_o_write_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1500 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
1502 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
1504 if (cmd
->nmodtab
!= 0)
1508 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
1511 for (i
= 0; i
< cmd
->nmodtab
; i
++)
1513 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
1517 iinit
= module
->iinit
& 0xffff;
1518 iinit
|= ((module
->iterm
& 0xffff) << 16);
1520 ninit
= module
->ninit
& 0xffff;
1521 ninit
|= ((module
->nterm
& 0xffff) << 16);
1523 if (bfd_mach_o_wide_p (abfd
))
1525 struct mach_o_dylib_module_64_external w
;
1527 bfd_h_put_32 (abfd
, module
->module_name_idx
, &w
.module_name
);
1528 bfd_h_put_32 (abfd
, module
->iextdefsym
, &w
.iextdefsym
);
1529 bfd_h_put_32 (abfd
, module
->nextdefsym
, &w
.nextdefsym
);
1530 bfd_h_put_32 (abfd
, module
->irefsym
, &w
.irefsym
);
1531 bfd_h_put_32 (abfd
, module
->nrefsym
, &w
.nrefsym
);
1532 bfd_h_put_32 (abfd
, module
->ilocalsym
, &w
.ilocalsym
);
1533 bfd_h_put_32 (abfd
, module
->nlocalsym
, &w
.nlocalsym
);
1534 bfd_h_put_32 (abfd
, module
->iextrel
, &w
.iextrel
);
1535 bfd_h_put_32 (abfd
, module
->nextrel
, &w
.nextrel
);
1536 bfd_h_put_32 (abfd
, iinit
, &w
.iinit_iterm
);
1537 bfd_h_put_32 (abfd
, ninit
, &w
.ninit_nterm
);
1538 bfd_h_put_64 (abfd
, module
->objc_module_info_addr
,
1539 &w
.objc_module_info_addr
);
1540 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
1541 &w
.objc_module_info_size
);
1543 if (bfd_bwrite ((void *) &w
, sizeof (w
), abfd
) != sizeof (w
))
1548 struct mach_o_dylib_module_external n
;
1550 bfd_h_put_32 (abfd
, module
->module_name_idx
, &n
.module_name
);
1551 bfd_h_put_32 (abfd
, module
->iextdefsym
, &n
.iextdefsym
);
1552 bfd_h_put_32 (abfd
, module
->nextdefsym
, &n
.nextdefsym
);
1553 bfd_h_put_32 (abfd
, module
->irefsym
, &n
.irefsym
);
1554 bfd_h_put_32 (abfd
, module
->nrefsym
, &n
.nrefsym
);
1555 bfd_h_put_32 (abfd
, module
->ilocalsym
, &n
.ilocalsym
);
1556 bfd_h_put_32 (abfd
, module
->nlocalsym
, &n
.nlocalsym
);
1557 bfd_h_put_32 (abfd
, module
->iextrel
, &n
.iextrel
);
1558 bfd_h_put_32 (abfd
, module
->nextrel
, &n
.nextrel
);
1559 bfd_h_put_32 (abfd
, iinit
, &n
.iinit_iterm
);
1560 bfd_h_put_32 (abfd
, ninit
, &n
.ninit_nterm
);
1561 bfd_h_put_32 (abfd
, module
->objc_module_info_addr
,
1562 &n
.objc_module_info_addr
);
1563 bfd_h_put_32 (abfd
, module
->objc_module_info_size
,
1564 &n
.objc_module_info_size
);
1566 if (bfd_bwrite ((void *) &n
, sizeof (n
), abfd
) != sizeof (n
))
1576 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
1579 for (i
= 0; i
< cmd
->ntoc
; i
++)
1581 struct mach_o_dylib_table_of_contents_external raw
;
1582 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
1584 bfd_h_put_32 (abfd
, toc
->symbol_index
, &raw
.symbol_index
);
1585 bfd_h_put_32 (abfd
, toc
->module_index
, &raw
.module_index
);
1587 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1592 if (cmd
->nindirectsyms
> 0)
1596 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
1599 for (i
= 0; i
< cmd
->nindirectsyms
; ++i
)
1601 unsigned char raw
[4];
1603 bfd_h_put_32 (abfd
, cmd
->indirect_syms
[i
], &raw
);
1604 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1609 if (cmd
->nextrefsyms
!= 0)
1613 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
1616 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
1619 unsigned char raw
[4];
1620 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
1622 /* Fields isym and flags are written as bit-fields, thus we need
1623 a specific processing for endianness. */
1625 if (bfd_big_endian (abfd
))
1627 v
= ((ref
->isym
& 0xffffff) << 8);
1628 v
|= ref
->flags
& 0xff;
1632 v
= ref
->isym
& 0xffffff;
1633 v
|= ((ref
->flags
& 0xff) << 24);
1636 bfd_h_put_32 (abfd
, v
, raw
);
1637 if (bfd_bwrite (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1643 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0)
1647 struct mach_o_dysymtab_command_external raw
;
1649 bfd_h_put_32 (abfd
, cmd
->ilocalsym
, &raw
.ilocalsym
);
1650 bfd_h_put_32 (abfd
, cmd
->nlocalsym
, &raw
.nlocalsym
);
1651 bfd_h_put_32 (abfd
, cmd
->iextdefsym
, &raw
.iextdefsym
);
1652 bfd_h_put_32 (abfd
, cmd
->nextdefsym
, &raw
.nextdefsym
);
1653 bfd_h_put_32 (abfd
, cmd
->iundefsym
, &raw
.iundefsym
);
1654 bfd_h_put_32 (abfd
, cmd
->nundefsym
, &raw
.nundefsym
);
1655 bfd_h_put_32 (abfd
, cmd
->tocoff
, &raw
.tocoff
);
1656 bfd_h_put_32 (abfd
, cmd
->ntoc
, &raw
.ntoc
);
1657 bfd_h_put_32 (abfd
, cmd
->modtaboff
, &raw
.modtaboff
);
1658 bfd_h_put_32 (abfd
, cmd
->nmodtab
, &raw
.nmodtab
);
1659 bfd_h_put_32 (abfd
, cmd
->extrefsymoff
, &raw
.extrefsymoff
);
1660 bfd_h_put_32 (abfd
, cmd
->nextrefsyms
, &raw
.nextrefsyms
);
1661 bfd_h_put_32 (abfd
, cmd
->indirectsymoff
, &raw
.indirectsymoff
);
1662 bfd_h_put_32 (abfd
, cmd
->nindirectsyms
, &raw
.nindirectsyms
);
1663 bfd_h_put_32 (abfd
, cmd
->extreloff
, &raw
.extreloff
);
1664 bfd_h_put_32 (abfd
, cmd
->nextrel
, &raw
.nextrel
);
1665 bfd_h_put_32 (abfd
, cmd
->locreloff
, &raw
.locreloff
);
1666 bfd_h_put_32 (abfd
, cmd
->nlocrel
, &raw
.nlocrel
);
1668 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1676 bfd_mach_o_primary_symbol_sort_key (unsigned type
)
1678 unsigned mtyp
= type
& BFD_MACH_O_N_TYPE
;
1680 /* Just leave debug symbols where they are (pretend they are local, and
1681 then they will just be sorted on position). */
1682 if (type
& BFD_MACH_O_N_STAB
)
1685 /* Sort indirects to last. */
1686 if (mtyp
== BFD_MACH_O_N_INDR
)
1689 /* Local (we should never see an undefined local AFAICT). */
1690 if (! (type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
)))
1693 /* Common symbols look like undefined externs. */
1694 if (mtyp
== BFD_MACH_O_N_UNDF
)
1697 /* A defined symbol that's not indirect or extern. */
1702 bfd_mach_o_cf_symbols (const void *a
, const void *b
)
1704 bfd_mach_o_asymbol
*sa
= *(bfd_mach_o_asymbol
**) a
;
1705 bfd_mach_o_asymbol
*sb
= *(bfd_mach_o_asymbol
**) b
;
1706 unsigned int soa
, sob
;
1708 soa
= bfd_mach_o_primary_symbol_sort_key (sa
->n_type
);
1709 sob
= bfd_mach_o_primary_symbol_sort_key (sb
->n_type
);
1716 /* If it's local or stab, just preserve the input order. */
1719 if (sa
->symbol
.udata
.i
< sb
->symbol
.udata
.i
)
1721 if (sa
->symbol
.udata
.i
> sb
->symbol
.udata
.i
)
1726 /* Unless it's an indirect the second sort key is name. */
1728 return strcmp (sa
->symbol
.name
, sb
->symbol
.name
);
1730 /* Here be indirect symbols, which have different sort rules. */
1732 /* Next sort key for indirect, is the section index. */
1733 if (sa
->n_sect
< sb
->n_sect
)
1736 if (sa
->n_sect
> sb
->n_sect
)
1739 /* Last sort key is the order of definition - which should be in line with
1740 the value, since a stub size of 0 is meaninglesss. */
1742 if (sa
->symbol
.value
< sb
->symbol
.value
)
1745 if (sa
->symbol
.value
> sb
->symbol
.value
)
1748 /* In the final analysis, this is probably an error ... but leave it alone
1753 /* When this is finished, return the number of non-indirect symbols. */
1756 bfd_mach_o_sort_symbol_table (asymbol
**symbols
, unsigned int nin
)
1758 qsort (symbols
, (size_t) nin
, sizeof (void *), bfd_mach_o_cf_symbols
);
1760 /* Find the last non-indirect symbol.
1761 There must be at least one non-indirect symbol otherwise there's
1762 nothing for the indirect(s) to refer to. */
1765 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[nin
- 1];
1766 if (IS_MACHO_INDIRECT (s
->n_type
))
1770 } while (nin
- 1 > 0);
1774 /* Process the symbols.
1776 This should be OK for single-module files - but it is not likely to work
1777 for multi-module shared libraries.
1779 (a) If the application has not filled in the relevant mach-o fields, make
1782 (b) Order them, like this:
1785 ( ii) external defined
1787 (iii) external undefined
1793 (by position within section).
1795 (c) Indirect symbols are moved to the end of the list. */
1798 bfd_mach_o_mangle_symbols (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1801 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1803 if (symbols
== NULL
|| bfd_get_symcount (abfd
) == 0)
1806 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
1808 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1810 if (s
->n_type
== BFD_MACH_O_N_UNDF
&& !(s
->symbol
.flags
& BSF_DEBUGGING
))
1812 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1813 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1814 values haven't been set. */
1815 if (s
->symbol
.section
== bfd_abs_section_ptr
)
1816 s
->n_type
= BFD_MACH_O_N_ABS
;
1817 else if (s
->symbol
.section
== bfd_und_section_ptr
)
1819 s
->n_type
= BFD_MACH_O_N_UNDF
;
1820 if (s
->symbol
.flags
& BSF_WEAK
)
1821 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
1822 /* mach-o automatically makes undefined symbols extern. */
1823 s
->n_type
|= BFD_MACH_O_N_EXT
;
1825 else if (s
->symbol
.section
== bfd_com_section_ptr
)
1826 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
1828 s
->n_type
= BFD_MACH_O_N_SECT
;
1830 if (s
->symbol
.flags
& BSF_GLOBAL
)
1831 s
->n_type
|= BFD_MACH_O_N_EXT
;
1834 /* Put the section index in, where required. */
1835 if ((s
->symbol
.section
!= bfd_abs_section_ptr
1836 && s
->symbol
.section
!= bfd_und_section_ptr
1837 && s
->symbol
.section
!= bfd_com_section_ptr
)
1838 || ((s
->n_type
& BFD_MACH_O_N_STAB
) != 0
1839 && s
->symbol
.name
== NULL
))
1840 s
->n_sect
= s
->symbol
.section
->target_index
;
1842 /* Unless we're looking at an indirect sym, note the input ordering.
1843 We use this to keep local symbols ordered as per the input. */
1844 if (! IS_MACHO_INDIRECT (s
->n_type
))
1845 s
->symbol
.udata
.i
= i
;
1848 /* Sort the symbols and determine how many will remain in the main symbol
1849 table, and how many will be emitted as indirect (assuming that we will
1850 be emitting a dysymtab). Renumber the sorted symbols so that the right
1851 index will be found during indirection. */
1852 i
= bfd_mach_o_sort_symbol_table (symbols
, bfd_get_symcount (abfd
));
1853 if (bfd_mach_o_should_emit_dysymtab ())
1855 /* Point at the first indirect symbol. */
1856 if (i
< bfd_get_symcount (abfd
))
1858 mdata
->indirect_syms
= &symbols
[i
];
1859 mdata
->nindirect
= bfd_get_symcount (abfd
) - i
;
1860 /* This is, essentially, local to the output section of mach-o,
1861 and therefore should be safe. */
1865 /* Now setup the counts for each type of symbol. */
1866 for (i
= 0; i
< bfd_get_symcount (abfd
); ++i
)
1868 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1869 s
->symbol
.udata
.i
= i
; /* renumber. */
1870 if (s
->n_type
& (BFD_MACH_O_N_EXT
| BFD_MACH_O_N_PEXT
))
1874 for (; i
< bfd_get_symcount (abfd
); ++i
)
1876 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1877 s
->symbol
.udata
.i
= i
; /* renumber. */
1878 if ((s
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_UNDF
)
1881 mdata
->ndefext
= i
- mdata
->nlocal
;
1882 mdata
->nundefext
= bfd_get_symcount (abfd
)
1885 for (; i
< bfd_get_symcount (abfd
); ++i
)
1887 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1888 s
->symbol
.udata
.i
= i
; /* renumber. */
1895 /* We build a flat table of sections, which can be re-ordered if necessary.
1896 Fill in the section number and other mach-o-specific data. */
1899 bfd_mach_o_mangle_sections (bfd
*abfd
, bfd_mach_o_data_struct
*mdata
)
1902 unsigned target_index
;
1905 nsect
= bfd_count_sections (abfd
);
1907 /* Don't do it if it's already set - assume the application knows what it's
1909 if (mdata
->nsects
== nsect
1910 && (mdata
->nsects
== 0 || mdata
->sections
!= NULL
))
1913 mdata
->nsects
= nsect
;
1914 mdata
->sections
= bfd_alloc (abfd
,
1915 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
1916 if (mdata
->sections
== NULL
)
1919 /* We need to check that this can be done... */
1921 (*_bfd_error_handler
) (_("mach-o: there are too many sections (%d)"
1922 " maximum is 255,\n"), nsect
);
1924 /* Create Mach-O sections.
1925 Section type, attribute and align should have been set when the
1926 section was created - either read in or specified. */
1928 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1930 unsigned bfd_align
= bfd_get_section_alignment (abfd
, sec
);
1931 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
1933 mdata
->sections
[target_index
] = msect
;
1935 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
1936 msect
->size
= bfd_get_section_size (sec
);
1938 /* Use the largest alignment set, in case it was bumped after the
1939 section was created. */
1940 msect
->align
= msect
->align
> bfd_align
? msect
->align
: bfd_align
;
1943 sec
->target_index
= ++target_index
;
1950 bfd_mach_o_write_contents (bfd
*abfd
)
1953 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1955 /* Make the commands, if not already present. */
1956 if (mdata
->header
.ncmds
== 0)
1957 if (!bfd_mach_o_build_commands (abfd
))
1960 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
1963 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
1965 struct mach_o_load_command_external raw
;
1966 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
1967 unsigned long typeflag
;
1969 typeflag
= cur
->type
| (cur
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
1971 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
1972 bfd_h_put_32 (abfd
, cur
->len
, raw
.cmdsize
);
1974 if (bfd_seek (abfd
, cur
->offset
, SEEK_SET
) != 0
1975 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
1980 case BFD_MACH_O_LC_SEGMENT
:
1981 if (bfd_mach_o_write_segment_32 (abfd
, cur
) != 0)
1984 case BFD_MACH_O_LC_SEGMENT_64
:
1985 if (bfd_mach_o_write_segment_64 (abfd
, cur
) != 0)
1988 case BFD_MACH_O_LC_SYMTAB
:
1989 if (!bfd_mach_o_write_symtab (abfd
, cur
))
1992 case BFD_MACH_O_LC_DYSYMTAB
:
1993 if (!bfd_mach_o_write_dysymtab (abfd
, cur
))
1996 case BFD_MACH_O_LC_SYMSEG
:
1998 case BFD_MACH_O_LC_THREAD
:
1999 case BFD_MACH_O_LC_UNIXTHREAD
:
2000 if (bfd_mach_o_write_thread (abfd
, cur
) != 0)
2003 case BFD_MACH_O_LC_LOADFVMLIB
:
2004 case BFD_MACH_O_LC_IDFVMLIB
:
2005 case BFD_MACH_O_LC_IDENT
:
2006 case BFD_MACH_O_LC_FVMFILE
:
2007 case BFD_MACH_O_LC_PREPAGE
:
2008 case BFD_MACH_O_LC_LOAD_DYLIB
:
2009 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2010 case BFD_MACH_O_LC_ID_DYLIB
:
2011 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2012 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
2013 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2014 case BFD_MACH_O_LC_ID_DYLINKER
:
2015 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
2016 case BFD_MACH_O_LC_ROUTINES
:
2017 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
2020 (*_bfd_error_handler
) (_("unable to write unknown load command 0x%lx"),
2021 (unsigned long) cur
->type
);
2030 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
2033 bfd_mach_o_section
*s
= (bfd_mach_o_section
*)sec
->used_by_bfd
;
2034 if (seg
->sect_head
== NULL
)
2037 seg
->sect_tail
->next
= s
;
2041 /* Create section Mach-O flags from BFD flags. */
2044 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
2047 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
2049 /* Create default flags. */
2050 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2051 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
2052 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2053 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2054 | BFD_MACH_O_S_REGULAR
;
2055 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
2056 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
2057 else if (bfd_flags
& SEC_DEBUGGING
)
2058 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
2060 s
->flags
= BFD_MACH_O_S_REGULAR
;
2063 /* Count the number of sections in the list for the segment named.
2065 The special case of NULL or "" for the segment name is valid for
2066 an MH_OBJECT file and means 'all sections available'.
2068 Requires that the sections table in mdata be filled in.
2070 Returns the number of sections (0 is valid).
2071 Any number > 255 signals an invalid section count, although we will,
2072 perhaps, allow the file to be written (in line with Darwin tools up
2075 A section count of (unsigned long) -1 signals a definite error. */
2077 static unsigned long
2078 bfd_mach_o_count_sections_for_seg (const char *segment
,
2079 bfd_mach_o_data_struct
*mdata
)
2082 if (mdata
== NULL
|| mdata
->sections
== NULL
)
2083 return (unsigned long) -1;
2085 /* The MH_OBJECT case, all sections are considered; Although nsects is
2086 is an unsigned long, the maximum valid section count is 255 and this
2087 will have been checked already by mangle_sections. */
2088 if (segment
== NULL
|| segment
[0] == '\0')
2089 return mdata
->nsects
;
2091 /* Count the number of sections we see in this segment. */
2093 for (i
= 0; i
< mdata
->nsects
; ++i
)
2095 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2096 if (strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
2103 bfd_mach_o_build_seg_command (const char *segment
,
2104 bfd_mach_o_data_struct
*mdata
,
2105 bfd_mach_o_segment_command
*seg
)
2108 int is_mho
= (segment
== NULL
|| segment
[0] == '\0');
2110 /* Fill segment command. */
2112 memset (seg
->segname
, 0, sizeof (seg
->segname
));
2114 strncpy (seg
->segname
, segment
, sizeof (seg
->segname
));
2116 /* TODO: fix this up for non-MH_OBJECT cases. */
2119 seg
->fileoff
= mdata
->filelen
;
2121 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
2122 | BFD_MACH_O_PROT_EXECUTE
;
2123 seg
->initprot
= seg
->maxprot
;
2125 seg
->sect_head
= NULL
;
2126 seg
->sect_tail
= NULL
;
2128 /* Append sections to the segment. */
2130 for (i
= 0; i
< mdata
->nsects
; ++i
)
2132 bfd_mach_o_section
*s
= mdata
->sections
[i
];
2133 asection
*sec
= s
->bfdsection
;
2135 /* If we're not making an MH_OBJECT, check whether this section is from
2136 our segment, and skip if not. Otherwise, just add all sections. */
2138 && strncmp (segment
, s
->segname
, BFD_MACH_O_SEGNAME_SIZE
) != 0)
2141 bfd_mach_o_append_section_to_segment (seg
, sec
);
2147 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, s
->align
);
2148 s
->offset
= mdata
->filelen
;
2151 sec
->filepos
= s
->offset
;
2153 mdata
->filelen
+= s
->size
;
2156 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
2157 seg
->vmsize
= seg
->filesize
;
2163 bfd_mach_o_build_dysymtab_command (bfd
*abfd
,
2164 bfd_mach_o_data_struct
*mdata
,
2165 bfd_mach_o_load_command
*cmd
)
2167 bfd_mach_o_dysymtab_command
*dsym
= &cmd
->command
.dysymtab
;
2170 We are not going to try and fill these in yet and, moreover, we are
2171 going to bail if they are already set. */
2172 if (dsym
->nmodtab
!= 0
2174 || dsym
->nextrefsyms
!= 0)
2176 (*_bfd_error_handler
) (_("sorry: modtab, toc and extrefsyms are not yet"
2177 " implemented for dysymtab commands."));
2181 dsym
->ilocalsym
= 0;
2182 dsym
->nlocalsym
= mdata
->nlocal
;
2183 dsym
->iextdefsym
= dsym
->nlocalsym
;
2184 dsym
->nextdefsym
= mdata
->ndefext
;
2185 dsym
->iundefsym
= dsym
->nextdefsym
+ dsym
->iextdefsym
;
2186 dsym
->nundefsym
= mdata
->nundefext
;
2188 if (mdata
->nindirect
> 0)
2192 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, 2);
2193 dsym
->indirectsymoff
= mdata
->filelen
;
2194 mdata
->filelen
+= mdata
->nindirect
* 4;
2196 dsym
->indirect_syms
= bfd_zalloc (abfd
, mdata
->nindirect
* 4);
2197 if (dsym
->indirect_syms
== NULL
)
2199 dsym
->nindirectsyms
= mdata
->nindirect
;
2201 /* So fill in the indices, and point the section reserved1 fields
2202 at the right one. */
2203 sect
= (unsigned) -1;
2204 for (i
= 0; i
< mdata
->nindirect
; ++i
)
2206 bfd_mach_o_asymbol
*s
=
2207 (bfd_mach_o_asymbol
*) mdata
->indirect_syms
[i
];
2208 /* Lookup the index of the referenced symbol. */
2209 dsym
->indirect_syms
[i
] =
2210 ((bfd_mach_o_asymbol
*) s
->symbol
.udata
.p
)->symbol
.udata
.i
;
2211 if (s
->n_sect
!= sect
)
2213 /* Mach-o sections are 1-based, but the section table
2215 bfd_mach_o_section
*sc
= mdata
->sections
[s
->n_sect
-1];
2225 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2226 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2227 and copy functionality. */
2230 bfd_mach_o_build_commands (bfd
*abfd
)
2232 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2233 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
2234 bfd_mach_o_segment_command
*seg
;
2235 bfd_mach_o_load_command
*cmd
;
2236 bfd_mach_o_load_command
*symtab_cmd
;
2239 /* Return now if commands are already present. */
2240 if (mdata
->header
.ncmds
)
2243 /* Fill in the file type, if not already set. */
2245 if (mdata
->header
.filetype
== 0)
2247 if (abfd
->flags
& EXEC_P
)
2248 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
2249 else if (abfd
->flags
& DYNAMIC
)
2250 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
2252 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
2255 /* If hasn't already been done, flatten sections list, and sort
2256 if/when required. Must be done before the symbol table is adjusted,
2257 since that depends on properly numbered sections. */
2258 if (mdata
->nsects
== 0 || mdata
->sections
== NULL
)
2259 if (! bfd_mach_o_mangle_sections (abfd
, mdata
))
2262 /* Order the symbol table, fill-in/check mach-o specific fields and
2263 partition out any indirect symbols. */
2264 if (!bfd_mach_o_mangle_symbols (abfd
, mdata
))
2267 /* It's valid to have a file with only absolute symbols... */
2268 if (mdata
->nsects
> 0)
2270 mdata
->header
.ncmds
= 1;
2276 /* It's OK to have a file with only section statements. */
2277 if (bfd_get_symcount (abfd
) > 0)
2278 mdata
->header
.ncmds
+= 1;
2280 /* Very simple version (only really applicable to MH_OBJECTs):
2281 a command (segment) to contain all the sections,
2282 a command for the symbol table
2283 a n (optional) command for the dysymtab.
2285 ??? maybe we should assert that this is an MH_OBJECT? */
2287 if (bfd_mach_o_should_emit_dysymtab ()
2288 && bfd_get_symcount (abfd
) > 0)
2289 mdata
->header
.ncmds
+= 1;
2291 /* A bit weird, but looks like no content;
2292 as -n empty.s -o empty.o */
2293 if (mdata
->header
.ncmds
== 0)
2296 mdata
->commands
= bfd_zalloc (abfd
, mdata
->header
.ncmds
2297 * sizeof (bfd_mach_o_load_command
));
2298 if (mdata
->commands
== NULL
)
2301 if (mdata
->nsects
> 0)
2303 cmd
= &mdata
->commands
[0];
2304 seg
= &cmd
->command
.segment
;
2306 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2307 seg
->nsects
= bfd_mach_o_count_sections_for_seg (NULL
, mdata
);
2308 if (seg
->nsects
== (unsigned long) -1)
2311 /* Init segment command. */
2314 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
2315 cmd
->offset
= BFD_MACH_O_HEADER_64_SIZE
;
2316 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
2317 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
2321 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
2322 cmd
->offset
= BFD_MACH_O_HEADER_SIZE
;
2323 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
2324 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
2326 cmd
->type_required
= FALSE
;
2327 mdata
->header
.sizeofcmds
= cmd
->len
;
2328 mdata
->filelen
= cmd
->offset
+ cmd
->len
;
2331 if (bfd_get_symcount (abfd
) > 0)
2333 /* Init symtab command. */
2334 symtab_cmd
= &mdata
->commands
[symcind
];
2336 symtab_cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
2338 symtab_cmd
->offset
= mdata
->commands
[0].offset
2339 + mdata
->commands
[0].len
;
2341 symtab_cmd
->offset
= 0;
2342 symtab_cmd
->len
= 6 * 4;
2343 symtab_cmd
->type_required
= FALSE
;
2345 mdata
->header
.sizeofcmds
+= symtab_cmd
->len
;
2346 mdata
->filelen
+= symtab_cmd
->len
;
2349 /* If required, setup symtab command. */
2350 if (bfd_mach_o_should_emit_dysymtab ()
2351 && bfd_get_symcount (abfd
) > 0)
2353 cmd
= &mdata
->commands
[symcind
+1];
2354 cmd
->type
= BFD_MACH_O_LC_DYSYMTAB
;
2355 cmd
->offset
= symtab_cmd
->offset
+ symtab_cmd
->len
;
2356 cmd
->type_required
= FALSE
;
2357 cmd
->len
= 18 * 4 + BFD_MACH_O_LC_SIZE
;
2359 mdata
->header
.sizeofcmds
+= cmd
->len
;
2360 mdata
->filelen
+= cmd
->len
;
2363 /* So, now we have sized the commands and the filelen set to that.
2364 Now we can build the segment command and set the section file offsets. */
2365 if (mdata
->nsects
> 0
2366 && ! bfd_mach_o_build_seg_command (NULL
, mdata
, seg
))
2369 /* If we're doing a dysymtab, cmd points to its load command. */
2370 if (bfd_mach_o_should_emit_dysymtab ()
2371 && bfd_get_symcount (abfd
) > 0
2372 && ! bfd_mach_o_build_dysymtab_command (abfd
, mdata
,
2373 &mdata
->commands
[symcind
+1]))
2376 /* The symtab command is filled in when the symtab is written. */
2380 /* Set the contents of a section. */
2383 bfd_mach_o_set_section_contents (bfd
*abfd
,
2385 const void * location
,
2387 bfd_size_type count
)
2391 /* Trying to write the first section contents will trigger the creation of
2392 the load commands if they are not already present. */
2393 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
2399 pos
= section
->filepos
+ offset
;
2400 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
2401 || bfd_bwrite (location
, count
, abfd
) != count
)
2408 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
2409 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2414 /* Make an empty symbol. This is required only because
2415 bfd_make_section_anyway wants to create a symbol for the section. */
2418 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
2420 asymbol
*new_symbol
;
2422 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
2423 if (new_symbol
== NULL
)
2425 new_symbol
->the_bfd
= abfd
;
2426 new_symbol
->udata
.i
= 0;
2431 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
2433 struct mach_o_header_external raw
;
2435 bfd_vma (*get32
) (const void *) = NULL
;
2437 /* Just read the magic number. */
2438 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2439 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
2442 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2444 header
->byteorder
= BFD_ENDIAN_BIG
;
2445 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2446 header
->version
= 1;
2449 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
2451 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2452 header
->magic
= BFD_MACH_O_MH_MAGIC
;
2453 header
->version
= 1;
2456 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2458 header
->byteorder
= BFD_ENDIAN_BIG
;
2459 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2460 header
->version
= 2;
2463 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
2465 header
->byteorder
= BFD_ENDIAN_LITTLE
;
2466 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
2467 header
->version
= 2;
2472 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
2476 /* Once the size of the header is known, read the full header. */
2477 size
= mach_o_wide_p (header
) ?
2478 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2480 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2481 || bfd_bread (&raw
, size
, abfd
) != size
)
2484 header
->cputype
= (*get32
) (raw
.cputype
);
2485 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
2486 header
->filetype
= (*get32
) (raw
.filetype
);
2487 header
->ncmds
= (*get32
) (raw
.ncmds
);
2488 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
2489 header
->flags
= (*get32
) (raw
.flags
);
2491 if (mach_o_wide_p (header
))
2492 header
->reserved
= (*get32
) (raw
.reserved
);
2498 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
2500 bfd_mach_o_section
*s
;
2501 unsigned bfdalign
= bfd_get_section_alignment (abfd
, sec
);
2503 s
= bfd_mach_o_get_mach_o_section (sec
);
2507 static const mach_o_section_name_xlat
* xlat
;
2509 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
2512 sec
->used_by_bfd
= s
;
2513 s
->bfdsection
= sec
;
2515 /* Create the Darwin seg/sect name pair from the bfd name.
2516 If this is a canonical name for which a specific paiting exists
2517 there will also be defined flags, type, attribute and alignment
2519 xlat
= bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
2522 s
->flags
= xlat
->macho_sectype
| xlat
->macho_secattr
;
2523 s
->align
= xlat
->sectalign
> bfdalign
? xlat
->sectalign
2525 bfd_set_section_alignment (abfd
, sec
, s
->align
);
2526 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
2527 if (bfd_flags
== SEC_NO_FLAGS
)
2528 bfd_set_section_flags (abfd
, sec
, xlat
->bfd_flags
);
2531 /* Create default flags. */
2532 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
2535 return _bfd_generic_new_section_hook (abfd
, sec
);
2539 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
2543 bfd_mach_o_section
*section
;
2545 flags
= bfd_get_section_flags (abfd
, sec
);
2546 section
= bfd_mach_o_get_mach_o_section (sec
);
2548 /* TODO: see if we should use the xlat system for doing this by
2549 preference and fall back to this for unknown sections. */
2551 if (flags
== SEC_NO_FLAGS
)
2553 /* Try to guess flags. */
2554 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
2555 flags
= SEC_DEBUGGING
;
2559 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
2560 != BFD_MACH_O_S_ZEROFILL
)
2563 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
2565 if (prot
& BFD_MACH_O_PROT_WRITE
)
2567 else if (prot
& BFD_MACH_O_PROT_READ
)
2568 flags
|= SEC_READONLY
;
2574 if ((flags
& SEC_DEBUGGING
) == 0)
2578 if (section
->offset
!= 0)
2579 flags
|= SEC_HAS_CONTENTS
;
2580 if (section
->nreloc
!= 0)
2583 bfd_set_section_flags (abfd
, sec
, flags
);
2585 sec
->vma
= section
->addr
;
2586 sec
->lma
= section
->addr
;
2587 sec
->size
= section
->size
;
2588 sec
->filepos
= section
->offset
;
2589 sec
->alignment_power
= section
->align
;
2590 sec
->segment_mark
= 0;
2591 sec
->reloc_count
= section
->nreloc
;
2592 sec
->rel_filepos
= section
->reloff
;
2596 bfd_mach_o_make_bfd_section (bfd
*abfd
,
2597 const unsigned char *segname
,
2598 const unsigned char *sectname
)
2603 bfd_mach_o_convert_section_name_to_bfd
2604 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
2608 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
2612 bfd_mach_o_read_section_32 (bfd
*abfd
,
2613 unsigned int offset
,
2616 struct mach_o_section_32_external raw
;
2618 bfd_mach_o_section
*section
;
2620 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2621 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
2622 != BFD_MACH_O_SECTION_SIZE
))
2625 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2629 section
= bfd_mach_o_get_mach_o_section (sec
);
2630 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2631 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2632 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2633 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2634 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
2635 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
2636 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2637 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2638 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2639 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2640 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2641 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2642 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2643 section
->reserved3
= 0;
2645 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2651 bfd_mach_o_read_section_64 (bfd
*abfd
,
2652 unsigned int offset
,
2655 struct mach_o_section_64_external raw
;
2657 bfd_mach_o_section
*section
;
2659 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
2660 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
2661 != BFD_MACH_O_SECTION_64_SIZE
))
2664 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
2668 section
= bfd_mach_o_get_mach_o_section (sec
);
2669 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
2670 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
2671 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
2672 section
->sectname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
2673 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
2674 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
2675 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
2676 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
2677 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
2678 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
2679 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2680 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
2681 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
2682 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
2684 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
2690 bfd_mach_o_read_section (bfd
*abfd
,
2691 unsigned int offset
,
2696 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
2698 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
2702 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
2703 bfd_mach_o_symtab_command
*sym
,
2704 bfd_mach_o_asymbol
*s
,
2707 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2708 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
2709 unsigned int symwidth
=
2710 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
2711 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
2712 struct mach_o_nlist_64_external raw
;
2713 unsigned char type
= -1;
2714 unsigned char section
= -1;
2716 symvalue value
= -1;
2717 unsigned long stroff
= -1;
2718 unsigned int symtype
= -1;
2720 BFD_ASSERT (sym
->strtab
!= NULL
);
2722 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
2723 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
2725 (*_bfd_error_handler
)
2726 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2727 symwidth
, (unsigned long) symoff
);
2731 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
2732 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
2733 symtype
= type
& BFD_MACH_O_N_TYPE
;
2734 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
2735 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
2737 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
2739 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
2741 if (stroff
>= sym
->strsize
)
2743 (*_bfd_error_handler
)
2744 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2745 (unsigned long) stroff
,
2746 (unsigned long) sym
->strsize
);
2750 s
->symbol
.the_bfd
= abfd
;
2751 s
->symbol
.name
= sym
->strtab
+ stroff
;
2752 s
->symbol
.value
= value
;
2753 s
->symbol
.flags
= 0x0;
2754 s
->symbol
.udata
.i
= 0;
2756 s
->n_sect
= section
;
2759 if (type
& BFD_MACH_O_N_STAB
)
2761 s
->symbol
.flags
|= BSF_DEBUGGING
;
2762 s
->symbol
.section
= bfd_und_section_ptr
;
2774 if ((section
> 0) && (section
<= mdata
->nsects
))
2776 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2778 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2785 if (type
& BFD_MACH_O_N_PEXT
)
2786 s
->symbol
.flags
|= BSF_GLOBAL
;
2788 if (type
& BFD_MACH_O_N_EXT
)
2789 s
->symbol
.flags
|= BSF_GLOBAL
;
2791 if (!(type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
)))
2792 s
->symbol
.flags
|= BSF_LOCAL
;
2796 case BFD_MACH_O_N_UNDF
:
2797 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
2798 && s
->symbol
.value
!= 0)
2800 /* A common symbol. */
2801 s
->symbol
.section
= bfd_com_section_ptr
;
2802 s
->symbol
.flags
= BSF_NO_FLAGS
;
2806 s
->symbol
.section
= bfd_und_section_ptr
;
2807 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
2808 s
->symbol
.flags
|= BSF_WEAK
;
2811 case BFD_MACH_O_N_PBUD
:
2812 s
->symbol
.section
= bfd_und_section_ptr
;
2814 case BFD_MACH_O_N_ABS
:
2815 s
->symbol
.section
= bfd_abs_section_ptr
;
2817 case BFD_MACH_O_N_SECT
:
2818 if ((section
> 0) && (section
<= mdata
->nsects
))
2820 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
2822 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
2826 /* Mach-O uses 0 to mean "no section"; not an error. */
2829 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2830 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2831 s
->symbol
.name
, section
, mdata
->nsects
);
2833 s
->symbol
.section
= bfd_und_section_ptr
;
2836 case BFD_MACH_O_N_INDR
:
2837 /* FIXME: we don't follow the BFD convention as this indirect symbol
2838 won't be followed by the referenced one. This looks harmless
2839 unless we start using the linker. */
2840 s
->symbol
.flags
|= BSF_INDIRECT
;
2841 s
->symbol
.section
= bfd_ind_section_ptr
;
2842 s
->symbol
.value
= 0;
2845 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
2846 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2847 s
->symbol
.name
, symtype
);
2848 s
->symbol
.section
= bfd_und_section_ptr
;
2857 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
2859 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2860 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2862 /* Fail if there is no symtab. */
2866 /* Success if already loaded. */
2870 if (abfd
->flags
& BFD_IN_MEMORY
)
2872 struct bfd_in_memory
*b
;
2874 b
= (struct bfd_in_memory
*) abfd
->iostream
;
2876 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
2878 bfd_set_error (bfd_error_file_truncated
);
2881 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
2885 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
2886 if (sym
->strtab
== NULL
)
2889 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
2890 || bfd_bread (sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
2892 bfd_set_error (bfd_error_file_truncated
);
2901 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
2903 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2904 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
2907 if (sym
== NULL
|| sym
->symbols
)
2909 /* Return now if there are no symbols or if already loaded. */
2913 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
2915 if (sym
->symbols
== NULL
)
2917 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2921 if (!bfd_mach_o_read_symtab_strtab (abfd
))
2924 for (i
= 0; i
< sym
->nsyms
; i
++)
2926 if (!bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
))
2934 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2936 switch ((int) flavour
)
2938 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2939 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2940 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2941 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2942 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2943 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2944 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2945 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2946 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2947 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2948 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2949 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2950 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2951 default: return "UNKNOWN";
2956 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2958 switch ((int) flavour
)
2960 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2961 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2962 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2963 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2964 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2965 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2966 default: return "UNKNOWN";
2971 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2973 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2974 struct mach_o_str_command_external raw
;
2975 unsigned int nameoff
;
2977 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
2978 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
2980 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2981 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2984 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
2986 cmd
->name_offset
= command
->offset
+ nameoff
;
2987 cmd
->name_len
= command
->len
- nameoff
;
2988 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2989 if (cmd
->name_str
== NULL
)
2991 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2992 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2998 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3000 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
3001 struct mach_o_dylib_command_external raw
;
3002 unsigned int nameoff
;
3004 switch (command
->type
)
3006 case BFD_MACH_O_LC_LOAD_DYLIB
:
3007 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3008 case BFD_MACH_O_LC_ID_DYLIB
:
3009 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3010 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3017 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3018 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3021 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
3022 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
3023 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
3024 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
3026 cmd
->name_offset
= command
->offset
+ nameoff
;
3027 cmd
->name_len
= command
->len
- nameoff
;
3028 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
3029 if (cmd
->name_str
== NULL
)
3031 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
3032 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
3038 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
3039 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
3041 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3043 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
3048 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3050 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3051 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
3052 unsigned int offset
;
3053 unsigned int nflavours
;
3056 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
3057 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
3059 /* Count the number of threads. */
3062 while (offset
!= command
->len
)
3064 struct mach_o_thread_command_external raw
;
3066 if (offset
>= command
->len
)
3069 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3070 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3073 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
3077 /* Allocate threads. */
3078 cmd
->flavours
= bfd_alloc
3079 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
3080 if (cmd
->flavours
== NULL
)
3082 cmd
->nflavours
= nflavours
;
3086 while (offset
!= command
->len
)
3088 struct mach_o_thread_command_external raw
;
3090 if (offset
>= command
->len
)
3093 if (nflavours
>= cmd
->nflavours
)
3096 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
3097 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3100 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
3101 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
3102 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
3103 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
3107 for (i
= 0; i
< nflavours
; i
++)
3110 unsigned int snamelen
;
3112 const char *flavourstr
;
3113 const char *prefix
= "LC_THREAD";
3116 switch (mdata
->header
.cputype
)
3118 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3119 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
3120 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
3122 case BFD_MACH_O_CPU_TYPE_I386
:
3123 case BFD_MACH_O_CPU_TYPE_X86_64
:
3124 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
3127 flavourstr
= "UNKNOWN_ARCHITECTURE";
3131 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
3132 sname
= bfd_alloc (abfd
, snamelen
);
3138 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
3139 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
3144 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
3148 bfdsec
->size
= cmd
->flavours
[i
].size
;
3149 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
3150 bfdsec
->alignment_power
= 0x0;
3152 cmd
->section
= bfdsec
;
3159 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3161 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
3162 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3164 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
3167 struct mach_o_dysymtab_command_external raw
;
3169 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3170 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3173 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
3174 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
3175 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
3176 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
3177 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
3178 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
3179 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
3180 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
3181 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
3182 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
3183 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
3184 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
3185 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
3186 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
3187 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
3188 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
3189 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
3190 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
3193 if (cmd
->nmodtab
!= 0)
3196 int wide
= bfd_mach_o_wide_p (abfd
);
3197 unsigned int module_len
= wide
? 56 : 52;
3200 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
3201 if (cmd
->dylib_module
== NULL
)
3204 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
3207 for (i
= 0; i
< cmd
->nmodtab
; i
++)
3209 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
3211 unsigned char buf
[56];
3213 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
3216 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
3217 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
3218 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
3219 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
3220 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
3221 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
3222 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
3223 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
3224 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
3225 v
= bfd_h_get_32 (abfd
, buf
+36);
3226 module
->iinit
= v
& 0xffff;
3227 module
->iterm
= (v
>> 16) & 0xffff;
3228 v
= bfd_h_get_32 (abfd
, buf
+ 40);
3229 module
->ninit
= v
& 0xffff;
3230 module
->nterm
= (v
>> 16) & 0xffff;
3233 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
3234 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
3238 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
3239 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
3248 cmd
->dylib_toc
= bfd_alloc
3249 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
3250 if (cmd
->dylib_toc
== NULL
)
3253 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
3256 for (i
= 0; i
< cmd
->ntoc
; i
++)
3258 struct mach_o_dylib_table_of_contents_external raw
;
3259 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
3261 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3264 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
3265 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
3269 if (cmd
->nindirectsyms
!= 0)
3273 cmd
->indirect_syms
= bfd_alloc
3274 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
3275 if (cmd
->indirect_syms
== NULL
)
3278 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
3281 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
3283 unsigned char raw
[4];
3284 unsigned int *is
= &cmd
->indirect_syms
[i
];
3286 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3289 *is
= bfd_h_get_32 (abfd
, raw
);
3293 if (cmd
->nextrefsyms
!= 0)
3298 cmd
->ext_refs
= bfd_alloc
3299 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
3300 if (cmd
->ext_refs
== NULL
)
3303 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
3306 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
3308 unsigned char raw
[4];
3309 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
3311 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3314 /* Fields isym and flags are written as bit-fields, thus we need
3315 a specific processing for endianness. */
3316 v
= bfd_h_get_32 (abfd
, raw
);
3317 if (bfd_big_endian (abfd
))
3319 ref
->isym
= (v
>> 8) & 0xffffff;
3320 ref
->flags
= v
& 0xff;
3324 ref
->isym
= v
& 0xffffff;
3325 ref
->flags
= (v
>> 24) & 0xff;
3330 if (mdata
->dysymtab
)
3332 mdata
->dysymtab
= cmd
;
3338 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3340 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
3341 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3342 struct mach_o_symtab_command_external raw
;
3344 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
3346 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3347 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3350 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
3351 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
3352 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
3353 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
3354 symtab
->symbols
= NULL
;
3355 symtab
->strtab
= NULL
;
3357 if (symtab
->nsyms
!= 0)
3358 abfd
->flags
|= HAS_SYMS
;
3362 mdata
->symtab
= symtab
;
3367 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3369 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
3371 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
3373 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3374 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
3381 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3383 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
3384 struct mach_o_linkedit_data_command_external raw
;
3386 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3387 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3390 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
3391 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
3396 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3398 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
3399 struct mach_o_str_command_external raw
;
3402 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3403 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3406 off
= bfd_get_32 (abfd
, raw
.str
);
3407 cmd
->stroff
= command
->offset
+ off
;
3408 cmd
->str_len
= command
->len
- off
;
3409 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
3410 if (cmd
->str
== NULL
)
3412 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
3413 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
3419 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3421 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
3422 struct mach_o_dyld_info_command_external raw
;
3424 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3425 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3428 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
3429 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
3430 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
3431 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
3432 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
3433 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
3434 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
3435 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
3436 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
3437 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
3442 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3444 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
3445 struct mach_o_version_min_command_external raw
;
3448 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3449 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3452 ver
= bfd_get_32 (abfd
, raw
.version
);
3453 cmd
->rel
= ver
>> 16;
3454 cmd
->maj
= ver
>> 8;
3456 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
3461 bfd_mach_o_read_encryption_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3463 bfd_mach_o_encryption_info_command
*cmd
= &command
->command
.encryption_info
;
3464 struct mach_o_encryption_info_command_external raw
;
3466 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3467 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3470 cmd
->cryptoff
= bfd_get_32 (abfd
, raw
.cryptoff
);
3471 cmd
->cryptsize
= bfd_get_32 (abfd
, raw
.cryptsize
);
3472 cmd
->cryptid
= bfd_get_32 (abfd
, raw
.cryptid
);
3477 bfd_mach_o_read_segment (bfd
*abfd
,
3478 bfd_mach_o_load_command
*command
,
3481 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
3486 struct mach_o_segment_command_64_external raw
;
3488 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
3490 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3491 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3494 memcpy (seg
->segname
, raw
.segname
, 16);
3495 seg
->segname
[16] = '\0';
3497 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
3498 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
3499 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
3500 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
3501 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3502 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3503 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3504 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3508 struct mach_o_segment_command_32_external raw
;
3510 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
3512 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
3513 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
3516 memcpy (seg
->segname
, raw
.segname
, 16);
3517 seg
->segname
[16] = '\0';
3519 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
3520 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
3521 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
3522 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
3523 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
3524 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
3525 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
3526 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
3528 seg
->sect_head
= NULL
;
3529 seg
->sect_tail
= NULL
;
3531 for (i
= 0; i
< seg
->nsects
; i
++)
3537 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
3538 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
3540 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
3541 + (i
* BFD_MACH_O_SECTION_SIZE
);
3543 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
3547 bfd_mach_o_append_section_to_segment (seg
, sec
);
3554 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3556 return bfd_mach_o_read_segment (abfd
, command
, 0);
3560 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3562 return bfd_mach_o_read_segment (abfd
, command
, 1);
3566 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
3568 struct mach_o_load_command_external raw
;
3571 /* Read command type and length. */
3572 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
3573 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
3576 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
3577 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
3578 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
3579 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
3581 switch (command
->type
)
3583 case BFD_MACH_O_LC_SEGMENT
:
3584 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
3587 case BFD_MACH_O_LC_SEGMENT_64
:
3588 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
3591 case BFD_MACH_O_LC_SYMTAB
:
3592 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
3595 case BFD_MACH_O_LC_SYMSEG
:
3597 case BFD_MACH_O_LC_THREAD
:
3598 case BFD_MACH_O_LC_UNIXTHREAD
:
3599 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
3602 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3603 case BFD_MACH_O_LC_ID_DYLINKER
:
3604 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
3607 case BFD_MACH_O_LC_LOAD_DYLIB
:
3608 case BFD_MACH_O_LC_ID_DYLIB
:
3609 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3610 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3611 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3612 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
3615 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
3616 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
3619 case BFD_MACH_O_LC_LOADFVMLIB
:
3620 case BFD_MACH_O_LC_IDFVMLIB
:
3621 case BFD_MACH_O_LC_IDENT
:
3622 case BFD_MACH_O_LC_FVMFILE
:
3623 case BFD_MACH_O_LC_PREPAGE
:
3624 case BFD_MACH_O_LC_ROUTINES
:
3625 case BFD_MACH_O_LC_ROUTINES_64
:
3627 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
3628 case BFD_MACH_O_LC_SUB_UMBRELLA
:
3629 case BFD_MACH_O_LC_SUB_LIBRARY
:
3630 case BFD_MACH_O_LC_SUB_CLIENT
:
3631 case BFD_MACH_O_LC_RPATH
:
3632 if (bfd_mach_o_read_str (abfd
, command
) != 0)
3635 case BFD_MACH_O_LC_DYSYMTAB
:
3636 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
3639 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
3640 case BFD_MACH_O_LC_PREBIND_CKSUM
:
3642 case BFD_MACH_O_LC_UUID
:
3643 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
3646 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3647 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3648 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3649 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
3652 case BFD_MACH_O_LC_ENCRYPTION_INFO
:
3653 if (!bfd_mach_o_read_encryption_info (abfd
, command
))
3656 case BFD_MACH_O_LC_DYLD_INFO
:
3657 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
3660 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
3661 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
3662 if (!bfd_mach_o_read_version_min (abfd
, command
))
3666 (*_bfd_error_handler
)(_("%B: unknown load command 0x%lx"),
3667 abfd
, (unsigned long) command
->type
);
3675 bfd_mach_o_flatten_sections (bfd
*abfd
)
3677 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3681 /* Count total number of sections. */
3684 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3686 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3687 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3689 bfd_mach_o_segment_command
*seg
;
3691 seg
= &mdata
->commands
[i
].command
.segment
;
3692 mdata
->nsects
+= seg
->nsects
;
3696 /* Allocate sections array. */
3697 mdata
->sections
= bfd_alloc (abfd
,
3698 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
3700 /* Fill the array. */
3703 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3705 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
3706 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
3708 bfd_mach_o_segment_command
*seg
;
3709 bfd_mach_o_section
*sec
;
3711 seg
= &mdata
->commands
[i
].command
.segment
;
3712 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
3714 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3715 mdata
->sections
[csect
++] = sec
;
3721 bfd_mach_o_scan_start_address (bfd
*abfd
)
3723 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3724 bfd_mach_o_thread_command
*cmd
= NULL
;
3727 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3728 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
3729 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
3731 cmd
= &mdata
->commands
[i
].command
.thread
;
3738 /* FIXME: create a subtarget hook ? */
3739 for (i
= 0; i
< cmd
->nflavours
; i
++)
3741 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
3742 && (cmd
->flavours
[i
].flavour
3743 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
3745 unsigned char buf
[4];
3747 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
3748 || bfd_bread (buf
, 4, abfd
) != 4)
3751 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3753 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
3754 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
3756 unsigned char buf
[4];
3758 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3759 || bfd_bread (buf
, 4, abfd
) != 4)
3762 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
3764 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
3765 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
3767 unsigned char buf
[8];
3769 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
3770 || bfd_bread (buf
, 8, abfd
) != 8)
3773 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3775 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
3776 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
3778 unsigned char buf
[8];
3780 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
3781 || bfd_bread (buf
, 8, abfd
) != 8)
3784 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
3792 bfd_mach_o_set_arch_mach (bfd
*abfd
,
3793 enum bfd_architecture arch
,
3794 unsigned long machine
)
3796 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
3798 /* If this isn't the right architecture for this backend, and this
3799 isn't the generic backend, fail. */
3800 if (arch
!= bed
->arch
3801 && arch
!= bfd_arch_unknown
3802 && bed
->arch
!= bfd_arch_unknown
)
3805 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3809 bfd_mach_o_scan (bfd
*abfd
,
3810 bfd_mach_o_header
*header
,
3811 bfd_mach_o_data_struct
*mdata
)
3814 enum bfd_architecture cputype
;
3815 unsigned long cpusubtype
;
3816 unsigned int hdrsize
;
3818 hdrsize
= mach_o_wide_p (header
) ?
3819 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
3821 mdata
->header
= *header
;
3823 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
3824 switch (header
->filetype
)
3826 case BFD_MACH_O_MH_OBJECT
:
3827 abfd
->flags
|= HAS_RELOC
;
3829 case BFD_MACH_O_MH_EXECUTE
:
3830 abfd
->flags
|= EXEC_P
;
3832 case BFD_MACH_O_MH_DYLIB
:
3833 case BFD_MACH_O_MH_BUNDLE
:
3834 abfd
->flags
|= DYNAMIC
;
3838 abfd
->tdata
.mach_o_data
= mdata
;
3840 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
3841 &cputype
, &cpusubtype
);
3842 if (cputype
== bfd_arch_unknown
)
3844 (*_bfd_error_handler
)
3845 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3846 header
->cputype
, header
->cpusubtype
);
3850 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
3852 if (header
->ncmds
!= 0)
3854 mdata
->commands
= bfd_alloc
3855 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
3856 if (mdata
->commands
== NULL
)
3859 for (i
= 0; i
< header
->ncmds
; i
++)
3861 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
3864 cur
->offset
= hdrsize
;
3867 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
3868 cur
->offset
= prev
->offset
+ prev
->len
;
3871 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
3876 if (bfd_mach_o_scan_start_address (abfd
) < 0)
3879 bfd_mach_o_flatten_sections (abfd
);
3884 bfd_mach_o_mkobject_init (bfd
*abfd
)
3886 bfd_mach_o_data_struct
*mdata
= NULL
;
3888 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3891 abfd
->tdata
.mach_o_data
= mdata
;
3893 mdata
->header
.magic
= 0;
3894 mdata
->header
.cputype
= 0;
3895 mdata
->header
.cpusubtype
= 0;
3896 mdata
->header
.filetype
= 0;
3897 mdata
->header
.ncmds
= 0;
3898 mdata
->header
.sizeofcmds
= 0;
3899 mdata
->header
.flags
= 0;
3900 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
3901 mdata
->commands
= NULL
;
3903 mdata
->sections
= NULL
;
3904 mdata
->dyn_reloc_cache
= NULL
;
3910 bfd_mach_o_gen_mkobject (bfd
*abfd
)
3912 bfd_mach_o_data_struct
*mdata
;
3914 if (!bfd_mach_o_mkobject_init (abfd
))
3917 mdata
= bfd_mach_o_get_data (abfd
);
3918 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
3919 mdata
->header
.cputype
= 0;
3920 mdata
->header
.cpusubtype
= 0;
3921 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
3922 mdata
->header
.version
= 1;
3928 bfd_mach_o_header_p (bfd
*abfd
,
3929 bfd_mach_o_filetype filetype
,
3930 bfd_mach_o_cpu_type cputype
)
3932 struct bfd_preserve preserve
;
3933 bfd_mach_o_header header
;
3935 preserve
.marker
= NULL
;
3936 if (!bfd_mach_o_read_header (abfd
, &header
))
3939 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3940 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3942 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3943 (unsigned long) header
.byteorder
);
3947 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3948 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3949 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3950 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3951 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3952 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3955 /* Check cputype and filetype.
3956 In case of wildcard, do not accept magics that are handled by existing
3960 if (header
.cputype
!= cputype
)
3965 if (header
.filetype
!= filetype
)
3970 switch (header
.filetype
)
3972 case BFD_MACH_O_MH_CORE
:
3973 /* Handled by core_p */
3980 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3981 if (preserve
.marker
== NULL
3982 || !bfd_preserve_save (abfd
, &preserve
))
3985 if (!bfd_mach_o_scan (abfd
, &header
,
3986 (bfd_mach_o_data_struct
*) preserve
.marker
))
3989 bfd_preserve_finish (abfd
, &preserve
);
3993 bfd_set_error (bfd_error_wrong_format
);
3996 if (preserve
.marker
!= NULL
)
3997 bfd_preserve_restore (abfd
, &preserve
);
4001 static const bfd_target
*
4002 bfd_mach_o_gen_object_p (bfd
*abfd
)
4004 return bfd_mach_o_header_p (abfd
, 0, 0);
4007 static const bfd_target
*
4008 bfd_mach_o_gen_core_p (bfd
*abfd
)
4010 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
4013 typedef struct mach_o_fat_archentry
4015 unsigned long cputype
;
4016 unsigned long cpusubtype
;
4017 unsigned long offset
;
4019 unsigned long align
;
4020 } mach_o_fat_archentry
;
4022 typedef struct mach_o_fat_data_struct
4024 unsigned long magic
;
4025 unsigned long nfat_arch
;
4026 mach_o_fat_archentry
*archentries
;
4027 } mach_o_fat_data_struct
;
4030 bfd_mach_o_archive_p (bfd
*abfd
)
4032 mach_o_fat_data_struct
*adata
= NULL
;
4033 struct mach_o_fat_header_external hdr
;
4036 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
4037 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
4040 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
4044 adata
->magic
= bfd_getb32 (hdr
.magic
);
4045 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
4046 if (adata
->magic
!= 0xcafebabe)
4048 /* Avoid matching Java bytecode files, which have the same magic number.
4049 In the Java bytecode file format this field contains the JVM version,
4050 which starts at 43.0. */
4051 if (adata
->nfat_arch
> 30)
4054 adata
->archentries
=
4055 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
4056 if (adata
->archentries
== NULL
)
4059 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4061 struct mach_o_fat_arch_external arch
;
4062 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
4064 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
4065 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
4066 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
4067 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
4068 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
4071 abfd
->tdata
.mach_o_fat_data
= adata
;
4076 bfd_release (abfd
, adata
);
4077 bfd_set_error (bfd_error_wrong_format
);
4082 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
4084 mach_o_fat_data_struct
*adata
;
4085 mach_o_fat_archentry
*entry
= NULL
;
4088 enum bfd_architecture arch_type
;
4089 unsigned long arch_subtype
;
4091 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
4092 BFD_ASSERT (adata
!= NULL
);
4094 /* Find index of previous entry. */
4096 i
= 0; /* Start at first one. */
4099 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4101 if (adata
->archentries
[i
].offset
== prev
->origin
)
4105 if (i
== adata
->nfat_arch
)
4108 bfd_set_error (bfd_error_bad_value
);
4111 i
++; /* Get next entry. */
4114 if (i
>= adata
->nfat_arch
)
4116 bfd_set_error (bfd_error_no_more_archived_files
);
4120 entry
= &adata
->archentries
[i
];
4121 nbfd
= _bfd_new_bfd_contained_in (archive
);
4125 nbfd
->origin
= entry
->offset
;
4127 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
4128 &arch_type
, &arch_subtype
);
4130 /* Create the member filename. Use ARCH_NAME. */
4131 nbfd
->filename
= bfd_printable_arch_mach (arch_type
, arch_subtype
);
4132 nbfd
->iostream
= NULL
;
4133 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
4138 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4139 If ABFD is a fat image containing a member that corresponds to FORMAT
4140 and ARCH, returns it.
4141 In other case, returns NULL.
4142 This function allows transparent uses of fat images. */
4144 bfd_mach_o_fat_extract (bfd
*abfd
,
4146 const bfd_arch_info_type
*arch
)
4149 mach_o_fat_data_struct
*adata
;
4152 if (bfd_check_format (abfd
, format
))
4154 if (bfd_get_arch_info (abfd
) == arch
)
4158 if (!bfd_check_format (abfd
, bfd_archive
)
4159 || abfd
->xvec
!= &mach_o_fat_vec
)
4162 /* This is a Mach-O fat image. */
4163 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
4164 BFD_ASSERT (adata
!= NULL
);
4166 for (i
= 0; i
< adata
->nfat_arch
; i
++)
4168 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
4169 enum bfd_architecture cpu_type
;
4170 unsigned long cpu_subtype
;
4172 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
4173 &cpu_type
, &cpu_subtype
);
4174 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
4177 /* The architecture is found. */
4178 res
= _bfd_new_bfd_contained_in (abfd
);
4182 res
->origin
= e
->offset
;
4184 res
->filename
= bfd_printable_arch_mach (cpu_type
, cpu_subtype
);
4185 res
->iostream
= NULL
;
4187 if (bfd_check_format (res
, format
))
4189 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
4200 bfd_mach_o_lookup_command (bfd
*abfd
,
4201 bfd_mach_o_load_command_type type
,
4202 bfd_mach_o_load_command
**mcommand
)
4204 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
4205 bfd_mach_o_load_command
*ncmd
= NULL
;
4206 unsigned int i
, num
;
4208 BFD_ASSERT (md
!= NULL
);
4209 BFD_ASSERT (mcommand
!= NULL
);
4212 for (i
= 0; i
< md
->header
.ncmds
; i
++)
4214 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
4216 if (cmd
->type
!= type
)
4229 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
4233 case BFD_MACH_O_CPU_TYPE_MC680x0
:
4235 case BFD_MACH_O_CPU_TYPE_MC88000
:
4237 case BFD_MACH_O_CPU_TYPE_POWERPC
:
4239 case BFD_MACH_O_CPU_TYPE_I386
:
4241 case BFD_MACH_O_CPU_TYPE_SPARC
:
4243 case BFD_MACH_O_CPU_TYPE_I860
:
4245 case BFD_MACH_O_CPU_TYPE_HPPA
:
4246 return 0xc0000000 - 0x04000000;
4252 /* The following two tables should be kept, as far as possible, in order of
4253 most frequently used entries to optimize their use from gas. */
4255 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
4257 { "regular", BFD_MACH_O_S_REGULAR
},
4258 { "coalesced", BFD_MACH_O_S_COALESCED
},
4259 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
4260 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
4261 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
4262 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
4263 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
4264 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
4265 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
4266 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
4267 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
4268 { "interposing", BFD_MACH_O_S_INTERPOSING
},
4269 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
4270 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
4271 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
4272 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
4273 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
4277 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
4279 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
4280 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
4281 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
4282 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
4283 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
4284 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
4285 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
4286 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
4287 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
4288 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4289 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
4293 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4296 bfd_mach_o_get_section_type_from_name (bfd
*abfd
, const char *name
)
4298 const bfd_mach_o_xlat_name
*x
;
4299 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4301 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
4302 if (strcmp (x
->name
, name
) == 0)
4304 /* We found it... does the target support it? */
4305 if (bed
->bfd_mach_o_section_type_valid_for_target
== NULL
4306 || bed
->bfd_mach_o_section_type_valid_for_target (x
->val
))
4307 return x
->val
; /* OK. */
4309 break; /* Not supported. */
4311 /* Maximum section ID = 0xff. */
4315 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4318 bfd_mach_o_get_section_attribute_from_name (const char *name
)
4320 const bfd_mach_o_xlat_name
*x
;
4322 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
4323 if (strcmp (x
->name
, name
) == 0)
4325 return (unsigned int)-1;
4329 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4330 unsigned char **rbuf
,
4333 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4334 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4337 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4339 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4340 bfd_mach_o_segment_command
*seg
= NULL
;
4342 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4345 seg
= &cur
->command
.segment
;
4347 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4349 unsigned long start
= seg
->fileoff
;
4350 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4351 unsigned char *buf
= bfd_malloc (1024);
4352 unsigned long size
= 1024;
4356 bfd_size_type nread
= 0;
4357 unsigned long offset
;
4358 int found_nonnull
= 0;
4360 if (size
> (end
- start
))
4361 size
= (end
- start
);
4363 buf
= bfd_realloc_or_free (buf
, size
);
4367 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4373 nread
= bfd_bread (buf
, size
, abfd
);
4381 for (offset
= 4; offset
<= size
; offset
+= 4)
4385 val
= *((unsigned long *) (buf
+ size
- offset
));
4386 if (! found_nonnull
)
4391 else if (val
== 0x0)
4393 unsigned long bottom
;
4396 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4397 top
= seg
->fileoff
+ seg
->filesize
- 4;
4398 *rbuf
= bfd_malloc (top
- bottom
);
4399 *rlen
= top
- bottom
;
4401 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4407 if (size
== (end
- start
))
4421 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4423 unsigned char *buf
= NULL
;
4424 unsigned int len
= 0;
4427 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4431 return (char *) buf
;
4435 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4440 static bfd_mach_o_uuid_command
*
4441 bfd_mach_o_lookup_uuid_command (bfd
*abfd
)
4443 bfd_mach_o_load_command
*uuid_cmd
;
4444 int ncmd
= bfd_mach_o_lookup_command (abfd
, BFD_MACH_O_LC_UUID
, &uuid_cmd
);
4447 return &uuid_cmd
->command
.uuid
;
4450 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4453 bfd_mach_o_dsym_for_uuid_p (bfd
*abfd
, const bfd_mach_o_uuid_command
*uuid_cmd
)
4455 bfd_mach_o_uuid_command
*dsym_uuid_cmd
;
4458 BFD_ASSERT (uuid_cmd
);
4460 if (!bfd_check_format (abfd
, bfd_object
))
4463 if (bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
4464 || bfd_mach_o_get_data (abfd
) == NULL
4465 || bfd_mach_o_get_data (abfd
)->header
.filetype
!= BFD_MACH_O_MH_DSYM
)
4468 dsym_uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4469 if (dsym_uuid_cmd
== NULL
)
4472 if (memcmp (uuid_cmd
->uuid
, dsym_uuid_cmd
->uuid
,
4473 sizeof (uuid_cmd
->uuid
)) != 0)
4479 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4480 The caller is responsible for closing the returned BFD object and
4481 its my_archive if the returned BFD is in a fat dSYM. */
4484 bfd_mach_o_find_dsym (const char *dsym_filename
,
4485 const bfd_mach_o_uuid_command
*uuid_cmd
,
4486 const bfd_arch_info_type
*arch
)
4488 bfd
*base_dsym_bfd
, *dsym_bfd
;
4490 BFD_ASSERT (uuid_cmd
);
4492 base_dsym_bfd
= bfd_openr (dsym_filename
, NULL
);
4493 if (base_dsym_bfd
== NULL
)
4496 dsym_bfd
= bfd_mach_o_fat_extract (base_dsym_bfd
, bfd_object
, arch
);
4497 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd
, uuid_cmd
))
4500 bfd_close (dsym_bfd
);
4501 if (base_dsym_bfd
!= dsym_bfd
)
4502 bfd_close (base_dsym_bfd
);
4507 /* Return a BFD created from a dSYM file for ABFD.
4508 The caller is responsible for closing the returned BFD object, its
4509 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4512 bfd_mach_o_follow_dsym (bfd
*abfd
)
4514 char *dsym_filename
;
4515 bfd_mach_o_uuid_command
*uuid_cmd
;
4516 bfd
*dsym_bfd
, *base_bfd
= abfd
;
4517 const char *base_basename
;
4519 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_mach_o_flavour
)
4522 if (abfd
->my_archive
)
4523 base_bfd
= abfd
->my_archive
;
4524 /* BFD may have been opened from a stream. */
4525 if (base_bfd
->filename
== NULL
)
4527 bfd_set_error (bfd_error_invalid_operation
);
4530 base_basename
= lbasename (base_bfd
->filename
);
4532 uuid_cmd
= bfd_mach_o_lookup_uuid_command (abfd
);
4533 if (uuid_cmd
== NULL
)
4536 /* TODO: We assume the DWARF file has the same as the binary's.
4537 It seems apple's GDB checks all files in the dSYM bundle directory.
4538 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4540 dsym_filename
= (char *)bfd_malloc (strlen (base_bfd
->filename
)
4541 + strlen (dsym_subdir
) + 1
4542 + strlen (base_basename
) + 1);
4543 sprintf (dsym_filename
, "%s%s/%s",
4544 base_bfd
->filename
, dsym_subdir
, base_basename
);
4546 dsym_bfd
= bfd_mach_o_find_dsym (dsym_filename
, uuid_cmd
,
4547 bfd_get_arch_info (abfd
));
4548 if (dsym_bfd
== NULL
)
4549 free (dsym_filename
);
4555 bfd_mach_o_find_nearest_line (bfd
*abfd
,
4559 const char **filename_ptr
,
4560 const char **functionname_ptr
,
4561 unsigned int *line_ptr
)
4563 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4566 switch (mdata
->header
.filetype
)
4568 case BFD_MACH_O_MH_OBJECT
:
4570 case BFD_MACH_O_MH_EXECUTE
:
4571 case BFD_MACH_O_MH_DYLIB
:
4572 case BFD_MACH_O_MH_BUNDLE
:
4573 case BFD_MACH_O_MH_KEXT_BUNDLE
:
4574 if (mdata
->dwarf2_find_line_info
== NULL
)
4576 mdata
->dsym_bfd
= bfd_mach_o_follow_dsym (abfd
);
4577 /* When we couldn't find dSYM for this binary, we look for
4578 the debug information in the binary itself. In this way,
4579 we won't try finding separated dSYM again because
4580 mdata->dwarf2_find_line_info will be filled. */
4581 if (! mdata
->dsym_bfd
)
4583 if (! _bfd_dwarf2_slurp_debug_info (abfd
, mdata
->dsym_bfd
,
4584 dwarf_debug_sections
, symbols
,
4585 &mdata
->dwarf2_find_line_info
))
4592 if (_bfd_dwarf2_find_nearest_line (abfd
, dwarf_debug_sections
,
4593 section
, symbols
, offset
,
4594 filename_ptr
, functionname_ptr
,
4596 &mdata
->dwarf2_find_line_info
))
4602 bfd_mach_o_close_and_cleanup (bfd
*abfd
)
4604 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4605 if (bfd_get_format (abfd
) == bfd_object
&& mdata
!= NULL
)
4607 _bfd_dwarf2_cleanup_debug_info (abfd
, &mdata
->dwarf2_find_line_info
);
4608 bfd_mach_o_free_cached_info (abfd
);
4609 if (mdata
->dsym_bfd
!= NULL
)
4611 bfd
*fat_bfd
= mdata
->dsym_bfd
->my_archive
;
4612 char *dsym_filename
= (char *)(fat_bfd
4614 : mdata
->dsym_bfd
->filename
);
4615 bfd_close (mdata
->dsym_bfd
);
4616 mdata
->dsym_bfd
= NULL
;
4618 bfd_close (fat_bfd
);
4619 free (dsym_filename
);
4623 return _bfd_generic_close_and_cleanup (abfd
);
4626 bfd_boolean
bfd_mach_o_free_cached_info (bfd
*abfd
)
4628 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4630 free (mdata
->dyn_reloc_cache
);
4631 mdata
->dyn_reloc_cache
= NULL
;
4632 for (asect
= abfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
4634 free (asect
->relocation
);
4635 asect
->relocation
= NULL
;
4641 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4642 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4644 #define bfd_mach_o_swap_reloc_in NULL
4645 #define bfd_mach_o_swap_reloc_out NULL
4646 #define bfd_mach_o_print_thread NULL
4647 #define bfd_mach_o_tgt_seg_table NULL
4648 #define bfd_mach_o_section_type_valid_for_tgt NULL
4650 #define TARGET_NAME mach_o_be_vec
4651 #define TARGET_STRING "mach-o-be"
4652 #define TARGET_ARCHITECTURE bfd_arch_unknown
4653 #define TARGET_BIG_ENDIAN 1
4654 #define TARGET_ARCHIVE 0
4655 #define TARGET_PRIORITY 1
4656 #include "mach-o-target.c"
4659 #undef TARGET_STRING
4660 #undef TARGET_ARCHITECTURE
4661 #undef TARGET_BIG_ENDIAN
4662 #undef TARGET_ARCHIVE
4663 #undef TARGET_PRIORITY
4665 #define TARGET_NAME mach_o_le_vec
4666 #define TARGET_STRING "mach-o-le"
4667 #define TARGET_ARCHITECTURE bfd_arch_unknown
4668 #define TARGET_BIG_ENDIAN 0
4669 #define TARGET_ARCHIVE 0
4670 #define TARGET_PRIORITY 1
4672 #include "mach-o-target.c"
4675 #undef TARGET_STRING
4676 #undef TARGET_ARCHITECTURE
4677 #undef TARGET_BIG_ENDIAN
4678 #undef TARGET_ARCHIVE
4679 #undef TARGET_PRIORITY
4681 /* Not yet handled: creating an archive. */
4682 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4685 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4686 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4687 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4688 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4689 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4690 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4691 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4692 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4693 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4694 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4696 #define TARGET_NAME mach_o_fat_vec
4697 #define TARGET_STRING "mach-o-fat"
4698 #define TARGET_ARCHITECTURE bfd_arch_unknown
4699 #define TARGET_BIG_ENDIAN 1
4700 #define TARGET_ARCHIVE 1
4701 #define TARGET_PRIORITY 0
4703 #include "mach-o-target.c"
4706 #undef TARGET_STRING
4707 #undef TARGET_ARCHITECTURE
4708 #undef TARGET_BIG_ENDIAN
4709 #undef TARGET_ARCHIVE
4710 #undef TARGET_PRIORITY