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