?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2012-01-04 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / mach-o.c
blob86012d5d0764629f030bada1fa58949fa319c0cd
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 /* Analogous to stat call. */
4207
4208 static int
4209 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4210 {
4211 if (abfd->arelt_data == NULL)
4212 {
4213 bfd_set_error (bfd_error_invalid_operation);
4214 return -1;
4215 }
4216
4217 buf->st_mtime = 0;
4218 buf->st_uid = 0;
4219 buf->st_gid = 0;
4220 buf->st_mode = 0644;
4221 buf->st_size = arelt_size (abfd);
4222
4223 return 0;
4224 }
4225
4226 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4227 If ABFD is a fat image containing a member that corresponds to FORMAT
4228 and ARCH, returns it.
4229 In other case, returns NULL.
4230 This function allows transparent uses of fat images. */
4231
4232 bfd *
4233 bfd_mach_o_fat_extract (bfd *abfd,
4234 bfd_format format,
4235 const bfd_arch_info_type *arch)
4236 {
4237 bfd *res;
4238 mach_o_fat_data_struct *adata;
4239 unsigned int i;
4240
4241 if (bfd_check_format (abfd, format))
4242 {
4243 if (bfd_get_arch_info (abfd) == arch)
4244 return abfd;
4245 return NULL;
4246 }
4247 if (!bfd_check_format (abfd, bfd_archive)
4248 || abfd->xvec != &mach_o_fat_vec)
4249 return NULL;
4250
4251 /* This is a Mach-O fat image. */
4252 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4253 BFD_ASSERT (adata != NULL);
4254
4255 for (i = 0; i < adata->nfat_arch; i++)
4256 {
4257 struct mach_o_fat_archentry *e = &adata->archentries[i];
4258 enum bfd_architecture cpu_type;
4259 unsigned long cpu_subtype;
4260
4261 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4262 &cpu_type, &cpu_subtype);
4263 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4264 continue;
4265
4266 /* The architecture is found. */
4267 res = _bfd_new_bfd_contained_in (abfd);
4268 if (res == NULL)
4269 return NULL;
4270
4271 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4272
4273 if (bfd_check_format (res, format))
4274 {
4275 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4276 return res;
4277 }
4278 bfd_close (res);
4279 return NULL;
4280 }
4281
4282 return NULL;
4283 }
4284
4285 int
4286 bfd_mach_o_lookup_command (bfd *abfd,
4287 bfd_mach_o_load_command_type type,
4288 bfd_mach_o_load_command **mcommand)
4289 {
4290 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4291 bfd_mach_o_load_command *ncmd = NULL;
4292 unsigned int i, num;
4293
4294 BFD_ASSERT (md != NULL);
4295 BFD_ASSERT (mcommand != NULL);
4296
4297 num = 0;
4298 for (i = 0; i < md->header.ncmds; i++)
4299 {
4300 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4301
4302 if (cmd->type != type)
4303 continue;
4304
4305 if (num == 0)
4306 ncmd = cmd;
4307 num++;
4308 }
4309
4310 *mcommand = ncmd;
4311 return num;
4312 }
4313
4314 unsigned long
4315 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4316 {
4317 switch (type)
4318 {
4319 case BFD_MACH_O_CPU_TYPE_MC680x0:
4320 return 0x04000000;
4321 case BFD_MACH_O_CPU_TYPE_MC88000:
4322 return 0xffffe000;
4323 case BFD_MACH_O_CPU_TYPE_POWERPC:
4324 return 0xc0000000;
4325 case BFD_MACH_O_CPU_TYPE_I386:
4326 return 0xc0000000;
4327 case BFD_MACH_O_CPU_TYPE_SPARC:
4328 return 0xf0000000;
4329 case BFD_MACH_O_CPU_TYPE_I860:
4330 return 0;
4331 case BFD_MACH_O_CPU_TYPE_HPPA:
4332 return 0xc0000000 - 0x04000000;
4333 default:
4334 return 0;
4335 }
4336 }
4337
4338 /* The following two tables should be kept, as far as possible, in order of
4339 most frequently used entries to optimize their use from gas. */
4340
4341 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4342 {
4343 { "regular", BFD_MACH_O_S_REGULAR},
4344 { "coalesced", BFD_MACH_O_S_COALESCED},
4345 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4346 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4347 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4348 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4349 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4350 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4351 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4352 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4353 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4354 { "interposing", BFD_MACH_O_S_INTERPOSING},
4355 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4356 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4357 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4358 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4359 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4360 { NULL, 0}
4361 };
4362
4363 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4364 {
4365 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4366 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4367 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4368 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4369 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4370 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4371 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4372 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4373 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4374 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4375 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4376 { NULL, 0}
4377 };
4378
4379 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4380
4381 unsigned int
4382 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4383 {
4384 const bfd_mach_o_xlat_name *x;
4385 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4386
4387 for (x = bfd_mach_o_section_type_name; x->name; x++)
4388 if (strcmp (x->name, name) == 0)
4389 {
4390 /* We found it... does the target support it? */
4391 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4392 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4393 return x->val; /* OK. */
4394 else
4395 break; /* Not supported. */
4396 }
4397 /* Maximum section ID = 0xff. */
4398 return 256;
4399 }
4400
4401 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4402
4403 unsigned int
4404 bfd_mach_o_get_section_attribute_from_name (const char *name)
4405 {
4406 const bfd_mach_o_xlat_name *x;
4407
4408 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4409 if (strcmp (x->name, name) == 0)
4410 return x->val;
4411 return (unsigned int)-1;
4412 }
4413
4414 int
4415 bfd_mach_o_core_fetch_environment (bfd *abfd,
4416 unsigned char **rbuf,
4417 unsigned int *rlen)
4418 {
4419 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4420 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4421 unsigned int i = 0;
4422
4423 for (i = 0; i < mdata->header.ncmds; i++)
4424 {
4425 bfd_mach_o_load_command *cur = &mdata->commands[i];
4426 bfd_mach_o_segment_command *seg = NULL;
4427
4428 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4429 continue;
4430
4431 seg = &cur->command.segment;
4432
4433 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4434 {
4435 unsigned long start = seg->fileoff;
4436 unsigned long end = seg->fileoff + seg->filesize;
4437 unsigned char *buf = bfd_malloc (1024);
4438 unsigned long size = 1024;
4439
4440 for (;;)
4441 {
4442 bfd_size_type nread = 0;
4443 unsigned long offset;
4444 int found_nonnull = 0;
4445
4446 if (size > (end - start))
4447 size = (end - start);
4448
4449 buf = bfd_realloc_or_free (buf, size);
4450 if (buf == NULL)
4451 return -1;
4452
4453 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4454 {
4455 free (buf);
4456 return -1;
4457 }
4458
4459 nread = bfd_bread (buf, size, abfd);
4460
4461 if (nread != size)
4462 {
4463 free (buf);
4464 return -1;
4465 }
4466
4467 for (offset = 4; offset <= size; offset += 4)
4468 {
4469 unsigned long val;
4470
4471 val = *((unsigned long *) (buf + size - offset));
4472 if (! found_nonnull)
4473 {
4474 if (val != 0)
4475 found_nonnull = 1;
4476 }
4477 else if (val == 0x0)
4478 {
4479 unsigned long bottom;
4480 unsigned long top;
4481
4482 bottom = seg->fileoff + seg->filesize - offset;
4483 top = seg->fileoff + seg->filesize - 4;
4484 *rbuf = bfd_malloc (top - bottom);
4485 *rlen = top - bottom;
4486
4487 memcpy (*rbuf, buf + size - *rlen, *rlen);
4488 free (buf);
4489 return 0;
4490 }
4491 }
4492
4493 if (size == (end - start))
4494 break;
4495
4496 size *= 2;
4497 }
4498
4499 free (buf);
4500 }
4501 }
4502
4503 return -1;
4504 }
4505
4506 char *
4507 bfd_mach_o_core_file_failing_command (bfd *abfd)
4508 {
4509 unsigned char *buf = NULL;
4510 unsigned int len = 0;
4511 int ret = -1;
4512
4513 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4514 if (ret < 0)
4515 return NULL;
4516
4517 return (char *) buf;
4518 }
4519
4520 int
4521 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4522 {
4523 return 0;
4524 }
4525
4526 static bfd_mach_o_uuid_command *
4527 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4528 {
4529 bfd_mach_o_load_command *uuid_cmd;
4530 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4531 if (ncmd != 1)
4532 return FALSE;
4533 return &uuid_cmd->command.uuid;
4534 }
4535
4536 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4537
4538 static bfd_boolean
4539 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4540 {
4541 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4542
4543 BFD_ASSERT (abfd);
4544 BFD_ASSERT (uuid_cmd);
4545
4546 if (!bfd_check_format (abfd, bfd_object))
4547 return FALSE;
4548
4549 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4550 || bfd_mach_o_get_data (abfd) == NULL
4551 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4552 return FALSE;
4553
4554 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4555 if (dsym_uuid_cmd == NULL)
4556 return FALSE;
4557
4558 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4559 sizeof (uuid_cmd->uuid)) != 0)
4560 return FALSE;
4561
4562 return TRUE;
4563 }
4564
4565 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4566 The caller is responsible for closing the returned BFD object and
4567 its my_archive if the returned BFD is in a fat dSYM. */
4568
4569 static bfd *
4570 bfd_mach_o_find_dsym (const char *dsym_filename,
4571 const bfd_mach_o_uuid_command *uuid_cmd,
4572 const bfd_arch_info_type *arch)
4573 {
4574 bfd *base_dsym_bfd, *dsym_bfd;
4575
4576 BFD_ASSERT (uuid_cmd);
4577
4578 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4579 if (base_dsym_bfd == NULL)
4580 return NULL;
4581
4582 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4583 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4584 return dsym_bfd;
4585
4586 bfd_close (dsym_bfd);
4587 if (base_dsym_bfd != dsym_bfd)
4588 bfd_close (base_dsym_bfd);
4589
4590 return NULL;
4591 }
4592
4593 /* Return a BFD created from a dSYM file for ABFD.
4594 The caller is responsible for closing the returned BFD object, its
4595 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4596
4597 static bfd *
4598 bfd_mach_o_follow_dsym (bfd *abfd)
4599 {
4600 char *dsym_filename;
4601 bfd_mach_o_uuid_command *uuid_cmd;
4602 bfd *dsym_bfd, *base_bfd = abfd;
4603 const char *base_basename;
4604
4605 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4606 return NULL;
4607
4608 if (abfd->my_archive)
4609 base_bfd = abfd->my_archive;
4610 /* BFD may have been opened from a stream. */
4611 if (base_bfd->filename == NULL)
4612 {
4613 bfd_set_error (bfd_error_invalid_operation);
4614 return NULL;
4615 }
4616 base_basename = lbasename (base_bfd->filename);
4617
4618 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4619 if (uuid_cmd == NULL)
4620 return NULL;
4621
4622 /* TODO: We assume the DWARF file has the same as the binary's.
4623 It seems apple's GDB checks all files in the dSYM bundle directory.
4624 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4625 */
4626 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4627 + strlen (dsym_subdir) + 1
4628 + strlen (base_basename) + 1);
4629 sprintf (dsym_filename, "%s%s/%s",
4630 base_bfd->filename, dsym_subdir, base_basename);
4631
4632 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4633 bfd_get_arch_info (abfd));
4634 if (dsym_bfd == NULL)
4635 free (dsym_filename);
4636
4637 return dsym_bfd;
4638 }
4639
4640 bfd_boolean
4641 bfd_mach_o_find_nearest_line (bfd *abfd,
4642 asection *section,
4643 asymbol **symbols,
4644 bfd_vma offset,
4645 const char **filename_ptr,
4646 const char **functionname_ptr,
4647 unsigned int *line_ptr)
4648 {
4649 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4650 if (mdata == NULL)
4651 return FALSE;
4652 switch (mdata->header.filetype)
4653 {
4654 case BFD_MACH_O_MH_OBJECT:
4655 break;
4656 case BFD_MACH_O_MH_EXECUTE:
4657 case BFD_MACH_O_MH_DYLIB:
4658 case BFD_MACH_O_MH_BUNDLE:
4659 case BFD_MACH_O_MH_KEXT_BUNDLE:
4660 if (mdata->dwarf2_find_line_info == NULL)
4661 {
4662 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4663 /* When we couldn't find dSYM for this binary, we look for
4664 the debug information in the binary itself. In this way,
4665 we won't try finding separated dSYM again because
4666 mdata->dwarf2_find_line_info will be filled. */
4667 if (! mdata->dsym_bfd)
4668 break;
4669 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4670 dwarf_debug_sections, symbols,
4671 &mdata->dwarf2_find_line_info))
4672 return FALSE;
4673 }
4674 break;
4675 default:
4676 return FALSE;
4677 }
4678 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4679 section, symbols, offset,
4680 filename_ptr, functionname_ptr,
4681 line_ptr, 0,
4682 &mdata->dwarf2_find_line_info))
4683 return TRUE;
4684 return FALSE;
4685 }
4686
4687 bfd_boolean
4688 bfd_mach_o_close_and_cleanup (bfd *abfd)
4689 {
4690 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4691 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4692 {
4693 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4694 bfd_mach_o_free_cached_info (abfd);
4695 if (mdata->dsym_bfd != NULL)
4696 {
4697 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4698 char *dsym_filename = (char *)(fat_bfd
4699 ? fat_bfd->filename
4700 : mdata->dsym_bfd->filename);
4701 bfd_close (mdata->dsym_bfd);
4702 mdata->dsym_bfd = NULL;
4703 if (fat_bfd)
4704 bfd_close (fat_bfd);
4705 free (dsym_filename);
4706 }
4707 }
4708
4709 return _bfd_generic_close_and_cleanup (abfd);
4710 }
4711
4712 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4713 {
4714 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4715 asection *asect;
4716 free (mdata->dyn_reloc_cache);
4717 mdata->dyn_reloc_cache = NULL;
4718 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4719 {
4720 free (asect->relocation);
4721 asect->relocation = NULL;
4722 }
4723
4724 return TRUE;
4725 }
4726
4727 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4728 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4729
4730 #define bfd_mach_o_swap_reloc_in NULL
4731 #define bfd_mach_o_swap_reloc_out NULL
4732 #define bfd_mach_o_print_thread NULL
4733 #define bfd_mach_o_tgt_seg_table NULL
4734 #define bfd_mach_o_section_type_valid_for_tgt NULL
4735
4736 #define TARGET_NAME mach_o_be_vec
4737 #define TARGET_STRING "mach-o-be"
4738 #define TARGET_ARCHITECTURE bfd_arch_unknown
4739 #define TARGET_BIG_ENDIAN 1
4740 #define TARGET_ARCHIVE 0
4741 #define TARGET_PRIORITY 1
4742 #include "mach-o-target.c"
4743
4744 #undef TARGET_NAME
4745 #undef TARGET_STRING
4746 #undef TARGET_ARCHITECTURE
4747 #undef TARGET_BIG_ENDIAN
4748 #undef TARGET_ARCHIVE
4749 #undef TARGET_PRIORITY
4750
4751 #define TARGET_NAME mach_o_le_vec
4752 #define TARGET_STRING "mach-o-le"
4753 #define TARGET_ARCHITECTURE bfd_arch_unknown
4754 #define TARGET_BIG_ENDIAN 0
4755 #define TARGET_ARCHIVE 0
4756 #define TARGET_PRIORITY 1
4757
4758 #include "mach-o-target.c"
4759
4760 #undef TARGET_NAME
4761 #undef TARGET_STRING
4762 #undef TARGET_ARCHITECTURE
4763 #undef TARGET_BIG_ENDIAN
4764 #undef TARGET_ARCHIVE
4765 #undef TARGET_PRIORITY
4766
4767 /* Not yet handled: creating an archive. */
4768 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4769
4770 /* Not used. */
4771 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4772 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4773 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4774 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4775 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4776 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4777 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4778 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4779 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
4780 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4781
4782 #define TARGET_NAME mach_o_fat_vec
4783 #define TARGET_STRING "mach-o-fat"
4784 #define TARGET_ARCHITECTURE bfd_arch_unknown
4785 #define TARGET_BIG_ENDIAN 1
4786 #define TARGET_ARCHIVE 1
4787 #define TARGET_PRIORITY 0
4788
4789 #include "mach-o-target.c"
4790
4791 #undef TARGET_NAME
4792 #undef TARGET_STRING
4793 #undef TARGET_ARCHITECTURE
4794 #undef TARGET_BIG_ENDIAN
4795 #undef TARGET_ARCHIVE
4796 #undef TARGET_PRIORITY
git-cvsimport of binutils cvsroot