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