projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
handle absolute indirect syms in mach-o
[binutils-gdb.git] / bfd / mach-o.c
1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
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.
12
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.
17
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. */
22
23 #include "sysdep.h"
24 #include "mach-o.h"
25 #include "bfd.h"
26 #include "libbfd.h"
27 #include "libiberty.h"
28 #include "aout/stab_gnu.h"
29 #include "mach-o/reloc.h"
30 #include "mach-o/external.h"
31 #include <ctype.h>
32 #include <stdlib.h>
33 #include <string.h>
34
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
38
39 #define FILE_ALIGN(off, algn) \
40 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
41
42 unsigned int
43 bfd_mach_o_version (bfd *abfd)
44 {
45 bfd_mach_o_data_struct *mdata = NULL;
46
47 BFD_ASSERT (bfd_mach_o_valid (abfd));
48 mdata = bfd_mach_o_get_data (abfd);
49
50 return mdata->header.version;
51 }
52
53 bfd_boolean
54 bfd_mach_o_valid (bfd *abfd)
55 {
56 if (abfd == NULL || abfd->xvec == NULL)
57 return FALSE;
58
59 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
60 return FALSE;
61
62 if (bfd_mach_o_get_data (abfd) == NULL)
63 return FALSE;
64 return TRUE;
65 }
66
67 static INLINE bfd_boolean
68 mach_o_wide_p (bfd_mach_o_header *header)
69 {
70 switch (header->version)
71 {
72 case 1:
73 return FALSE;
74 case 2:
75 return TRUE;
76 default:
77 BFD_FAIL ();
78 return FALSE;
79 }
80 }
81
82 static INLINE bfd_boolean
83 bfd_mach_o_wide_p (bfd *abfd)
84 {
85 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
86 }
87
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
90 by gdb. */
91
92 /* __TEXT Segment. */
93 static const mach_o_section_name_xlat text_section_names_xlat[] =
94 {
95 { ".text", "__text",
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}
129 };
130
131 /* __DATA Segment. */
132 static const mach_o_section_name_xlat data_section_names_xlat[] =
133 {
134 { ".data", "__data",
135 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
136 BFD_MACH_O_S_ATTR_NONE, 0},
137 { ".bss", "__bss",
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},
152 { ".dyld", "__dyld",
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}
159 };
160
161 /* __DWARF Segment. */
162 static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
163 {
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}
201 };
202
203 /* __OBJC Segment. */
204 static const mach_o_section_name_xlat objc_section_names_xlat[] =
205 {
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},
260 /* Objc V1 */
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}
271 };
272
273 static const mach_o_segment_name_xlat segsec_names_xlat[] =
274 {
275 { "__TEXT", text_section_names_xlat },
276 { "__DATA", data_section_names_xlat },
277 { "__DWARF", dwarf_section_names_xlat },
278 { "__OBJC", objc_section_names_xlat },
279 { NULL, NULL }
280 };
281
282 static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
283
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. */
287
288 /* Fetch the translation from a Mach-O section designation (segment, section)
289 as a bfd short name, if one exists. Otherwise return NULL.
290
291 Allow the segment and section names to be unterminated 16 byte arrays. */
292
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)
296 {
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);
300
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)
308 return sec;
309
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)
316 return sec;
317
318 return NULL;
319 }
320
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. */
324
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)
328 {
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);
332 *segname = NULL;
333
334 if (bfd_name[0] != '.')
335 return NULL;
336
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)
342 {
343 *segname = seg->segname;
344 return sec;
345 }
346
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)
351 {
352 *segname = seg->segname;
353 return sec;
354 }
355
356 return NULL;
357 }
358
359 /* Convert Mach-O section name to BFD.
360
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.
365
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). */
369
370 void
371 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
372 const char *secname, const char **name,
373 flagword *flags)
374 {
375 const mach_o_section_name_xlat *xlat;
376 char *res;
377 unsigned int len;
378 const char *pfx = "";
379
380 *name = NULL;
381 *flags = SEC_NO_FLAGS;
382
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);
386 if (xlat)
387 {
388 len = strlen (xlat->bfd_name);
389 res = bfd_alloc (abfd, len+1);
390 if (res == NULL)
391 return;
392 memcpy (res, xlat->bfd_name, len+1);
393 *name = res;
394 *flags = xlat->bfd_flags;
395 return;
396 }
397
398 /* ... else we make up a bfd name from the segment concatenated with the
399 section. */
400
401 len = 16 + 1 + 16 + 1;
402
403 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
404 with an underscore. */
405 if (segname[0] != '_')
406 {
407 static const char seg_pfx[] = "LC_SEGMENT.";
408
409 pfx = seg_pfx;
410 len += sizeof (seg_pfx) - 1;
411 }
412
413 res = bfd_alloc (abfd, len);
414 if (res == NULL)
415 return;
416 snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
417 *name = res;
418 }
419
420 /* Convert a bfd section name to a Mach-O segment + section name.
421
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.
425
426 Otherwise, expand the bfd_name (assumed to be in the form
427 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
428
429 static const mach_o_section_name_xlat *
430 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
431 asection *sect,
432 bfd_mach_o_section *section)
433 {
434 const mach_o_section_name_xlat *xlat;
435 const char *name = bfd_get_section_name (abfd, sect);
436 const char *segname;
437 const char *dot;
438 unsigned int len;
439 unsigned int seglen;
440 unsigned int seclen;
441
442 memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
443 memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
444
445 /* See if is a canonical name ... */
446 xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
447 if (xlat)
448 {
449 strcpy (section->segname, segname);
450 strcpy (section->sectname, xlat->mach_o_name);
451 return xlat;
452 }
453
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)
457 name += 11;
458
459 /* Find a dot. */
460 dot = strchr (name, '.');
461 len = strlen (name);
462
463 /* Try to split name into segment and section names. */
464 if (dot && dot != name)
465 {
466 seglen = dot - name;
467 seclen = len - (dot + 1 - name);
468
469 if (seglen < 16 && seclen < 16)
470 {
471 memcpy (section->segname, name, seglen);
472 section->segname[seglen] = 0;
473 memcpy (section->sectname, dot + 1, seclen);
474 section->sectname[seclen] = 0;
475 return NULL;
476 }
477 }
478
479 /* The segment and section names are both missing - don't make them
480 into dots. */
481 if (dot && dot == name)
482 return NULL;
483
484 /* Just duplicate the name into both segment and section. */
485 if (len > 16)
486 len = 16;
487 memcpy (section->segname, name, len);
488 section->segname[len] = 0;
489 memcpy (section->sectname, name, len);
490 section->sectname[len] = 0;
491 return NULL;
492 }
493
494 /* Return the size of an entry for section SEC.
495 Must be called only for symbol pointer section and symbol stubs
496 sections. */
497
498 unsigned int
499 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
500 {
501 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
502 {
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;
508 default:
509 BFD_FAIL ();
510 return 0;
511 }
512 }
513
514 /* Return the number of indirect symbols for a section.
515 Must be called only for symbol pointer section and symbol stubs
516 sections. */
517
518 unsigned int
519 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
520 {
521 unsigned int elsz;
522
523 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
524 if (elsz == 0)
525 return 0;
526 else
527 return sec->size / elsz;
528 }
529
530
531 /* Copy any private info we understand from the input symbol
532 to the output symbol. */
533
534 bfd_boolean
535 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
536 asymbol *isymbol,
537 bfd *obfd ATTRIBUTE_UNUSED,
538 asymbol *osymbol)
539 {
540 bfd_mach_o_asymbol *os, *is;
541 os = (bfd_mach_o_asymbol *)osymbol;
542 is = (bfd_mach_o_asymbol *)isymbol;
543 os->n_type = is->n_type;
544 os->n_sect = is->n_sect;
545 os->n_desc = is->n_desc;
546 os->symbol.udata.i = is->symbol.udata.i;
547 return TRUE;
548 }
549
550 /* Copy any private info we understand from the input section
551 to the output section. */
552
553 bfd_boolean
554 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
555 asection *isection,
556 bfd *obfd ATTRIBUTE_UNUSED,
557 asection *osection)
558 {
559 if (osection->used_by_bfd == NULL)
560 osection->used_by_bfd = isection->used_by_bfd;
561 else
562 if (isection->used_by_bfd != NULL)
563 memcpy (osection->used_by_bfd, isection->used_by_bfd,
564 sizeof (bfd_mach_o_section));
565
566 if (osection->used_by_bfd != NULL)
567 ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
568
569 return TRUE;
570 }
571
572 /* Copy any private info we understand from the input bfd
573 to the output bfd. */
574
575 bfd_boolean
576 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
577 {
578 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
579 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
580 return TRUE;
581
582 BFD_ASSERT (bfd_mach_o_valid (ibfd));
583 BFD_ASSERT (bfd_mach_o_valid (obfd));
584
585 /* FIXME: copy commands. */
586
587 return TRUE;
588 }
589
590 /* This allows us to set up to 32 bits of flags (unless we invent some
591 fiendish scheme to subdivide). For now, we'll just set the file flags
592 without error checking - just overwrite. */
593
594 bfd_boolean
595 bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
596 {
597 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
598
599 if (!mdata)
600 return FALSE;
601
602 mdata->header.flags = flags;
603 return TRUE;
604 }
605
606 /* Count the total number of symbols. */
607
608 static long
609 bfd_mach_o_count_symbols (bfd *abfd)
610 {
611 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
612
613 if (mdata->symtab == NULL)
614 return 0;
615 return mdata->symtab->nsyms;
616 }
617
618 long
619 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
620 {
621 long nsyms = bfd_mach_o_count_symbols (abfd);
622
623 return ((nsyms + 1) * sizeof (asymbol *));
624 }
625
626 long
627 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
628 {
629 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
630 long nsyms = bfd_mach_o_count_symbols (abfd);
631 bfd_mach_o_symtab_command *sym = mdata->symtab;
632 unsigned long j;
633
634 if (nsyms < 0)
635 return nsyms;
636
637 if (nsyms == 0)
638 {
639 /* Do not try to read symbols if there are none. */
640 alocation[0] = NULL;
641 return 0;
642 }
643
644 if (!bfd_mach_o_read_symtab_symbols (abfd))
645 {
646 (*_bfd_error_handler)
647 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
648 return 0;
649 }
650
651 BFD_ASSERT (sym->symbols != NULL);
652
653 for (j = 0; j < sym->nsyms; j++)
654 alocation[j] = &sym->symbols[j].symbol;
655
656 alocation[j] = NULL;
657
658 return nsyms;
659 }
660
661 /* Create synthetic symbols for indirect symbols. */
662
663 long
664 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
665 long symcount ATTRIBUTE_UNUSED,
666 asymbol **syms ATTRIBUTE_UNUSED,
667 long dynsymcount ATTRIBUTE_UNUSED,
668 asymbol **dynsyms ATTRIBUTE_UNUSED,
669 asymbol **ret)
670 {
671 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
672 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
673 bfd_mach_o_symtab_command *symtab = mdata->symtab;
674 asymbol *s;
675 unsigned long count, i, j, n;
676 size_t size;
677 char *names;
678 char *nul_name;
679
680 *ret = NULL;
681
682 /* Stop now if no symbols or no indirect symbols. */
683 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
684 return 0;
685
686 if (dysymtab->nindirectsyms == 0)
687 return 0;
688
689 /* We need to allocate a bfd symbol for every indirect symbol and to
690 allocate the memory for its name. */
691 count = dysymtab->nindirectsyms;
692 size = count * sizeof (asymbol) + 1;
693
694 for (j = 0; j < count; j++)
695 {
696 unsigned int isym = dysymtab->indirect_syms[j];
697
698 /* Some indirect symbols are anonymous. */
699 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
700 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
701 }
702
703 s = *ret = (asymbol *) bfd_malloc (size);
704 if (s == NULL)
705 return -1;
706 names = (char *) (s + count);
707 nul_name = names;
708 *names++ = 0;
709
710 n = 0;
711 for (i = 0; i < mdata->nsects; i++)
712 {
713 bfd_mach_o_section *sec = mdata->sections[i];
714 unsigned int first, last;
715 bfd_vma addr;
716 bfd_vma entry_size;
717
718 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
719 {
720 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
721 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
722 case BFD_MACH_O_S_SYMBOL_STUBS:
723 /* Only these sections have indirect symbols. */
724 first = sec->reserved1;
725 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
726 addr = sec->addr;
727 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
728 for (j = first; j < last; j++)
729 {
730 unsigned int isym = dysymtab->indirect_syms[j];
731
732 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
733 s->section = sec->bfdsection;
734 s->value = addr - sec->addr;
735 s->udata.p = NULL;
736
737 if (isym < symtab->nsyms
738 && symtab->symbols[isym].symbol.name)
739 {
740 const char *sym = symtab->symbols[isym].symbol.name;
741 size_t len;
742
743 s->name = names;
744 len = strlen (sym);
745 memcpy (names, sym, len);
746 names += len;
747 memcpy (names, "$stub", sizeof ("$stub"));
748 names += sizeof ("$stub");
749 }
750 else
751 s->name = nul_name;
752
753 addr += entry_size;
754 s++;
755 n++;
756 }
757 break;
758 default:
759 break;
760 }
761 }
762
763 return n;
764 }
765
766 void
767 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
768 asymbol *symbol,
769 symbol_info *ret)
770 {
771 bfd_symbol_info (symbol, ret);
772 }
773
774 void
775 bfd_mach_o_print_symbol (bfd *abfd,
776 void * afile,
777 asymbol *symbol,
778 bfd_print_symbol_type how)
779 {
780 FILE *file = (FILE *) afile;
781 const char *name;
782 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
783
784 switch (how)
785 {
786 case bfd_print_symbol_name:
787 fprintf (file, "%s", symbol->name);
788 break;
789 default:
790 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
791 if (asym->n_type & BFD_MACH_O_N_STAB)
792 name = bfd_get_stab_name (asym->n_type);
793 else
794 switch (asym->n_type & BFD_MACH_O_N_TYPE)
795 {
796 case BFD_MACH_O_N_UNDF:
797 if (symbol->value == 0)
798 name = "UND";
799 else
800 name = "COM";
801 break;
802 case BFD_MACH_O_N_ABS:
803 name = "ABS";
804 break;
805 case BFD_MACH_O_N_INDR:
806 name = "INDR";
807 break;
808 case BFD_MACH_O_N_PBUD:
809 name = "PBUD";
810 break;
811 case BFD_MACH_O_N_SECT:
812 name = "SECT";
813 break;
814 default:
815 name = "???";
816 break;
817 }
818 if (name == NULL)
819 name = "";
820 fprintf (file, " %02x %-6s %02x %04x",
821 asym->n_type, name, asym->n_sect, asym->n_desc);
822 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
823 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
824 fprintf (file, " [%s]", symbol->section->name);
825 fprintf (file, " %s", symbol->name);
826 }
827 }
828
829 static void
830 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
831 bfd_mach_o_cpu_subtype msubtype,
832 enum bfd_architecture *type,
833 unsigned long *subtype)
834 {
835 *subtype = bfd_arch_unknown;
836
837 switch (mtype)
838 {
839 case BFD_MACH_O_CPU_TYPE_VAX:
840 *type = bfd_arch_vax;
841 break;
842 case BFD_MACH_O_CPU_TYPE_MC680x0:
843 *type = bfd_arch_m68k;
844 break;
845 case BFD_MACH_O_CPU_TYPE_I386:
846 *type = bfd_arch_i386;
847 *subtype = bfd_mach_i386_i386;
848 break;
849 case BFD_MACH_O_CPU_TYPE_X86_64:
850 *type = bfd_arch_i386;
851 *subtype = bfd_mach_x86_64;
852 break;
853 case BFD_MACH_O_CPU_TYPE_MIPS:
854 *type = bfd_arch_mips;
855 break;
856 case BFD_MACH_O_CPU_TYPE_MC98000:
857 *type = bfd_arch_m98k;
858 break;
859 case BFD_MACH_O_CPU_TYPE_HPPA:
860 *type = bfd_arch_hppa;
861 break;
862 case BFD_MACH_O_CPU_TYPE_ARM:
863 *type = bfd_arch_arm;
864 switch (msubtype)
865 {
866 case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
867 *subtype = bfd_mach_arm_4T;
868 break;
869 case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
870 *subtype = bfd_mach_arm_4T; /* Best fit ? */
871 break;
872 case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
873 *subtype = bfd_mach_arm_5TE;
874 break;
875 case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
876 *subtype = bfd_mach_arm_XScale;
877 break;
878 case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
879 *subtype = bfd_mach_arm_5TE; /* Best fit ? */
880 break;
881 case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
882 default:
883 break;
884 }
885 break;
886 case BFD_MACH_O_CPU_TYPE_MC88000:
887 *type = bfd_arch_m88k;
888 break;
889 case BFD_MACH_O_CPU_TYPE_SPARC:
890 *type = bfd_arch_sparc;
891 *subtype = bfd_mach_sparc;
892 break;
893 case BFD_MACH_O_CPU_TYPE_I860:
894 *type = bfd_arch_i860;
895 break;
896 case BFD_MACH_O_CPU_TYPE_ALPHA:
897 *type = bfd_arch_alpha;
898 break;
899 case BFD_MACH_O_CPU_TYPE_POWERPC:
900 *type = bfd_arch_powerpc;
901 *subtype = bfd_mach_ppc;
902 break;
903 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
904 *type = bfd_arch_powerpc;
905 *subtype = bfd_mach_ppc64;
906 break;
907 default:
908 *type = bfd_arch_unknown;
909 break;
910 }
911 }
912
913 static bfd_boolean
914 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
915 {
916 struct mach_o_header_external raw;
917 unsigned int size;
918
919 size = mach_o_wide_p (header) ?
920 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
921
922 bfd_h_put_32 (abfd, header->magic, raw.magic);
923 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
924 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
925 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
926 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
927 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
928 bfd_h_put_32 (abfd, header->flags, raw.flags);
929
930 if (mach_o_wide_p (header))
931 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
932
933 if (bfd_seek (abfd, 0, SEEK_SET) != 0
934 || bfd_bwrite (&raw, size, abfd) != size)
935 return FALSE;
936
937 return TRUE;
938 }
939
940 static int
941 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
942 {
943 bfd_mach_o_thread_command *cmd = &command->command.thread;
944 unsigned int i;
945 struct mach_o_thread_command_external raw;
946 unsigned int offset;
947
948 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
949 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
950
951 offset = 8;
952 for (i = 0; i < cmd->nflavours; i++)
953 {
954 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
955 BFD_ASSERT (cmd->flavours[i].offset ==
956 (command->offset + offset + BFD_MACH_O_LC_SIZE));
957
958 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
959 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
960
961 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
962 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
963 return -1;
964
965 offset += cmd->flavours[i].size + sizeof (raw);
966 }
967
968 return 0;
969 }
970
971 long
972 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
973 asection *asect)
974 {
975 return (asect->reloc_count + 1) * sizeof (arelent *);
976 }
977
978 static int
979 bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
980 struct mach_o_reloc_info_external *raw,
981 arelent *res, asymbol **syms)
982 {
983 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
984 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
985 bfd_mach_o_reloc_info reloc;
986 bfd_vma addr;
987 bfd_vma symnum;
988 asymbol **sym;
989
990 addr = bfd_get_32 (abfd, raw->r_address);
991 symnum = bfd_get_32 (abfd, raw->r_symbolnum);
992
993 if (addr & BFD_MACH_O_SR_SCATTERED)
994 {
995 unsigned int j;
996
997 /* Scattered relocation.
998 Extract section and offset from r_value. */
999 res->sym_ptr_ptr = NULL;
1000 res->addend = 0;
1001 for (j = 0; j < mdata->nsects; j++)
1002 {
1003 bfd_mach_o_section *sect = mdata->sections[j];
1004 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1005 {
1006 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1007 res->addend = symnum - sect->addr;
1008 break;
1009 }
1010 }
1011 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1012 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1013 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1014 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1015 reloc.r_scattered = 1;
1016 }
1017 else
1018 {
1019 unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);
1020 res->addend = 0;
1021 res->address = addr;
1022 if (symnum & BFD_MACH_O_R_EXTERN)
1023 {
1024 sym = syms + num;
1025 reloc.r_extern = 1;
1026 }
1027 else
1028 {
1029 BFD_ASSERT (num != 0);
1030 BFD_ASSERT (num <= mdata->nsects);
1031 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1032 /* For a symbol defined in section S, the addend (stored in the
1033 binary) contains the address of the section. To comply with
1034 bfd conventio, substract the section address.
1035 Use the address from the header, so that the user can modify
1036 the vma of the section. */
1037 res->addend = -mdata->sections[num - 1]->addr;
1038 reloc.r_extern = 0;
1039 }
1040 res->sym_ptr_ptr = sym;
1041 reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
1042 reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);
1043 reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;
1044 reloc.r_scattered = 0;
1045 }
1046
1047 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1048 return -1;
1049 return 0;
1050 }
1051
1052 static int
1053 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1054 unsigned long count,
1055 arelent *res, asymbol **syms)
1056 {
1057 unsigned long i;
1058 struct mach_o_reloc_info_external *native_relocs;
1059 bfd_size_type native_size;
1060
1061 /* Allocate and read relocs. */
1062 native_size = count * BFD_MACH_O_RELENT_SIZE;
1063 native_relocs =
1064 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1065 if (native_relocs == NULL)
1066 return -1;
1067
1068 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1069 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1070 goto err;
1071
1072 for (i = 0; i < count; i++)
1073 {
1074 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1075 &res[i], syms) < 0)
1076 goto err;
1077 }
1078 free (native_relocs);
1079 return i;
1080 err:
1081 free (native_relocs);
1082 return -1;
1083 }
1084
1085 long
1086 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1087 arelent **rels, asymbol **syms)
1088 {
1089 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1090 unsigned long i;
1091 arelent *res;
1092
1093 if (asect->reloc_count == 0)
1094 return 0;
1095
1096 /* No need to go further if we don't know how to read relocs. */
1097 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1098 return 0;
1099
1100 if (asect->relocation == NULL)
1101 {
1102 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1103 if (res == NULL)
1104 return -1;
1105
1106 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1107 asect->reloc_count, res, syms) < 0)
1108 {
1109 free (res);
1110 return -1;
1111 }
1112 asect->relocation = res;
1113 }
1114
1115 res = asect->relocation;
1116 for (i = 0; i < asect->reloc_count; i++)
1117 rels[i] = &res[i];
1118 rels[i] = NULL;
1119
1120 return i;
1121 }
1122
1123 long
1124 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1125 {
1126 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1127
1128 if (mdata->dysymtab == NULL)
1129 return 1;
1130 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1131 * sizeof (arelent *);
1132 }
1133
1134 long
1135 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1136 struct bfd_symbol **syms)
1137 {
1138 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1139 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1140 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1141 unsigned long i;
1142 arelent *res;
1143
1144 if (dysymtab == NULL)
1145 return 0;
1146 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1147 return 0;
1148
1149 /* No need to go further if we don't know how to read relocs. */
1150 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1151 return 0;
1152
1153 if (mdata->dyn_reloc_cache == NULL)
1154 {
1155 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1156 * sizeof (arelent));
1157 if (res == NULL)
1158 return -1;
1159
1160 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1161 dysymtab->nextrel, res, syms) < 0)
1162 {
1163 free (res);
1164 return -1;
1165 }
1166
1167 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1168 dysymtab->nlocrel,
1169 res + dysymtab->nextrel, syms) < 0)
1170 {
1171 free (res);
1172 return -1;
1173 }
1174
1175 mdata->dyn_reloc_cache = res;
1176 }
1177
1178 res = mdata->dyn_reloc_cache;
1179 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1180 rels[i] = &res[i];
1181 rels[i] = NULL;
1182 return i;
1183 }
1184
1185 static bfd_boolean
1186 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1187 {
1188 unsigned int i;
1189 arelent **entries;
1190 asection *sec;
1191 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1192
1193 sec = section->bfdsection;
1194 if (sec->reloc_count == 0)
1195 return TRUE;
1196
1197 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1198 return TRUE;
1199
1200 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1201 return FALSE;
1202
1203 /* Convert and write. */
1204 entries = section->bfdsection->orelocation;
1205 for (i = 0; i < section->nreloc; i++)
1206 {
1207 arelent *rel = entries[i];
1208 struct mach_o_reloc_info_external raw;
1209 bfd_mach_o_reloc_info info, *pinfo = &info;
1210
1211 /* Convert relocation to an intermediate representation. */
1212 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1213 return FALSE;
1214
1215 /* Lower the relocation info. */
1216 if (pinfo->r_scattered)
1217 {
1218 unsigned long v;
1219
1220 v = BFD_MACH_O_SR_SCATTERED
1221 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1222 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1223 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1224 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
1225 /* Note: scattered relocs have field in reverse order... */
1226 bfd_put_32 (abfd, v, raw.r_address);
1227 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1228 }
1229 else
1230 {
1231 unsigned long v;
1232
1233 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1234 v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value)
1235 | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0)
1236 | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length)
1237 | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0)
1238 | BFD_MACH_O_SET_R_TYPE (pinfo->r_type);
1239 bfd_put_32 (abfd, v, raw.r_symbolnum);
1240 }
1241
1242 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1243 != BFD_MACH_O_RELENT_SIZE)
1244 return FALSE;
1245 }
1246 return TRUE;
1247 }
1248
1249 static int
1250 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1251 {
1252 struct mach_o_section_32_external raw;
1253
1254 memcpy (raw.sectname, section->sectname, 16);
1255 memcpy (raw.segname, section->segname, 16);
1256 bfd_h_put_32 (abfd, section->addr, raw.addr);
1257 bfd_h_put_32 (abfd, section->size, raw.size);
1258 bfd_h_put_32 (abfd, section->offset, raw.offset);
1259 bfd_h_put_32 (abfd, section->align, raw.align);
1260 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1261 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1262 bfd_h_put_32 (abfd, section->flags, raw.flags);
1263 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1264 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1265
1266 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1267 != BFD_MACH_O_SECTION_SIZE)
1268 return -1;
1269
1270 return 0;
1271 }
1272
1273 static int
1274 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1275 {
1276 struct mach_o_section_64_external raw;
1277
1278 memcpy (raw.sectname, section->sectname, 16);
1279 memcpy (raw.segname, section->segname, 16);
1280 bfd_h_put_64 (abfd, section->addr, raw.addr);
1281 bfd_h_put_64 (abfd, section->size, raw.size);
1282 bfd_h_put_32 (abfd, section->offset, raw.offset);
1283 bfd_h_put_32 (abfd, section->align, raw.align);
1284 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1285 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1286 bfd_h_put_32 (abfd, section->flags, raw.flags);
1287 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1288 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1289 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1290
1291 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1292 != BFD_MACH_O_SECTION_64_SIZE)
1293 return -1;
1294
1295 return 0;
1296 }
1297
1298 static int
1299 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1300 {
1301 struct mach_o_segment_command_32_external raw;
1302 bfd_mach_o_segment_command *seg = &command->command.segment;
1303 bfd_mach_o_section *sec;
1304
1305 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1306
1307 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1308 if (!bfd_mach_o_write_relocs (abfd, sec))
1309 return -1;
1310
1311 memcpy (raw.segname, seg->segname, 16);
1312 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1313 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1314 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1315 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1316 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1317 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1318 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1319 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1320
1321 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1322 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1323 return -1;
1324
1325 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1326 if (bfd_mach_o_write_section_32 (abfd, sec))
1327 return -1;
1328
1329 return 0;
1330 }
1331
1332 static int
1333 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1334 {
1335 struct mach_o_segment_command_64_external raw;
1336 bfd_mach_o_segment_command *seg = &command->command.segment;
1337 bfd_mach_o_section *sec;
1338
1339 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1340
1341 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1342 if (!bfd_mach_o_write_relocs (abfd, sec))
1343 return -1;
1344
1345 memcpy (raw.segname, seg->segname, 16);
1346 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1347 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1348 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1349 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1350 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1351 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1352 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1353 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1354
1355 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1356 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1357 return -1;
1358
1359 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1360 if (bfd_mach_o_write_section_64 (abfd, sec))
1361 return -1;
1362
1363 return 0;
1364 }
1365
1366 static bfd_boolean
1367 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1368 {
1369 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1370 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1371 unsigned long i;
1372 unsigned int wide = bfd_mach_o_wide_p (abfd);
1373 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1374 struct bfd_strtab_hash *strtab;
1375 asymbol **symbols = bfd_get_outsymbols (abfd);
1376
1377 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1378
1379 /* Write the symbols first. */
1380 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1381 sym->symoff = mdata->filelen;
1382 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1383 return FALSE;
1384
1385 sym->nsyms = bfd_get_symcount (abfd);
1386 mdata->filelen += sym->nsyms * symlen;
1387
1388 strtab = _bfd_stringtab_init ();
1389 if (strtab == NULL)
1390 return FALSE;
1391
1392 if (sym->nsyms > 0)
1393 /* Although we don't strictly need to do this, for compatibility with
1394 Darwin system tools, actually output an empty string for the index
1395 0 entry. */
1396 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1397
1398 for (i = 0; i < sym->nsyms; i++)
1399 {
1400 bfd_size_type str_index;
1401 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1402
1403 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1404 /* An index of 0 always means the empty string. */
1405 str_index = 0;
1406 else
1407 {
1408 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1409
1410 if (str_index == (bfd_size_type) -1)
1411 goto err;
1412 }
1413
1414 if (wide)
1415 {
1416 struct mach_o_nlist_64_external raw;
1417
1418 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1419 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1420 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1421 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1422 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1423 raw.n_value);
1424
1425 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1426 goto err;
1427 }
1428 else
1429 {
1430 struct mach_o_nlist_external raw;
1431
1432 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1433 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1434 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1435 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1436 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1437 raw.n_value);
1438
1439 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1440 goto err;
1441 }
1442 }
1443 sym->strsize = _bfd_stringtab_size (strtab);
1444 sym->stroff = mdata->filelen;
1445 mdata->filelen += sym->strsize;
1446
1447 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1448 goto err;
1449 _bfd_stringtab_free (strtab);
1450
1451 /* The command. */
1452 {
1453 struct mach_o_symtab_command_external raw;
1454
1455 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1456 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1457 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1458 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1459
1460 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1461 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1462 return FALSE;
1463 }
1464
1465 return TRUE;
1466
1467 err:
1468 _bfd_stringtab_free (strtab);
1469 return FALSE;
1470 }
1471
1472 /* Write a dysymtab command.
1473 TODO: Possibly coalesce writes of smaller objects. */
1474
1475 static bfd_boolean
1476 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1477 {
1478 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1479
1480 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1481
1482 if (cmd->nmodtab != 0)
1483 {
1484 unsigned int i;
1485
1486 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1487 return FALSE;
1488
1489 for (i = 0; i < cmd->nmodtab; i++)
1490 {
1491 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1492 unsigned int iinit;
1493 unsigned int ninit;
1494
1495 iinit = module->iinit & 0xffff;
1496 iinit |= ((module->iterm & 0xffff) << 16);
1497
1498 ninit = module->ninit & 0xffff;
1499 ninit |= ((module->nterm & 0xffff) << 16);
1500
1501 if (bfd_mach_o_wide_p (abfd))
1502 {
1503 struct mach_o_dylib_module_64_external w;
1504
1505 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1506 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1507 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1508 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1509 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1510 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1511 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1512 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1513 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1514 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1515 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1516 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1517 &w.objc_module_info_addr);
1518 bfd_h_put_32 (abfd, module->objc_module_info_size,
1519 &w.objc_module_info_size);
1520
1521 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1522 return FALSE;
1523 }
1524 else
1525 {
1526 struct mach_o_dylib_module_external n;
1527
1528 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1529 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1530 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1531 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1532 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1533 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1534 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1535 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1536 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1537 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1538 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1539 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1540 &n.objc_module_info_addr);
1541 bfd_h_put_32 (abfd, module->objc_module_info_size,
1542 &n.objc_module_info_size);
1543
1544 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1545 return FALSE;
1546 }
1547 }
1548 }
1549
1550 if (cmd->ntoc != 0)
1551 {
1552 unsigned int i;
1553
1554 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1555 return FALSE;
1556
1557 for (i = 0; i < cmd->ntoc; i++)
1558 {
1559 struct mach_o_dylib_table_of_contents_external raw;
1560 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1561
1562 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1563 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1564
1565 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1566 return FALSE;
1567 }
1568 }
1569
1570 if (cmd->nindirectsyms > 0)
1571 {
1572 unsigned int i;
1573
1574 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1575 return FALSE;
1576
1577 for (i = 0; i < cmd->nindirectsyms; ++i)
1578 {
1579 unsigned char raw[4];
1580
1581 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1582 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1583 return FALSE;
1584 }
1585 }
1586
1587 if (cmd->nextrefsyms != 0)
1588 {
1589 unsigned int i;
1590
1591 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1592 return FALSE;
1593
1594 for (i = 0; i < cmd->nextrefsyms; i++)
1595 {
1596 unsigned long v;
1597 unsigned char raw[4];
1598 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1599
1600 /* Fields isym and flags are written as bit-fields, thus we need
1601 a specific processing for endianness. */
1602
1603 if (bfd_big_endian (abfd))
1604 {
1605 v = ((ref->isym & 0xffffff) << 8);
1606 v |= ref->flags & 0xff;
1607 }
1608 else
1609 {
1610 v = ref->isym & 0xffffff;
1611 v |= ((ref->flags & 0xff) << 24);
1612 }
1613
1614 bfd_h_put_32 (abfd, v, raw);
1615 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1616 return FALSE;
1617 }
1618 }
1619
1620 /* The command. */
1621 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1622 return FALSE;
1623 else
1624 {
1625 struct mach_o_dysymtab_command_external raw;
1626
1627 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1628 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1629 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1630 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1631 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1632 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1633 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1634 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1635 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1636 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1637 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1638 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1639 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1640 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1641 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1642 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1643 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1644 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1645
1646 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1647 return FALSE;
1648 }
1649
1650 return TRUE;
1651 }
1652
1653 static unsigned
1654 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
1655 {
1656 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
1657
1658 /* Just leave debug symbols where they are (pretend they are local, and
1659 then they will just be sorted on position). */
1660 if (s->n_type & BFD_MACH_O_N_STAB)
1661 return 0;
1662
1663 /* Local (we should never see an undefined local AFAICT). */
1664 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
1665 return 0;
1666
1667 /* Common symbols look like undefined externs. */
1668 if (mtyp == BFD_MACH_O_N_UNDF)
1669 return 2;
1670
1671 /* A defined non-local, non-debug symbol. */
1672 return 1;
1673 }
1674
1675 static int
1676 bfd_mach_o_cf_symbols (const void *a, const void *b)
1677 {
1678 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1679 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1680 unsigned int soa, sob;
1681
1682 soa = bfd_mach_o_primary_symbol_sort_key (sa);
1683 sob = bfd_mach_o_primary_symbol_sort_key (sb);
1684 if (soa < sob)
1685 return -1;
1686
1687 if (soa > sob)
1688 return 1;
1689
1690 /* If it's local or stab, just preserve the input order. */
1691 if (soa == 0)
1692 {
1693 if (sa->symbol.udata.i < sb->symbol.udata.i)
1694 return -1;
1695 if (sa->symbol.udata.i > sb->symbol.udata.i)
1696 return 1;
1697
1698 /* This is probably an error. */
1699 return 0;
1700 }
1701
1702 /* The second sort key is name. */
1703 return strcmp (sa->symbol.name, sb->symbol.name);
1704 }
1705
1706 /* Process the symbols.
1707
1708 This should be OK for single-module files - but it is not likely to work
1709 for multi-module shared libraries.
1710
1711 (a) If the application has not filled in the relevant mach-o fields, make
1712 an estimate.
1713
1714 (b) Order them, like this:
1715 ( i) local.
1716 (unsorted)
1717 ( ii) external defined
1718 (by name)
1719 (iii) external undefined/common
1720 (by name)
1721 ( iv) common
1722 (by name)
1723 */
1724
1725 static bfd_boolean
1726 bfd_mach_o_mangle_symbols (bfd *abfd)
1727 {
1728 unsigned long i;
1729 asymbol **symbols = bfd_get_outsymbols (abfd);
1730
1731 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1732 return TRUE;
1733
1734 for (i = 0; i < bfd_get_symcount (abfd); i++)
1735 {
1736 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1737
1738 /* We use this value, which is out-of-range as a symbol index, to signal
1739 that the mach-o-specific data are not filled in and need to be created
1740 from the bfd values. It is much preferable for the application to do
1741 this, since more meaningful diagnostics can be made that way. */
1742
1743 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
1744 {
1745 /* No symbol information has been set - therefore determine
1746 it from the bfd symbol flags/info. */
1747 if (s->symbol.section == bfd_abs_section_ptr)
1748 s->n_type = BFD_MACH_O_N_ABS;
1749 else if (s->symbol.section == bfd_und_section_ptr)
1750 {
1751 s->n_type = BFD_MACH_O_N_UNDF;
1752 if (s->symbol.flags & BSF_WEAK)
1753 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1754 /* mach-o automatically makes undefined symbols extern. */
1755 s->n_type |= BFD_MACH_O_N_EXT;
1756 s->symbol.flags |= BSF_GLOBAL;
1757 }
1758 else if (s->symbol.section == bfd_com_section_ptr)
1759 {
1760 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1761 s->symbol.flags |= BSF_GLOBAL;
1762 }
1763 else
1764 s->n_type = BFD_MACH_O_N_SECT;
1765
1766 if (s->symbol.flags & BSF_GLOBAL)
1767 s->n_type |= BFD_MACH_O_N_EXT;
1768 }
1769
1770 /* Put the section index in, where required. */
1771 if ((s->symbol.section != bfd_abs_section_ptr
1772 && s->symbol.section != bfd_und_section_ptr
1773 && s->symbol.section != bfd_com_section_ptr)
1774 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1775 && s->symbol.name == NULL))
1776 s->n_sect = s->symbol.section->target_index;
1777
1778 /* Number to preserve order for local and debug syms. */
1779 s->symbol.udata.i = i;
1780 }
1781
1782 /* Sort the symbols. */
1783 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
1784 sizeof (asymbol *), bfd_mach_o_cf_symbols);
1785
1786 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1787 {
1788 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1789 s->symbol.udata.i = i; /* renumber. */
1790 }
1791
1792 return TRUE;
1793 }
1794
1795 /* We build a flat table of sections, which can be re-ordered if necessary.
1796 Fill in the section number and other mach-o-specific data. */
1797
1798 static bfd_boolean
1799 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1800 {
1801 asection *sec;
1802 unsigned target_index;
1803 unsigned nsect;
1804
1805 nsect = bfd_count_sections (abfd);
1806
1807 /* Don't do it if it's already set - assume the application knows what it's
1808 doing. */
1809 if (mdata->nsects == nsect
1810 && (mdata->nsects == 0 || mdata->sections != NULL))
1811 return TRUE;
1812
1813 mdata->nsects = nsect;
1814 mdata->sections = bfd_alloc (abfd,
1815 mdata->nsects * sizeof (bfd_mach_o_section *));
1816 if (mdata->sections == NULL)
1817 return FALSE;
1818
1819 /* We need to check that this can be done... */
1820 if (nsect > 255)
1821 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1822 " maximum is 255,\n"), nsect);
1823
1824 /* Create Mach-O sections.
1825 Section type, attribute and align should have been set when the
1826 section was created - either read in or specified. */
1827 target_index = 0;
1828 for (sec = abfd->sections; sec; sec = sec->next)
1829 {
1830 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1831 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1832
1833 mdata->sections[target_index] = msect;
1834
1835 msect->addr = bfd_get_section_vma (abfd, sec);
1836 msect->size = bfd_get_section_size (sec);
1837
1838 /* Use the largest alignment set, in case it was bumped after the
1839 section was created. */
1840 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1841
1842 msect->offset = 0;
1843 sec->target_index = ++target_index;
1844 }
1845
1846 return TRUE;
1847 }
1848
1849 bfd_boolean
1850 bfd_mach_o_write_contents (bfd *abfd)
1851 {
1852 unsigned int i;
1853 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1854
1855 /* Make the commands, if not already present. */
1856 if (mdata->header.ncmds == 0)
1857 if (!bfd_mach_o_build_commands (abfd))
1858 return FALSE;
1859
1860 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1861 return FALSE;
1862
1863 for (i = 0; i < mdata->header.ncmds; i++)
1864 {
1865 struct mach_o_load_command_external raw;
1866 bfd_mach_o_load_command *cur = &mdata->commands[i];
1867 unsigned long typeflag;
1868
1869 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1870
1871 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1872 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
1873
1874 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1875 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
1876 return FALSE;
1877
1878 switch (cur->type)
1879 {
1880 case BFD_MACH_O_LC_SEGMENT:
1881 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1882 return FALSE;
1883 break;
1884 case BFD_MACH_O_LC_SEGMENT_64:
1885 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1886 return FALSE;
1887 break;
1888 case BFD_MACH_O_LC_SYMTAB:
1889 if (!bfd_mach_o_write_symtab (abfd, cur))
1890 return FALSE;
1891 break;
1892 case BFD_MACH_O_LC_DYSYMTAB:
1893 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1894 return FALSE;
1895 break;
1896 case BFD_MACH_O_LC_SYMSEG:
1897 break;
1898 case BFD_MACH_O_LC_THREAD:
1899 case BFD_MACH_O_LC_UNIXTHREAD:
1900 if (bfd_mach_o_write_thread (abfd, cur) != 0)
1901 return FALSE;
1902 break;
1903 case BFD_MACH_O_LC_LOADFVMLIB:
1904 case BFD_MACH_O_LC_IDFVMLIB:
1905 case BFD_MACH_O_LC_IDENT:
1906 case BFD_MACH_O_LC_FVMFILE:
1907 case BFD_MACH_O_LC_PREPAGE:
1908 case BFD_MACH_O_LC_LOAD_DYLIB:
1909 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1910 case BFD_MACH_O_LC_ID_DYLIB:
1911 case BFD_MACH_O_LC_REEXPORT_DYLIB:
1912 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
1913 case BFD_MACH_O_LC_LOAD_DYLINKER:
1914 case BFD_MACH_O_LC_ID_DYLINKER:
1915 case BFD_MACH_O_LC_PREBOUND_DYLIB:
1916 case BFD_MACH_O_LC_ROUTINES:
1917 case BFD_MACH_O_LC_SUB_FRAMEWORK:
1918 break;
1919 default:
1920 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
1921 (unsigned long) cur->type);
1922 return FALSE;
1923 }
1924 }
1925
1926 return TRUE;
1927 }
1928
1929 static void
1930 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
1931 asection *sec)
1932 {
1933 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
1934 if (seg->sect_head == NULL)
1935 seg->sect_head = s;
1936 else
1937 seg->sect_tail->next = s;
1938 seg->sect_tail = s;
1939 }
1940
1941 /* Create section Mach-O flags from BFD flags. */
1942
1943 static void
1944 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1945 {
1946 flagword bfd_flags;
1947 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
1948
1949 /* Create default flags. */
1950 bfd_flags = bfd_get_section_flags (abfd, sec);
1951 if ((bfd_flags & SEC_CODE) == SEC_CODE)
1952 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1953 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1954 | BFD_MACH_O_S_REGULAR;
1955 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
1956 s->flags = BFD_MACH_O_S_ZEROFILL;
1957 else if (bfd_flags & SEC_DEBUGGING)
1958 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
1959 else
1960 s->flags = BFD_MACH_O_S_REGULAR;
1961 }
1962
1963 /* Count the number of sections in the list for the segment named.
1964
1965 The special case of NULL or "" for the segment name is valid for
1966 an MH_OBJECT file and means 'all sections available'.
1967
1968 Requires that the sections table in mdata be filled in.
1969
1970 Returns the number of sections (0 is valid).
1971 Any number > 255 signals an invalid section count, although we will,
1972 perhaps, allow the file to be written (in line with Darwin tools up
1973 to XCode 4).
1974
1975 A section count of (unsigned long) -1 signals a definite error. */
1976
1977 static unsigned long
1978 bfd_mach_o_count_sections_for_seg (const char *segment,
1979 bfd_mach_o_data_struct *mdata)
1980 {
1981 unsigned i,j;
1982 if (mdata == NULL || mdata->sections == NULL)
1983 return (unsigned long) -1;
1984
1985 /* The MH_OBJECT case, all sections are considered; Although nsects is
1986 is an unsigned long, the maximum valid section count is 255 and this
1987 will have been checked already by mangle_sections. */
1988 if (segment == NULL || segment[0] == '\0')
1989 return mdata->nsects;
1990
1991 /* Count the number of sections we see in this segment. */
1992 j = 0;
1993 for (i = 0; i < mdata->nsects; ++i)
1994 {
1995 bfd_mach_o_section *s = mdata->sections[i];
1996 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
1997 j++;
1998 }
1999 return j;
2000 }
2001
2002 static bfd_boolean
2003 bfd_mach_o_build_seg_command (const char *segment,
2004 bfd_mach_o_data_struct *mdata,
2005 bfd_mach_o_segment_command *seg)
2006 {
2007 unsigned i;
2008 int is_mho = (segment == NULL || segment[0] == '\0');
2009
2010 /* Fill segment command. */
2011 if (is_mho)
2012 memset (seg->segname, 0, sizeof (seg->segname));
2013 else
2014 strncpy (seg->segname, segment, sizeof (seg->segname));
2015
2016 /* TODO: fix this up for non-MH_OBJECT cases. */
2017 seg->vmaddr = 0;
2018 seg->vmsize = 0;
2019
2020 seg->fileoff = mdata->filelen;
2021 seg->filesize = 0;
2022 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2023 | BFD_MACH_O_PROT_EXECUTE;
2024 seg->initprot = seg->maxprot;
2025 seg->flags = 0;
2026 seg->sect_head = NULL;
2027 seg->sect_tail = NULL;
2028
2029 /* Append sections to the segment. */
2030
2031 for (i = 0; i < mdata->nsects; ++i)
2032 {
2033 bfd_mach_o_section *s = mdata->sections[i];
2034 asection *sec = s->bfdsection;
2035
2036 /* If we're not making an MH_OBJECT, check whether this section is from
2037 our segment, and skip if not. Otherwise, just add all sections. */
2038 if (! is_mho
2039 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2040 continue;
2041
2042 bfd_mach_o_append_section_to_segment (seg, sec);
2043
2044 s->offset = 0;
2045 if (s->size > 0)
2046 {
2047 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2048 seg->vmsize += s->size;
2049 }
2050
2051 /* Zerofill sections have zero file size & offset,
2052 and are not written. */
2053 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2054 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2055 == BFD_MACH_O_S_GB_ZEROFILL)
2056 continue;
2057
2058 if (s->size > 0)
2059 {
2060 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2061 s->offset = mdata->filelen;
2062 }
2063
2064 sec->filepos = s->offset;
2065
2066 mdata->filelen += s->size;
2067 }
2068
2069 seg->filesize = mdata->filelen - seg->fileoff;
2070 seg->filesize = FILE_ALIGN(seg->filesize, 2);
2071
2072 /* Allocate relocation room. */
2073 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
2074
2075 for (i = 0; i < mdata->nsects; ++i)
2076 {
2077 bfd_mach_o_section *ms = mdata->sections[i];
2078 asection *sec = ms->bfdsection;
2079
2080 if ((ms->nreloc = sec->reloc_count) == 0)
2081 {
2082 ms->reloff = 0;
2083 continue;
2084 }
2085 sec->rel_filepos = mdata->filelen;
2086 ms->reloff = sec->rel_filepos;
2087 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2088 }
2089
2090 return TRUE;
2091 }
2092
2093 /* Count the number of indirect symbols in the image.
2094 Requires that the sections are in their final order. */
2095
2096 static unsigned int
2097 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2098 {
2099 unsigned int i;
2100 unsigned int nisyms = 0;
2101
2102 for (i = 0; i < mdata->nsects; ++i)
2103 {
2104 bfd_mach_o_section *sec = mdata->sections[i];
2105
2106 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2107 {
2108 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2109 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2110 case BFD_MACH_O_S_SYMBOL_STUBS:
2111 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2112 break;
2113 default:
2114 break;
2115 }
2116 }
2117 return nisyms;
2118 }
2119
2120 static bfd_boolean
2121 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2122 bfd_mach_o_data_struct *mdata,
2123 bfd_mach_o_load_command *cmd)
2124 {
2125 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2126
2127 /* TODO:
2128 We are not going to try and fill these in yet and, moreover, we are
2129 going to bail if they are already set. */
2130 if (dsym->nmodtab != 0
2131 || dsym->ntoc != 0
2132 || dsym->nextrefsyms != 0)
2133 {
2134 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2135 " implemented for dysymtab commands."));
2136 return FALSE;
2137 }
2138
2139 dsym->ilocalsym = 0;
2140
2141 if (bfd_get_symcount (abfd) > 0)
2142 {
2143 asymbol **symbols = bfd_get_outsymbols (abfd);
2144 unsigned long i;
2145
2146 /* Count the number of each kind of symbol. */
2147 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2148 {
2149 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2150 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2151 break;
2152 }
2153 dsym->nlocalsym = i;
2154 dsym->iextdefsym = i;
2155 for (; i < bfd_get_symcount (abfd); ++i)
2156 {
2157 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2158 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2159 break;
2160 }
2161 dsym->nextdefsym = i - dsym->nlocalsym;
2162 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2163 dsym->nundefsym = bfd_get_symcount (abfd)
2164 - dsym->nlocalsym
2165 - dsym->nextdefsym;
2166 }
2167 else
2168 {
2169 dsym->nlocalsym = 0;
2170 dsym->iextdefsym = 0;
2171 dsym->nextdefsym = 0;
2172 dsym->iundefsym = 0;
2173 dsym->nundefsym = 0;
2174 }
2175
2176 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2177 if (dsym->nindirectsyms > 0)
2178 {
2179 unsigned i;
2180 unsigned n;
2181
2182 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2183 dsym->indirectsymoff = mdata->filelen;
2184 mdata->filelen += dsym->nindirectsyms * 4;
2185
2186 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2187 if (dsym->indirect_syms == NULL)
2188 return FALSE;
2189
2190 n = 0;
2191 for (i = 0; i < mdata->nsects; ++i)
2192 {
2193 bfd_mach_o_section *sec = mdata->sections[i];
2194
2195 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2196 {
2197 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2198 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2199 case BFD_MACH_O_S_SYMBOL_STUBS:
2200 {
2201 unsigned j, num;
2202 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2203
2204 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2205 if (isyms == NULL || num == 0)
2206 break;
2207 /* Record the starting index in the reserved1 field. */
2208 sec->reserved1 = n;
2209 for (j = 0; j < num; j++, n++)
2210 {
2211 if (isyms[j] == NULL)
2212 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2213 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2214 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2215 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2216 | BFD_MACH_O_INDIRECT_SYM_ABS;
2217 else
2218 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2219 }
2220 }
2221 break;
2222 default:
2223 break;
2224 }
2225 }
2226 }
2227
2228 return TRUE;
2229 }
2230
2231 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2232 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2233 and copy functionality. */
2234
2235 bfd_boolean
2236 bfd_mach_o_build_commands (bfd *abfd)
2237 {
2238 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2239 unsigned wide = mach_o_wide_p (&mdata->header);
2240 int segcmd_idx = -1;
2241 int symtab_idx = -1;
2242 int dysymtab_idx = -1;
2243 unsigned long base_offset = 0;
2244
2245 /* Return now if commands are already present. */
2246 if (mdata->header.ncmds)
2247 return FALSE;
2248
2249 /* Fill in the file type, if not already set. */
2250
2251 if (mdata->header.filetype == 0)
2252 {
2253 if (abfd->flags & EXEC_P)
2254 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2255 else if (abfd->flags & DYNAMIC)
2256 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2257 else
2258 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2259 }
2260
2261 /* If hasn't already been done, flatten sections list, and sort
2262 if/when required. Must be done before the symbol table is adjusted,
2263 since that depends on properly numbered sections. */
2264 if (mdata->nsects == 0 || mdata->sections == NULL)
2265 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2266 return FALSE;
2267
2268 /* Order the symbol table, fill-in/check mach-o specific fields and
2269 partition out any indirect symbols. */
2270 if (!bfd_mach_o_mangle_symbols (abfd))
2271 return FALSE;
2272
2273 /* Very simple command set (only really applicable to MH_OBJECTs):
2274 All the commands are optional - present only when there is suitable data.
2275 (i.e. it is valid to have an empty file)
2276
2277 a command (segment) to contain all the sections,
2278 command for the symbol table,
2279 a command for the dysymtab.
2280
2281 ??? maybe we should assert that this is an MH_OBJECT? */
2282
2283 if (mdata->nsects > 0)
2284 {
2285 segcmd_idx = 0;
2286 mdata->header.ncmds = 1;
2287 }
2288
2289 if (bfd_get_symcount (abfd) > 0)
2290 {
2291 mdata->header.ncmds++;
2292 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2293 }
2294
2295 /* FIXME:
2296 This is a rather crude test for whether we should build a dysymtab. */
2297 if (bfd_mach_o_should_emit_dysymtab ()
2298 && bfd_get_symcount (abfd))
2299 {
2300 mdata->header.ncmds++;
2301 /* If there should be a case where a dysymtab could be emitted without
2302 a symtab (seems improbable), this would need amending. */
2303 dysymtab_idx = symtab_idx + 1;
2304 }
2305
2306 if (wide)
2307 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2308 else
2309 base_offset = BFD_MACH_O_HEADER_SIZE;
2310
2311 /* Well, we must have a header, at least. */
2312 mdata->filelen = base_offset;
2313
2314 /* A bit unusual, but no content is valid;
2315 as -n empty.s -o empty.o */
2316 if (mdata->header.ncmds == 0)
2317 return TRUE;
2318
2319 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2320 * sizeof (bfd_mach_o_load_command));
2321 if (mdata->commands == NULL)
2322 return FALSE;
2323
2324 if (segcmd_idx >= 0)
2325 {
2326 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2327 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2328
2329 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2330 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2331 if (seg->nsects == (unsigned long) -1)
2332 return FALSE;
2333
2334 /* Init segment command. */
2335 cmd->offset = base_offset;
2336 if (wide)
2337 {
2338 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2339 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2340 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2341 }
2342 else
2343 {
2344 cmd->type = BFD_MACH_O_LC_SEGMENT;
2345 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2346 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2347 }
2348
2349 cmd->type_required = FALSE;
2350 mdata->header.sizeofcmds = cmd->len;
2351 mdata->filelen += cmd->len;
2352 }
2353
2354 if (symtab_idx >= 0)
2355 {
2356 /* Init symtab command. */
2357 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2358
2359 cmd->type = BFD_MACH_O_LC_SYMTAB;
2360 cmd->offset = base_offset;
2361 if (segcmd_idx >= 0)
2362 cmd->offset += mdata->commands[segcmd_idx].len;
2363
2364 cmd->len = sizeof (struct mach_o_symtab_command_external)
2365 + BFD_MACH_O_LC_SIZE;
2366 cmd->type_required = FALSE;
2367 mdata->header.sizeofcmds += cmd->len;
2368 mdata->filelen += cmd->len;
2369 }
2370
2371 /* If required, setup symtab command, see comment above about the quality
2372 of this test. */
2373 if (dysymtab_idx >= 0)
2374 {
2375 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2376
2377 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2378 if (symtab_idx >= 0)
2379 cmd->offset = mdata->commands[symtab_idx].offset
2380 + mdata->commands[symtab_idx].len;
2381 else if (segcmd_idx >= 0)
2382 cmd->offset = mdata->commands[segcmd_idx].offset
2383 + mdata->commands[segcmd_idx].len;
2384 else
2385 cmd->offset = base_offset;
2386
2387 cmd->type_required = FALSE;
2388 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2389 + BFD_MACH_O_LC_SIZE;
2390
2391 mdata->header.sizeofcmds += cmd->len;
2392 mdata->filelen += cmd->len;
2393 }
2394
2395 /* So, now we have sized the commands and the filelen set to that.
2396 Now we can build the segment command and set the section file offsets. */
2397 if (segcmd_idx >= 0
2398 && ! bfd_mach_o_build_seg_command
2399 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2400 return FALSE;
2401
2402 /* If we're doing a dysymtab, cmd points to its load command. */
2403 if (dysymtab_idx >= 0
2404 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2405 &mdata->commands[dysymtab_idx]))
2406 return FALSE;
2407
2408 /* The symtab command is filled in when the symtab is written. */
2409 return TRUE;
2410 }
2411
2412 /* Set the contents of a section. */
2413
2414 bfd_boolean
2415 bfd_mach_o_set_section_contents (bfd *abfd,
2416 asection *section,
2417 const void * location,
2418 file_ptr offset,
2419 bfd_size_type count)
2420 {
2421 file_ptr pos;
2422
2423 /* Trying to write the first section contents will trigger the creation of
2424 the load commands if they are not already present. */
2425 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2426 return FALSE;
2427
2428 if (count == 0)
2429 return TRUE;
2430
2431 pos = section->filepos + offset;
2432 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2433 || bfd_bwrite (location, count, abfd) != count)
2434 return FALSE;
2435
2436 return TRUE;
2437 }
2438
2439 int
2440 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2441 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2442 {
2443 return 0;
2444 }
2445
2446 /* Make an empty symbol. This is required only because
2447 bfd_make_section_anyway wants to create a symbol for the section. */
2448
2449 asymbol *
2450 bfd_mach_o_make_empty_symbol (bfd *abfd)
2451 {
2452 asymbol *new_symbol;
2453
2454 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2455 if (new_symbol == NULL)
2456 return new_symbol;
2457 new_symbol->the_bfd = abfd;
2458 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2459 return new_symbol;
2460 }
2461
2462 static bfd_boolean
2463 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2464 {
2465 struct mach_o_header_external raw;
2466 unsigned int size;
2467 bfd_vma (*get32) (const void *) = NULL;
2468
2469 /* Just read the magic number. */
2470 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2471 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2472 return FALSE;
2473
2474 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2475 {
2476 header->byteorder = BFD_ENDIAN_BIG;
2477 header->magic = BFD_MACH_O_MH_MAGIC;
2478 header->version = 1;
2479 get32 = bfd_getb32;
2480 }
2481 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2482 {
2483 header->byteorder = BFD_ENDIAN_LITTLE;
2484 header->magic = BFD_MACH_O_MH_MAGIC;
2485 header->version = 1;
2486 get32 = bfd_getl32;
2487 }
2488 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2489 {
2490 header->byteorder = BFD_ENDIAN_BIG;
2491 header->magic = BFD_MACH_O_MH_MAGIC_64;
2492 header->version = 2;
2493 get32 = bfd_getb32;
2494 }
2495 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2496 {
2497 header->byteorder = BFD_ENDIAN_LITTLE;
2498 header->magic = BFD_MACH_O_MH_MAGIC_64;
2499 header->version = 2;
2500 get32 = bfd_getl32;
2501 }
2502 else
2503 {
2504 header->byteorder = BFD_ENDIAN_UNKNOWN;
2505 return FALSE;
2506 }
2507
2508 /* Once the size of the header is known, read the full header. */
2509 size = mach_o_wide_p (header) ?
2510 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2511
2512 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2513 || bfd_bread (&raw, size, abfd) != size)
2514 return FALSE;
2515
2516 header->cputype = (*get32) (raw.cputype);
2517 header->cpusubtype = (*get32) (raw.cpusubtype);
2518 header->filetype = (*get32) (raw.filetype);
2519 header->ncmds = (*get32) (raw.ncmds);
2520 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2521 header->flags = (*get32) (raw.flags);
2522
2523 if (mach_o_wide_p (header))
2524 header->reserved = (*get32) (raw.reserved);
2525
2526 return TRUE;
2527 }
2528
2529 bfd_boolean
2530 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2531 {
2532 bfd_mach_o_section *s;
2533 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2534
2535 s = bfd_mach_o_get_mach_o_section (sec);
2536 if (s == NULL)
2537 {
2538 flagword bfd_flags;
2539 static const mach_o_section_name_xlat * xlat;
2540
2541 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2542 if (s == NULL)
2543 return FALSE;
2544 sec->used_by_bfd = s;
2545 s->bfdsection = sec;
2546
2547 /* Create the Darwin seg/sect name pair from the bfd name.
2548 If this is a canonical name for which a specific paiting exists
2549 there will also be defined flags, type, attribute and alignment
2550 values. */
2551 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2552 if (xlat != NULL)
2553 {
2554 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2555 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2556 : bfdalign;
2557 bfd_set_section_alignment (abfd, sec, s->align);
2558 bfd_flags = bfd_get_section_flags (abfd, sec);
2559 if (bfd_flags == SEC_NO_FLAGS)
2560 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2561 }
2562 else
2563 /* Create default flags. */
2564 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2565 }
2566
2567 return _bfd_generic_new_section_hook (abfd, sec);
2568 }
2569
2570 static void
2571 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2572 unsigned long prot)
2573 {
2574 flagword flags;
2575 bfd_mach_o_section *section;
2576
2577 flags = bfd_get_section_flags (abfd, sec);
2578 section = bfd_mach_o_get_mach_o_section (sec);
2579
2580 /* TODO: see if we should use the xlat system for doing this by
2581 preference and fall back to this for unknown sections. */
2582
2583 if (flags == SEC_NO_FLAGS)
2584 {
2585 /* Try to guess flags. */
2586 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2587 flags = SEC_DEBUGGING;
2588 else
2589 {
2590 flags = SEC_ALLOC;
2591 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2592 != BFD_MACH_O_S_ZEROFILL)
2593 {
2594 flags |= SEC_LOAD;
2595 if (prot & BFD_MACH_O_PROT_EXECUTE)
2596 flags |= SEC_CODE;
2597 if (prot & BFD_MACH_O_PROT_WRITE)
2598 flags |= SEC_DATA;
2599 else if (prot & BFD_MACH_O_PROT_READ)
2600 flags |= SEC_READONLY;
2601 }
2602 }
2603 }
2604 else
2605 {
2606 if ((flags & SEC_DEBUGGING) == 0)
2607 flags |= SEC_ALLOC;
2608 }
2609
2610 if (section->offset != 0)
2611 flags |= SEC_HAS_CONTENTS;
2612 if (section->nreloc != 0)
2613 flags |= SEC_RELOC;
2614
2615 bfd_set_section_flags (abfd, sec, flags);
2616
2617 sec->vma = section->addr;
2618 sec->lma = section->addr;
2619 sec->size = section->size;
2620 sec->filepos = section->offset;
2621 sec->alignment_power = section->align;
2622 sec->segment_mark = 0;
2623 sec->reloc_count = section->nreloc;
2624 sec->rel_filepos = section->reloff;
2625 }
2626
2627 static asection *
2628 bfd_mach_o_make_bfd_section (bfd *abfd,
2629 const unsigned char *segname,
2630 const unsigned char *sectname)
2631 {
2632 const char *sname;
2633 flagword flags;
2634
2635 bfd_mach_o_convert_section_name_to_bfd
2636 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2637 if (sname == NULL)
2638 return NULL;
2639
2640 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2641 }
2642
2643 static asection *
2644 bfd_mach_o_read_section_32 (bfd *abfd,
2645 unsigned int offset,
2646 unsigned long prot)
2647 {
2648 struct mach_o_section_32_external raw;
2649 asection *sec;
2650 bfd_mach_o_section *section;
2651
2652 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2653 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2654 != BFD_MACH_O_SECTION_SIZE))
2655 return NULL;
2656
2657 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2658 if (sec == NULL)
2659 return NULL;
2660
2661 section = bfd_mach_o_get_mach_o_section (sec);
2662 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2663 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2664 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2665 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2666 section->addr = bfd_h_get_32 (abfd, raw.addr);
2667 section->size = bfd_h_get_32 (abfd, raw.size);
2668 section->offset = bfd_h_get_32 (abfd, raw.offset);
2669 section->align = bfd_h_get_32 (abfd, raw.align);
2670 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2671 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2672 section->flags = bfd_h_get_32 (abfd, raw.flags);
2673 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2674 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2675 section->reserved3 = 0;
2676
2677 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2678
2679 return sec;
2680 }
2681
2682 static asection *
2683 bfd_mach_o_read_section_64 (bfd *abfd,
2684 unsigned int offset,
2685 unsigned long prot)
2686 {
2687 struct mach_o_section_64_external raw;
2688 asection *sec;
2689 bfd_mach_o_section *section;
2690
2691 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2692 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2693 != BFD_MACH_O_SECTION_64_SIZE))
2694 return NULL;
2695
2696 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2697 if (sec == NULL)
2698 return NULL;
2699
2700 section = bfd_mach_o_get_mach_o_section (sec);
2701 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2702 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2703 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2704 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2705 section->addr = bfd_h_get_64 (abfd, raw.addr);
2706 section->size = bfd_h_get_64 (abfd, raw.size);
2707 section->offset = bfd_h_get_32 (abfd, raw.offset);
2708 section->align = bfd_h_get_32 (abfd, raw.align);
2709 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2710 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2711 section->flags = bfd_h_get_32 (abfd, raw.flags);
2712 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2713 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2714 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2715
2716 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2717
2718 return sec;
2719 }
2720
2721 static asection *
2722 bfd_mach_o_read_section (bfd *abfd,
2723 unsigned int offset,
2724 unsigned long prot,
2725 unsigned int wide)
2726 {
2727 if (wide)
2728 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2729 else
2730 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2731 }
2732
2733 static bfd_boolean
2734 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2735 bfd_mach_o_symtab_command *sym,
2736 bfd_mach_o_asymbol *s,
2737 unsigned long i)
2738 {
2739 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2740 unsigned int wide = mach_o_wide_p (&mdata->header);
2741 unsigned int symwidth =
2742 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2743 unsigned int symoff = sym->symoff + (i * symwidth);
2744 struct mach_o_nlist_64_external raw;
2745 unsigned char type = -1;
2746 unsigned char section = -1;
2747 short desc = -1;
2748 symvalue value = -1;
2749 unsigned long stroff = -1;
2750 unsigned int symtype = -1;
2751
2752 BFD_ASSERT (sym->strtab != NULL);
2753
2754 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2755 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2756 {
2757 (*_bfd_error_handler)
2758 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2759 symwidth, (unsigned long) symoff);
2760 return FALSE;
2761 }
2762
2763 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2764 type = bfd_h_get_8 (abfd, raw.n_type);
2765 symtype = type & BFD_MACH_O_N_TYPE;
2766 section = bfd_h_get_8 (abfd, raw.n_sect);
2767 desc = bfd_h_get_16 (abfd, raw.n_desc);
2768 if (wide)
2769 value = bfd_h_get_64 (abfd, raw.n_value);
2770 else
2771 value = bfd_h_get_32 (abfd, raw.n_value);
2772
2773 if (stroff >= sym->strsize)
2774 {
2775 (*_bfd_error_handler)
2776 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2777 (unsigned long) stroff,
2778 (unsigned long) sym->strsize);
2779 return FALSE;
2780 }
2781
2782 s->symbol.the_bfd = abfd;
2783 s->symbol.name = sym->strtab + stroff;
2784 s->symbol.value = value;
2785 s->symbol.flags = 0x0;
2786 s->symbol.udata.i = i;
2787 s->n_type = type;
2788 s->n_sect = section;
2789 s->n_desc = desc;
2790
2791 if (type & BFD_MACH_O_N_STAB)
2792 {
2793 s->symbol.flags |= BSF_DEBUGGING;
2794 s->symbol.section = bfd_und_section_ptr;
2795 switch (type)
2796 {
2797 case N_FUN:
2798 case N_STSYM:
2799 case N_LCSYM:
2800 case N_BNSYM:
2801 case N_SLINE:
2802 case N_ENSYM:
2803 case N_ECOMM:
2804 case N_ECOML:
2805 case N_GSYM:
2806 if ((section > 0) && (section <= mdata->nsects))
2807 {
2808 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2809 s->symbol.value =
2810 s->symbol.value - mdata->sections[section - 1]->addr;
2811 }
2812 break;
2813 }
2814 }
2815 else
2816 {
2817 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2818 s->symbol.flags |= BSF_GLOBAL;
2819 else
2820 s->symbol.flags |= BSF_LOCAL;
2821
2822 switch (symtype)
2823 {
2824 case BFD_MACH_O_N_UNDF:
2825 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2826 && s->symbol.value != 0)
2827 {
2828 /* A common symbol. */
2829 s->symbol.section = bfd_com_section_ptr;
2830 s->symbol.flags = BSF_NO_FLAGS;
2831 }
2832 else
2833 {
2834 s->symbol.section = bfd_und_section_ptr;
2835 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2836 s->symbol.flags |= BSF_WEAK;
2837 }
2838 break;
2839 case BFD_MACH_O_N_PBUD:
2840 s->symbol.section = bfd_und_section_ptr;
2841 break;
2842 case BFD_MACH_O_N_ABS:
2843 s->symbol.section = bfd_abs_section_ptr;
2844 break;
2845 case BFD_MACH_O_N_SECT:
2846 if ((section > 0) && (section <= mdata->nsects))
2847 {
2848 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2849 s->symbol.value =
2850 s->symbol.value - mdata->sections[section - 1]->addr;
2851 }
2852 else
2853 {
2854 /* Mach-O uses 0 to mean "no section"; not an error. */
2855 if (section != 0)
2856 {
2857 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2858 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2859 s->symbol.name, section, mdata->nsects);
2860 }
2861 s->symbol.section = bfd_und_section_ptr;
2862 }
2863 break;
2864 case BFD_MACH_O_N_INDR:
2865 /* FIXME: we don't follow the BFD convention as this indirect symbol
2866 won't be followed by the referenced one. This looks harmless
2867 unless we start using the linker. */
2868 s->symbol.flags |= BSF_INDIRECT;
2869 s->symbol.section = bfd_ind_section_ptr;
2870 s->symbol.value = 0;
2871 break;
2872 default:
2873 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2874 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2875 s->symbol.name, symtype);
2876 s->symbol.section = bfd_und_section_ptr;
2877 break;
2878 }
2879 }
2880
2881 return TRUE;
2882 }
2883
2884 bfd_boolean
2885 bfd_mach_o_read_symtab_strtab (bfd *abfd)
2886 {
2887 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2888 bfd_mach_o_symtab_command *sym = mdata->symtab;
2889
2890 /* Fail if there is no symtab. */
2891 if (sym == NULL)
2892 return FALSE;
2893
2894 /* Success if already loaded. */
2895 if (sym->strtab)
2896 return TRUE;
2897
2898 if (abfd->flags & BFD_IN_MEMORY)
2899 {
2900 struct bfd_in_memory *b;
2901
2902 b = (struct bfd_in_memory *) abfd->iostream;
2903
2904 if ((sym->stroff + sym->strsize) > b->size)
2905 {
2906 bfd_set_error (bfd_error_file_truncated);
2907 return FALSE;
2908 }
2909 sym->strtab = (char *) b->buffer + sym->stroff;
2910 }
2911 else
2912 {
2913 sym->strtab = bfd_alloc (abfd, sym->strsize);
2914 if (sym->strtab == NULL)
2915 return FALSE;
2916
2917 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
2918 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
2919 {
2920 bfd_set_error (bfd_error_file_truncated);
2921 return FALSE;
2922 }
2923 }
2924
2925 return TRUE;
2926 }
2927
2928 bfd_boolean
2929 bfd_mach_o_read_symtab_symbols (bfd *abfd)
2930 {
2931 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2932 bfd_mach_o_symtab_command *sym = mdata->symtab;
2933 unsigned long i;
2934
2935 if (sym == NULL || sym->symbols)
2936 {
2937 /* Return now if there are no symbols or if already loaded. */
2938 return TRUE;
2939 }
2940
2941 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
2942
2943 if (sym->symbols == NULL)
2944 {
2945 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
2946 return FALSE;
2947 }
2948
2949 if (!bfd_mach_o_read_symtab_strtab (abfd))
2950 return FALSE;
2951
2952 for (i = 0; i < sym->nsyms; i++)
2953 {
2954 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
2955 return FALSE;
2956 }
2957
2958 return TRUE;
2959 }
2960
2961 static const char *
2962 bfd_mach_o_i386_flavour_string (unsigned int flavour)
2963 {
2964 switch ((int) flavour)
2965 {
2966 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
2967 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
2968 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
2969 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
2970 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
2971 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
2972 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
2973 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
2974 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
2975 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
2976 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
2977 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
2978 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
2979 default: return "UNKNOWN";
2980 }
2981 }
2982
2983 static const char *
2984 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
2985 {
2986 switch ((int) flavour)
2987 {
2988 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
2989 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
2990 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
2991 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
2992 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
2993 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
2994 default: return "UNKNOWN";
2995 }
2996 }
2997
2998 static int
2999 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3000 {
3001 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3002 struct mach_o_str_command_external raw;
3003 unsigned int nameoff;
3004
3005 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
3006 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
3007
3008 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3009 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3010 return -1;
3011
3012 nameoff = bfd_h_get_32 (abfd, raw.str);
3013
3014 cmd->name_offset = command->offset + nameoff;
3015 cmd->name_len = command->len - nameoff;
3016 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3017 if (cmd->name_str == NULL)
3018 return -1;
3019 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3020 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3021 return -1;
3022 return 0;
3023 }
3024
3025 static int
3026 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3027 {
3028 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3029 struct mach_o_dylib_command_external raw;
3030 unsigned int nameoff;
3031
3032 switch (command->type)
3033 {
3034 case BFD_MACH_O_LC_LOAD_DYLIB:
3035 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3036 case BFD_MACH_O_LC_ID_DYLIB:
3037 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3038 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3039 break;
3040 default:
3041 BFD_FAIL ();
3042 return -1;
3043 }
3044
3045 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3046 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3047 return -1;
3048
3049 nameoff = bfd_h_get_32 (abfd, raw.name);
3050 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3051 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3052 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3053
3054 cmd->name_offset = command->offset + nameoff;
3055 cmd->name_len = command->len - nameoff;
3056 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3057 if (cmd->name_str == NULL)
3058 return -1;
3059 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3060 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3061 return -1;
3062 return 0;
3063 }
3064
3065 static int
3066 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
3067 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3068 {
3069 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3070
3071 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3072 return 0;
3073 }
3074
3075 static int
3076 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3077 {
3078 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3079 struct mach_o_fvmlib_command_external raw;
3080 unsigned int nameoff;
3081
3082 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3083 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3084 return -1;
3085
3086 nameoff = bfd_h_get_32 (abfd, raw.name);
3087 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3088 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3089
3090 fvm->name_offset = command->offset + nameoff;
3091 fvm->name_len = command->len - nameoff;
3092 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3093 if (fvm->name_str == NULL)
3094 return -1;
3095 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3096 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3097 return -1;
3098 return 0;
3099 }
3100
3101 static int
3102 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3103 {
3104 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3105 bfd_mach_o_thread_command *cmd = &command->command.thread;
3106 unsigned int offset;
3107 unsigned int nflavours;
3108 unsigned int i;
3109
3110 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3111 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3112
3113 /* Count the number of threads. */
3114 offset = 8;
3115 nflavours = 0;
3116 while (offset != command->len)
3117 {
3118 struct mach_o_thread_command_external raw;
3119
3120 if (offset >= command->len)
3121 return -1;
3122
3123 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3124 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3125 return -1;
3126
3127 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3128 nflavours++;
3129 }
3130
3131 /* Allocate threads. */
3132 cmd->flavours = bfd_alloc
3133 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3134 if (cmd->flavours == NULL)
3135 return -1;
3136 cmd->nflavours = nflavours;
3137
3138 offset = 8;
3139 nflavours = 0;
3140 while (offset != command->len)
3141 {
3142 struct mach_o_thread_command_external raw;
3143
3144 if (offset >= command->len)
3145 return -1;
3146
3147 if (nflavours >= cmd->nflavours)
3148 return -1;
3149
3150 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3151 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3152 return -1;
3153
3154 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3155 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3156 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3157 offset += cmd->flavours[nflavours].size + sizeof (raw);
3158 nflavours++;
3159 }
3160
3161 for (i = 0; i < nflavours; i++)
3162 {
3163 asection *bfdsec;
3164 unsigned int snamelen;
3165 char *sname;
3166 const char *flavourstr;
3167 const char *prefix = "LC_THREAD";
3168 unsigned int j = 0;
3169
3170 switch (mdata->header.cputype)
3171 {
3172 case BFD_MACH_O_CPU_TYPE_POWERPC:
3173 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3174 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3175 break;
3176 case BFD_MACH_O_CPU_TYPE_I386:
3177 case BFD_MACH_O_CPU_TYPE_X86_64:
3178 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3179 break;
3180 default:
3181 flavourstr = "UNKNOWN_ARCHITECTURE";
3182 break;
3183 }
3184
3185 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3186 sname = bfd_alloc (abfd, snamelen);
3187 if (sname == NULL)
3188 return -1;
3189
3190 for (;;)
3191 {
3192 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3193 if (bfd_get_section_by_name (abfd, sname) == NULL)
3194 break;
3195 j++;
3196 }
3197
3198 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3199
3200 bfdsec->vma = 0;
3201 bfdsec->lma = 0;
3202 bfdsec->size = cmd->flavours[i].size;
3203 bfdsec->filepos = cmd->flavours[i].offset;
3204 bfdsec->alignment_power = 0x0;
3205
3206 cmd->section = bfdsec;
3207 }
3208
3209 return 0;
3210 }
3211
3212 static int
3213 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3214 {
3215 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3216 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3217
3218 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3219
3220 {
3221 struct mach_o_dysymtab_command_external raw;
3222
3223 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3224 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3225 return -1;
3226
3227 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3228 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3229 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3230 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3231 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3232 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3233 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3234 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3235 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3236 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3237 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3238 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3239 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3240 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3241 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3242 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3243 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3244 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3245 }
3246
3247 if (cmd->nmodtab != 0)
3248 {
3249 unsigned int i;
3250 int wide = bfd_mach_o_wide_p (abfd);
3251 unsigned int module_len = wide ? 56 : 52;
3252
3253 cmd->dylib_module =
3254 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3255 if (cmd->dylib_module == NULL)
3256 return -1;
3257
3258 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3259 return -1;
3260
3261 for (i = 0; i < cmd->nmodtab; i++)
3262 {
3263 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3264 unsigned long v;
3265 unsigned char buf[56];
3266
3267 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3268 return -1;
3269
3270 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3271 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3272 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3273 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3274 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3275 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3276 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3277 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3278 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3279 v = bfd_h_get_32 (abfd, buf +36);
3280 module->iinit = v & 0xffff;
3281 module->iterm = (v >> 16) & 0xffff;
3282 v = bfd_h_get_32 (abfd, buf + 40);
3283 module->ninit = v & 0xffff;
3284 module->nterm = (v >> 16) & 0xffff;
3285 if (wide)
3286 {
3287 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3288 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3289 }
3290 else
3291 {
3292 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3293 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3294 }
3295 }
3296 }
3297
3298 if (cmd->ntoc != 0)
3299 {
3300 unsigned int i;
3301
3302 cmd->dylib_toc = bfd_alloc
3303 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3304 if (cmd->dylib_toc == NULL)
3305 return -1;
3306
3307 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3308 return -1;
3309
3310 for (i = 0; i < cmd->ntoc; i++)
3311 {
3312 struct mach_o_dylib_table_of_contents_external raw;
3313 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3314
3315 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3316 return -1;
3317
3318 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3319 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3320 }
3321 }
3322
3323 if (cmd->nindirectsyms != 0)
3324 {
3325 unsigned int i;
3326
3327 cmd->indirect_syms = bfd_alloc
3328 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3329 if (cmd->indirect_syms == NULL)
3330 return -1;
3331
3332 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3333 return -1;
3334
3335 for (i = 0; i < cmd->nindirectsyms; i++)
3336 {
3337 unsigned char raw[4];
3338 unsigned int *is = &cmd->indirect_syms[i];
3339
3340 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3341 return -1;
3342
3343 *is = bfd_h_get_32 (abfd, raw);
3344 }
3345 }
3346
3347 if (cmd->nextrefsyms != 0)
3348 {
3349 unsigned long v;
3350 unsigned int i;
3351
3352 cmd->ext_refs = bfd_alloc
3353 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3354 if (cmd->ext_refs == NULL)
3355 return -1;
3356
3357 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3358 return -1;
3359
3360 for (i = 0; i < cmd->nextrefsyms; i++)
3361 {
3362 unsigned char raw[4];
3363 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3364
3365 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3366 return -1;
3367
3368 /* Fields isym and flags are written as bit-fields, thus we need
3369 a specific processing for endianness. */
3370 v = bfd_h_get_32 (abfd, raw);
3371 if (bfd_big_endian (abfd))
3372 {
3373 ref->isym = (v >> 8) & 0xffffff;
3374 ref->flags = v & 0xff;
3375 }
3376 else
3377 {
3378 ref->isym = v & 0xffffff;
3379 ref->flags = (v >> 24) & 0xff;
3380 }
3381 }
3382 }
3383
3384 if (mdata->dysymtab)
3385 return -1;
3386 mdata->dysymtab = cmd;
3387
3388 return 0;
3389 }
3390
3391 static int
3392 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3393 {
3394 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3395 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3396 struct mach_o_symtab_command_external raw;
3397
3398 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3399
3400 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3401 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3402 return -1;
3403
3404 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3405 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3406 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3407 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3408 symtab->symbols = NULL;
3409 symtab->strtab = NULL;
3410
3411 if (symtab->nsyms != 0)
3412 abfd->flags |= HAS_SYMS;
3413
3414 if (mdata->symtab)
3415 return -1;
3416 mdata->symtab = symtab;
3417 return 0;
3418 }
3419
3420 static int
3421 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3422 {
3423 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3424
3425 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3426
3427 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3428 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3429 return -1;
3430
3431 return 0;
3432 }
3433
3434 static int
3435 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3436 {
3437 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3438 struct mach_o_linkedit_data_command_external raw;
3439
3440 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3441 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3442 return -1;
3443
3444 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3445 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3446 return 0;
3447 }
3448
3449 static int
3450 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3451 {
3452 bfd_mach_o_str_command *cmd = &command->command.str;
3453 struct mach_o_str_command_external raw;
3454 unsigned long off;
3455
3456 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3457 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3458 return -1;
3459
3460 off = bfd_get_32 (abfd, raw.str);
3461 cmd->stroff = command->offset + off;
3462 cmd->str_len = command->len - off;
3463 cmd->str = bfd_alloc (abfd, cmd->str_len);
3464 if (cmd->str == NULL)
3465 return -1;
3466 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3467 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3468 return -1;
3469 return 0;
3470 }
3471
3472 static int
3473 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3474 {
3475 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3476 struct mach_o_dyld_info_command_external raw;
3477
3478 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3479 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3480 return -1;
3481
3482 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3483 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3484 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3485 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3486 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3487 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3488 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3489 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3490 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3491 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3492 return 0;
3493 }
3494
3495 static bfd_boolean
3496 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3497 {
3498 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3499 struct mach_o_version_min_command_external raw;
3500 unsigned int ver;
3501
3502 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3503 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3504 return FALSE;
3505
3506 ver = bfd_get_32 (abfd, raw.version);
3507 cmd->rel = ver >> 16;
3508 cmd->maj = ver >> 8;
3509 cmd->min = ver;
3510 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3511 return TRUE;
3512 }
3513
3514 static bfd_boolean
3515 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3516 {
3517 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3518 struct mach_o_encryption_info_command_external raw;
3519
3520 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3521 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3522 return FALSE;
3523
3524 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3525 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3526 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3527 return TRUE;
3528 }
3529
3530 static int
3531 bfd_mach_o_read_segment (bfd *abfd,
3532 bfd_mach_o_load_command *command,
3533 unsigned int wide)
3534 {
3535 bfd_mach_o_segment_command *seg = &command->command.segment;
3536 unsigned long i;
3537
3538 if (wide)
3539 {
3540 struct mach_o_segment_command_64_external raw;
3541
3542 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3543
3544 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3545 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3546 return -1;
3547
3548 memcpy (seg->segname, raw.segname, 16);
3549 seg->segname[16] = '\0';
3550
3551 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3552 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3553 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3554 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3555 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3556 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3557 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3558 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3559 }
3560 else
3561 {
3562 struct mach_o_segment_command_32_external raw;
3563
3564 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3565
3566 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3567 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3568 return -1;
3569
3570 memcpy (seg->segname, raw.segname, 16);
3571 seg->segname[16] = '\0';
3572
3573 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3574 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3575 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3576 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3577 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3578 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3579 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3580 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3581 }
3582 seg->sect_head = NULL;
3583 seg->sect_tail = NULL;
3584
3585 for (i = 0; i < seg->nsects; i++)
3586 {
3587 bfd_vma segoff;
3588 asection *sec;
3589
3590 if (wide)
3591 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3592 + (i * BFD_MACH_O_SECTION_64_SIZE);
3593 else
3594 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3595 + (i * BFD_MACH_O_SECTION_SIZE);
3596
3597 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3598 if (sec == NULL)
3599 return -1;
3600
3601 bfd_mach_o_append_section_to_segment (seg, sec);
3602 }
3603
3604 return 0;
3605 }
3606
3607 static int
3608 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3609 {
3610 return bfd_mach_o_read_segment (abfd, command, 0);
3611 }
3612
3613 static int
3614 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3615 {
3616 return bfd_mach_o_read_segment (abfd, command, 1);
3617 }
3618
3619 static int
3620 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3621 {
3622 struct mach_o_load_command_external raw;
3623 unsigned int cmd;
3624
3625 /* Read command type and length. */
3626 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3627 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3628 return -1;
3629
3630 cmd = bfd_h_get_32 (abfd, raw.cmd);
3631 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3632 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3633 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3634
3635 switch (command->type)
3636 {
3637 case BFD_MACH_O_LC_SEGMENT:
3638 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3639 return -1;
3640 break;
3641 case BFD_MACH_O_LC_SEGMENT_64:
3642 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3643 return -1;
3644 break;
3645 case BFD_MACH_O_LC_SYMTAB:
3646 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3647 return -1;
3648 break;
3649 case BFD_MACH_O_LC_SYMSEG:
3650 break;
3651 case BFD_MACH_O_LC_THREAD:
3652 case BFD_MACH_O_LC_UNIXTHREAD:
3653 if (bfd_mach_o_read_thread (abfd, command) != 0)
3654 return -1;
3655 break;
3656 case BFD_MACH_O_LC_LOAD_DYLINKER:
3657 case BFD_MACH_O_LC_ID_DYLINKER:
3658 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3659 return -1;
3660 break;
3661 case BFD_MACH_O_LC_LOAD_DYLIB:
3662 case BFD_MACH_O_LC_ID_DYLIB:
3663 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3664 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3665 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3666 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3667 return -1;
3668 break;
3669 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3670 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3671 return -1;
3672 break;
3673 case BFD_MACH_O_LC_LOADFVMLIB:
3674 case BFD_MACH_O_LC_IDFVMLIB:
3675 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3676 return -1;
3677 break;
3678 case BFD_MACH_O_LC_IDENT:
3679 case BFD_MACH_O_LC_FVMFILE:
3680 case BFD_MACH_O_LC_PREPAGE:
3681 case BFD_MACH_O_LC_ROUTINES:
3682 case BFD_MACH_O_LC_ROUTINES_64:
3683 break;
3684 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3685 case BFD_MACH_O_LC_SUB_UMBRELLA:
3686 case BFD_MACH_O_LC_SUB_LIBRARY:
3687 case BFD_MACH_O_LC_SUB_CLIENT:
3688 case BFD_MACH_O_LC_RPATH:
3689 if (bfd_mach_o_read_str (abfd, command) != 0)
3690 return -1;
3691 break;
3692 case BFD_MACH_O_LC_DYSYMTAB:
3693 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3694 return -1;
3695 break;
3696 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3697 case BFD_MACH_O_LC_PREBIND_CKSUM:
3698 break;
3699 case BFD_MACH_O_LC_UUID:
3700 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3701 return -1;
3702 break;
3703 case BFD_MACH_O_LC_CODE_SIGNATURE:
3704 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3705 case BFD_MACH_O_LC_FUNCTION_STARTS:
3706 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3707 return -1;
3708 break;
3709 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3710 if (!bfd_mach_o_read_encryption_info (abfd, command))
3711 return -1;
3712 break;
3713 case BFD_MACH_O_LC_DYLD_INFO:
3714 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3715 return -1;
3716 break;
3717 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3718 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3719 if (!bfd_mach_o_read_version_min (abfd, command))
3720 return -1;
3721 break;
3722 default:
3723 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3724 abfd, (unsigned long) command->type);
3725 break;
3726 }
3727
3728 return 0;
3729 }
3730
3731 static void
3732 bfd_mach_o_flatten_sections (bfd *abfd)
3733 {
3734 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3735 long csect = 0;
3736 unsigned long i;
3737
3738 /* Count total number of sections. */
3739 mdata->nsects = 0;
3740
3741 for (i = 0; i < mdata->header.ncmds; i++)
3742 {
3743 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3744 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3745 {
3746 bfd_mach_o_segment_command *seg;
3747
3748 seg = &mdata->commands[i].command.segment;
3749 mdata->nsects += seg->nsects;
3750 }
3751 }
3752
3753 /* Allocate sections array. */
3754 mdata->sections = bfd_alloc (abfd,
3755 mdata->nsects * sizeof (bfd_mach_o_section *));
3756
3757 /* Fill the array. */
3758 csect = 0;
3759
3760 for (i = 0; i < mdata->header.ncmds; i++)
3761 {
3762 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3763 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3764 {
3765 bfd_mach_o_segment_command *seg;
3766 bfd_mach_o_section *sec;
3767
3768 seg = &mdata->commands[i].command.segment;
3769 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3770
3771 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3772 mdata->sections[csect++] = sec;
3773 }
3774 }
3775 }
3776
3777 static bfd_boolean
3778 bfd_mach_o_scan_start_address (bfd *abfd)
3779 {
3780 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3781 bfd_mach_o_thread_command *cmd = NULL;
3782 unsigned long i;
3783
3784 for (i = 0; i < mdata->header.ncmds; i++)
3785 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3786 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3787 {
3788 cmd = &mdata->commands[i].command.thread;
3789 break;
3790 }
3791
3792 if (cmd == NULL)
3793 return FALSE;
3794
3795 /* FIXME: create a subtarget hook ? */
3796 for (i = 0; i < cmd->nflavours; i++)
3797 {
3798 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
3799 && (cmd->flavours[i].flavour
3800 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
3801 {
3802 unsigned char buf[4];
3803
3804 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
3805 || bfd_bread (buf, 4, abfd) != 4)
3806 return FALSE;
3807
3808 abfd->start_address = bfd_h_get_32 (abfd, buf);
3809 }
3810 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
3811 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
3812 {
3813 unsigned char buf[4];
3814
3815 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3816 || bfd_bread (buf, 4, abfd) != 4)
3817 return FALSE;
3818
3819 abfd->start_address = bfd_h_get_32 (abfd, buf);
3820 }
3821 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
3822 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
3823 {
3824 unsigned char buf[8];
3825
3826 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3827 || bfd_bread (buf, 8, abfd) != 8)
3828 return FALSE;
3829
3830 abfd->start_address = bfd_h_get_64 (abfd, buf);
3831 }
3832 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
3833 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
3834 {
3835 unsigned char buf[8];
3836
3837 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
3838 || bfd_bread (buf, 8, abfd) != 8)
3839 return FALSE;
3840
3841 abfd->start_address = bfd_h_get_64 (abfd, buf);
3842 }
3843 }
3844
3845 return TRUE;
3846 }
3847
3848 bfd_boolean
3849 bfd_mach_o_set_arch_mach (bfd *abfd,
3850 enum bfd_architecture arch,
3851 unsigned long machine)
3852 {
3853 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
3854
3855 /* If this isn't the right architecture for this backend, and this
3856 isn't the generic backend, fail. */
3857 if (arch != bed->arch
3858 && arch != bfd_arch_unknown
3859 && bed->arch != bfd_arch_unknown)
3860 return FALSE;
3861
3862 return bfd_default_set_arch_mach (abfd, arch, machine);
3863 }
3864
3865 static bfd_boolean
3866 bfd_mach_o_scan (bfd *abfd,
3867 bfd_mach_o_header *header,
3868 bfd_mach_o_data_struct *mdata)
3869 {
3870 unsigned int i;
3871 enum bfd_architecture cputype;
3872 unsigned long cpusubtype;
3873 unsigned int hdrsize;
3874
3875 hdrsize = mach_o_wide_p (header) ?
3876 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3877
3878 mdata->header = *header;
3879
3880 abfd->flags = abfd->flags & BFD_IN_MEMORY;
3881 switch (header->filetype)
3882 {
3883 case BFD_MACH_O_MH_OBJECT:
3884 abfd->flags |= HAS_RELOC;
3885 break;
3886 case BFD_MACH_O_MH_EXECUTE:
3887 abfd->flags |= EXEC_P;
3888 break;
3889 case BFD_MACH_O_MH_DYLIB:
3890 case BFD_MACH_O_MH_BUNDLE:
3891 abfd->flags |= DYNAMIC;
3892 break;
3893 }
3894
3895 abfd->tdata.mach_o_data = mdata;
3896
3897 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
3898 &cputype, &cpusubtype);
3899 if (cputype == bfd_arch_unknown)
3900 {
3901 (*_bfd_error_handler)
3902 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3903 header->cputype, header->cpusubtype);
3904 return FALSE;
3905 }
3906
3907 bfd_set_arch_mach (abfd, cputype, cpusubtype);
3908
3909 if (header->ncmds != 0)
3910 {
3911 mdata->commands = bfd_alloc
3912 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
3913 if (mdata->commands == NULL)
3914 return FALSE;
3915
3916 for (i = 0; i < header->ncmds; i++)
3917 {
3918 bfd_mach_o_load_command *cur = &mdata->commands[i];
3919
3920 if (i == 0)
3921 cur->offset = hdrsize;
3922 else
3923 {
3924 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
3925 cur->offset = prev->offset + prev->len;
3926 }
3927
3928 if (bfd_mach_o_read_command (abfd, cur) < 0)
3929 return FALSE;
3930 }
3931 }
3932
3933 if (bfd_mach_o_scan_start_address (abfd) < 0)
3934 return FALSE;
3935
3936 bfd_mach_o_flatten_sections (abfd);
3937 return TRUE;
3938 }
3939
3940 bfd_boolean
3941 bfd_mach_o_mkobject_init (bfd *abfd)
3942 {
3943 bfd_mach_o_data_struct *mdata = NULL;
3944
3945 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
3946 if (mdata == NULL)
3947 return FALSE;
3948 abfd->tdata.mach_o_data = mdata;
3949
3950 mdata->header.magic = 0;
3951 mdata->header.cputype = 0;
3952 mdata->header.cpusubtype = 0;
3953 mdata->header.filetype = 0;
3954 mdata->header.ncmds = 0;
3955 mdata->header.sizeofcmds = 0;
3956 mdata->header.flags = 0;
3957 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
3958 mdata->commands = NULL;
3959 mdata->nsects = 0;
3960 mdata->sections = NULL;
3961 mdata->dyn_reloc_cache = NULL;
3962
3963 return TRUE;
3964 }
3965
3966 static bfd_boolean
3967 bfd_mach_o_gen_mkobject (bfd *abfd)
3968 {
3969 bfd_mach_o_data_struct *mdata;
3970
3971 if (!bfd_mach_o_mkobject_init (abfd))
3972 return FALSE;
3973
3974 mdata = bfd_mach_o_get_data (abfd);
3975 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
3976 mdata->header.cputype = 0;
3977 mdata->header.cpusubtype = 0;
3978 mdata->header.byteorder = abfd->xvec->byteorder;
3979 mdata->header.version = 1;
3980
3981 return TRUE;
3982 }
3983
3984 const bfd_target *
3985 bfd_mach_o_header_p (bfd *abfd,
3986 bfd_mach_o_filetype filetype,
3987 bfd_mach_o_cpu_type cputype)
3988 {
3989 struct bfd_preserve preserve;
3990 bfd_mach_o_header header;
3991
3992 preserve.marker = NULL;
3993 if (!bfd_mach_o_read_header (abfd, &header))
3994 goto wrong;
3995
3996 if (! (header.byteorder == BFD_ENDIAN_BIG
3997 || header.byteorder == BFD_ENDIAN_LITTLE))
3998 {
3999 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4000 (unsigned long) header.byteorder);
4001 goto wrong;
4002 }
4003
4004 if (! ((header.byteorder == BFD_ENDIAN_BIG
4005 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4006 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4007 || (header.byteorder == BFD_ENDIAN_LITTLE
4008 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4009 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4010 goto wrong;
4011
4012 /* Check cputype and filetype.
4013 In case of wildcard, do not accept magics that are handled by existing
4014 targets. */
4015 if (cputype)
4016 {
4017 if (header.cputype != cputype)
4018 goto wrong;
4019 }
4020
4021 if (filetype)
4022 {
4023 if (header.filetype != filetype)
4024 goto wrong;
4025 }
4026 else
4027 {
4028 switch (header.filetype)
4029 {
4030 case BFD_MACH_O_MH_CORE:
4031 /* Handled by core_p */
4032 goto wrong;
4033 default:
4034 break;
4035 }
4036 }
4037
4038 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4039 if (preserve.marker == NULL
4040 || !bfd_preserve_save (abfd, &preserve))
4041 goto fail;
4042
4043 if (!bfd_mach_o_scan (abfd, &header,
4044 (bfd_mach_o_data_struct *) preserve.marker))
4045 goto wrong;
4046
4047 bfd_preserve_finish (abfd, &preserve);
4048 return abfd->xvec;
4049
4050 wrong:
4051 bfd_set_error (bfd_error_wrong_format);
4052
4053 fail:
4054 if (preserve.marker != NULL)
4055 bfd_preserve_restore (abfd, &preserve);
4056 return NULL;
4057 }
4058
4059 static const bfd_target *
4060 bfd_mach_o_gen_object_p (bfd *abfd)
4061 {
4062 return bfd_mach_o_header_p (abfd, 0, 0);
4063 }
4064
4065 static const bfd_target *
4066 bfd_mach_o_gen_core_p (bfd *abfd)
4067 {
4068 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4069 }
4070
4071 typedef struct mach_o_fat_archentry
4072 {
4073 unsigned long cputype;
4074 unsigned long cpusubtype;
4075 unsigned long offset;
4076 unsigned long size;
4077 unsigned long align;
4078 } mach_o_fat_archentry;
4079
4080 typedef struct mach_o_fat_data_struct
4081 {
4082 unsigned long magic;
4083 unsigned long nfat_arch;
4084 mach_o_fat_archentry *archentries;
4085 } mach_o_fat_data_struct;
4086
4087 const bfd_target *
4088 bfd_mach_o_archive_p (bfd *abfd)
4089 {
4090 mach_o_fat_data_struct *adata = NULL;
4091 struct mach_o_fat_header_external hdr;
4092 unsigned long i;
4093
4094 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4095 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4096 goto error;
4097
4098 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4099 if (adata == NULL)
4100 goto error;
4101
4102 adata->magic = bfd_getb32 (hdr.magic);
4103 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4104 if (adata->magic != 0xcafebabe)
4105 goto error;
4106 /* Avoid matching Java bytecode files, which have the same magic number.
4107 In the Java bytecode file format this field contains the JVM version,
4108 which starts at 43.0. */
4109 if (adata->nfat_arch > 30)
4110 goto error;
4111
4112 adata->archentries =
4113 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4114 if (adata->archentries == NULL)
4115 goto error;
4116
4117 for (i = 0; i < adata->nfat_arch; i++)
4118 {
4119 struct mach_o_fat_arch_external arch;
4120 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4121 goto error;
4122 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4123 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4124 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4125 adata->archentries[i].size = bfd_getb32 (arch.size);
4126 adata->archentries[i].align = bfd_getb32 (arch.align);
4127 }
4128
4129 abfd->tdata.mach_o_fat_data = adata;
4130 return abfd->xvec;
4131
4132 error:
4133 if (adata != NULL)
4134 bfd_release (abfd, adata);
4135 bfd_set_error (bfd_error_wrong_format);
4136 return NULL;
4137 }
4138
4139 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4140 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4141 Set arelt_data and origin fields too. */
4142
4143 static void
4144 bfd_mach_o_fat_member_init (bfd *abfd,
4145 enum bfd_architecture arch_type,
4146 unsigned long arch_subtype,
4147 mach_o_fat_archentry *entry)
4148 {
4149 struct areltdata *areltdata;
4150 /* Create the member filename. Use ARCH_NAME. */
4151 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4152
4153 if (ap)
4154 {
4155 /* Use the architecture name if known. */
4156 abfd->filename = ap->printable_name;
4157 }
4158 else
4159 {
4160 /* Forge a uniq id. */
4161 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4162 char *name = bfd_alloc (abfd, namelen);
4163 snprintf (name, namelen, "0x%lx-0x%lx",
4164 entry->cputype, entry->cpusubtype);
4165 abfd->filename = name;
4166 }
4167
4168 areltdata = bfd_zalloc (abfd, sizeof (struct areltdata));
4169 areltdata->parsed_size = entry->size;
4170 abfd->arelt_data = areltdata;
4171 abfd->iostream = NULL;
4172 abfd->origin = entry->offset;
4173 }
4174
4175 bfd *
4176 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4177 {
4178 mach_o_fat_data_struct *adata;
4179 mach_o_fat_archentry *entry = NULL;
4180 unsigned long i;
4181 bfd *nbfd;
4182 enum bfd_architecture arch_type;
4183 unsigned long arch_subtype;
4184
4185 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4186 BFD_ASSERT (adata != NULL);
4187
4188 /* Find index of previous entry. */
4189 if (prev == NULL)
4190 {
4191 /* Start at first one. */
4192 i = 0;
4193 }
4194 else
4195 {
4196 /* Find index of PREV. */
4197 for (i = 0; i < adata->nfat_arch; i++)
4198 {
4199 if (adata->archentries[i].offset == prev->origin)
4200 break;
4201 }
4202
4203 if (i == adata->nfat_arch)
4204 {
4205 /* Not found. */
4206 bfd_set_error (bfd_error_bad_value);
4207 return NULL;
4208 }
4209
4210 /* Get next entry. */
4211 i++;
4212 }
4213
4214 if (i >= adata->nfat_arch)
4215 {
4216 bfd_set_error (bfd_error_no_more_archived_files);
4217 return NULL;
4218 }
4219
4220 entry = &adata->archentries[i];
4221 nbfd = _bfd_new_bfd_contained_in (archive);
4222 if (nbfd == NULL)
4223 return NULL;
4224
4225 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4226 &arch_type, &arch_subtype);
4227
4228 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4229
4230 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4231
4232 return nbfd;
4233 }
4234
4235 /* Analogous to stat call. */
4236
4237 static int
4238 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4239 {
4240 if (abfd->arelt_data == NULL)
4241 {
4242 bfd_set_error (bfd_error_invalid_operation);
4243 return -1;
4244 }
4245
4246 buf->st_mtime = 0;
4247 buf->st_uid = 0;
4248 buf->st_gid = 0;
4249 buf->st_mode = 0644;
4250 buf->st_size = arelt_size (abfd);
4251
4252 return 0;
4253 }
4254
4255 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4256 If ABFD is a fat image containing a member that corresponds to FORMAT
4257 and ARCH, returns it.
4258 In other case, returns NULL.
4259 This function allows transparent uses of fat images. */
4260
4261 bfd *
4262 bfd_mach_o_fat_extract (bfd *abfd,
4263 bfd_format format,
4264 const bfd_arch_info_type *arch)
4265 {
4266 bfd *res;
4267 mach_o_fat_data_struct *adata;
4268 unsigned int i;
4269
4270 if (bfd_check_format (abfd, format))
4271 {
4272 if (bfd_get_arch_info (abfd) == arch)
4273 return abfd;
4274 return NULL;
4275 }
4276 if (!bfd_check_format (abfd, bfd_archive)
4277 || abfd->xvec != &mach_o_fat_vec)
4278 return NULL;
4279
4280 /* This is a Mach-O fat image. */
4281 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4282 BFD_ASSERT (adata != NULL);
4283
4284 for (i = 0; i < adata->nfat_arch; i++)
4285 {
4286 struct mach_o_fat_archentry *e = &adata->archentries[i];
4287 enum bfd_architecture cpu_type;
4288 unsigned long cpu_subtype;
4289
4290 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4291 &cpu_type, &cpu_subtype);
4292 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4293 continue;
4294
4295 /* The architecture is found. */
4296 res = _bfd_new_bfd_contained_in (abfd);
4297 if (res == NULL)
4298 return NULL;
4299
4300 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4301
4302 if (bfd_check_format (res, format))
4303 {
4304 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4305 return res;
4306 }
4307 bfd_close (res);
4308 return NULL;
4309 }
4310
4311 return NULL;
4312 }
4313
4314 int
4315 bfd_mach_o_lookup_command (bfd *abfd,
4316 bfd_mach_o_load_command_type type,
4317 bfd_mach_o_load_command **mcommand)
4318 {
4319 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4320 bfd_mach_o_load_command *ncmd = NULL;
4321 unsigned int i, num;
4322
4323 BFD_ASSERT (md != NULL);
4324 BFD_ASSERT (mcommand != NULL);
4325
4326 num = 0;
4327 for (i = 0; i < md->header.ncmds; i++)
4328 {
4329 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4330
4331 if (cmd->type != type)
4332 continue;
4333
4334 if (num == 0)
4335 ncmd = cmd;
4336 num++;
4337 }
4338
4339 *mcommand = ncmd;
4340 return num;
4341 }
4342
4343 unsigned long
4344 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4345 {
4346 switch (type)
4347 {
4348 case BFD_MACH_O_CPU_TYPE_MC680x0:
4349 return 0x04000000;
4350 case BFD_MACH_O_CPU_TYPE_MC88000:
4351 return 0xffffe000;
4352 case BFD_MACH_O_CPU_TYPE_POWERPC:
4353 return 0xc0000000;
4354 case BFD_MACH_O_CPU_TYPE_I386:
4355 return 0xc0000000;
4356 case BFD_MACH_O_CPU_TYPE_SPARC:
4357 return 0xf0000000;
4358 case BFD_MACH_O_CPU_TYPE_I860:
4359 return 0;
4360 case BFD_MACH_O_CPU_TYPE_HPPA:
4361 return 0xc0000000 - 0x04000000;
4362 default:
4363 return 0;
4364 }
4365 }
4366
4367 /* The following two tables should be kept, as far as possible, in order of
4368 most frequently used entries to optimize their use from gas. */
4369
4370 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4371 {
4372 { "regular", BFD_MACH_O_S_REGULAR},
4373 { "coalesced", BFD_MACH_O_S_COALESCED},
4374 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4375 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4376 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4377 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4378 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4379 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4380 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4381 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4382 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4383 { "interposing", BFD_MACH_O_S_INTERPOSING},
4384 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4385 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4386 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4387 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4388 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4389 { NULL, 0}
4390 };
4391
4392 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4393 {
4394 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4395 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4396 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4397 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4398 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4399 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4400 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4401 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4402 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4403 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4404 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4405 { NULL, 0}
4406 };
4407
4408 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4409
4410 unsigned int
4411 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4412 {
4413 const bfd_mach_o_xlat_name *x;
4414 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4415
4416 for (x = bfd_mach_o_section_type_name; x->name; x++)
4417 if (strcmp (x->name, name) == 0)
4418 {
4419 /* We found it... does the target support it? */
4420 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4421 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4422 return x->val; /* OK. */
4423 else
4424 break; /* Not supported. */
4425 }
4426 /* Maximum section ID = 0xff. */
4427 return 256;
4428 }
4429
4430 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4431
4432 unsigned int
4433 bfd_mach_o_get_section_attribute_from_name (const char *name)
4434 {
4435 const bfd_mach_o_xlat_name *x;
4436
4437 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4438 if (strcmp (x->name, name) == 0)
4439 return x->val;
4440 return (unsigned int)-1;
4441 }
4442
4443 int
4444 bfd_mach_o_core_fetch_environment (bfd *abfd,
4445 unsigned char **rbuf,
4446 unsigned int *rlen)
4447 {
4448 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4449 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4450 unsigned int i = 0;
4451
4452 for (i = 0; i < mdata->header.ncmds; i++)
4453 {
4454 bfd_mach_o_load_command *cur = &mdata->commands[i];
4455 bfd_mach_o_segment_command *seg = NULL;
4456
4457 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4458 continue;
4459
4460 seg = &cur->command.segment;
4461
4462 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4463 {
4464 unsigned long start = seg->fileoff;
4465 unsigned long end = seg->fileoff + seg->filesize;
4466 unsigned char *buf = bfd_malloc (1024);
4467 unsigned long size = 1024;
4468
4469 for (;;)
4470 {
4471 bfd_size_type nread = 0;
4472 unsigned long offset;
4473 int found_nonnull = 0;
4474
4475 if (size > (end - start))
4476 size = (end - start);
4477
4478 buf = bfd_realloc_or_free (buf, size);
4479 if (buf == NULL)
4480 return -1;
4481
4482 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4483 {
4484 free (buf);
4485 return -1;
4486 }
4487
4488 nread = bfd_bread (buf, size, abfd);
4489
4490 if (nread != size)
4491 {
4492 free (buf);
4493 return -1;
4494 }
4495
4496 for (offset = 4; offset <= size; offset += 4)
4497 {
4498 unsigned long val;
4499
4500 val = *((unsigned long *) (buf + size - offset));
4501 if (! found_nonnull)
4502 {
4503 if (val != 0)
4504 found_nonnull = 1;
4505 }
4506 else if (val == 0x0)
4507 {
4508 unsigned long bottom;
4509 unsigned long top;
4510
4511 bottom = seg->fileoff + seg->filesize - offset;
4512 top = seg->fileoff + seg->filesize - 4;
4513 *rbuf = bfd_malloc (top - bottom);
4514 *rlen = top - bottom;
4515
4516 memcpy (*rbuf, buf + size - *rlen, *rlen);
4517 free (buf);
4518 return 0;
4519 }
4520 }
4521
4522 if (size == (end - start))
4523 break;
4524
4525 size *= 2;
4526 }
4527
4528 free (buf);
4529 }
4530 }
4531
4532 return -1;
4533 }
4534
4535 char *
4536 bfd_mach_o_core_file_failing_command (bfd *abfd)
4537 {
4538 unsigned char *buf = NULL;
4539 unsigned int len = 0;
4540 int ret = -1;
4541
4542 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4543 if (ret < 0)
4544 return NULL;
4545
4546 return (char *) buf;
4547 }
4548
4549 int
4550 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4551 {
4552 return 0;
4553 }
4554
4555 static bfd_mach_o_uuid_command *
4556 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4557 {
4558 bfd_mach_o_load_command *uuid_cmd;
4559 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4560 if (ncmd != 1)
4561 return FALSE;
4562 return &uuid_cmd->command.uuid;
4563 }
4564
4565 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4566
4567 static bfd_boolean
4568 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4569 {
4570 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4571
4572 BFD_ASSERT (abfd);
4573 BFD_ASSERT (uuid_cmd);
4574
4575 if (!bfd_check_format (abfd, bfd_object))
4576 return FALSE;
4577
4578 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4579 || bfd_mach_o_get_data (abfd) == NULL
4580 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4581 return FALSE;
4582
4583 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4584 if (dsym_uuid_cmd == NULL)
4585 return FALSE;
4586
4587 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4588 sizeof (uuid_cmd->uuid)) != 0)
4589 return FALSE;
4590
4591 return TRUE;
4592 }
4593
4594 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4595 The caller is responsible for closing the returned BFD object and
4596 its my_archive if the returned BFD is in a fat dSYM. */
4597
4598 static bfd *
4599 bfd_mach_o_find_dsym (const char *dsym_filename,
4600 const bfd_mach_o_uuid_command *uuid_cmd,
4601 const bfd_arch_info_type *arch)
4602 {
4603 bfd *base_dsym_bfd, *dsym_bfd;
4604
4605 BFD_ASSERT (uuid_cmd);
4606
4607 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4608 if (base_dsym_bfd == NULL)
4609 return NULL;
4610
4611 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4612 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4613 return dsym_bfd;
4614
4615 bfd_close (dsym_bfd);
4616 if (base_dsym_bfd != dsym_bfd)
4617 bfd_close (base_dsym_bfd);
4618
4619 return NULL;
4620 }
4621
4622 /* Return a BFD created from a dSYM file for ABFD.
4623 The caller is responsible for closing the returned BFD object, its
4624 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4625
4626 static bfd *
4627 bfd_mach_o_follow_dsym (bfd *abfd)
4628 {
4629 char *dsym_filename;
4630 bfd_mach_o_uuid_command *uuid_cmd;
4631 bfd *dsym_bfd, *base_bfd = abfd;
4632 const char *base_basename;
4633
4634 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4635 return NULL;
4636
4637 if (abfd->my_archive)
4638 base_bfd = abfd->my_archive;
4639 /* BFD may have been opened from a stream. */
4640 if (base_bfd->filename == NULL)
4641 {
4642 bfd_set_error (bfd_error_invalid_operation);
4643 return NULL;
4644 }
4645 base_basename = lbasename (base_bfd->filename);
4646
4647 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4648 if (uuid_cmd == NULL)
4649 return NULL;
4650
4651 /* TODO: We assume the DWARF file has the same as the binary's.
4652 It seems apple's GDB checks all files in the dSYM bundle directory.
4653 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4654 */
4655 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4656 + strlen (dsym_subdir) + 1
4657 + strlen (base_basename) + 1);
4658 sprintf (dsym_filename, "%s%s/%s",
4659 base_bfd->filename, dsym_subdir, base_basename);
4660
4661 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4662 bfd_get_arch_info (abfd));
4663 if (dsym_bfd == NULL)
4664 free (dsym_filename);
4665
4666 return dsym_bfd;
4667 }
4668
4669 bfd_boolean
4670 bfd_mach_o_find_nearest_line (bfd *abfd,
4671 asection *section,
4672 asymbol **symbols,
4673 bfd_vma offset,
4674 const char **filename_ptr,
4675 const char **functionname_ptr,
4676 unsigned int *line_ptr)
4677 {
4678 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4679 if (mdata == NULL)
4680 return FALSE;
4681 switch (mdata->header.filetype)
4682 {
4683 case BFD_MACH_O_MH_OBJECT:
4684 break;
4685 case BFD_MACH_O_MH_EXECUTE:
4686 case BFD_MACH_O_MH_DYLIB:
4687 case BFD_MACH_O_MH_BUNDLE:
4688 case BFD_MACH_O_MH_KEXT_BUNDLE:
4689 if (mdata->dwarf2_find_line_info == NULL)
4690 {
4691 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4692 /* When we couldn't find dSYM for this binary, we look for
4693 the debug information in the binary itself. In this way,
4694 we won't try finding separated dSYM again because
4695 mdata->dwarf2_find_line_info will be filled. */
4696 if (! mdata->dsym_bfd)
4697 break;
4698 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4699 dwarf_debug_sections, symbols,
4700 &mdata->dwarf2_find_line_info))
4701 return FALSE;
4702 }
4703 break;
4704 default:
4705 return FALSE;
4706 }
4707 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4708 section, symbols, offset,
4709 filename_ptr, functionname_ptr,
4710 line_ptr, 0,
4711 &mdata->dwarf2_find_line_info))
4712 return TRUE;
4713 return FALSE;
4714 }
4715
4716 bfd_boolean
4717 bfd_mach_o_close_and_cleanup (bfd *abfd)
4718 {
4719 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4720 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4721 {
4722 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4723 bfd_mach_o_free_cached_info (abfd);
4724 if (mdata->dsym_bfd != NULL)
4725 {
4726 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4727 char *dsym_filename = (char *)(fat_bfd
4728 ? fat_bfd->filename
4729 : mdata->dsym_bfd->filename);
4730 bfd_close (mdata->dsym_bfd);
4731 mdata->dsym_bfd = NULL;
4732 if (fat_bfd)
4733 bfd_close (fat_bfd);
4734 free (dsym_filename);
4735 }
4736 }
4737
4738 return _bfd_generic_close_and_cleanup (abfd);
4739 }
4740
4741 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4742 {
4743 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4744 asection *asect;
4745 free (mdata->dyn_reloc_cache);
4746 mdata->dyn_reloc_cache = NULL;
4747 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4748 {
4749 free (asect->relocation);
4750 asect->relocation = NULL;
4751 }
4752
4753 return TRUE;
4754 }
4755
4756 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4757 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4758
4759 #define bfd_mach_o_swap_reloc_in NULL
4760 #define bfd_mach_o_swap_reloc_out NULL
4761 #define bfd_mach_o_print_thread NULL
4762 #define bfd_mach_o_tgt_seg_table NULL
4763 #define bfd_mach_o_section_type_valid_for_tgt NULL
4764
4765 #define TARGET_NAME mach_o_be_vec
4766 #define TARGET_STRING "mach-o-be"
4767 #define TARGET_ARCHITECTURE bfd_arch_unknown
4768 #define TARGET_BIG_ENDIAN 1
4769 #define TARGET_ARCHIVE 0
4770 #define TARGET_PRIORITY 1
4771 #include "mach-o-target.c"
4772
4773 #undef TARGET_NAME
4774 #undef TARGET_STRING
4775 #undef TARGET_ARCHITECTURE
4776 #undef TARGET_BIG_ENDIAN
4777 #undef TARGET_ARCHIVE
4778 #undef TARGET_PRIORITY
4779
4780 #define TARGET_NAME mach_o_le_vec
4781 #define TARGET_STRING "mach-o-le"
4782 #define TARGET_ARCHITECTURE bfd_arch_unknown
4783 #define TARGET_BIG_ENDIAN 0
4784 #define TARGET_ARCHIVE 0
4785 #define TARGET_PRIORITY 1
4786
4787 #include "mach-o-target.c"
4788
4789 #undef TARGET_NAME
4790 #undef TARGET_STRING
4791 #undef TARGET_ARCHITECTURE
4792 #undef TARGET_BIG_ENDIAN
4793 #undef TARGET_ARCHIVE
4794 #undef TARGET_PRIORITY
4795
4796 /* Not yet handled: creating an archive. */
4797 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4798
4799 /* Not used. */
4800 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4801 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4802 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4803 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4804 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4805 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4806 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4807 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4808 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
4809 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4810
4811 #define TARGET_NAME mach_o_fat_vec
4812 #define TARGET_STRING "mach-o-fat"
4813 #define TARGET_ARCHITECTURE bfd_arch_unknown
4814 #define TARGET_BIG_ENDIAN 1
4815 #define TARGET_ARCHIVE 1
4816 #define TARGET_PRIORITY 0
4817
4818 #include "mach-o-target.c"
4819
4820 #undef TARGET_NAME
4821 #undef TARGET_STRING
4822 #undef TARGET_ARCHITECTURE
4823 #undef TARGET_BIG_ENDIAN
4824 #undef TARGET_ARCHIVE
4825 #undef TARGET_PRIORITY