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