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