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


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