projects / deliverable / binutils-gdb.git / blob
? search:


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