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