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