projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Mach-O: Add BFD_MACH_O_CPU_TYPE_ARM64.
[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) (_("unable to write unknown load command 0x%lx"),
2022 (unsigned long) cur->type);
2023 return FALSE;
2024 }
2025 }
2026
2027 return TRUE;
2028 }
2029
2030 static void
2031 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2032 asection *sec)
2033 {
2034 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
2035 if (seg->sect_head == NULL)
2036 seg->sect_head = s;
2037 else
2038 seg->sect_tail->next = s;
2039 seg->sect_tail = s;
2040 }
2041
2042 /* Create section Mach-O flags from BFD flags. */
2043
2044 static void
2045 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
2046 {
2047 flagword bfd_flags;
2048 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2049
2050 /* Create default flags. */
2051 bfd_flags = bfd_get_section_flags (abfd, sec);
2052 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2053 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2054 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2055 | BFD_MACH_O_S_REGULAR;
2056 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2057 s->flags = BFD_MACH_O_S_ZEROFILL;
2058 else if (bfd_flags & SEC_DEBUGGING)
2059 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2060 else
2061 s->flags = BFD_MACH_O_S_REGULAR;
2062 }
2063
2064 /* Count the number of sections in the list for the segment named.
2065
2066 The special case of NULL or "" for the segment name is valid for
2067 an MH_OBJECT file and means 'all sections available'.
2068
2069 Requires that the sections table in mdata be filled in.
2070
2071 Returns the number of sections (0 is valid).
2072 Any number > 255 signals an invalid section count, although we will,
2073 perhaps, allow the file to be written (in line with Darwin tools up
2074 to XCode 4).
2075
2076 A section count of (unsigned long) -1 signals a definite error. */
2077
2078 static unsigned long
2079 bfd_mach_o_count_sections_for_seg (const char *segment,
2080 bfd_mach_o_data_struct *mdata)
2081 {
2082 unsigned i,j;
2083 if (mdata == NULL || mdata->sections == NULL)
2084 return (unsigned long) -1;
2085
2086 /* The MH_OBJECT case, all sections are considered; Although nsects is
2087 is an unsigned long, the maximum valid section count is 255 and this
2088 will have been checked already by mangle_sections. */
2089 if (segment == NULL || segment[0] == '\0')
2090 return mdata->nsects;
2091
2092 /* Count the number of sections we see in this segment. */
2093 j = 0;
2094 for (i = 0; i < mdata->nsects; ++i)
2095 {
2096 bfd_mach_o_section *s = mdata->sections[i];
2097 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2098 j++;
2099 }
2100 return j;
2101 }
2102
2103 static bfd_boolean
2104 bfd_mach_o_build_seg_command (const char *segment,
2105 bfd_mach_o_data_struct *mdata,
2106 bfd_mach_o_segment_command *seg)
2107 {
2108 unsigned i;
2109 int is_mho = (segment == NULL || segment[0] == '\0');
2110
2111 /* Fill segment command. */
2112 if (is_mho)
2113 memset (seg->segname, 0, sizeof (seg->segname));
2114 else
2115 strncpy (seg->segname, segment, sizeof (seg->segname));
2116
2117 /* TODO: fix this up for non-MH_OBJECT cases. */
2118 seg->vmaddr = 0;
2119 seg->vmsize = 0;
2120
2121 seg->fileoff = mdata->filelen;
2122 seg->filesize = 0;
2123 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2124 | BFD_MACH_O_PROT_EXECUTE;
2125 seg->initprot = seg->maxprot;
2126 seg->flags = 0;
2127 seg->sect_head = NULL;
2128 seg->sect_tail = NULL;
2129
2130 /* Append sections to the segment.
2131
2132 This is a little tedious, we have to honor the need to account zerofill
2133 sections after all the rest. This forces us to do the calculation of
2134 total vmsize in three passes so that any alignment increments are
2135 properly accounted. */
2136
2137 for (i = 0; i < mdata->nsects; ++i)
2138 {
2139 bfd_mach_o_section *s = mdata->sections[i];
2140 asection *sec = s->bfdsection;
2141
2142 /* If we're not making an MH_OBJECT, check whether this section is from
2143 our segment, and skip if not. Otherwise, just add all sections. */
2144 if (! is_mho
2145 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2146 continue;
2147
2148 /* Although we account for zerofill section sizes in vm order, they are
2149 placed in the file in source sequence. */
2150 bfd_mach_o_append_section_to_segment (seg, sec);
2151 s->offset = 0;
2152
2153 /* Zerofill sections have zero file size & offset,
2154 and are not written. */
2155 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2156 || (s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2157 == BFD_MACH_O_S_GB_ZEROFILL)
2158 continue;
2159
2160 if (s->size > 0)
2161 {
2162 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2163 seg->vmsize += s->size;
2164
2165 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2166 seg->filesize += s->size;
2167
2168 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2169 s->offset = mdata->filelen;
2170 }
2171
2172 sec->filepos = s->offset;
2173 mdata->filelen += s->size;
2174 }
2175
2176 /* Now pass through again, for zerofill, only now we just update the vmsize. */
2177 for (i = 0; i < mdata->nsects; ++i)
2178 {
2179 bfd_mach_o_section *s = mdata->sections[i];
2180
2181 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2182 continue;
2183
2184 if (! is_mho
2185 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2186 continue;
2187
2188 if (s->size > 0)
2189 {
2190 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2191 seg->vmsize += s->size;
2192 }
2193 }
2194
2195 /* Now pass through again, for zerofill_GB. */
2196 for (i = 0; i < mdata->nsects; ++i)
2197 {
2198 bfd_mach_o_section *s = mdata->sections[i];
2199
2200 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2201 continue;
2202
2203 if (! is_mho
2204 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2205 continue;
2206
2207 if (s->size > 0)
2208 {
2209 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2210 seg->vmsize += s->size;
2211 }
2212 }
2213
2214 /* Allocate space for the relocations. */
2215 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
2216
2217 for (i = 0; i < mdata->nsects; ++i)
2218 {
2219 bfd_mach_o_section *ms = mdata->sections[i];
2220 asection *sec = ms->bfdsection;
2221
2222 if ((ms->nreloc = sec->reloc_count) == 0)
2223 {
2224 ms->reloff = 0;
2225 continue;
2226 }
2227 sec->rel_filepos = mdata->filelen;
2228 ms->reloff = sec->rel_filepos;
2229 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2230 }
2231
2232 return TRUE;
2233 }
2234
2235 /* Count the number of indirect symbols in the image.
2236 Requires that the sections are in their final order. */
2237
2238 static unsigned int
2239 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2240 {
2241 unsigned int i;
2242 unsigned int nisyms = 0;
2243
2244 for (i = 0; i < mdata->nsects; ++i)
2245 {
2246 bfd_mach_o_section *sec = mdata->sections[i];
2247
2248 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2249 {
2250 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2251 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2252 case BFD_MACH_O_S_SYMBOL_STUBS:
2253 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2254 break;
2255 default:
2256 break;
2257 }
2258 }
2259 return nisyms;
2260 }
2261
2262 static bfd_boolean
2263 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2264 bfd_mach_o_data_struct *mdata,
2265 bfd_mach_o_load_command *cmd)
2266 {
2267 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2268
2269 /* TODO:
2270 We are not going to try and fill these in yet and, moreover, we are
2271 going to bail if they are already set. */
2272 if (dsym->nmodtab != 0
2273 || dsym->ntoc != 0
2274 || dsym->nextrefsyms != 0)
2275 {
2276 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2277 " implemented for dysymtab commands."));
2278 return FALSE;
2279 }
2280
2281 dsym->ilocalsym = 0;
2282
2283 if (bfd_get_symcount (abfd) > 0)
2284 {
2285 asymbol **symbols = bfd_get_outsymbols (abfd);
2286 unsigned long i;
2287
2288 /* Count the number of each kind of symbol. */
2289 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2290 {
2291 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2292 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2293 break;
2294 }
2295 dsym->nlocalsym = i;
2296 dsym->iextdefsym = i;
2297 for (; i < bfd_get_symcount (abfd); ++i)
2298 {
2299 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2300 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2301 break;
2302 }
2303 dsym->nextdefsym = i - dsym->nlocalsym;
2304 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2305 dsym->nundefsym = bfd_get_symcount (abfd)
2306 - dsym->nlocalsym
2307 - dsym->nextdefsym;
2308 }
2309 else
2310 {
2311 dsym->nlocalsym = 0;
2312 dsym->iextdefsym = 0;
2313 dsym->nextdefsym = 0;
2314 dsym->iundefsym = 0;
2315 dsym->nundefsym = 0;
2316 }
2317
2318 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2319 if (dsym->nindirectsyms > 0)
2320 {
2321 unsigned i;
2322 unsigned n;
2323
2324 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2325 dsym->indirectsymoff = mdata->filelen;
2326 mdata->filelen += dsym->nindirectsyms * 4;
2327
2328 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2329 if (dsym->indirect_syms == NULL)
2330 return FALSE;
2331
2332 n = 0;
2333 for (i = 0; i < mdata->nsects; ++i)
2334 {
2335 bfd_mach_o_section *sec = mdata->sections[i];
2336
2337 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2338 {
2339 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2340 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2341 case BFD_MACH_O_S_SYMBOL_STUBS:
2342 {
2343 unsigned j, num;
2344 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2345
2346 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2347 if (isyms == NULL || num == 0)
2348 break;
2349 /* Record the starting index in the reserved1 field. */
2350 sec->reserved1 = n;
2351 for (j = 0; j < num; j++, n++)
2352 {
2353 if (isyms[j] == NULL)
2354 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2355 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2356 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2357 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2358 | BFD_MACH_O_INDIRECT_SYM_ABS;
2359 else
2360 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2361 }
2362 }
2363 break;
2364 default:
2365 break;
2366 }
2367 }
2368 }
2369
2370 return TRUE;
2371 }
2372
2373 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2374 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2375 and copy functionality. */
2376
2377 bfd_boolean
2378 bfd_mach_o_build_commands (bfd *abfd)
2379 {
2380 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2381 unsigned wide = mach_o_wide_p (&mdata->header);
2382 int segcmd_idx = -1;
2383 int symtab_idx = -1;
2384 int dysymtab_idx = -1;
2385 unsigned long base_offset = 0;
2386
2387 /* Return now if commands are already present. */
2388 if (mdata->header.ncmds)
2389 return FALSE;
2390
2391 /* Fill in the file type, if not already set. */
2392
2393 if (mdata->header.filetype == 0)
2394 {
2395 if (abfd->flags & EXEC_P)
2396 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2397 else if (abfd->flags & DYNAMIC)
2398 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2399 else
2400 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2401 }
2402
2403 /* If hasn't already been done, flatten sections list, and sort
2404 if/when required. Must be done before the symbol table is adjusted,
2405 since that depends on properly numbered sections. */
2406 if (mdata->nsects == 0 || mdata->sections == NULL)
2407 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2408 return FALSE;
2409
2410 /* Order the symbol table, fill-in/check mach-o specific fields and
2411 partition out any indirect symbols. */
2412 if (!bfd_mach_o_mangle_symbols (abfd))
2413 return FALSE;
2414
2415 /* Very simple command set (only really applicable to MH_OBJECTs):
2416 All the commands are optional - present only when there is suitable data.
2417 (i.e. it is valid to have an empty file)
2418
2419 a command (segment) to contain all the sections,
2420 command for the symbol table,
2421 a command for the dysymtab.
2422
2423 ??? maybe we should assert that this is an MH_OBJECT? */
2424
2425 if (mdata->nsects > 0)
2426 {
2427 segcmd_idx = 0;
2428 mdata->header.ncmds = 1;
2429 }
2430
2431 if (bfd_get_symcount (abfd) > 0)
2432 {
2433 mdata->header.ncmds++;
2434 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2435 }
2436
2437 /* FIXME:
2438 This is a rather crude test for whether we should build a dysymtab. */
2439 if (bfd_mach_o_should_emit_dysymtab ()
2440 && bfd_get_symcount (abfd))
2441 {
2442 mdata->header.ncmds++;
2443 /* If there should be a case where a dysymtab could be emitted without
2444 a symtab (seems improbable), this would need amending. */
2445 dysymtab_idx = symtab_idx + 1;
2446 }
2447
2448 if (wide)
2449 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2450 else
2451 base_offset = BFD_MACH_O_HEADER_SIZE;
2452
2453 /* Well, we must have a header, at least. */
2454 mdata->filelen = base_offset;
2455
2456 /* A bit unusual, but no content is valid;
2457 as -n empty.s -o empty.o */
2458 if (mdata->header.ncmds == 0)
2459 return TRUE;
2460
2461 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2462 * sizeof (bfd_mach_o_load_command));
2463 if (mdata->commands == NULL)
2464 return FALSE;
2465
2466 if (segcmd_idx >= 0)
2467 {
2468 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2469 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2470
2471 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2472 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2473 if (seg->nsects == (unsigned long) -1)
2474 return FALSE;
2475
2476 /* Init segment command. */
2477 cmd->offset = base_offset;
2478 if (wide)
2479 {
2480 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2481 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2482 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2483 }
2484 else
2485 {
2486 cmd->type = BFD_MACH_O_LC_SEGMENT;
2487 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2488 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2489 }
2490
2491 cmd->type_required = FALSE;
2492 mdata->header.sizeofcmds = cmd->len;
2493 mdata->filelen += cmd->len;
2494 }
2495
2496 if (symtab_idx >= 0)
2497 {
2498 /* Init symtab command. */
2499 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2500
2501 cmd->type = BFD_MACH_O_LC_SYMTAB;
2502 cmd->offset = base_offset;
2503 if (segcmd_idx >= 0)
2504 cmd->offset += mdata->commands[segcmd_idx].len;
2505
2506 cmd->len = sizeof (struct mach_o_symtab_command_external)
2507 + BFD_MACH_O_LC_SIZE;
2508 cmd->type_required = FALSE;
2509 mdata->header.sizeofcmds += cmd->len;
2510 mdata->filelen += cmd->len;
2511 }
2512
2513 /* If required, setup symtab command, see comment above about the quality
2514 of this test. */
2515 if (dysymtab_idx >= 0)
2516 {
2517 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2518
2519 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2520 if (symtab_idx >= 0)
2521 cmd->offset = mdata->commands[symtab_idx].offset
2522 + mdata->commands[symtab_idx].len;
2523 else if (segcmd_idx >= 0)
2524 cmd->offset = mdata->commands[segcmd_idx].offset
2525 + mdata->commands[segcmd_idx].len;
2526 else
2527 cmd->offset = base_offset;
2528
2529 cmd->type_required = FALSE;
2530 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2531 + BFD_MACH_O_LC_SIZE;
2532
2533 mdata->header.sizeofcmds += cmd->len;
2534 mdata->filelen += cmd->len;
2535 }
2536
2537 /* So, now we have sized the commands and the filelen set to that.
2538 Now we can build the segment command and set the section file offsets. */
2539 if (segcmd_idx >= 0
2540 && ! bfd_mach_o_build_seg_command
2541 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2542 return FALSE;
2543
2544 /* If we're doing a dysymtab, cmd points to its load command. */
2545 if (dysymtab_idx >= 0
2546 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2547 &mdata->commands[dysymtab_idx]))
2548 return FALSE;
2549
2550 /* The symtab command is filled in when the symtab is written. */
2551 return TRUE;
2552 }
2553
2554 /* Set the contents of a section. */
2555
2556 bfd_boolean
2557 bfd_mach_o_set_section_contents (bfd *abfd,
2558 asection *section,
2559 const void * location,
2560 file_ptr offset,
2561 bfd_size_type count)
2562 {
2563 file_ptr pos;
2564
2565 /* Trying to write the first section contents will trigger the creation of
2566 the load commands if they are not already present. */
2567 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2568 return FALSE;
2569
2570 if (count == 0)
2571 return TRUE;
2572
2573 pos = section->filepos + offset;
2574 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2575 || bfd_bwrite (location, count, abfd) != count)
2576 return FALSE;
2577
2578 return TRUE;
2579 }
2580
2581 int
2582 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2583 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2584 {
2585 return 0;
2586 }
2587
2588 /* Make an empty symbol. This is required only because
2589 bfd_make_section_anyway wants to create a symbol for the section. */
2590
2591 asymbol *
2592 bfd_mach_o_make_empty_symbol (bfd *abfd)
2593 {
2594 asymbol *new_symbol;
2595
2596 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2597 if (new_symbol == NULL)
2598 return new_symbol;
2599 new_symbol->the_bfd = abfd;
2600 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2601 return new_symbol;
2602 }
2603
2604 static bfd_boolean
2605 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2606 {
2607 struct mach_o_header_external raw;
2608 unsigned int size;
2609 bfd_vma (*get32) (const void *) = NULL;
2610
2611 /* Just read the magic number. */
2612 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2613 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2614 return FALSE;
2615
2616 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2617 {
2618 header->byteorder = BFD_ENDIAN_BIG;
2619 header->magic = BFD_MACH_O_MH_MAGIC;
2620 header->version = 1;
2621 get32 = bfd_getb32;
2622 }
2623 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2624 {
2625 header->byteorder = BFD_ENDIAN_LITTLE;
2626 header->magic = BFD_MACH_O_MH_MAGIC;
2627 header->version = 1;
2628 get32 = bfd_getl32;
2629 }
2630 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2631 {
2632 header->byteorder = BFD_ENDIAN_BIG;
2633 header->magic = BFD_MACH_O_MH_MAGIC_64;
2634 header->version = 2;
2635 get32 = bfd_getb32;
2636 }
2637 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2638 {
2639 header->byteorder = BFD_ENDIAN_LITTLE;
2640 header->magic = BFD_MACH_O_MH_MAGIC_64;
2641 header->version = 2;
2642 get32 = bfd_getl32;
2643 }
2644 else
2645 {
2646 header->byteorder = BFD_ENDIAN_UNKNOWN;
2647 return FALSE;
2648 }
2649
2650 /* Once the size of the header is known, read the full header. */
2651 size = mach_o_wide_p (header) ?
2652 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2653
2654 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2655 || bfd_bread (&raw, size, abfd) != size)
2656 return FALSE;
2657
2658 header->cputype = (*get32) (raw.cputype);
2659 header->cpusubtype = (*get32) (raw.cpusubtype);
2660 header->filetype = (*get32) (raw.filetype);
2661 header->ncmds = (*get32) (raw.ncmds);
2662 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2663 header->flags = (*get32) (raw.flags);
2664
2665 if (mach_o_wide_p (header))
2666 header->reserved = (*get32) (raw.reserved);
2667 else
2668 header->reserved = 0;
2669
2670 return TRUE;
2671 }
2672
2673 bfd_boolean
2674 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2675 {
2676 bfd_mach_o_section *s;
2677 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2678
2679 s = bfd_mach_o_get_mach_o_section (sec);
2680 if (s == NULL)
2681 {
2682 flagword bfd_flags;
2683 static const mach_o_section_name_xlat * xlat;
2684
2685 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2686 if (s == NULL)
2687 return FALSE;
2688 sec->used_by_bfd = s;
2689 s->bfdsection = sec;
2690
2691 /* Create the Darwin seg/sect name pair from the bfd name.
2692 If this is a canonical name for which a specific paiting exists
2693 there will also be defined flags, type, attribute and alignment
2694 values. */
2695 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2696 if (xlat != NULL)
2697 {
2698 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2699 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2700 : bfdalign;
2701 (void) bfd_set_section_alignment (abfd, sec, s->align);
2702 bfd_flags = bfd_get_section_flags (abfd, sec);
2703 if (bfd_flags == SEC_NO_FLAGS)
2704 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2705 }
2706 else
2707 /* Create default flags. */
2708 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2709 }
2710
2711 return _bfd_generic_new_section_hook (abfd, sec);
2712 }
2713
2714 static void
2715 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2716 unsigned long prot)
2717 {
2718 flagword flags;
2719 bfd_mach_o_section *section;
2720
2721 flags = bfd_get_section_flags (abfd, sec);
2722 section = bfd_mach_o_get_mach_o_section (sec);
2723
2724 /* TODO: see if we should use the xlat system for doing this by
2725 preference and fall back to this for unknown sections. */
2726
2727 if (flags == SEC_NO_FLAGS)
2728 {
2729 /* Try to guess flags. */
2730 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2731 flags = SEC_DEBUGGING;
2732 else
2733 {
2734 flags = SEC_ALLOC;
2735 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2736 != BFD_MACH_O_S_ZEROFILL)
2737 {
2738 flags |= SEC_LOAD;
2739 if (prot & BFD_MACH_O_PROT_EXECUTE)
2740 flags |= SEC_CODE;
2741 if (prot & BFD_MACH_O_PROT_WRITE)
2742 flags |= SEC_DATA;
2743 else if (prot & BFD_MACH_O_PROT_READ)
2744 flags |= SEC_READONLY;
2745 }
2746 }
2747 }
2748 else
2749 {
2750 if ((flags & SEC_DEBUGGING) == 0)
2751 flags |= SEC_ALLOC;
2752 }
2753
2754 if (section->offset != 0)
2755 flags |= SEC_HAS_CONTENTS;
2756 if (section->nreloc != 0)
2757 flags |= SEC_RELOC;
2758
2759 bfd_set_section_flags (abfd, sec, flags);
2760
2761 sec->vma = section->addr;
2762 sec->lma = section->addr;
2763 sec->size = section->size;
2764 sec->filepos = section->offset;
2765 sec->alignment_power = section->align;
2766 sec->segment_mark = 0;
2767 sec->reloc_count = section->nreloc;
2768 sec->rel_filepos = section->reloff;
2769 }
2770
2771 static asection *
2772 bfd_mach_o_make_bfd_section (bfd *abfd,
2773 const unsigned char *segname,
2774 const unsigned char *sectname)
2775 {
2776 const char *sname;
2777 flagword flags;
2778
2779 bfd_mach_o_convert_section_name_to_bfd
2780 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2781 if (sname == NULL)
2782 return NULL;
2783
2784 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2785 }
2786
2787 static asection *
2788 bfd_mach_o_read_section_32 (bfd *abfd,
2789 unsigned int offset,
2790 unsigned long prot)
2791 {
2792 struct mach_o_section_32_external raw;
2793 asection *sec;
2794 bfd_mach_o_section *section;
2795
2796 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2797 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2798 != BFD_MACH_O_SECTION_SIZE))
2799 return NULL;
2800
2801 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2802 if (sec == NULL)
2803 return NULL;
2804
2805 section = bfd_mach_o_get_mach_o_section (sec);
2806 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2807 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2808 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2809 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2810 section->addr = bfd_h_get_32 (abfd, raw.addr);
2811 section->size = bfd_h_get_32 (abfd, raw.size);
2812 section->offset = bfd_h_get_32 (abfd, raw.offset);
2813 section->align = bfd_h_get_32 (abfd, raw.align);
2814 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2815 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2816 section->flags = bfd_h_get_32 (abfd, raw.flags);
2817 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2818 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2819 section->reserved3 = 0;
2820
2821 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2822
2823 return sec;
2824 }
2825
2826 static asection *
2827 bfd_mach_o_read_section_64 (bfd *abfd,
2828 unsigned int offset,
2829 unsigned long prot)
2830 {
2831 struct mach_o_section_64_external raw;
2832 asection *sec;
2833 bfd_mach_o_section *section;
2834
2835 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2836 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2837 != BFD_MACH_O_SECTION_64_SIZE))
2838 return NULL;
2839
2840 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2841 if (sec == NULL)
2842 return NULL;
2843
2844 section = bfd_mach_o_get_mach_o_section (sec);
2845 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2846 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2847 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2848 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2849 section->addr = bfd_h_get_64 (abfd, raw.addr);
2850 section->size = bfd_h_get_64 (abfd, raw.size);
2851 section->offset = bfd_h_get_32 (abfd, raw.offset);
2852 section->align = bfd_h_get_32 (abfd, raw.align);
2853 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2854 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2855 section->flags = bfd_h_get_32 (abfd, raw.flags);
2856 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2857 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2858 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2859
2860 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2861
2862 return sec;
2863 }
2864
2865 static asection *
2866 bfd_mach_o_read_section (bfd *abfd,
2867 unsigned int offset,
2868 unsigned long prot,
2869 unsigned int wide)
2870 {
2871 if (wide)
2872 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2873 else
2874 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2875 }
2876
2877 static bfd_boolean
2878 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2879 bfd_mach_o_symtab_command *sym,
2880 bfd_mach_o_asymbol *s,
2881 unsigned long i)
2882 {
2883 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2884 unsigned int wide = mach_o_wide_p (&mdata->header);
2885 unsigned int symwidth =
2886 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2887 unsigned int symoff = sym->symoff + (i * symwidth);
2888 struct mach_o_nlist_64_external raw;
2889 unsigned char type = -1;
2890 unsigned char section = -1;
2891 short desc = -1;
2892 symvalue value = -1;
2893 unsigned long stroff = -1;
2894 unsigned int symtype = -1;
2895
2896 BFD_ASSERT (sym->strtab != NULL);
2897
2898 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2899 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2900 {
2901 (*_bfd_error_handler)
2902 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2903 symwidth, (unsigned long) symoff);
2904 return FALSE;
2905 }
2906
2907 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2908 type = bfd_h_get_8 (abfd, raw.n_type);
2909 symtype = type & BFD_MACH_O_N_TYPE;
2910 section = bfd_h_get_8 (abfd, raw.n_sect);
2911 desc = bfd_h_get_16 (abfd, raw.n_desc);
2912 if (wide)
2913 value = bfd_h_get_64 (abfd, raw.n_value);
2914 else
2915 value = bfd_h_get_32 (abfd, raw.n_value);
2916
2917 if (stroff >= sym->strsize)
2918 {
2919 (*_bfd_error_handler)
2920 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2921 (unsigned long) stroff,
2922 (unsigned long) sym->strsize);
2923 return FALSE;
2924 }
2925
2926 s->symbol.the_bfd = abfd;
2927 s->symbol.name = sym->strtab + stroff;
2928 s->symbol.value = value;
2929 s->symbol.flags = 0x0;
2930 s->symbol.udata.i = i;
2931 s->n_type = type;
2932 s->n_sect = section;
2933 s->n_desc = desc;
2934
2935 if (type & BFD_MACH_O_N_STAB)
2936 {
2937 s->symbol.flags |= BSF_DEBUGGING;
2938 s->symbol.section = bfd_und_section_ptr;
2939 switch (type)
2940 {
2941 case N_FUN:
2942 case N_STSYM:
2943 case N_LCSYM:
2944 case N_BNSYM:
2945 case N_SLINE:
2946 case N_ENSYM:
2947 case N_ECOMM:
2948 case N_ECOML:
2949 case N_GSYM:
2950 if ((section > 0) && (section <= mdata->nsects))
2951 {
2952 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2953 s->symbol.value =
2954 s->symbol.value - mdata->sections[section - 1]->addr;
2955 }
2956 break;
2957 }
2958 }
2959 else
2960 {
2961 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2962 s->symbol.flags |= BSF_GLOBAL;
2963 else
2964 s->symbol.flags |= BSF_LOCAL;
2965
2966 switch (symtype)
2967 {
2968 case BFD_MACH_O_N_UNDF:
2969 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2970 && s->symbol.value != 0)
2971 {
2972 /* A common symbol. */
2973 s->symbol.section = bfd_com_section_ptr;
2974 s->symbol.flags = BSF_NO_FLAGS;
2975 }
2976 else
2977 {
2978 s->symbol.section = bfd_und_section_ptr;
2979 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2980 s->symbol.flags |= BSF_WEAK;
2981 }
2982 break;
2983 case BFD_MACH_O_N_PBUD:
2984 s->symbol.section = bfd_und_section_ptr;
2985 break;
2986 case BFD_MACH_O_N_ABS:
2987 s->symbol.section = bfd_abs_section_ptr;
2988 break;
2989 case BFD_MACH_O_N_SECT:
2990 if ((section > 0) && (section <= mdata->nsects))
2991 {
2992 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2993 s->symbol.value =
2994 s->symbol.value - mdata->sections[section - 1]->addr;
2995 }
2996 else
2997 {
2998 /* Mach-O uses 0 to mean "no section"; not an error. */
2999 if (section != 0)
3000 {
3001 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3002 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3003 s->symbol.name, section, mdata->nsects);
3004 }
3005 s->symbol.section = bfd_und_section_ptr;
3006 }
3007 break;
3008 case BFD_MACH_O_N_INDR:
3009 /* FIXME: we don't follow the BFD convention as this indirect symbol
3010 won't be followed by the referenced one. This looks harmless
3011 unless we start using the linker. */
3012 s->symbol.flags |= BSF_INDIRECT;
3013 s->symbol.section = bfd_ind_section_ptr;
3014 s->symbol.value = 0;
3015 break;
3016 default:
3017 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3018 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3019 s->symbol.name, symtype);
3020 s->symbol.section = bfd_und_section_ptr;
3021 break;
3022 }
3023 }
3024
3025 return TRUE;
3026 }
3027
3028 bfd_boolean
3029 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3030 {
3031 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3032 bfd_mach_o_symtab_command *sym = mdata->symtab;
3033
3034 /* Fail if there is no symtab. */
3035 if (sym == NULL)
3036 return FALSE;
3037
3038 /* Success if already loaded. */
3039 if (sym->strtab)
3040 return TRUE;
3041
3042 if (abfd->flags & BFD_IN_MEMORY)
3043 {
3044 struct bfd_in_memory *b;
3045
3046 b = (struct bfd_in_memory *) abfd->iostream;
3047
3048 if ((sym->stroff + sym->strsize) > b->size)
3049 {
3050 bfd_set_error (bfd_error_file_truncated);
3051 return FALSE;
3052 }
3053 sym->strtab = (char *) b->buffer + sym->stroff;
3054 }
3055 else
3056 {
3057 sym->strtab = bfd_alloc (abfd, sym->strsize);
3058 if (sym->strtab == NULL)
3059 return FALSE;
3060
3061 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3062 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3063 {
3064 bfd_set_error (bfd_error_file_truncated);
3065 return FALSE;
3066 }
3067 }
3068
3069 return TRUE;
3070 }
3071
3072 bfd_boolean
3073 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3074 {
3075 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3076 bfd_mach_o_symtab_command *sym = mdata->symtab;
3077 unsigned long i;
3078
3079 if (sym == NULL || sym->symbols)
3080 {
3081 /* Return now if there are no symbols or if already loaded. */
3082 return TRUE;
3083 }
3084
3085 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3086
3087 if (sym->symbols == NULL)
3088 {
3089 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3090 return FALSE;
3091 }
3092
3093 if (!bfd_mach_o_read_symtab_strtab (abfd))
3094 return FALSE;
3095
3096 for (i = 0; i < sym->nsyms; i++)
3097 {
3098 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3099 return FALSE;
3100 }
3101
3102 return TRUE;
3103 }
3104
3105 static const char *
3106 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3107 {
3108 switch ((int) flavour)
3109 {
3110 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3111 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3112 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3113 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3114 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3115 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3116 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3117 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3118 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3119 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3120 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3121 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3122 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3123 default: return "UNKNOWN";
3124 }
3125 }
3126
3127 static const char *
3128 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3129 {
3130 switch ((int) flavour)
3131 {
3132 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3133 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3134 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3135 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3136 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3137 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3138 default: return "UNKNOWN";
3139 }
3140 }
3141
3142 static int
3143 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3144 {
3145 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3146 struct mach_o_str_command_external raw;
3147 unsigned int nameoff;
3148
3149 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
3150 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
3151
3152 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3153 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3154 return -1;
3155
3156 nameoff = bfd_h_get_32 (abfd, raw.str);
3157
3158 cmd->name_offset = command->offset + nameoff;
3159 cmd->name_len = command->len - nameoff;
3160 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3161 if (cmd->name_str == NULL)
3162 return -1;
3163 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3164 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3165 return -1;
3166 return 0;
3167 }
3168
3169 static int
3170 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3171 {
3172 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3173 struct mach_o_dylib_command_external raw;
3174 unsigned int nameoff;
3175
3176 switch (command->type)
3177 {
3178 case BFD_MACH_O_LC_LOAD_DYLIB:
3179 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3180 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3181 case BFD_MACH_O_LC_ID_DYLIB:
3182 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3183 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3184 break;
3185 default:
3186 BFD_FAIL ();
3187 return -1;
3188 }
3189
3190 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3191 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3192 return -1;
3193
3194 nameoff = bfd_h_get_32 (abfd, raw.name);
3195 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3196 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3197 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3198
3199 cmd->name_offset = command->offset + nameoff;
3200 cmd->name_len = command->len - nameoff;
3201 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3202 if (cmd->name_str == NULL)
3203 return -1;
3204 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3205 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3206 return -1;
3207 return 0;
3208 }
3209
3210 static int
3211 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
3212 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3213 {
3214 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
3215
3216 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
3217 return 0;
3218 }
3219
3220 static int
3221 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3222 {
3223 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3224 struct mach_o_fvmlib_command_external raw;
3225 unsigned int nameoff;
3226
3227 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3228 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3229 return -1;
3230
3231 nameoff = bfd_h_get_32 (abfd, raw.name);
3232 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3233 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3234
3235 fvm->name_offset = command->offset + nameoff;
3236 fvm->name_len = command->len - nameoff;
3237 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3238 if (fvm->name_str == NULL)
3239 return -1;
3240 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3241 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3242 return -1;
3243 return 0;
3244 }
3245
3246 static int
3247 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3248 {
3249 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3250 bfd_mach_o_thread_command *cmd = &command->command.thread;
3251 unsigned int offset;
3252 unsigned int nflavours;
3253 unsigned int i;
3254
3255 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3256 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3257
3258 /* Count the number of threads. */
3259 offset = 8;
3260 nflavours = 0;
3261 while (offset != command->len)
3262 {
3263 struct mach_o_thread_command_external raw;
3264
3265 if (offset >= command->len)
3266 return -1;
3267
3268 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3269 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3270 return -1;
3271
3272 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3273 nflavours++;
3274 }
3275
3276 /* Allocate threads. */
3277 cmd->flavours = bfd_alloc
3278 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3279 if (cmd->flavours == NULL)
3280 return -1;
3281 cmd->nflavours = nflavours;
3282
3283 offset = 8;
3284 nflavours = 0;
3285 while (offset != command->len)
3286 {
3287 struct mach_o_thread_command_external raw;
3288
3289 if (offset >= command->len)
3290 return -1;
3291
3292 if (nflavours >= cmd->nflavours)
3293 return -1;
3294
3295 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3296 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3297 return -1;
3298
3299 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3300 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3301 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3302 offset += cmd->flavours[nflavours].size + sizeof (raw);
3303 nflavours++;
3304 }
3305
3306 for (i = 0; i < nflavours; i++)
3307 {
3308 asection *bfdsec;
3309 unsigned int snamelen;
3310 char *sname;
3311 const char *flavourstr;
3312 const char *prefix = "LC_THREAD";
3313 unsigned int j = 0;
3314
3315 switch (mdata->header.cputype)
3316 {
3317 case BFD_MACH_O_CPU_TYPE_POWERPC:
3318 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3319 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3320 break;
3321 case BFD_MACH_O_CPU_TYPE_I386:
3322 case BFD_MACH_O_CPU_TYPE_X86_64:
3323 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3324 break;
3325 default:
3326 flavourstr = "UNKNOWN_ARCHITECTURE";
3327 break;
3328 }
3329
3330 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3331 sname = bfd_alloc (abfd, snamelen);
3332 if (sname == NULL)
3333 return -1;
3334
3335 for (;;)
3336 {
3337 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3338 if (bfd_get_section_by_name (abfd, sname) == NULL)
3339 break;
3340 j++;
3341 }
3342
3343 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3344
3345 bfdsec->vma = 0;
3346 bfdsec->lma = 0;
3347 bfdsec->size = cmd->flavours[i].size;
3348 bfdsec->filepos = cmd->flavours[i].offset;
3349 bfdsec->alignment_power = 0x0;
3350
3351 cmd->section = bfdsec;
3352 }
3353
3354 return 0;
3355 }
3356
3357 static int
3358 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3359 {
3360 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3361 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3362
3363 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3364
3365 {
3366 struct mach_o_dysymtab_command_external raw;
3367
3368 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3369 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3370 return -1;
3371
3372 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3373 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3374 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3375 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3376 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3377 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3378 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3379 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3380 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3381 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3382 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3383 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3384 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3385 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3386 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3387 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3388 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3389 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3390 }
3391
3392 if (cmd->nmodtab != 0)
3393 {
3394 unsigned int i;
3395 int wide = bfd_mach_o_wide_p (abfd);
3396 unsigned int module_len = wide ? 56 : 52;
3397
3398 cmd->dylib_module =
3399 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3400 if (cmd->dylib_module == NULL)
3401 return -1;
3402
3403 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3404 return -1;
3405
3406 for (i = 0; i < cmd->nmodtab; i++)
3407 {
3408 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3409 unsigned long v;
3410 unsigned char buf[56];
3411
3412 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3413 return -1;
3414
3415 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3416 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3417 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3418 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3419 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3420 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3421 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3422 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3423 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3424 v = bfd_h_get_32 (abfd, buf +36);
3425 module->iinit = v & 0xffff;
3426 module->iterm = (v >> 16) & 0xffff;
3427 v = bfd_h_get_32 (abfd, buf + 40);
3428 module->ninit = v & 0xffff;
3429 module->nterm = (v >> 16) & 0xffff;
3430 if (wide)
3431 {
3432 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3433 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3434 }
3435 else
3436 {
3437 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3438 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3439 }
3440 }
3441 }
3442
3443 if (cmd->ntoc != 0)
3444 {
3445 unsigned int i;
3446
3447 cmd->dylib_toc = bfd_alloc
3448 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3449 if (cmd->dylib_toc == NULL)
3450 return -1;
3451
3452 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3453 return -1;
3454
3455 for (i = 0; i < cmd->ntoc; i++)
3456 {
3457 struct mach_o_dylib_table_of_contents_external raw;
3458 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3459
3460 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3461 return -1;
3462
3463 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3464 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3465 }
3466 }
3467
3468 if (cmd->nindirectsyms != 0)
3469 {
3470 unsigned int i;
3471
3472 cmd->indirect_syms = bfd_alloc
3473 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3474 if (cmd->indirect_syms == NULL)
3475 return -1;
3476
3477 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3478 return -1;
3479
3480 for (i = 0; i < cmd->nindirectsyms; i++)
3481 {
3482 unsigned char raw[4];
3483 unsigned int *is = &cmd->indirect_syms[i];
3484
3485 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3486 return -1;
3487
3488 *is = bfd_h_get_32 (abfd, raw);
3489 }
3490 }
3491
3492 if (cmd->nextrefsyms != 0)
3493 {
3494 unsigned long v;
3495 unsigned int i;
3496
3497 cmd->ext_refs = bfd_alloc
3498 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3499 if (cmd->ext_refs == NULL)
3500 return -1;
3501
3502 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3503 return -1;
3504
3505 for (i = 0; i < cmd->nextrefsyms; i++)
3506 {
3507 unsigned char raw[4];
3508 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3509
3510 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3511 return -1;
3512
3513 /* Fields isym and flags are written as bit-fields, thus we need
3514 a specific processing for endianness. */
3515 v = bfd_h_get_32 (abfd, raw);
3516 if (bfd_big_endian (abfd))
3517 {
3518 ref->isym = (v >> 8) & 0xffffff;
3519 ref->flags = v & 0xff;
3520 }
3521 else
3522 {
3523 ref->isym = v & 0xffffff;
3524 ref->flags = (v >> 24) & 0xff;
3525 }
3526 }
3527 }
3528
3529 if (mdata->dysymtab)
3530 return -1;
3531 mdata->dysymtab = cmd;
3532
3533 return 0;
3534 }
3535
3536 static int
3537 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3538 {
3539 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3540 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3541 struct mach_o_symtab_command_external raw;
3542
3543 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3544
3545 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3546 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3547 return -1;
3548
3549 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3550 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3551 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3552 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3553 symtab->symbols = NULL;
3554 symtab->strtab = NULL;
3555
3556 if (symtab->nsyms != 0)
3557 abfd->flags |= HAS_SYMS;
3558
3559 if (mdata->symtab)
3560 return -1;
3561 mdata->symtab = symtab;
3562 return 0;
3563 }
3564
3565 static int
3566 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3567 {
3568 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3569
3570 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3571
3572 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3573 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3574 return -1;
3575
3576 return 0;
3577 }
3578
3579 static int
3580 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3581 {
3582 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3583 struct mach_o_linkedit_data_command_external raw;
3584
3585 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3586 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3587 return -1;
3588
3589 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3590 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3591 return 0;
3592 }
3593
3594 static int
3595 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3596 {
3597 bfd_mach_o_str_command *cmd = &command->command.str;
3598 struct mach_o_str_command_external raw;
3599 unsigned long off;
3600
3601 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3602 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3603 return -1;
3604
3605 off = bfd_get_32 (abfd, raw.str);
3606 cmd->stroff = command->offset + off;
3607 cmd->str_len = command->len - off;
3608 cmd->str = bfd_alloc (abfd, cmd->str_len);
3609 if (cmd->str == NULL)
3610 return -1;
3611 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3612 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3613 return -1;
3614 return 0;
3615 }
3616
3617 static int
3618 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3619 {
3620 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3621 struct mach_o_dyld_info_command_external raw;
3622
3623 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3624 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3625 return -1;
3626
3627 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3628 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3629 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3630 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3631 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3632 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3633 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3634 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3635 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3636 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3637 return 0;
3638 }
3639
3640 static bfd_boolean
3641 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3642 {
3643 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3644 struct mach_o_version_min_command_external raw;
3645 unsigned int ver;
3646
3647 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3648 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3649 return FALSE;
3650
3651 ver = bfd_get_32 (abfd, raw.version);
3652 cmd->rel = ver >> 16;
3653 cmd->maj = ver >> 8;
3654 cmd->min = ver;
3655 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3656 return TRUE;
3657 }
3658
3659 static bfd_boolean
3660 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3661 {
3662 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3663 struct mach_o_encryption_info_command_external raw;
3664
3665 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3666 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3667 return FALSE;
3668
3669 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3670 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3671 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3672 return TRUE;
3673 }
3674
3675 static bfd_boolean
3676 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3677 {
3678 bfd_mach_o_main_command *cmd = &command->command.main;
3679 struct mach_o_entry_point_command_external raw;
3680
3681 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3682 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3683 return FALSE;
3684
3685 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3686 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3687 return TRUE;
3688 }
3689
3690 static bfd_boolean
3691 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3692 {
3693 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3694 struct mach_o_source_version_command_external raw;
3695 bfd_uint64_t ver;
3696
3697 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3698 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3699 return FALSE;
3700
3701 ver = bfd_get_64 (abfd, raw.version);
3702 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3703 generates warnings) in case of the host doesn't support 64 bit
3704 integers. */
3705 cmd->e = ver & 0x3ff;
3706 ver >>= 10;
3707 cmd->d = ver & 0x3ff;
3708 ver >>= 10;
3709 cmd->c = ver & 0x3ff;
3710 ver >>= 10;
3711 cmd->b = ver & 0x3ff;
3712 ver >>= 10;
3713 cmd->a = ver & 0xffffff;
3714 return TRUE;
3715 }
3716
3717 static int
3718 bfd_mach_o_read_segment (bfd *abfd,
3719 bfd_mach_o_load_command *command,
3720 unsigned int wide)
3721 {
3722 bfd_mach_o_segment_command *seg = &command->command.segment;
3723 unsigned long i;
3724
3725 if (wide)
3726 {
3727 struct mach_o_segment_command_64_external raw;
3728
3729 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3730
3731 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3732 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3733 return -1;
3734
3735 memcpy (seg->segname, raw.segname, 16);
3736 seg->segname[16] = '\0';
3737
3738 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3739 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3740 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3741 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3742 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3743 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3744 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3745 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3746 }
3747 else
3748 {
3749 struct mach_o_segment_command_32_external raw;
3750
3751 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3752
3753 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3754 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3755 return -1;
3756
3757 memcpy (seg->segname, raw.segname, 16);
3758 seg->segname[16] = '\0';
3759
3760 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3761 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3762 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3763 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3764 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3765 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3766 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3767 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3768 }
3769 seg->sect_head = NULL;
3770 seg->sect_tail = NULL;
3771
3772 for (i = 0; i < seg->nsects; i++)
3773 {
3774 bfd_vma segoff;
3775 asection *sec;
3776
3777 if (wide)
3778 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3779 + (i * BFD_MACH_O_SECTION_64_SIZE);
3780 else
3781 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3782 + (i * BFD_MACH_O_SECTION_SIZE);
3783
3784 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3785 if (sec == NULL)
3786 return -1;
3787
3788 bfd_mach_o_append_section_to_segment (seg, sec);
3789 }
3790
3791 return 0;
3792 }
3793
3794 static int
3795 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3796 {
3797 return bfd_mach_o_read_segment (abfd, command, 0);
3798 }
3799
3800 static int
3801 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3802 {
3803 return bfd_mach_o_read_segment (abfd, command, 1);
3804 }
3805
3806 static int
3807 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3808 {
3809 struct mach_o_load_command_external raw;
3810 unsigned int cmd;
3811
3812 /* Read command type and length. */
3813 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3814 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3815 return -1;
3816
3817 cmd = bfd_h_get_32 (abfd, raw.cmd);
3818 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3819 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3820 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3821
3822 switch (command->type)
3823 {
3824 case BFD_MACH_O_LC_SEGMENT:
3825 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3826 return -1;
3827 break;
3828 case BFD_MACH_O_LC_SEGMENT_64:
3829 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3830 return -1;
3831 break;
3832 case BFD_MACH_O_LC_SYMTAB:
3833 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3834 return -1;
3835 break;
3836 case BFD_MACH_O_LC_SYMSEG:
3837 break;
3838 case BFD_MACH_O_LC_THREAD:
3839 case BFD_MACH_O_LC_UNIXTHREAD:
3840 if (bfd_mach_o_read_thread (abfd, command) != 0)
3841 return -1;
3842 break;
3843 case BFD_MACH_O_LC_LOAD_DYLINKER:
3844 case BFD_MACH_O_LC_ID_DYLINKER:
3845 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3846 return -1;
3847 break;
3848 case BFD_MACH_O_LC_LOAD_DYLIB:
3849 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3850 case BFD_MACH_O_LC_ID_DYLIB:
3851 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3852 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3853 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3854 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3855 return -1;
3856 break;
3857 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3858 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3859 return -1;
3860 break;
3861 case BFD_MACH_O_LC_LOADFVMLIB:
3862 case BFD_MACH_O_LC_IDFVMLIB:
3863 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3864 return -1;
3865 break;
3866 case BFD_MACH_O_LC_IDENT:
3867 case BFD_MACH_O_LC_FVMFILE:
3868 case BFD_MACH_O_LC_PREPAGE:
3869 case BFD_MACH_O_LC_ROUTINES:
3870 case BFD_MACH_O_LC_ROUTINES_64:
3871 break;
3872 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3873 case BFD_MACH_O_LC_SUB_UMBRELLA:
3874 case BFD_MACH_O_LC_SUB_LIBRARY:
3875 case BFD_MACH_O_LC_SUB_CLIENT:
3876 case BFD_MACH_O_LC_RPATH:
3877 if (bfd_mach_o_read_str (abfd, command) != 0)
3878 return -1;
3879 break;
3880 case BFD_MACH_O_LC_DYSYMTAB:
3881 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3882 return -1;
3883 break;
3884 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3885 case BFD_MACH_O_LC_PREBIND_CKSUM:
3886 break;
3887 case BFD_MACH_O_LC_UUID:
3888 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3889 return -1;
3890 break;
3891 case BFD_MACH_O_LC_CODE_SIGNATURE:
3892 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3893 case BFD_MACH_O_LC_FUNCTION_STARTS:
3894 case BFD_MACH_O_LC_DATA_IN_CODE:
3895 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3896 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3897 return -1;
3898 break;
3899 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3900 if (!bfd_mach_o_read_encryption_info (abfd, command))
3901 return -1;
3902 break;
3903 case BFD_MACH_O_LC_DYLD_INFO:
3904 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3905 return -1;
3906 break;
3907 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3908 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3909 if (!bfd_mach_o_read_version_min (abfd, command))
3910 return -1;
3911 break;
3912 case BFD_MACH_O_LC_MAIN:
3913 if (!bfd_mach_o_read_main (abfd, command))
3914 return -1;
3915 break;
3916 case BFD_MACH_O_LC_SOURCE_VERSION:
3917 if (!bfd_mach_o_read_source_version (abfd, command))
3918 return -1;
3919 break;
3920 default:
3921 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3922 abfd, (unsigned long) command->type);
3923 break;
3924 }
3925
3926 return 0;
3927 }
3928
3929 static void
3930 bfd_mach_o_flatten_sections (bfd *abfd)
3931 {
3932 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3933 long csect = 0;
3934 unsigned long i;
3935
3936 /* Count total number of sections. */
3937 mdata->nsects = 0;
3938
3939 for (i = 0; i < mdata->header.ncmds; i++)
3940 {
3941 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3942 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3943 {
3944 bfd_mach_o_segment_command *seg;
3945
3946 seg = &mdata->commands[i].command.segment;
3947 mdata->nsects += seg->nsects;
3948 }
3949 }
3950
3951 /* Allocate sections array. */
3952 mdata->sections = bfd_alloc (abfd,
3953 mdata->nsects * sizeof (bfd_mach_o_section *));
3954
3955 /* Fill the array. */
3956 csect = 0;
3957
3958 for (i = 0; i < mdata->header.ncmds; i++)
3959 {
3960 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3961 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3962 {
3963 bfd_mach_o_segment_command *seg;
3964 bfd_mach_o_section *sec;
3965
3966 seg = &mdata->commands[i].command.segment;
3967 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3968
3969 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3970 mdata->sections[csect++] = sec;
3971 }
3972 }
3973 }
3974
3975 static bfd_boolean
3976 bfd_mach_o_scan_start_address (bfd *abfd)
3977 {
3978 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3979 bfd_mach_o_thread_command *cmd = NULL;
3980 unsigned long i;
3981
3982 for (i = 0; i < mdata->header.ncmds; i++)
3983 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3984 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3985 {
3986 cmd = &mdata->commands[i].command.thread;
3987 break;
3988 }
3989 else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
3990 && mdata->nsects > 1)
3991 {
3992 bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
3993 bfd_mach_o_section *text_sect = mdata->sections[0];
3994 if (text_sect)
3995 {
3996 abfd->start_address = main_cmd->entryoff
3997 + (text_sect->addr - text_sect->offset);
3998 return TRUE;
3999 }
4000 }
4001
4002 /* An object file has no start address, so do not fail if not found. */
4003 if (cmd == NULL)
4004 return TRUE;
4005
4006 /* FIXME: create a subtarget hook ? */
4007 for (i = 0; i < cmd->nflavours; i++)
4008 {
4009 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4010 && (cmd->flavours[i].flavour
4011 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4012 {
4013 unsigned char buf[4];
4014
4015 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4016 || bfd_bread (buf, 4, abfd) != 4)
4017 return FALSE;
4018
4019 abfd->start_address = bfd_h_get_32 (abfd, buf);
4020 }
4021 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4022 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4023 {
4024 unsigned char buf[4];
4025
4026 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4027 || bfd_bread (buf, 4, abfd) != 4)
4028 return FALSE;
4029
4030 abfd->start_address = bfd_h_get_32 (abfd, buf);
4031 }
4032 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4033 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4034 {
4035 unsigned char buf[8];
4036
4037 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4038 || bfd_bread (buf, 8, abfd) != 8)
4039 return FALSE;
4040
4041 abfd->start_address = bfd_h_get_64 (abfd, buf);
4042 }
4043 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4044 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4045 {
4046 unsigned char buf[8];
4047
4048 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4049 || bfd_bread (buf, 8, abfd) != 8)
4050 return FALSE;
4051
4052 abfd->start_address = bfd_h_get_64 (abfd, buf);
4053 }
4054 }
4055
4056 return TRUE;
4057 }
4058
4059 bfd_boolean
4060 bfd_mach_o_set_arch_mach (bfd *abfd,
4061 enum bfd_architecture arch,
4062 unsigned long machine)
4063 {
4064 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4065
4066 /* If this isn't the right architecture for this backend, and this
4067 isn't the generic backend, fail. */
4068 if (arch != bed->arch
4069 && arch != bfd_arch_unknown
4070 && bed->arch != bfd_arch_unknown)
4071 return FALSE;
4072
4073 return bfd_default_set_arch_mach (abfd, arch, machine);
4074 }
4075
4076 static bfd_boolean
4077 bfd_mach_o_scan (bfd *abfd,
4078 bfd_mach_o_header *header,
4079 bfd_mach_o_data_struct *mdata)
4080 {
4081 unsigned int i;
4082 enum bfd_architecture cputype;
4083 unsigned long cpusubtype;
4084 unsigned int hdrsize;
4085
4086 hdrsize = mach_o_wide_p (header) ?
4087 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4088
4089 mdata->header = *header;
4090
4091 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4092 switch (header->filetype)
4093 {
4094 case BFD_MACH_O_MH_OBJECT:
4095 abfd->flags |= HAS_RELOC;
4096 break;
4097 case BFD_MACH_O_MH_EXECUTE:
4098 abfd->flags |= EXEC_P;
4099 break;
4100 case BFD_MACH_O_MH_DYLIB:
4101 case BFD_MACH_O_MH_BUNDLE:
4102 abfd->flags |= DYNAMIC;
4103 break;
4104 }
4105
4106 abfd->tdata.mach_o_data = mdata;
4107
4108 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4109 &cputype, &cpusubtype);
4110 if (cputype == bfd_arch_unknown)
4111 {
4112 (*_bfd_error_handler)
4113 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4114 header->cputype, header->cpusubtype);
4115 return FALSE;
4116 }
4117
4118 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4119
4120 if (header->ncmds != 0)
4121 {
4122 mdata->commands = bfd_alloc
4123 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4124 if (mdata->commands == NULL)
4125 return FALSE;
4126
4127 for (i = 0; i < header->ncmds; i++)
4128 {
4129 bfd_mach_o_load_command *cur = &mdata->commands[i];
4130
4131 if (i == 0)
4132 cur->offset = hdrsize;
4133 else
4134 {
4135 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4136 cur->offset = prev->offset + prev->len;
4137 }
4138
4139 if (bfd_mach_o_read_command (abfd, cur) < 0)
4140 return FALSE;
4141 }
4142 }
4143
4144 /* Sections should be flatten before scanning start address. */
4145 bfd_mach_o_flatten_sections (abfd);
4146 if (!bfd_mach_o_scan_start_address (abfd))
4147 return FALSE;
4148
4149 return TRUE;
4150 }
4151
4152 bfd_boolean
4153 bfd_mach_o_mkobject_init (bfd *abfd)
4154 {
4155 bfd_mach_o_data_struct *mdata = NULL;
4156
4157 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4158 if (mdata == NULL)
4159 return FALSE;
4160 abfd->tdata.mach_o_data = mdata;
4161
4162 mdata->header.magic = 0;
4163 mdata->header.cputype = 0;
4164 mdata->header.cpusubtype = 0;
4165 mdata->header.filetype = 0;
4166 mdata->header.ncmds = 0;
4167 mdata->header.sizeofcmds = 0;
4168 mdata->header.flags = 0;
4169 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4170 mdata->commands = NULL;
4171 mdata->nsects = 0;
4172 mdata->sections = NULL;
4173 mdata->dyn_reloc_cache = NULL;
4174
4175 return TRUE;
4176 }
4177
4178 static bfd_boolean
4179 bfd_mach_o_gen_mkobject (bfd *abfd)
4180 {
4181 bfd_mach_o_data_struct *mdata;
4182
4183 if (!bfd_mach_o_mkobject_init (abfd))
4184 return FALSE;
4185
4186 mdata = bfd_mach_o_get_data (abfd);
4187 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4188 mdata->header.cputype = 0;
4189 mdata->header.cpusubtype = 0;
4190 mdata->header.byteorder = abfd->xvec->byteorder;
4191 mdata->header.version = 1;
4192
4193 return TRUE;
4194 }
4195
4196 const bfd_target *
4197 bfd_mach_o_header_p (bfd *abfd,
4198 bfd_mach_o_filetype filetype,
4199 bfd_mach_o_cpu_type cputype)
4200 {
4201 bfd_mach_o_header header;
4202 bfd_mach_o_data_struct *mdata;
4203
4204 if (!bfd_mach_o_read_header (abfd, &header))
4205 goto wrong;
4206
4207 if (! (header.byteorder == BFD_ENDIAN_BIG
4208 || header.byteorder == BFD_ENDIAN_LITTLE))
4209 {
4210 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4211 (unsigned long) header.byteorder);
4212 goto wrong;
4213 }
4214
4215 if (! ((header.byteorder == BFD_ENDIAN_BIG
4216 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4217 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4218 || (header.byteorder == BFD_ENDIAN_LITTLE
4219 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4220 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4221 goto wrong;
4222
4223 /* Check cputype and filetype.
4224 In case of wildcard, do not accept magics that are handled by existing
4225 targets. */
4226 if (cputype)
4227 {
4228 if (header.cputype != cputype)
4229 goto wrong;
4230 }
4231
4232 if (filetype)
4233 {
4234 if (header.filetype != filetype)
4235 goto wrong;
4236 }
4237 else
4238 {
4239 switch (header.filetype)
4240 {
4241 case BFD_MACH_O_MH_CORE:
4242 /* Handled by core_p */
4243 goto wrong;
4244 default:
4245 break;
4246 }
4247 }
4248
4249 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4250 if (mdata == NULL)
4251 goto fail;
4252
4253 if (!bfd_mach_o_scan (abfd, &header, mdata))
4254 goto wrong;
4255
4256 return abfd->xvec;
4257
4258 wrong:
4259 bfd_set_error (bfd_error_wrong_format);
4260
4261 fail:
4262 return NULL;
4263 }
4264
4265 static const bfd_target *
4266 bfd_mach_o_gen_object_p (bfd *abfd)
4267 {
4268 return bfd_mach_o_header_p (abfd, 0, 0);
4269 }
4270
4271 static const bfd_target *
4272 bfd_mach_o_gen_core_p (bfd *abfd)
4273 {
4274 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4275 }
4276
4277 typedef struct mach_o_fat_archentry
4278 {
4279 unsigned long cputype;
4280 unsigned long cpusubtype;
4281 unsigned long offset;
4282 unsigned long size;
4283 unsigned long align;
4284 } mach_o_fat_archentry;
4285
4286 typedef struct mach_o_fat_data_struct
4287 {
4288 unsigned long magic;
4289 unsigned long nfat_arch;
4290 mach_o_fat_archentry *archentries;
4291 } mach_o_fat_data_struct;
4292
4293 const bfd_target *
4294 bfd_mach_o_archive_p (bfd *abfd)
4295 {
4296 mach_o_fat_data_struct *adata = NULL;
4297 struct mach_o_fat_header_external hdr;
4298 unsigned long i;
4299
4300 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4301 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4302 goto error;
4303
4304 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4305 if (adata == NULL)
4306 goto error;
4307
4308 adata->magic = bfd_getb32 (hdr.magic);
4309 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4310 if (adata->magic != 0xcafebabe)
4311 goto error;
4312 /* Avoid matching Java bytecode files, which have the same magic number.
4313 In the Java bytecode file format this field contains the JVM version,
4314 which starts at 43.0. */
4315 if (adata->nfat_arch > 30)
4316 goto error;
4317
4318 adata->archentries =
4319 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4320 if (adata->archentries == NULL)
4321 goto error;
4322
4323 for (i = 0; i < adata->nfat_arch; i++)
4324 {
4325 struct mach_o_fat_arch_external arch;
4326 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4327 goto error;
4328 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4329 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4330 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4331 adata->archentries[i].size = bfd_getb32 (arch.size);
4332 adata->archentries[i].align = bfd_getb32 (arch.align);
4333 }
4334
4335 abfd->tdata.mach_o_fat_data = adata;
4336 return abfd->xvec;
4337
4338 error:
4339 if (adata != NULL)
4340 bfd_release (abfd, adata);
4341 bfd_set_error (bfd_error_wrong_format);
4342 return NULL;
4343 }
4344
4345 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4346 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4347 Set arelt_data and origin fields too. */
4348
4349 static void
4350 bfd_mach_o_fat_member_init (bfd *abfd,
4351 enum bfd_architecture arch_type,
4352 unsigned long arch_subtype,
4353 mach_o_fat_archentry *entry)
4354 {
4355 struct areltdata *areltdata;
4356 /* Create the member filename. Use ARCH_NAME. */
4357 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4358
4359 if (ap)
4360 {
4361 /* Use the architecture name if known. */
4362 abfd->filename = xstrdup (ap->printable_name);
4363 }
4364 else
4365 {
4366 /* Forge a uniq id. */
4367 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4368 char *name = xmalloc (namelen);
4369 snprintf (name, namelen, "0x%lx-0x%lx",
4370 entry->cputype, entry->cpusubtype);
4371 abfd->filename = name;
4372 }
4373
4374 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4375 areltdata->parsed_size = entry->size;
4376 abfd->arelt_data = areltdata;
4377 abfd->iostream = NULL;
4378 abfd->origin = entry->offset;
4379 }
4380
4381 bfd *
4382 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4383 {
4384 mach_o_fat_data_struct *adata;
4385 mach_o_fat_archentry *entry = NULL;
4386 unsigned long i;
4387 bfd *nbfd;
4388 enum bfd_architecture arch_type;
4389 unsigned long arch_subtype;
4390
4391 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4392 BFD_ASSERT (adata != NULL);
4393
4394 /* Find index of previous entry. */
4395 if (prev == NULL)
4396 {
4397 /* Start at first one. */
4398 i = 0;
4399 }
4400 else
4401 {
4402 /* Find index of PREV. */
4403 for (i = 0; i < adata->nfat_arch; i++)
4404 {
4405 if (adata->archentries[i].offset == prev->origin)
4406 break;
4407 }
4408
4409 if (i == adata->nfat_arch)
4410 {
4411 /* Not found. */
4412 bfd_set_error (bfd_error_bad_value);
4413 return NULL;
4414 }
4415
4416 /* Get next entry. */
4417 i++;
4418 }
4419
4420 if (i >= adata->nfat_arch)
4421 {
4422 bfd_set_error (bfd_error_no_more_archived_files);
4423 return NULL;
4424 }
4425
4426 entry = &adata->archentries[i];
4427 nbfd = _bfd_new_bfd_contained_in (archive);
4428 if (nbfd == NULL)
4429 return NULL;
4430
4431 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4432 &arch_type, &arch_subtype);
4433
4434 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4435
4436 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4437
4438 return nbfd;
4439 }
4440
4441 /* Analogous to stat call. */
4442
4443 static int
4444 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4445 {
4446 if (abfd->arelt_data == NULL)
4447 {
4448 bfd_set_error (bfd_error_invalid_operation);
4449 return -1;
4450 }
4451
4452 buf->st_mtime = 0;
4453 buf->st_uid = 0;
4454 buf->st_gid = 0;
4455 buf->st_mode = 0644;
4456 buf->st_size = arelt_size (abfd);
4457
4458 return 0;
4459 }
4460
4461 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4462 If ABFD is a fat image containing a member that corresponds to FORMAT
4463 and ARCH, returns it.
4464 In other case, returns NULL.
4465 This function allows transparent uses of fat images. */
4466
4467 bfd *
4468 bfd_mach_o_fat_extract (bfd *abfd,
4469 bfd_format format,
4470 const bfd_arch_info_type *arch)
4471 {
4472 bfd *res;
4473 mach_o_fat_data_struct *adata;
4474 unsigned int i;
4475
4476 if (bfd_check_format (abfd, format))
4477 {
4478 if (bfd_get_arch_info (abfd) == arch)
4479 return abfd;
4480 return NULL;
4481 }
4482 if (!bfd_check_format (abfd, bfd_archive)
4483 || abfd->xvec != &mach_o_fat_vec)
4484 return NULL;
4485
4486 /* This is a Mach-O fat image. */
4487 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4488 BFD_ASSERT (adata != NULL);
4489
4490 for (i = 0; i < adata->nfat_arch; i++)
4491 {
4492 struct mach_o_fat_archentry *e = &adata->archentries[i];
4493 enum bfd_architecture cpu_type;
4494 unsigned long cpu_subtype;
4495
4496 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4497 &cpu_type, &cpu_subtype);
4498 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4499 continue;
4500
4501 /* The architecture is found. */
4502 res = _bfd_new_bfd_contained_in (abfd);
4503 if (res == NULL)
4504 return NULL;
4505
4506 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4507
4508 if (bfd_check_format (res, format))
4509 {
4510 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4511 return res;
4512 }
4513 bfd_close (res);
4514 return NULL;
4515 }
4516
4517 return NULL;
4518 }
4519
4520 int
4521 bfd_mach_o_lookup_command (bfd *abfd,
4522 bfd_mach_o_load_command_type type,
4523 bfd_mach_o_load_command **mcommand)
4524 {
4525 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4526 bfd_mach_o_load_command *ncmd = NULL;
4527 unsigned int i, num;
4528
4529 BFD_ASSERT (md != NULL);
4530 BFD_ASSERT (mcommand != NULL);
4531
4532 num = 0;
4533 for (i = 0; i < md->header.ncmds; i++)
4534 {
4535 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4536
4537 if (cmd->type != type)
4538 continue;
4539
4540 if (num == 0)
4541 ncmd = cmd;
4542 num++;
4543 }
4544
4545 *mcommand = ncmd;
4546 return num;
4547 }
4548
4549 unsigned long
4550 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4551 {
4552 switch (type)
4553 {
4554 case BFD_MACH_O_CPU_TYPE_MC680x0:
4555 return 0x04000000;
4556 case BFD_MACH_O_CPU_TYPE_MC88000:
4557 return 0xffffe000;
4558 case BFD_MACH_O_CPU_TYPE_POWERPC:
4559 return 0xc0000000;
4560 case BFD_MACH_O_CPU_TYPE_I386:
4561 return 0xc0000000;
4562 case BFD_MACH_O_CPU_TYPE_SPARC:
4563 return 0xf0000000;
4564 case BFD_MACH_O_CPU_TYPE_I860:
4565 return 0;
4566 case BFD_MACH_O_CPU_TYPE_HPPA:
4567 return 0xc0000000 - 0x04000000;
4568 default:
4569 return 0;
4570 }
4571 }
4572
4573 /* The following two tables should be kept, as far as possible, in order of
4574 most frequently used entries to optimize their use from gas. */
4575
4576 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4577 {
4578 { "regular", BFD_MACH_O_S_REGULAR},
4579 { "coalesced", BFD_MACH_O_S_COALESCED},
4580 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4581 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4582 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4583 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4584 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4585 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4586 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4587 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4588 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4589 { "interposing", BFD_MACH_O_S_INTERPOSING},
4590 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4591 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4592 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4593 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4594 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4595 { NULL, 0}
4596 };
4597
4598 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4599 {
4600 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4601 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4602 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4603 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4604 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4605 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4606 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4607 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4608 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4609 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4610 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4611 { NULL, 0}
4612 };
4613
4614 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4615
4616 unsigned int
4617 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4618 {
4619 const bfd_mach_o_xlat_name *x;
4620 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4621
4622 for (x = bfd_mach_o_section_type_name; x->name; x++)
4623 if (strcmp (x->name, name) == 0)
4624 {
4625 /* We found it... does the target support it? */
4626 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4627 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4628 return x->val; /* OK. */
4629 else
4630 break; /* Not supported. */
4631 }
4632 /* Maximum section ID = 0xff. */
4633 return 256;
4634 }
4635
4636 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4637
4638 unsigned int
4639 bfd_mach_o_get_section_attribute_from_name (const char *name)
4640 {
4641 const bfd_mach_o_xlat_name *x;
4642
4643 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4644 if (strcmp (x->name, name) == 0)
4645 return x->val;
4646 return (unsigned int)-1;
4647 }
4648
4649 int
4650 bfd_mach_o_core_fetch_environment (bfd *abfd,
4651 unsigned char **rbuf,
4652 unsigned int *rlen)
4653 {
4654 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4655 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4656 unsigned int i = 0;
4657
4658 for (i = 0; i < mdata->header.ncmds; i++)
4659 {
4660 bfd_mach_o_load_command *cur = &mdata->commands[i];
4661 bfd_mach_o_segment_command *seg = NULL;
4662
4663 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4664 continue;
4665
4666 seg = &cur->command.segment;
4667
4668 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4669 {
4670 unsigned long start = seg->fileoff;
4671 unsigned long end = seg->fileoff + seg->filesize;
4672 unsigned char *buf = bfd_malloc (1024);
4673 unsigned long size = 1024;
4674
4675 for (;;)
4676 {
4677 bfd_size_type nread = 0;
4678 unsigned long offset;
4679 int found_nonnull = 0;
4680
4681 if (size > (end - start))
4682 size = (end - start);
4683
4684 buf = bfd_realloc_or_free (buf, size);
4685 if (buf == NULL)
4686 return -1;
4687
4688 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4689 {
4690 free (buf);
4691 return -1;
4692 }
4693
4694 nread = bfd_bread (buf, size, abfd);
4695
4696 if (nread != size)
4697 {
4698 free (buf);
4699 return -1;
4700 }
4701
4702 for (offset = 4; offset <= size; offset += 4)
4703 {
4704 unsigned long val;
4705
4706 val = *((unsigned long *) (buf + size - offset));
4707 if (! found_nonnull)
4708 {
4709 if (val != 0)
4710 found_nonnull = 1;
4711 }
4712 else if (val == 0x0)
4713 {
4714 unsigned long bottom;
4715 unsigned long top;
4716
4717 bottom = seg->fileoff + seg->filesize - offset;
4718 top = seg->fileoff + seg->filesize - 4;
4719 *rbuf = bfd_malloc (top - bottom);
4720 *rlen = top - bottom;
4721
4722 memcpy (*rbuf, buf + size - *rlen, *rlen);
4723 free (buf);
4724 return 0;
4725 }
4726 }
4727
4728 if (size == (end - start))
4729 break;
4730
4731 size *= 2;
4732 }
4733
4734 free (buf);
4735 }
4736 }
4737
4738 return -1;
4739 }
4740
4741 char *
4742 bfd_mach_o_core_file_failing_command (bfd *abfd)
4743 {
4744 unsigned char *buf = NULL;
4745 unsigned int len = 0;
4746 int ret = -1;
4747
4748 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4749 if (ret < 0)
4750 return NULL;
4751
4752 return (char *) buf;
4753 }
4754
4755 int
4756 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4757 {
4758 return 0;
4759 }
4760
4761 static bfd_mach_o_uuid_command *
4762 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4763 {
4764 bfd_mach_o_load_command *uuid_cmd;
4765 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4766 if (ncmd != 1)
4767 return FALSE;
4768 return &uuid_cmd->command.uuid;
4769 }
4770
4771 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4772
4773 static bfd_boolean
4774 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4775 {
4776 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4777
4778 BFD_ASSERT (abfd);
4779 BFD_ASSERT (uuid_cmd);
4780
4781 if (!bfd_check_format (abfd, bfd_object))
4782 return FALSE;
4783
4784 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4785 || bfd_mach_o_get_data (abfd) == NULL
4786 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4787 return FALSE;
4788
4789 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4790 if (dsym_uuid_cmd == NULL)
4791 return FALSE;
4792
4793 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4794 sizeof (uuid_cmd->uuid)) != 0)
4795 return FALSE;
4796
4797 return TRUE;
4798 }
4799
4800 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4801 The caller is responsible for closing the returned BFD object and
4802 its my_archive if the returned BFD is in a fat dSYM. */
4803
4804 static bfd *
4805 bfd_mach_o_find_dsym (const char *dsym_filename,
4806 const bfd_mach_o_uuid_command *uuid_cmd,
4807 const bfd_arch_info_type *arch)
4808 {
4809 bfd *base_dsym_bfd, *dsym_bfd;
4810
4811 BFD_ASSERT (uuid_cmd);
4812
4813 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4814 if (base_dsym_bfd == NULL)
4815 return NULL;
4816
4817 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4818 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4819 return dsym_bfd;
4820
4821 bfd_close (dsym_bfd);
4822 if (base_dsym_bfd != dsym_bfd)
4823 bfd_close (base_dsym_bfd);
4824
4825 return NULL;
4826 }
4827
4828 /* Return a BFD created from a dSYM file for ABFD.
4829 The caller is responsible for closing the returned BFD object, its
4830 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4831
4832 static bfd *
4833 bfd_mach_o_follow_dsym (bfd *abfd)
4834 {
4835 char *dsym_filename;
4836 bfd_mach_o_uuid_command *uuid_cmd;
4837 bfd *dsym_bfd, *base_bfd = abfd;
4838 const char *base_basename;
4839
4840 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4841 return NULL;
4842
4843 if (abfd->my_archive)
4844 base_bfd = abfd->my_archive;
4845 /* BFD may have been opened from a stream. */
4846 if (base_bfd->filename == NULL)
4847 {
4848 bfd_set_error (bfd_error_invalid_operation);
4849 return NULL;
4850 }
4851 base_basename = lbasename (base_bfd->filename);
4852
4853 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4854 if (uuid_cmd == NULL)
4855 return NULL;
4856
4857 /* TODO: We assume the DWARF file has the same as the binary's.
4858 It seems apple's GDB checks all files in the dSYM bundle directory.
4859 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4860 */
4861 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4862 + strlen (dsym_subdir) + 1
4863 + strlen (base_basename) + 1);
4864 sprintf (dsym_filename, "%s%s/%s",
4865 base_bfd->filename, dsym_subdir, base_basename);
4866
4867 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4868 bfd_get_arch_info (abfd));
4869 if (dsym_bfd == NULL)
4870 free (dsym_filename);
4871
4872 return dsym_bfd;
4873 }
4874
4875 bfd_boolean
4876 bfd_mach_o_find_nearest_line (bfd *abfd,
4877 asection *section,
4878 asymbol **symbols,
4879 bfd_vma offset,
4880 const char **filename_ptr,
4881 const char **functionname_ptr,
4882 unsigned int *line_ptr)
4883 {
4884 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4885 if (mdata == NULL)
4886 return FALSE;
4887 switch (mdata->header.filetype)
4888 {
4889 case BFD_MACH_O_MH_OBJECT:
4890 break;
4891 case BFD_MACH_O_MH_EXECUTE:
4892 case BFD_MACH_O_MH_DYLIB:
4893 case BFD_MACH_O_MH_BUNDLE:
4894 case BFD_MACH_O_MH_KEXT_BUNDLE:
4895 if (mdata->dwarf2_find_line_info == NULL)
4896 {
4897 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4898 /* When we couldn't find dSYM for this binary, we look for
4899 the debug information in the binary itself. In this way,
4900 we won't try finding separated dSYM again because
4901 mdata->dwarf2_find_line_info will be filled. */
4902 if (! mdata->dsym_bfd)
4903 break;
4904 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4905 dwarf_debug_sections, symbols,
4906 &mdata->dwarf2_find_line_info))
4907 return FALSE;
4908 }
4909 break;
4910 default:
4911 return FALSE;
4912 }
4913 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4914 section, symbols, offset,
4915 filename_ptr, functionname_ptr,
4916 line_ptr, NULL, 0,
4917 &mdata->dwarf2_find_line_info))
4918 return TRUE;
4919 return FALSE;
4920 }
4921
4922 bfd_boolean
4923 bfd_mach_o_close_and_cleanup (bfd *abfd)
4924 {
4925 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4926 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4927 {
4928 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4929 bfd_mach_o_free_cached_info (abfd);
4930 if (mdata->dsym_bfd != NULL)
4931 {
4932 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4933 char *dsym_filename = (char *)(fat_bfd
4934 ? fat_bfd->filename
4935 : mdata->dsym_bfd->filename);
4936 bfd_close (mdata->dsym_bfd);
4937 mdata->dsym_bfd = NULL;
4938 if (fat_bfd)
4939 bfd_close (fat_bfd);
4940 free (dsym_filename);
4941 }
4942 }
4943
4944 if (bfd_get_format (abfd) == bfd_archive
4945 && abfd->xvec == &mach_o_fat_vec)
4946 return TRUE;
4947 return _bfd_generic_close_and_cleanup (abfd);
4948 }
4949
4950 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4951 {
4952 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4953 asection *asect;
4954 free (mdata->dyn_reloc_cache);
4955 mdata->dyn_reloc_cache = NULL;
4956 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4957 {
4958 free (asect->relocation);
4959 asect->relocation = NULL;
4960 }
4961
4962 return TRUE;
4963 }
4964
4965 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4966 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4967
4968 #define bfd_mach_o_swap_reloc_in NULL
4969 #define bfd_mach_o_swap_reloc_out NULL
4970 #define bfd_mach_o_print_thread NULL
4971 #define bfd_mach_o_tgt_seg_table NULL
4972 #define bfd_mach_o_section_type_valid_for_tgt NULL
4973
4974 #define TARGET_NAME mach_o_be_vec
4975 #define TARGET_STRING "mach-o-be"
4976 #define TARGET_ARCHITECTURE bfd_arch_unknown
4977 #define TARGET_BIG_ENDIAN 1
4978 #define TARGET_ARCHIVE 0
4979 #define TARGET_PRIORITY 1
4980 #include "mach-o-target.c"
4981
4982 #undef TARGET_NAME
4983 #undef TARGET_STRING
4984 #undef TARGET_ARCHITECTURE
4985 #undef TARGET_BIG_ENDIAN
4986 #undef TARGET_ARCHIVE
4987 #undef TARGET_PRIORITY
4988
4989 #define TARGET_NAME mach_o_le_vec
4990 #define TARGET_STRING "mach-o-le"
4991 #define TARGET_ARCHITECTURE bfd_arch_unknown
4992 #define TARGET_BIG_ENDIAN 0
4993 #define TARGET_ARCHIVE 0
4994 #define TARGET_PRIORITY 1
4995
4996 #include "mach-o-target.c"
4997
4998 #undef TARGET_NAME
4999 #undef TARGET_STRING
5000 #undef TARGET_ARCHITECTURE
5001 #undef TARGET_BIG_ENDIAN
5002 #undef TARGET_ARCHIVE
5003 #undef TARGET_PRIORITY
5004
5005 /* Not yet handled: creating an archive. */
5006 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5007
5008 /* Not used. */
5009 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5010 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5011 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5012 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5013 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5014 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5015 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5016 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5017 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5018 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5019
5020 #define TARGET_NAME mach_o_fat_vec
5021 #define TARGET_STRING "mach-o-fat"
5022 #define TARGET_ARCHITECTURE bfd_arch_unknown
5023 #define TARGET_BIG_ENDIAN 1
5024 #define TARGET_ARCHIVE 1
5025 #define TARGET_PRIORITY 0
5026
5027 #include "mach-o-target.c"
5028
5029 #undef TARGET_NAME
5030 #undef TARGET_STRING
5031 #undef TARGET_ARCHITECTURE
5032 #undef TARGET_BIG_ENDIAN
5033 #undef TARGET_ARCHIVE
5034 #undef TARGET_PRIORITY
GDB Binutils - Deliverables
This page took 0.125553 seconds and 5 git commands to generate.