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