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