projects / binutils-gdb.git / blob
? search:


61d60db54a2a6d93b3ff4b78ea681193b0dab064
[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
1356 /* An external symbol number. */
1357 sym = syms + num;
1358 }
1359 else if (num == 0x00ffffff || num == 0)
1360 {
1361 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1362 is generic code, we don't know wether this is really a PAIR.
1363 This value is almost certainly not a valid section number, hence
1364 this specific case to avoid an assertion failure.
1365 Target specific swap_reloc_in routine should adjust that. */
1366 sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1367 }
1368 else
1369 {
1370 /* PR 17512: file: 006-2964-0.004. */
1371 if (num > mdata->nsects)
1372 return -1;
1373
1374 /* A section number. */
1375 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1376 /* For a symbol defined in section S, the addend (stored in the
1377 binary) contains the address of the section. To comply with
1378 bfd convention, subtract the section address.
1379 Use the address from the header, so that the user can modify
1380 the vma of the section. */
1381 res->addend = -mdata->sections[num - 1]->addr;
1382 }
1383 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1384 in the lower 16bits of the address value. So we have to find the
1385 'symbol' from the preceding reloc. We do this even though the
1386 section symbol is probably not needed here, because NULL symbol
1387 values cause an assert in generic BFD code. This must be done in
1388 the PPC swap_reloc_in routine. */
1389 res->sym_ptr_ptr = sym;
1390
1391 /* The 'address' is just r_address.
1392 ??? maybe this should be masked with 0xffffff for safety. */
1393 res->address = addr;
1394 reloc.r_address = addr;
1395 }
1396
1397 /* We have set up a reloc with all the information present, so the swapper
1398 can modify address, value and addend fields, if necessary, to convey
1399 information in the generic BFD reloc that is mach-o specific. */
1400
1401 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
1402 return -1;
1403
1404 return 0;
1405 }
1406
1407 static int
1408 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1409 unsigned long count,
1410 arelent *res, asymbol **syms)
1411 {
1412 unsigned long i;
1413 struct mach_o_reloc_info_external *native_relocs;
1414 bfd_size_type native_size;
1415
1416 /* Allocate and read relocs. */
1417 native_size = count * BFD_MACH_O_RELENT_SIZE;
1418
1419 native_relocs =
1420 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
1421 if (native_relocs == NULL)
1422 return -1;
1423
1424 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
1425 || bfd_bread (native_relocs, native_size, abfd) != native_size)
1426 goto err;
1427
1428 for (i = 0; i < count; i++)
1429 {
1430 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1431 &res[i], syms) < 0)
1432 goto err;
1433 }
1434 free (native_relocs);
1435 return i;
1436 err:
1437 free (native_relocs);
1438 return -1;
1439 }
1440
1441 long
1442 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1443 arelent **rels, asymbol **syms)
1444 {
1445 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1446 unsigned long i;
1447 arelent *res;
1448
1449 if (asect->reloc_count == 0)
1450 return 0;
1451
1452 /* No need to go further if we don't know how to read relocs. */
1453 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1454 return 0;
1455
1456 if (asect->relocation == NULL)
1457 {
1458 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1459 if (res == NULL)
1460 return -1;
1461
1462 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1463 asect->reloc_count, res, syms) < 0)
1464 {
1465 free (res);
1466 return -1;
1467 }
1468 asect->relocation = res;
1469 }
1470
1471 res = asect->relocation;
1472 for (i = 0; i < asect->reloc_count; i++)
1473 rels[i] = &res[i];
1474 rels[i] = NULL;
1475
1476 return i;
1477 }
1478
1479 long
1480 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1481 {
1482 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1483
1484 if (mdata->dysymtab == NULL)
1485 return 1;
1486 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
1487 * sizeof (arelent *);
1488 }
1489
1490 long
1491 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1492 struct bfd_symbol **syms)
1493 {
1494 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1495 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1496 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1497 unsigned long i;
1498 arelent *res;
1499
1500 if (dysymtab == NULL)
1501 return 0;
1502 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1503 return 0;
1504
1505 /* No need to go further if we don't know how to read relocs. */
1506 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1507 return 0;
1508
1509 if (mdata->dyn_reloc_cache == NULL)
1510 {
1511 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1512 * sizeof (arelent));
1513 if (res == NULL)
1514 return -1;
1515
1516 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1517 dysymtab->nextrel, res, syms) < 0)
1518 {
1519 free (res);
1520 return -1;
1521 }
1522
1523 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1524 dysymtab->nlocrel,
1525 res + dysymtab->nextrel, syms) < 0)
1526 {
1527 free (res);
1528 return -1;
1529 }
1530
1531 mdata->dyn_reloc_cache = res;
1532 }
1533
1534 res = mdata->dyn_reloc_cache;
1535 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1536 rels[i] = &res[i];
1537 rels[i] = NULL;
1538 return i;
1539 }
1540
1541 /* In addition to the need to byte-swap the symbol number, the bit positions
1542 of the fields in the relocation information vary per target endian-ness. */
1543
1544 static void
1545 bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1546 bfd_mach_o_reloc_info *rel)
1547 {
1548 unsigned char info = 0;
1549
1550 BFD_ASSERT (rel->r_type <= 15);
1551 BFD_ASSERT (rel->r_length <= 3);
1552
1553 if (bfd_big_endian (abfd))
1554 {
1555 fields[0] = (rel->r_value >> 16) & 0xff;
1556 fields[1] = (rel->r_value >> 8) & 0xff;
1557 fields[2] = rel->r_value & 0xff;
1558 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1559 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1560 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1561 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1562 }
1563 else
1564 {
1565 fields[2] = (rel->r_value >> 16) & 0xff;
1566 fields[1] = (rel->r_value >> 8) & 0xff;
1567 fields[0] = rel->r_value & 0xff;
1568 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1569 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1570 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1571 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1572 }
1573 fields[3] = info;
1574 }
1575
1576 static bfd_boolean
1577 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1578 {
1579 unsigned int i;
1580 arelent **entries;
1581 asection *sec;
1582 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1583
1584 sec = section->bfdsection;
1585 if (sec->reloc_count == 0)
1586 return TRUE;
1587
1588 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1589 return TRUE;
1590
1591 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1592 return FALSE;
1593
1594 /* Convert and write. */
1595 entries = section->bfdsection->orelocation;
1596 for (i = 0; i < section->nreloc; i++)
1597 {
1598 arelent *rel = entries[i];
1599 struct mach_o_reloc_info_external raw;
1600 bfd_mach_o_reloc_info info, *pinfo = &info;
1601
1602 /* Convert relocation to an intermediate representation. */
1603 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1604 return FALSE;
1605
1606 /* Lower the relocation info. */
1607 if (pinfo->r_scattered)
1608 {
1609 unsigned long v;
1610
1611 v = BFD_MACH_O_SR_SCATTERED
1612 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1613 | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
1614 | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
1615 | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
1616 /* Note: scattered relocs have field in reverse order... */
1617 bfd_put_32 (abfd, v, raw.r_address);
1618 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1619 }
1620 else
1621 {
1622 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1623 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1624 pinfo);
1625 }
1626
1627 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1628 != BFD_MACH_O_RELENT_SIZE)
1629 return FALSE;
1630 }
1631 return TRUE;
1632 }
1633
1634 static bfd_boolean
1635 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1636 {
1637 struct mach_o_section_32_external raw;
1638
1639 memcpy (raw.sectname, section->sectname, 16);
1640 memcpy (raw.segname, section->segname, 16);
1641 bfd_h_put_32 (abfd, section->addr, raw.addr);
1642 bfd_h_put_32 (abfd, section->size, raw.size);
1643 bfd_h_put_32 (abfd, section->offset, raw.offset);
1644 bfd_h_put_32 (abfd, section->align, raw.align);
1645 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1646 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1647 bfd_h_put_32 (abfd, section->flags, raw.flags);
1648 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1649 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1650
1651 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1652 != BFD_MACH_O_SECTION_SIZE)
1653 return FALSE;
1654
1655 return TRUE;
1656 }
1657
1658 static bfd_boolean
1659 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1660 {
1661 struct mach_o_section_64_external raw;
1662
1663 memcpy (raw.sectname, section->sectname, 16);
1664 memcpy (raw.segname, section->segname, 16);
1665 bfd_h_put_64 (abfd, section->addr, raw.addr);
1666 bfd_h_put_64 (abfd, section->size, raw.size);
1667 bfd_h_put_32 (abfd, section->offset, raw.offset);
1668 bfd_h_put_32 (abfd, section->align, raw.align);
1669 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1670 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1671 bfd_h_put_32 (abfd, section->flags, raw.flags);
1672 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1673 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1674 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1675
1676 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1677 != BFD_MACH_O_SECTION_64_SIZE)
1678 return FALSE;
1679
1680 return TRUE;
1681 }
1682
1683 static bfd_boolean
1684 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1685 {
1686 struct mach_o_segment_command_32_external raw;
1687 bfd_mach_o_segment_command *seg = &command->command.segment;
1688 bfd_mach_o_section *sec;
1689
1690 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1691
1692 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1693 if (!bfd_mach_o_write_relocs (abfd, sec))
1694 return FALSE;
1695
1696 memcpy (raw.segname, seg->segname, 16);
1697 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1698 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1699 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1700 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1701 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1702 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1703 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1704 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1705
1706 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1707 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1708 return FALSE;
1709
1710 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1711 if (!bfd_mach_o_write_section_32 (abfd, sec))
1712 return FALSE;
1713
1714 return TRUE;
1715 }
1716
1717 static bfd_boolean
1718 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1719 {
1720 struct mach_o_segment_command_64_external raw;
1721 bfd_mach_o_segment_command *seg = &command->command.segment;
1722 bfd_mach_o_section *sec;
1723
1724 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1725
1726 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1727 if (!bfd_mach_o_write_relocs (abfd, sec))
1728 return FALSE;
1729
1730 memcpy (raw.segname, seg->segname, 16);
1731 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1732 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1733 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1734 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1735 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1736 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1737 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1738 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1739
1740 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1741 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1742 return FALSE;
1743
1744 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1745 if (!bfd_mach_o_write_section_64 (abfd, sec))
1746 return FALSE;
1747
1748 return TRUE;
1749 }
1750
1751 static bfd_boolean
1752 bfd_mach_o_write_symtab_content (bfd *abfd, bfd_mach_o_symtab_command *sym)
1753 {
1754 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1755 unsigned long i;
1756 unsigned int wide = bfd_mach_o_wide_p (abfd);
1757 struct bfd_strtab_hash *strtab;
1758 asymbol **symbols = bfd_get_outsymbols (abfd);
1759 int padlen;
1760
1761 /* Write the symbols first. */
1762 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1763 return FALSE;
1764
1765 strtab = _bfd_stringtab_init ();
1766 if (strtab == NULL)
1767 return FALSE;
1768
1769 if (sym->nsyms > 0)
1770 /* Although we don't strictly need to do this, for compatibility with
1771 Darwin system tools, actually output an empty string for the index
1772 0 entry. */
1773 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1774
1775 for (i = 0; i < sym->nsyms; i++)
1776 {
1777 bfd_size_type str_index;
1778 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1779
1780 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1781 /* An index of 0 always means the empty string. */
1782 str_index = 0;
1783 else
1784 {
1785 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1786
1787 if (str_index == (bfd_size_type) -1)
1788 goto err;
1789 }
1790
1791 if (wide)
1792 {
1793 struct mach_o_nlist_64_external raw;
1794
1795 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1796 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1797 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1798 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1799 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1800 raw.n_value);
1801
1802 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1803 goto err;
1804 }
1805 else
1806 {
1807 struct mach_o_nlist_external raw;
1808
1809 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1810 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1811 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1812 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1813 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1814 raw.n_value);
1815
1816 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1817 goto err;
1818 }
1819 }
1820 sym->strsize = _bfd_stringtab_size (strtab);
1821 sym->stroff = mdata->filelen;
1822 mdata->filelen += sym->strsize;
1823
1824 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
1825 return FALSE;
1826
1827 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1828 goto err;
1829 _bfd_stringtab_free (strtab);
1830
1831 /* Pad string table. */
1832 padlen = bfd_mach_o_pad4 (abfd, sym->strsize);
1833 if (padlen < 0)
1834 return FALSE;
1835 mdata->filelen += padlen;
1836 sym->strsize += padlen;
1837
1838 return TRUE;
1839
1840 err:
1841 _bfd_stringtab_free (strtab);
1842 return FALSE;
1843 }
1844
1845 static bfd_boolean
1846 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1847 {
1848 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1849 struct mach_o_symtab_command_external raw;
1850
1851 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1852
1853 /* The command. */
1854 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1855 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1856 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1857 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1858
1859 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1860 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1861 return FALSE;
1862
1863 return TRUE;
1864 }
1865
1866 /* Count the number of indirect symbols in the image.
1867 Requires that the sections are in their final order. */
1868
1869 static unsigned int
1870 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
1871 {
1872 unsigned int i;
1873 unsigned int nisyms = 0;
1874
1875 for (i = 0; i < mdata->nsects; ++i)
1876 {
1877 bfd_mach_o_section *sec = mdata->sections[i];
1878
1879 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1880 {
1881 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
1882 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
1883 case BFD_MACH_O_S_SYMBOL_STUBS:
1884 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
1885 break;
1886 default:
1887 break;
1888 }
1889 }
1890 return nisyms;
1891 }
1892
1893 /* Create the dysymtab. */
1894
1895 static bfd_boolean
1896 bfd_mach_o_build_dysymtab (bfd *abfd, bfd_mach_o_dysymtab_command *cmd)
1897 {
1898 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1899
1900 /* TODO:
1901 We are not going to try and fill these in yet and, moreover, we are
1902 going to bail if they are already set. */
1903 if (cmd->nmodtab != 0
1904 || cmd->ntoc != 0
1905 || cmd->nextrefsyms != 0)
1906 {
1907 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
1908 " implemented for dysymtab commands."));
1909 return FALSE;
1910 }
1911
1912 cmd->ilocalsym = 0;
1913
1914 if (bfd_get_symcount (abfd) > 0)
1915 {
1916 asymbol **symbols = bfd_get_outsymbols (abfd);
1917 unsigned long i;
1918
1919 /* Count the number of each kind of symbol. */
1920 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1921 {
1922 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1923 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
1924 break;
1925 }
1926 cmd->nlocalsym = i;
1927 cmd->iextdefsym = i;
1928 for (; i < bfd_get_symcount (abfd); ++i)
1929 {
1930 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1931 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
1932 break;
1933 }
1934 cmd->nextdefsym = i - cmd->nlocalsym;
1935 cmd->iundefsym = cmd->nextdefsym + cmd->iextdefsym;
1936 cmd->nundefsym = bfd_get_symcount (abfd)
1937 - cmd->nlocalsym
1938 - cmd->nextdefsym;
1939 }
1940 else
1941 {
1942 cmd->nlocalsym = 0;
1943 cmd->iextdefsym = 0;
1944 cmd->nextdefsym = 0;
1945 cmd->iundefsym = 0;
1946 cmd->nundefsym = 0;
1947 }
1948
1949 cmd->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
1950 if (cmd->nindirectsyms > 0)
1951 {
1952 unsigned i;
1953 unsigned n;
1954
1955 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
1956 cmd->indirectsymoff = mdata->filelen;
1957 mdata->filelen += cmd->nindirectsyms * 4;
1958
1959 cmd->indirect_syms = bfd_zalloc (abfd, cmd->nindirectsyms * 4);
1960 if (cmd->indirect_syms == NULL)
1961 return FALSE;
1962
1963 n = 0;
1964 for (i = 0; i < mdata->nsects; ++i)
1965 {
1966 bfd_mach_o_section *sec = mdata->sections[i];
1967
1968 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1969 {
1970 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
1971 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
1972 case BFD_MACH_O_S_SYMBOL_STUBS:
1973 {
1974 unsigned j, num;
1975 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
1976
1977 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
1978 if (isyms == NULL || num == 0)
1979 break;
1980 /* Record the starting index in the reserved1 field. */
1981 sec->reserved1 = n;
1982 for (j = 0; j < num; j++, n++)
1983 {
1984 if (isyms[j] == NULL)
1985 cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
1986 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
1987 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
1988 cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
1989 | BFD_MACH_O_INDIRECT_SYM_ABS;
1990 else
1991 cmd->indirect_syms[n] = isyms[j]->symbol.udata.i;
1992 }
1993 }
1994 break;
1995 default:
1996 break;
1997 }
1998 }
1999 }
2000
2001 return TRUE;
2002 }
2003
2004 /* Write a dysymtab command.
2005 TODO: Possibly coalesce writes of smaller objects. */
2006
2007 static bfd_boolean
2008 bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2009 {
2010 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2011
2012 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2013
2014 if (cmd->nmodtab != 0)
2015 {
2016 unsigned int i;
2017
2018 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2019 return FALSE;
2020
2021 for (i = 0; i < cmd->nmodtab; i++)
2022 {
2023 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2024 unsigned int iinit;
2025 unsigned int ninit;
2026
2027 iinit = module->iinit & 0xffff;
2028 iinit |= ((module->iterm & 0xffff) << 16);
2029
2030 ninit = module->ninit & 0xffff;
2031 ninit |= ((module->nterm & 0xffff) << 16);
2032
2033 if (bfd_mach_o_wide_p (abfd))
2034 {
2035 struct mach_o_dylib_module_64_external w;
2036
2037 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
2038 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
2039 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
2040 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
2041 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
2042 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
2043 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
2044 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
2045 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
2046 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
2047 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
2048 bfd_h_put_64 (abfd, module->objc_module_info_addr,
2049 &w.objc_module_info_addr);
2050 bfd_h_put_32 (abfd, module->objc_module_info_size,
2051 &w.objc_module_info_size);
2052
2053 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
2054 return FALSE;
2055 }
2056 else
2057 {
2058 struct mach_o_dylib_module_external n;
2059
2060 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
2061 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
2062 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
2063 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
2064 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
2065 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
2066 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
2067 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
2068 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
2069 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
2070 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
2071 bfd_h_put_32 (abfd, module->objc_module_info_addr,
2072 &n.objc_module_info_addr);
2073 bfd_h_put_32 (abfd, module->objc_module_info_size,
2074 &n.objc_module_info_size);
2075
2076 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
2077 return FALSE;
2078 }
2079 }
2080 }
2081
2082 if (cmd->ntoc != 0)
2083 {
2084 unsigned int i;
2085
2086 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2087 return FALSE;
2088
2089 for (i = 0; i < cmd->ntoc; i++)
2090 {
2091 struct mach_o_dylib_table_of_contents_external raw;
2092 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2093
2094 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
2095 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
2096
2097 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2098 return FALSE;
2099 }
2100 }
2101
2102 if (cmd->nindirectsyms > 0)
2103 {
2104 unsigned int i;
2105
2106 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2107 return FALSE;
2108
2109 for (i = 0; i < cmd->nindirectsyms; ++i)
2110 {
2111 unsigned char raw[4];
2112
2113 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
2114 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2115 return FALSE;
2116 }
2117 }
2118
2119 if (cmd->nextrefsyms != 0)
2120 {
2121 unsigned int i;
2122
2123 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2124 return FALSE;
2125
2126 for (i = 0; i < cmd->nextrefsyms; i++)
2127 {
2128 unsigned long v;
2129 unsigned char raw[4];
2130 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2131
2132 /* Fields isym and flags are written as bit-fields, thus we need
2133 a specific processing for endianness. */
2134
2135 if (bfd_big_endian (abfd))
2136 {
2137 v = ((ref->isym & 0xffffff) << 8);
2138 v |= ref->flags & 0xff;
2139 }
2140 else
2141 {
2142 v = ref->isym & 0xffffff;
2143 v |= ((ref->flags & 0xff) << 24);
2144 }
2145
2146 bfd_h_put_32 (abfd, v, raw);
2147 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2148 return FALSE;
2149 }
2150 }
2151
2152 /* The command. */
2153 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
2154 return FALSE;
2155 else
2156 {
2157 struct mach_o_dysymtab_command_external raw;
2158
2159 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
2160 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
2161 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
2162 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
2163 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
2164 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
2165 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
2166 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
2167 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
2168 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
2169 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
2170 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
2171 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
2172 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
2173 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
2174 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
2175 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
2176 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
2177
2178 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2179 return FALSE;
2180 }
2181
2182 return TRUE;
2183 }
2184
2185 static unsigned
2186 bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
2187 {
2188 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
2189
2190 /* Just leave debug symbols where they are (pretend they are local, and
2191 then they will just be sorted on position). */
2192 if (s->n_type & BFD_MACH_O_N_STAB)
2193 return 0;
2194
2195 /* Local (we should never see an undefined local AFAICT). */
2196 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
2197 return 0;
2198
2199 /* Common symbols look like undefined externs. */
2200 if (mtyp == BFD_MACH_O_N_UNDF)
2201 return 2;
2202
2203 /* A defined non-local, non-debug symbol. */
2204 return 1;
2205 }
2206
2207 static int
2208 bfd_mach_o_cf_symbols (const void *a, const void *b)
2209 {
2210 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
2211 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
2212 unsigned int soa, sob;
2213
2214 soa = bfd_mach_o_primary_symbol_sort_key (sa);
2215 sob = bfd_mach_o_primary_symbol_sort_key (sb);
2216 if (soa < sob)
2217 return -1;
2218
2219 if (soa > sob)
2220 return 1;
2221
2222 /* If it's local or stab, just preserve the input order. */
2223 if (soa == 0)
2224 {
2225 if (sa->symbol.udata.i < sb->symbol.udata.i)
2226 return -1;
2227 if (sa->symbol.udata.i > sb->symbol.udata.i)
2228 return 1;
2229
2230 /* This is probably an error. */
2231 return 0;
2232 }
2233
2234 /* The second sort key is name. */
2235 return strcmp (sa->symbol.name, sb->symbol.name);
2236 }
2237
2238 /* Process the symbols.
2239
2240 This should be OK for single-module files - but it is not likely to work
2241 for multi-module shared libraries.
2242
2243 (a) If the application has not filled in the relevant mach-o fields, make
2244 an estimate.
2245
2246 (b) Order them, like this:
2247 ( i) local.
2248 (unsorted)
2249 ( ii) external defined
2250 (by name)
2251 (iii) external undefined/common
2252 (by name)
2253 ( iv) common
2254 (by name)
2255 */
2256
2257 static bfd_boolean
2258 bfd_mach_o_mangle_symbols (bfd *abfd)
2259 {
2260 unsigned long i;
2261 asymbol **symbols = bfd_get_outsymbols (abfd);
2262
2263 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
2264 return TRUE;
2265
2266 for (i = 0; i < bfd_get_symcount (abfd); i++)
2267 {
2268 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2269
2270 /* We use this value, which is out-of-range as a symbol index, to signal
2271 that the mach-o-specific data are not filled in and need to be created
2272 from the bfd values. It is much preferable for the application to do
2273 this, since more meaningful diagnostics can be made that way. */
2274
2275 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
2276 {
2277 /* No symbol information has been set - therefore determine
2278 it from the bfd symbol flags/info. */
2279 if (s->symbol.section == bfd_abs_section_ptr)
2280 s->n_type = BFD_MACH_O_N_ABS;
2281 else if (s->symbol.section == bfd_und_section_ptr)
2282 {
2283 s->n_type = BFD_MACH_O_N_UNDF;
2284 if (s->symbol.flags & BSF_WEAK)
2285 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
2286 /* mach-o automatically makes undefined symbols extern. */
2287 s->n_type |= BFD_MACH_O_N_EXT;
2288 s->symbol.flags |= BSF_GLOBAL;
2289 }
2290 else if (s->symbol.section == bfd_com_section_ptr)
2291 {
2292 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
2293 s->symbol.flags |= BSF_GLOBAL;
2294 }
2295 else
2296 s->n_type = BFD_MACH_O_N_SECT;
2297
2298 if (s->symbol.flags & BSF_GLOBAL)
2299 s->n_type |= BFD_MACH_O_N_EXT;
2300 }
2301
2302 /* Put the section index in, where required. */
2303 if ((s->symbol.section != bfd_abs_section_ptr
2304 && s->symbol.section != bfd_und_section_ptr
2305 && s->symbol.section != bfd_com_section_ptr)
2306 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
2307 && s->symbol.name == NULL))
2308 s->n_sect = s->symbol.section->output_section->target_index;
2309
2310 /* Number to preserve order for local and debug syms. */
2311 s->symbol.udata.i = i;
2312 }
2313
2314 /* Sort the symbols. */
2315 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
2316 sizeof (asymbol *), bfd_mach_o_cf_symbols);
2317
2318 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2319 {
2320 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2321 s->symbol.udata.i = i; /* renumber. */
2322 }
2323
2324 return TRUE;
2325 }
2326
2327 /* We build a flat table of sections, which can be re-ordered if necessary.
2328 Fill in the section number and other mach-o-specific data. */
2329
2330 static bfd_boolean
2331 bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
2332 {
2333 asection *sec;
2334 unsigned target_index;
2335 unsigned nsect;
2336
2337 nsect = bfd_count_sections (abfd);
2338
2339 /* Don't do it if it's already set - assume the application knows what it's
2340 doing. */
2341 if (mdata->nsects == nsect
2342 && (mdata->nsects == 0 || mdata->sections != NULL))
2343 return TRUE;
2344
2345 /* We need to check that this can be done... */
2346 if (nsect > 255)
2347 {
2348 (*_bfd_error_handler) (_("mach-o: there are too many sections (%u)"
2349 " maximum is 255,\n"), nsect);
2350 return FALSE;
2351 }
2352
2353 mdata->nsects = nsect;
2354 mdata->sections = bfd_alloc (abfd,
2355 mdata->nsects * sizeof (bfd_mach_o_section *));
2356 if (mdata->sections == NULL)
2357 return FALSE;
2358
2359 /* Create Mach-O sections.
2360 Section type, attribute and align should have been set when the
2361 section was created - either read in or specified. */
2362 target_index = 0;
2363 for (sec = abfd->sections; sec; sec = sec->next)
2364 {
2365 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
2366 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
2367
2368 mdata->sections[target_index] = msect;
2369
2370 msect->addr = bfd_get_section_vma (abfd, sec);
2371 msect->size = bfd_get_section_size (sec);
2372
2373 /* Use the largest alignment set, in case it was bumped after the
2374 section was created. */
2375 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
2376
2377 msect->offset = 0;
2378 sec->target_index = ++target_index;
2379 }
2380
2381 return TRUE;
2382 }
2383
2384 bfd_boolean
2385 bfd_mach_o_write_contents (bfd *abfd)
2386 {
2387 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2388 bfd_mach_o_load_command *cmd;
2389 bfd_mach_o_symtab_command *symtab = NULL;
2390 bfd_mach_o_dysymtab_command *dysymtab = NULL;
2391 bfd_mach_o_segment_command *linkedit = NULL;
2392
2393 /* Make the commands, if not already present. */
2394 if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
2395 return FALSE;
2396 abfd->output_has_begun = TRUE;
2397
2398 /* Write the header. */
2399 if (!bfd_mach_o_write_header (abfd, &mdata->header))
2400 return FALSE;
2401
2402 /* First pass: allocate the linkedit segment. */
2403 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2404 switch (cmd->type)
2405 {
2406 case BFD_MACH_O_LC_SEGMENT_64:
2407 case BFD_MACH_O_LC_SEGMENT:
2408 if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
2409 linkedit = &cmd->command.segment;
2410 break;
2411 case BFD_MACH_O_LC_SYMTAB:
2412 symtab = &cmd->command.symtab;
2413 break;
2414 case BFD_MACH_O_LC_DYSYMTAB:
2415 dysymtab = &cmd->command.dysymtab;
2416 break;
2417 case BFD_MACH_O_LC_DYLD_INFO:
2418 {
2419 bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
2420
2421 if (di->rebase_size != 0)
2422 {
2423 di->rebase_off = mdata->filelen;
2424 mdata->filelen += di->rebase_size;
2425 }
2426 if (di->bind_size != 0)
2427 {
2428 di->bind_off = mdata->filelen;
2429 mdata->filelen += di->bind_size;
2430 }
2431 if (di->weak_bind_size != 0)
2432 {
2433 di->weak_bind_off = mdata->filelen;
2434 mdata->filelen += di->weak_bind_size;
2435 }
2436 if (di->lazy_bind_size != 0)
2437 {
2438 di->lazy_bind_off = mdata->filelen;
2439 mdata->filelen += di->lazy_bind_size;
2440 }
2441 if (di->export_size != 0)
2442 {
2443 di->export_off = mdata->filelen;
2444 mdata->filelen += di->export_size;
2445 }
2446 }
2447 break;
2448 case BFD_MACH_O_LC_LOAD_DYLIB:
2449 case BFD_MACH_O_LC_LOAD_DYLINKER:
2450 case BFD_MACH_O_LC_MAIN:
2451 /* Nothing to do. */
2452 break;
2453 default:
2454 (*_bfd_error_handler)
2455 (_("unable to allocate data for load command 0x%lx"),
2456 (unsigned long) cmd->type);
2457 break;
2458 }
2459
2460 /* Specially handle symtab and dysymtab. */
2461
2462 /* Pre-allocate the symbol table (but not the string table). The reason
2463 is that the dysymtab is after the symbol table but before the string
2464 table (required by the native strip tool). */
2465 if (symtab != NULL)
2466 {
2467 unsigned int symlen;
2468 unsigned int wide = bfd_mach_o_wide_p (abfd);
2469
2470 symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2471
2472 /* Align for symbols. */
2473 mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
2474 symtab->symoff = mdata->filelen;
2475
2476 symtab->nsyms = bfd_get_symcount (abfd);
2477 mdata->filelen += symtab->nsyms * symlen;
2478 }
2479
2480 /* Build the dysymtab. */
2481 if (dysymtab != NULL)
2482 if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
2483 return FALSE;
2484
2485 /* Write symtab and strtab. */
2486 if (symtab != NULL)
2487 if (!bfd_mach_o_write_symtab_content (abfd, symtab))
2488 return FALSE;
2489
2490 /* Adjust linkedit size. */
2491 if (linkedit != NULL)
2492 {
2493 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2494
2495 linkedit->vmsize = mdata->filelen - linkedit->fileoff;
2496 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2497 linkedit->filesize = mdata->filelen - linkedit->fileoff;
2498
2499 linkedit->initprot = BFD_MACH_O_PROT_READ;
2500 linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2501 | BFD_MACH_O_PROT_EXECUTE;
2502 }
2503
2504 /* Second pass: write commands. */
2505 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2506 {
2507 struct mach_o_load_command_external raw;
2508 unsigned long typeflag;
2509
2510 typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
2511
2512 bfd_h_put_32 (abfd, typeflag, raw.cmd);
2513 bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
2514
2515 if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
2516 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
2517 return FALSE;
2518
2519 switch (cmd->type)
2520 {
2521 case BFD_MACH_O_LC_SEGMENT:
2522 if (!bfd_mach_o_write_segment_32 (abfd, cmd))
2523 return FALSE;
2524 break;
2525 case BFD_MACH_O_LC_SEGMENT_64:
2526 if (!bfd_mach_o_write_segment_64 (abfd, cmd))
2527 return FALSE;
2528 break;
2529 case BFD_MACH_O_LC_SYMTAB:
2530 if (!bfd_mach_o_write_symtab (abfd, cmd))
2531 return FALSE;
2532 break;
2533 case BFD_MACH_O_LC_DYSYMTAB:
2534 if (!bfd_mach_o_write_dysymtab (abfd, cmd))
2535 return FALSE;
2536 break;
2537 case BFD_MACH_O_LC_THREAD:
2538 case BFD_MACH_O_LC_UNIXTHREAD:
2539 if (!bfd_mach_o_write_thread (abfd, cmd))
2540 return FALSE;
2541 break;
2542 case BFD_MACH_O_LC_LOAD_DYLIB:
2543 if (!bfd_mach_o_write_dylib (abfd, cmd))
2544 return FALSE;
2545 break;
2546 case BFD_MACH_O_LC_LOAD_DYLINKER:
2547 if (!bfd_mach_o_write_dylinker (abfd, cmd))
2548 return FALSE;
2549 break;
2550 case BFD_MACH_O_LC_MAIN:
2551 if (!bfd_mach_o_write_main (abfd, cmd))
2552 return FALSE;
2553 break;
2554 case BFD_MACH_O_LC_DYLD_INFO:
2555 if (!bfd_mach_o_write_dyld_info (abfd, cmd))
2556 return FALSE;
2557 break;
2558 default:
2559 (*_bfd_error_handler)
2560 (_("unable to write unknown load command 0x%lx"),
2561 (unsigned long) cmd->type);
2562 return FALSE;
2563 }
2564 }
2565
2566 return TRUE;
2567 }
2568
2569 static void
2570 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2571 bfd_mach_o_section *s)
2572 {
2573 if (seg->sect_head == NULL)
2574 seg->sect_head = s;
2575 else
2576 seg->sect_tail->next = s;
2577 seg->sect_tail = s;
2578 }
2579
2580 /* Create section Mach-O flags from BFD flags. */
2581
2582 static void
2583 bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2584 asection *sec)
2585 {
2586 flagword bfd_flags;
2587 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2588
2589 /* Create default flags. */
2590 bfd_flags = bfd_get_section_flags (abfd, sec);
2591 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2592 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2593 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2594 | BFD_MACH_O_S_REGULAR;
2595 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2596 s->flags = BFD_MACH_O_S_ZEROFILL;
2597 else if (bfd_flags & SEC_DEBUGGING)
2598 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2599 else
2600 s->flags = BFD_MACH_O_S_REGULAR;
2601 }
2602
2603 static bfd_boolean
2604 bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2605 {
2606 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2607 unsigned int i, j;
2608
2609 seg->vmaddr = 0;
2610 seg->fileoff = mdata->filelen;
2611 seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2612 | BFD_MACH_O_PROT_EXECUTE;
2613 seg->maxprot = seg->initprot;
2614
2615 /* Append sections to the segment.
2616
2617 This is a little tedious, we have to honor the need to account zerofill
2618 sections after all the rest. This forces us to do the calculation of
2619 total vmsize in three passes so that any alignment increments are
2620 properly accounted. */
2621 for (i = 0; i < mdata->nsects; ++i)
2622 {
2623 bfd_mach_o_section *s = mdata->sections[i];
2624 asection *sec = s->bfdsection;
2625
2626 /* Although we account for zerofill section sizes in vm order, they are
2627 placed in the file in source sequence. */
2628 bfd_mach_o_append_section_to_segment (seg, s);
2629 s->offset = 0;
2630
2631 /* Zerofill sections have zero file size & offset, the only content
2632 written to the file is the symbols. */
2633 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2634 || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2635 == BFD_MACH_O_S_GB_ZEROFILL))
2636 continue;
2637
2638 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2639 sections, even those with zero size. */
2640 if (s->size > 0)
2641 {
2642 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2643 seg->vmsize += s->size;
2644
2645 /* MH_OBJECT files have unaligned content. */
2646 if (1)
2647 {
2648 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2649 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2650 }
2651 seg->filesize += s->size;
2652
2653 /* The system tools write even zero-sized sections with an offset
2654 field set to the current file position. */
2655 s->offset = mdata->filelen;
2656 }
2657
2658 sec->filepos = s->offset;
2659 mdata->filelen += s->size;
2660 }
2661
2662 /* Now pass through again, for zerofill, only now we just update the
2663 vmsize, and then for zerofill_GB. */
2664 for (j = 0; j < 2; j++)
2665 {
2666 unsigned int stype;
2667
2668 if (j == 0)
2669 stype = BFD_MACH_O_S_ZEROFILL;
2670 else
2671 stype = BFD_MACH_O_S_GB_ZEROFILL;
2672
2673 for (i = 0; i < mdata->nsects; ++i)
2674 {
2675 bfd_mach_o_section *s = mdata->sections[i];
2676
2677 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
2678 continue;
2679
2680 if (s->size > 0)
2681 {
2682 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2683 seg->vmsize += s->size;
2684 }
2685 }
2686 }
2687
2688 /* Allocate space for the relocations. */
2689 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2690
2691 for (i = 0; i < mdata->nsects; ++i)
2692 {
2693 bfd_mach_o_section *ms = mdata->sections[i];
2694 asection *sec = ms->bfdsection;
2695
2696 ms->nreloc = sec->reloc_count;
2697 if (ms->nreloc == 0)
2698 {
2699 /* Clear nreloc and reloff if there is no relocs. */
2700 ms->reloff = 0;
2701 continue;
2702 }
2703 sec->rel_filepos = mdata->filelen;
2704 ms->reloff = sec->rel_filepos;
2705 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2706 }
2707
2708 return TRUE;
2709 }
2710
2711 static bfd_boolean
2712 bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2713 {
2714 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2715 unsigned int i;
2716 bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
2717 bfd_vma vma;
2718 bfd_mach_o_section *s;
2719
2720 seg->vmsize = 0;
2721
2722 seg->fileoff = mdata->filelen;
2723 seg->maxprot = 0;
2724 seg->initprot = 0;
2725 seg->flags = 0;
2726
2727 /* Append sections to the segment. We assume they are properly ordered
2728 by vma (but we check that). */
2729 vma = 0;
2730 for (i = 0; i < mdata->nsects; ++i)
2731 {
2732 s = mdata->sections[i];
2733
2734 /* Consider only sections for this segment. */
2735 if (strcmp (seg->segname, s->segname) != 0)
2736 continue;
2737
2738 bfd_mach_o_append_section_to_segment (seg, s);
2739
2740 BFD_ASSERT (s->addr >= vma);
2741 vma = s->addr + s->size;
2742 }
2743
2744 /* Set segment file offset: make it page aligned. */
2745 vma = seg->sect_head->addr;
2746 seg->vmaddr = vma & ~pagemask;
2747 if ((mdata->filelen & pagemask) > (vma & pagemask))
2748 mdata->filelen += pagemask + 1;
2749 seg->fileoff = mdata->filelen & ~pagemask;
2750 mdata->filelen = seg->fileoff + (vma & pagemask);
2751
2752 /* Set section file offset. */
2753 for (s = seg->sect_head; s != NULL; s = s->next)
2754 {
2755 asection *sec = s->bfdsection;
2756 flagword flags = bfd_get_section_flags (abfd, sec);
2757
2758 /* Adjust segment size. */
2759 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2760 seg->vmsize += s->size;
2761
2762 /* File offset and length. */
2763 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2764
2765 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
2766 && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2767 != BFD_MACH_O_S_GB_ZEROFILL))
2768 {
2769 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2770
2771 s->offset = mdata->filelen;
2772 s->bfdsection->filepos = s->offset;
2773
2774 seg->filesize += s->size;
2775 mdata->filelen += s->size;
2776 }
2777 else
2778 {
2779 s->offset = 0;
2780 s->bfdsection->filepos = 0;
2781 }
2782
2783 /* Set protection. */
2784 if (flags & SEC_LOAD)
2785 {
2786 if (flags & SEC_CODE)
2787 seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
2788 if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
2789 seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
2790 }
2791
2792 /* Relocs shouldn't appear in non-object files. */
2793 if (s->bfdsection->reloc_count != 0)
2794 return FALSE;
2795 }
2796
2797 /* Set maxprot. */
2798 if (seg->initprot != 0)
2799 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2800 | BFD_MACH_O_PROT_EXECUTE;
2801 else
2802 seg->maxprot = 0;
2803
2804 /* Round segment size (and file size). */
2805 seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
2806 seg->filesize = (seg->filesize + pagemask) & ~pagemask;
2807 mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
2808
2809 return TRUE;
2810 }
2811
2812 /* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
2813 fields in header. */
2814
2815 static void
2816 bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
2817 {
2818 unsigned wide = mach_o_wide_p (&mdata->header);
2819 unsigned int hdrlen;
2820 ufile_ptr offset;
2821 bfd_mach_o_load_command *cmd;
2822 unsigned int align;
2823
2824 hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2825 align = wide ? 8 - 1 : 4 - 1;
2826 offset = hdrlen;
2827 mdata->header.ncmds = 0;
2828
2829 for (cmd = mdata->first_command; cmd; cmd = cmd->next)
2830 {
2831 mdata->header.ncmds++;
2832 cmd->offset = offset;
2833
2834 switch (cmd->type)
2835 {
2836 case BFD_MACH_O_LC_SEGMENT_64:
2837 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2838 + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
2839 break;
2840 case BFD_MACH_O_LC_SEGMENT:
2841 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2842 + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
2843 break;
2844 case BFD_MACH_O_LC_SYMTAB:
2845 cmd->len = sizeof (struct mach_o_symtab_command_external)
2846 + BFD_MACH_O_LC_SIZE;
2847 break;
2848 case BFD_MACH_O_LC_DYSYMTAB:
2849 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2850 + BFD_MACH_O_LC_SIZE;
2851 break;
2852 case BFD_MACH_O_LC_LOAD_DYLIB:
2853 cmd->len = sizeof (struct mach_o_dylib_command_external)
2854 + BFD_MACH_O_LC_SIZE;
2855 cmd->command.dylib.name_offset = cmd->len;
2856 cmd->len += strlen (cmd->command.dylib.name_str);
2857 cmd->len = (cmd->len + align) & ~align;
2858 break;
2859 case BFD_MACH_O_LC_LOAD_DYLINKER:
2860 cmd->len = sizeof (struct mach_o_str_command_external)
2861 + BFD_MACH_O_LC_SIZE;
2862 cmd->command.dylinker.name_offset = cmd->len;
2863 cmd->len += strlen (cmd->command.dylinker.name_str);
2864 cmd->len = (cmd->len + align) & ~align;
2865 break;
2866 case BFD_MACH_O_LC_MAIN:
2867 cmd->len = sizeof (struct mach_o_entry_point_command_external)
2868 + BFD_MACH_O_LC_SIZE;
2869 break;
2870 case BFD_MACH_O_LC_DYLD_INFO:
2871 cmd->len = sizeof (struct mach_o_dyld_info_command_external)
2872 + BFD_MACH_O_LC_SIZE;
2873 break;
2874 default:
2875 (*_bfd_error_handler)
2876 (_("unable to layout unknown load command 0x%lx"),
2877 (unsigned long) cmd->type);
2878 break;
2879 }
2880
2881 BFD_ASSERT (cmd->len % (align + 1) == 0);
2882 offset += cmd->len;
2883 }
2884 mdata->header.sizeofcmds = offset - hdrlen;
2885 mdata->filelen = offset;
2886 }
2887
2888 /* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
2889 segment. */
2890
2891 static void
2892 bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
2893 bfd_mach_o_load_command *cmd,
2894 const char *segname, unsigned int nbr_sect)
2895 {
2896 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2897 unsigned wide = mach_o_wide_p (&mdata->header);
2898
2899 /* Init segment command. */
2900 cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
2901 cmd->type_required = FALSE;
2902
2903 strcpy (seg->segname, segname);
2904 seg->nsects = nbr_sect;
2905
2906 seg->vmaddr = 0;
2907 seg->vmsize = 0;
2908
2909 seg->fileoff = 0;
2910 seg->filesize = 0;
2911 seg->maxprot = 0;
2912 seg->initprot = 0;
2913 seg->flags = 0;
2914 seg->sect_head = NULL;
2915 seg->sect_tail = NULL;
2916 }
2917
2918 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2919 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2920 and copy functionality. */
2921
2922 bfd_boolean
2923 bfd_mach_o_build_commands (bfd *abfd)
2924 {
2925 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2926 unsigned wide = mach_o_wide_p (&mdata->header);
2927 unsigned int nbr_segcmd = 0;
2928 bfd_mach_o_load_command *commands;
2929 unsigned int nbr_commands;
2930 int symtab_idx = -1;
2931 int dysymtab_idx = -1;
2932 int main_idx = -1;
2933 unsigned int i;
2934
2935 /* Return now if already built. */
2936 if (mdata->header.ncmds != 0)
2937 return TRUE;
2938
2939 /* Fill in the file type, if not already set. */
2940 if (mdata->header.filetype == 0)
2941 {
2942 if (abfd->flags & EXEC_P)
2943 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2944 else if (abfd->flags & DYNAMIC)
2945 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2946 else
2947 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2948 }
2949
2950 /* If hasn't already been done, flatten sections list, and sort
2951 if/when required. Must be done before the symbol table is adjusted,
2952 since that depends on properly numbered sections. */
2953 if (mdata->nsects == 0 || mdata->sections == NULL)
2954 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2955 return FALSE;
2956
2957 /* Order the symbol table, fill-in/check mach-o specific fields and
2958 partition out any indirect symbols. */
2959 if (!bfd_mach_o_mangle_symbols (abfd))
2960 return FALSE;
2961
2962 /* Segment commands. */
2963 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
2964 {
2965 /* Only one segment for all the sections. But the segment is
2966 optional if there is no sections. */
2967 nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
2968 }
2969 else
2970 {
2971 bfd_mach_o_section *prev_sect = NULL;
2972
2973 /* One pagezero segment and one linkedit segment. */
2974 nbr_segcmd = 2;
2975
2976 /* Create one segment for associated segment name in sections.
2977 Assume that sections with the same segment name are consecutive. */
2978 for (i = 0; i < mdata->nsects; i++)
2979 {
2980 bfd_mach_o_section *this_sect = mdata->sections[i];
2981
2982 if (prev_sect == NULL
2983 || strcmp (prev_sect->segname, this_sect->segname) != 0)
2984 {
2985 nbr_segcmd++;
2986 prev_sect = this_sect;
2987 }
2988 }
2989 }
2990
2991 nbr_commands = nbr_segcmd;
2992
2993 /* One command for the symbol table (only if there are symbols. */
2994 if (bfd_get_symcount (abfd) > 0)
2995 symtab_idx = nbr_commands++;
2996
2997 /* FIXME:
2998 This is a rather crude test for whether we should build a dysymtab. */
2999 if (bfd_mach_o_should_emit_dysymtab ()
3000 && bfd_get_symcount (abfd))
3001 {
3002 /* If there should be a case where a dysymtab could be emitted without
3003 a symtab (seems improbable), this would need amending. */
3004 dysymtab_idx = nbr_commands++;
3005 }
3006
3007 /* Add an entry point command. */
3008 if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3009 && bfd_get_start_address (abfd) != 0)
3010 main_idx = nbr_commands++;
3011
3012 /* Well, we must have a header, at least. */
3013 mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3014
3015 /* A bit unusual, but no content is valid;
3016 as -n empty.s -o empty.o */
3017 if (nbr_commands == 0)
3018 {
3019 /* Layout commands (well none...) and set headers command fields. */
3020 bfd_mach_o_layout_commands (mdata);
3021 return TRUE;
3022 }
3023
3024 /* Create commands for segments (and symtabs), prepend them. */
3025 commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3026 if (commands == NULL)
3027 return FALSE;
3028 for (i = 0; i < nbr_commands - 1; i++)
3029 commands[i].next = &commands[i + 1];
3030 commands[nbr_commands - 1].next = mdata->first_command;
3031 if (mdata->first_command == NULL)
3032 mdata->last_command = &commands[nbr_commands - 1];
3033 mdata->first_command = &commands[0];
3034
3035 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3036 {
3037 /* For object file, there is only one segment. */
3038 bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3039 }
3040 else if (nbr_segcmd != 0)
3041 {
3042 bfd_mach_o_load_command *cmd;
3043
3044 BFD_ASSERT (nbr_segcmd >= 2);
3045
3046 /* The pagezero. */
3047 cmd = &commands[0];
3048 bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3049
3050 /* Segments from sections. */
3051 cmd++;
3052 for (i = 0; i < mdata->nsects;)
3053 {
3054 const char *segname = mdata->sections[i]->segname;
3055 unsigned int nbr_sect = 1;
3056
3057 /* Count number of sections for this segment. */
3058 for (i++; i < mdata->nsects; i++)
3059 if (strcmp (mdata->sections[i]->segname, segname) == 0)
3060 nbr_sect++;
3061 else
3062 break;
3063
3064 bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3065 cmd++;
3066 }
3067
3068 /* The linkedit. */
3069 bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
3070 }
3071
3072 if (symtab_idx >= 0)
3073 {
3074 /* Init symtab command. */
3075 bfd_mach_o_load_command *cmd = &commands[symtab_idx];
3076
3077 cmd->type = BFD_MACH_O_LC_SYMTAB;
3078 cmd->type_required = FALSE;
3079 }
3080
3081 /* If required, setup symtab command, see comment above about the quality
3082 of this test. */
3083 if (dysymtab_idx >= 0)
3084 {
3085 bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
3086
3087 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
3088 cmd->type_required = FALSE;
3089 }
3090
3091 /* Create the main command. */
3092 if (main_idx >= 0)
3093 {
3094 bfd_mach_o_load_command *cmd = &commands[main_idx];
3095
3096 cmd->type = BFD_MACH_O_LC_MAIN;
3097 cmd->type_required = TRUE;
3098
3099 cmd->command.main.entryoff = 0;
3100 cmd->command.main.stacksize = 0;
3101 }
3102
3103 /* Layout commands. */
3104 bfd_mach_o_layout_commands (mdata);
3105
3106 /* So, now we have sized the commands and the filelen set to that.
3107 Now we can build the segment command and set the section file offsets. */
3108 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3109 {
3110 for (i = 0; i < nbr_segcmd; i++)
3111 if (!bfd_mach_o_build_obj_seg_command
3112 (abfd, &commands[i].command.segment))
3113 return FALSE;
3114 }
3115 else
3116 {
3117 bfd_vma maxvma = 0;
3118
3119 /* Skip pagezero and linkedit segments. */
3120 for (i = 1; i < nbr_segcmd - 1; i++)
3121 {
3122 bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3123
3124 if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3125 return FALSE;
3126
3127 if (seg->vmaddr + seg->vmsize > maxvma)
3128 maxvma = seg->vmaddr + seg->vmsize;
3129 }
3130
3131 /* Set the size of __PAGEZERO. */
3132 commands[0].command.segment.vmsize =
3133 commands[1].command.segment.vmaddr;
3134
3135 /* Set the vma and fileoff of __LINKEDIT. */
3136 commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3137 commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3138
3139 /* Set entry point (once segments have been laid out). */
3140 if (main_idx >= 0)
3141 commands[main_idx].command.main.entryoff =
3142 bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3143 }
3144
3145 return TRUE;
3146 }
3147
3148 /* Set the contents of a section. */
3149
3150 bfd_boolean
3151 bfd_mach_o_set_section_contents (bfd *abfd,
3152 asection *section,
3153 const void * location,
3154 file_ptr offset,
3155 bfd_size_type count)
3156 {
3157 file_ptr pos;
3158
3159 /* Trying to write the first section contents will trigger the creation of
3160 the load commands if they are not already present. */
3161 if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
3162 return FALSE;
3163
3164 if (count == 0)
3165 return TRUE;
3166
3167 pos = section->filepos + offset;
3168 if (bfd_seek (abfd, pos, SEEK_SET) != 0
3169 || bfd_bwrite (location, count, abfd) != count)
3170 return FALSE;
3171
3172 return TRUE;
3173 }
3174
3175 int
3176 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
3177 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3178 {
3179 return 0;
3180 }
3181
3182 /* Make an empty symbol. This is required only because
3183 bfd_make_section_anyway wants to create a symbol for the section. */
3184
3185 asymbol *
3186 bfd_mach_o_make_empty_symbol (bfd *abfd)
3187 {
3188 asymbol *new_symbol;
3189
3190 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3191 if (new_symbol == NULL)
3192 return new_symbol;
3193 new_symbol->the_bfd = abfd;
3194 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
3195 return new_symbol;
3196 }
3197
3198 static bfd_boolean
3199 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
3200 {
3201 struct mach_o_header_external raw;
3202 unsigned int size;
3203 bfd_vma (*get32) (const void *) = NULL;
3204
3205 /* Just read the magic number. */
3206 if (bfd_seek (abfd, 0, SEEK_SET) != 0
3207 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
3208 return FALSE;
3209
3210 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3211 {
3212 header->byteorder = BFD_ENDIAN_BIG;
3213 header->magic = BFD_MACH_O_MH_MAGIC;
3214 header->version = 1;
3215 get32 = bfd_getb32;
3216 }
3217 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3218 {
3219 header->byteorder = BFD_ENDIAN_LITTLE;
3220 header->magic = BFD_MACH_O_MH_MAGIC;
3221 header->version = 1;
3222 get32 = bfd_getl32;
3223 }
3224 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3225 {
3226 header->byteorder = BFD_ENDIAN_BIG;
3227 header->magic = BFD_MACH_O_MH_MAGIC_64;
3228 header->version = 2;
3229 get32 = bfd_getb32;
3230 }
3231 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3232 {
3233 header->byteorder = BFD_ENDIAN_LITTLE;
3234 header->magic = BFD_MACH_O_MH_MAGIC_64;
3235 header->version = 2;
3236 get32 = bfd_getl32;
3237 }
3238 else
3239 {
3240 header->byteorder = BFD_ENDIAN_UNKNOWN;
3241 return FALSE;
3242 }
3243
3244 /* Once the size of the header is known, read the full header. */
3245 size = mach_o_wide_p (header) ?
3246 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3247
3248 if (bfd_seek (abfd, 0, SEEK_SET) != 0
3249 || bfd_bread (&raw, size, abfd) != size)
3250 return FALSE;
3251
3252 header->cputype = (*get32) (raw.cputype);
3253 header->cpusubtype = (*get32) (raw.cpusubtype);
3254 header->filetype = (*get32) (raw.filetype);
3255 header->ncmds = (*get32) (raw.ncmds);
3256 header->sizeofcmds = (*get32) (raw.sizeofcmds);
3257 header->flags = (*get32) (raw.flags);
3258
3259 if (mach_o_wide_p (header))
3260 header->reserved = (*get32) (raw.reserved);
3261 else
3262 header->reserved = 0;
3263
3264 return TRUE;
3265 }
3266
3267 bfd_boolean
3268 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3269 {
3270 bfd_mach_o_section *s;
3271 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
3272
3273 s = bfd_mach_o_get_mach_o_section (sec);
3274 if (s == NULL)
3275 {
3276 flagword bfd_flags;
3277 static const mach_o_section_name_xlat * xlat;
3278
3279 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3280 if (s == NULL)
3281 return FALSE;
3282 sec->used_by_bfd = s;
3283 s->bfdsection = sec;
3284
3285 /* Create the Darwin seg/sect name pair from the bfd name.
3286 If this is a canonical name for which a specific paiting exists
3287 there will also be defined flags, type, attribute and alignment
3288 values. */
3289 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3290 if (xlat != NULL)
3291 {
3292 s->flags = xlat->macho_sectype | xlat->macho_secattr;
3293 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
3294 : bfdalign;
3295 (void) bfd_set_section_alignment (abfd, sec, s->align);
3296 bfd_flags = bfd_get_section_flags (abfd, sec);
3297 if (bfd_flags == SEC_NO_FLAGS)
3298 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
3299 }
3300 else
3301 /* Create default flags. */
3302 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
3303 }
3304
3305 return _bfd_generic_new_section_hook (abfd, sec);
3306 }
3307
3308 static void
3309 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
3310 unsigned long prot)
3311 {
3312 flagword flags;
3313 bfd_mach_o_section *section;
3314
3315 flags = bfd_get_section_flags (abfd, sec);
3316 section = bfd_mach_o_get_mach_o_section (sec);
3317
3318 /* TODO: see if we should use the xlat system for doing this by
3319 preference and fall back to this for unknown sections. */
3320
3321 if (flags == SEC_NO_FLAGS)
3322 {
3323 /* Try to guess flags. */
3324 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
3325 flags = SEC_DEBUGGING;
3326 else
3327 {
3328 flags = SEC_ALLOC;
3329 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3330 != BFD_MACH_O_S_ZEROFILL)
3331 {
3332 flags |= SEC_LOAD;
3333 if (prot & BFD_MACH_O_PROT_EXECUTE)
3334 flags |= SEC_CODE;
3335 if (prot & BFD_MACH_O_PROT_WRITE)
3336 flags |= SEC_DATA;
3337 else if (prot & BFD_MACH_O_PROT_READ)
3338 flags |= SEC_READONLY;
3339 }
3340 }
3341 }
3342 else
3343 {
3344 if ((flags & SEC_DEBUGGING) == 0)
3345 flags |= SEC_ALLOC;
3346 }
3347
3348 if (section->offset != 0)
3349 flags |= SEC_HAS_CONTENTS;
3350 if (section->nreloc != 0)
3351 flags |= SEC_RELOC;
3352
3353 bfd_set_section_flags (abfd, sec, flags);
3354
3355 sec->vma = section->addr;
3356 sec->lma = section->addr;
3357 sec->size = section->size;
3358 sec->filepos = section->offset;
3359 sec->alignment_power = section->align;
3360 sec->segment_mark = 0;
3361 sec->reloc_count = section->nreloc;
3362 sec->rel_filepos = section->reloff;
3363 }
3364
3365 static asection *
3366 bfd_mach_o_make_bfd_section (bfd *abfd,
3367 const unsigned char *segname,
3368 const unsigned char *sectname)
3369 {
3370 const char *sname;
3371 flagword flags;
3372
3373 bfd_mach_o_convert_section_name_to_bfd
3374 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3375 if (sname == NULL)
3376 return NULL;
3377
3378 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3379 }
3380
3381 static asection *
3382 bfd_mach_o_read_section_32 (bfd *abfd,
3383 unsigned int offset,
3384 unsigned long prot)
3385 {
3386 struct mach_o_section_32_external raw;
3387 asection *sec;
3388 bfd_mach_o_section *section;
3389
3390 if (bfd_seek (abfd, offset, SEEK_SET) != 0
3391 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3392 != BFD_MACH_O_SECTION_SIZE))
3393 return NULL;
3394
3395 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3396 if (sec == NULL)
3397 return NULL;
3398
3399 section = bfd_mach_o_get_mach_o_section (sec);
3400 memcpy (section->segname, raw.segname, sizeof (raw.segname));
3401 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3402 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3403 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3404 section->addr = bfd_h_get_32 (abfd, raw.addr);
3405 section->size = bfd_h_get_32 (abfd, raw.size);
3406 section->offset = bfd_h_get_32 (abfd, raw.offset);
3407 section->align = bfd_h_get_32 (abfd, raw.align);
3408 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3409 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3410 section->flags = bfd_h_get_32 (abfd, raw.flags);
3411 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3412 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3413 section->reserved3 = 0;
3414
3415 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3416
3417 return sec;
3418 }
3419
3420 static asection *
3421 bfd_mach_o_read_section_64 (bfd *abfd,
3422 unsigned int offset,
3423 unsigned long prot)
3424 {
3425 struct mach_o_section_64_external raw;
3426 asection *sec;
3427 bfd_mach_o_section *section;
3428
3429 if (bfd_seek (abfd, offset, SEEK_SET) != 0
3430 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3431 != BFD_MACH_O_SECTION_64_SIZE))
3432 return NULL;
3433
3434 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3435 if (sec == NULL)
3436 return NULL;
3437
3438 section = bfd_mach_o_get_mach_o_section (sec);
3439 memcpy (section->segname, raw.segname, sizeof (raw.segname));
3440 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3441 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3442 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3443 section->addr = bfd_h_get_64 (abfd, raw.addr);
3444 section->size = bfd_h_get_64 (abfd, raw.size);
3445 section->offset = bfd_h_get_32 (abfd, raw.offset);
3446 section->align = bfd_h_get_32 (abfd, raw.align);
3447 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3448 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3449 section->flags = bfd_h_get_32 (abfd, raw.flags);
3450 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3451 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3452 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3453
3454 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3455
3456 return sec;
3457 }
3458
3459 static asection *
3460 bfd_mach_o_read_section (bfd *abfd,
3461 unsigned int offset,
3462 unsigned long prot,
3463 unsigned int wide)
3464 {
3465 if (wide)
3466 return bfd_mach_o_read_section_64 (abfd, offset, prot);
3467 else
3468 return bfd_mach_o_read_section_32 (abfd, offset, prot);
3469 }
3470
3471 static bfd_boolean
3472 bfd_mach_o_read_symtab_symbol (bfd *abfd,
3473 bfd_mach_o_symtab_command *sym,
3474 bfd_mach_o_asymbol *s,
3475 unsigned long i)
3476 {
3477 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3478 unsigned int wide = mach_o_wide_p (&mdata->header);
3479 unsigned int symwidth =
3480 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3481 unsigned int symoff = sym->symoff + (i * symwidth);
3482 struct mach_o_nlist_64_external raw;
3483 unsigned char type = -1;
3484 unsigned char section = -1;
3485 short desc = -1;
3486 symvalue value = -1;
3487 unsigned long stroff = -1;
3488 unsigned int symtype = -1;
3489
3490 BFD_ASSERT (sym->strtab != NULL);
3491
3492 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
3493 || bfd_bread (&raw, symwidth, abfd) != symwidth)
3494 {
3495 (*_bfd_error_handler)
3496 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
3497 symwidth, (unsigned long) symoff);
3498 return FALSE;
3499 }
3500
3501 stroff = bfd_h_get_32 (abfd, raw.n_strx);
3502 type = bfd_h_get_8 (abfd, raw.n_type);
3503 symtype = type & BFD_MACH_O_N_TYPE;
3504 section = bfd_h_get_8 (abfd, raw.n_sect);
3505 desc = bfd_h_get_16 (abfd, raw.n_desc);
3506 if (wide)
3507 value = bfd_h_get_64 (abfd, raw.n_value);
3508 else
3509 value = bfd_h_get_32 (abfd, raw.n_value);
3510
3511 if (stroff >= sym->strsize)
3512 {
3513 (*_bfd_error_handler)
3514 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
3515 (unsigned long) stroff,
3516 (unsigned long) sym->strsize);
3517 return FALSE;
3518 }
3519
3520 s->symbol.the_bfd = abfd;
3521 s->symbol.name = sym->strtab + stroff;
3522 s->symbol.value = value;
3523 s->symbol.flags = 0x0;
3524 s->symbol.udata.i = i;
3525 s->n_type = type;
3526 s->n_sect = section;
3527 s->n_desc = desc;
3528
3529 if (type & BFD_MACH_O_N_STAB)
3530 {
3531 s->symbol.flags |= BSF_DEBUGGING;
3532 s->symbol.section = bfd_und_section_ptr;
3533 switch (type)
3534 {
3535 case N_FUN:
3536 case N_STSYM:
3537 case N_LCSYM:
3538 case N_BNSYM:
3539 case N_SLINE:
3540 case N_ENSYM:
3541 case N_ECOMM:
3542 case N_ECOML:
3543 case N_GSYM:
3544 if ((section > 0) && (section <= mdata->nsects))
3545 {
3546 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3547 s->symbol.value =
3548 s->symbol.value - mdata->sections[section - 1]->addr;
3549 }
3550 break;
3551 }
3552 }
3553 else
3554 {
3555 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
3556 s->symbol.flags |= BSF_GLOBAL;
3557 else
3558 s->symbol.flags |= BSF_LOCAL;
3559
3560 switch (symtype)
3561 {
3562 case BFD_MACH_O_N_UNDF:
3563 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3564 && s->symbol.value != 0)
3565 {
3566 /* A common symbol. */
3567 s->symbol.section = bfd_com_section_ptr;
3568 s->symbol.flags = BSF_NO_FLAGS;
3569 }
3570 else
3571 {
3572 s->symbol.section = bfd_und_section_ptr;
3573 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3574 s->symbol.flags |= BSF_WEAK;
3575 }
3576 break;
3577 case BFD_MACH_O_N_PBUD:
3578 s->symbol.section = bfd_und_section_ptr;
3579 break;
3580 case BFD_MACH_O_N_ABS:
3581 s->symbol.section = bfd_abs_section_ptr;
3582 break;
3583 case BFD_MACH_O_N_SECT:
3584 if ((section > 0) && (section <= mdata->nsects))
3585 {
3586 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3587 s->symbol.value =
3588 s->symbol.value - mdata->sections[section - 1]->addr;
3589 }
3590 else
3591 {
3592 /* Mach-O uses 0 to mean "no section"; not an error. */
3593 if (section != 0)
3594 {
3595 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3596 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3597 s->symbol.name, section, mdata->nsects);
3598 }
3599 s->symbol.section = bfd_und_section_ptr;
3600 }
3601 break;
3602 case BFD_MACH_O_N_INDR:
3603 /* FIXME: we don't follow the BFD convention as this indirect symbol
3604 won't be followed by the referenced one. This looks harmless
3605 unless we start using the linker. */
3606 s->symbol.flags |= BSF_INDIRECT;
3607 s->symbol.section = bfd_ind_section_ptr;
3608 s->symbol.value = 0;
3609 break;
3610 default:
3611 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3612 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3613 s->symbol.name, symtype);
3614 s->symbol.section = bfd_und_section_ptr;
3615 break;
3616 }
3617 }
3618
3619 return TRUE;
3620 }
3621
3622 bfd_boolean
3623 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3624 {
3625 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3626 bfd_mach_o_symtab_command *sym = mdata->symtab;
3627
3628 /* Fail if there is no symtab. */
3629 if (sym == NULL)
3630 return FALSE;
3631
3632 /* Success if already loaded. */
3633 if (sym->strtab)
3634 return TRUE;
3635
3636 if (abfd->flags & BFD_IN_MEMORY)
3637 {
3638 struct bfd_in_memory *b;
3639
3640 b = (struct bfd_in_memory *) abfd->iostream;
3641
3642 if ((sym->stroff + sym->strsize) > b->size)
3643 {
3644 bfd_set_error (bfd_error_file_truncated);
3645 return FALSE;
3646 }
3647 sym->strtab = (char *) b->buffer + sym->stroff;
3648 }
3649 else
3650 {
3651 sym->strtab = bfd_alloc (abfd, sym->strsize);
3652 if (sym->strtab == NULL)
3653 return FALSE;
3654
3655 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3656 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3657 {
3658 /* PR 17512: file: 10888-1609-0.004. */
3659 bfd_release (abfd, sym->strtab);
3660 sym->strtab = NULL;
3661 bfd_set_error (bfd_error_file_truncated);
3662 return FALSE;
3663 }
3664 }
3665
3666 return TRUE;
3667 }
3668
3669 bfd_boolean
3670 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3671 {
3672 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3673 bfd_mach_o_symtab_command *sym = mdata->symtab;
3674 unsigned long i;
3675
3676 if (sym == NULL || sym->symbols)
3677 /* Return now if there are no symbols or if already loaded. */
3678 return TRUE;
3679
3680 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3681
3682 if (sym->symbols == NULL)
3683 {
3684 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3685 return FALSE;
3686 }
3687
3688 if (!bfd_mach_o_read_symtab_strtab (abfd))
3689 {
3690 bfd_release (abfd, sym->symbols);
3691 sym->symbols = NULL;
3692 return FALSE;
3693 }
3694
3695 for (i = 0; i < sym->nsyms; i++)
3696 {
3697 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3698 {
3699 bfd_release (abfd, sym->symbols);
3700 sym->symbols = NULL;
3701 return FALSE;
3702 }
3703 }
3704
3705 return TRUE;
3706 }
3707
3708 static const char *
3709 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3710 {
3711 switch ((int) flavour)
3712 {
3713 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3714 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3715 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3716 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3717 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3718 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3719 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3720 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3721 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3722 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3723 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3724 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3725 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3726 default: return "UNKNOWN";
3727 }
3728 }
3729
3730 static const char *
3731 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3732 {
3733 switch ((int) flavour)
3734 {
3735 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3736 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3737 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3738 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3739 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3740 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3741 default: return "UNKNOWN";
3742 }
3743 }
3744
3745 static bfd_boolean
3746 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3747 {
3748 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3749 struct mach_o_str_command_external raw;
3750 unsigned int nameoff;
3751 unsigned int namelen;
3752
3753 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3754 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3755 return FALSE;
3756
3757 nameoff = bfd_h_get_32 (abfd, raw.str);
3758
3759 cmd->name_offset = nameoff;
3760 namelen = command->len - nameoff;
3761 nameoff += command->offset;
3762 cmd->name_str = bfd_alloc (abfd, namelen);
3763 if (cmd->name_str == NULL)
3764 return FALSE;
3765 if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
3766 || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3767 return FALSE;
3768 return TRUE;
3769 }
3770
3771 static bfd_boolean
3772 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3773 {
3774 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3775 struct mach_o_dylib_command_external raw;
3776 unsigned int nameoff;
3777 unsigned int namelen;
3778
3779 switch (command->type)
3780 {
3781 case BFD_MACH_O_LC_LOAD_DYLIB:
3782 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3783 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3784 case BFD_MACH_O_LC_ID_DYLIB:
3785 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3786 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3787 break;
3788 default:
3789 BFD_FAIL ();
3790 return FALSE;
3791 }
3792
3793 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3794 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3795 return FALSE;
3796
3797 nameoff = bfd_h_get_32 (abfd, raw.name);
3798 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3799 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3800 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3801
3802 cmd->name_offset = command->offset + nameoff;
3803 namelen = command->len - nameoff;
3804 cmd->name_str = bfd_alloc (abfd, namelen);
3805 if (cmd->name_str == NULL)
3806 return FALSE;
3807 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3808 || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
3809 return FALSE;
3810 return TRUE;
3811 }
3812
3813 static bfd_boolean
3814 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3815 bfd_mach_o_load_command *command)
3816 {
3817 bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3818 struct mach_o_prebound_dylib_command_external raw;
3819 unsigned int nameoff;
3820 unsigned int modoff;
3821 unsigned int str_len;
3822 unsigned char *str;
3823
3824 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3825 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3826 return FALSE;
3827
3828 nameoff = bfd_h_get_32 (abfd, raw.name);
3829 modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3830 if (nameoff > command->len || modoff > command->len)
3831 return FALSE;
3832
3833 str_len = command->len - sizeof (raw);
3834 str = bfd_alloc (abfd, str_len);
3835 if (str == NULL)
3836 return FALSE;
3837 if (bfd_bread (str, str_len, abfd) != str_len)
3838 return FALSE;
3839
3840 cmd->name_offset = command->offset + nameoff;
3841 cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3842 cmd->linked_modules_offset = command->offset + modoff;
3843
3844 cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3845 cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3846 return TRUE;
3847 }
3848
3849 static bfd_boolean
3850 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3851 bfd_mach_o_load_command *command)
3852 {
3853 bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3854 struct mach_o_prebind_cksum_command_external raw;
3855
3856 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3857 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3858 return FALSE;
3859
3860 cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3861 return TRUE;
3862 }
3863
3864 static bfd_boolean
3865 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3866 bfd_mach_o_load_command *command)
3867 {
3868 bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3869 struct mach_o_twolevel_hints_command_external raw;
3870
3871 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3872 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3873 return FALSE;
3874
3875 cmd->offset = bfd_get_32 (abfd, raw.offset);
3876 cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3877 return TRUE;
3878 }
3879
3880 static bfd_boolean
3881 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3882 {
3883 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3884 struct mach_o_fvmlib_command_external raw;
3885 unsigned int nameoff;
3886 unsigned int namelen;
3887
3888 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3889 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3890 return FALSE;
3891
3892 nameoff = bfd_h_get_32 (abfd, raw.name);
3893 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3894 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3895
3896 fvm->name_offset = command->offset + nameoff;
3897 namelen = command->len - nameoff;
3898 fvm->name_str = bfd_alloc (abfd, namelen);
3899 if (fvm->name_str == NULL)
3900 return FALSE;
3901 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3902 || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
3903 return FALSE;
3904 return TRUE;
3905 }
3906
3907 static bfd_boolean
3908 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3909 {
3910 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3911 bfd_mach_o_thread_command *cmd = &command->command.thread;
3912 unsigned int offset;
3913 unsigned int nflavours;
3914 unsigned int i;
3915
3916 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3917 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3918
3919 /* Count the number of threads. */
3920 offset = 8;
3921 nflavours = 0;
3922 while (offset != command->len)
3923 {
3924 struct mach_o_thread_command_external raw;
3925
3926 if (offset >= command->len)
3927 return FALSE;
3928
3929 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3930 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3931 return FALSE;
3932
3933 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3934 nflavours++;
3935 }
3936
3937 /* Allocate threads. */
3938 cmd->flavours = bfd_alloc
3939 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3940 if (cmd->flavours == NULL)
3941 return FALSE;
3942 cmd->nflavours = nflavours;
3943
3944 offset = 8;
3945 nflavours = 0;
3946 while (offset != command->len)
3947 {
3948 struct mach_o_thread_command_external raw;
3949
3950 if (offset >= command->len)
3951 return FALSE;
3952
3953 if (nflavours >= cmd->nflavours)
3954 return FALSE;
3955
3956 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3957 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3958 return FALSE;
3959
3960 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3961 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3962 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3963 offset += cmd->flavours[nflavours].size + sizeof (raw);
3964 nflavours++;
3965 }
3966
3967 for (i = 0; i < nflavours; i++)
3968 {
3969 asection *bfdsec;
3970 unsigned int snamelen;
3971 char *sname;
3972 const char *flavourstr;
3973 const char *prefix = "LC_THREAD";
3974 unsigned int j = 0;
3975
3976 switch (mdata->header.cputype)
3977 {
3978 case BFD_MACH_O_CPU_TYPE_POWERPC:
3979 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3980 flavourstr =
3981 bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3982 break;
3983 case BFD_MACH_O_CPU_TYPE_I386:
3984 case BFD_MACH_O_CPU_TYPE_X86_64:
3985 flavourstr =
3986 bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3987 break;
3988 default:
3989 flavourstr = "UNKNOWN_ARCHITECTURE";
3990 break;
3991 }
3992
3993 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3994 sname = bfd_alloc (abfd, snamelen);
3995 if (sname == NULL)
3996 return FALSE;
3997
3998 for (;;)
3999 {
4000 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4001 if (bfd_get_section_by_name (abfd, sname) == NULL)
4002 break;
4003 j++;
4004 }
4005
4006 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
4007
4008 bfdsec->vma = 0;
4009 bfdsec->lma = 0;
4010 bfdsec->size = cmd->flavours[i].size;
4011 bfdsec->filepos = cmd->flavours[i].offset;
4012 bfdsec->alignment_power = 0x0;
4013
4014 cmd->section = bfdsec;
4015 }
4016
4017 return TRUE;
4018 }
4019
4020 static bfd_boolean
4021 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
4022 {
4023 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
4024 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4025
4026 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4027
4028 {
4029 struct mach_o_dysymtab_command_external raw;
4030
4031 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4032 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4033 return FALSE;
4034
4035 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4036 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4037 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4038 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4039 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4040 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4041 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4042 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4043 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4044 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4045 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4046 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4047 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4048 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4049 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4050 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4051 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4052 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4053 }
4054
4055 if (cmd->nmodtab != 0)
4056 {
4057 unsigned int i;
4058 int wide = bfd_mach_o_wide_p (abfd);
4059 unsigned int module_len = wide ? 56 : 52;
4060
4061 cmd->dylib_module =
4062 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
4063 if (cmd->dylib_module == NULL)
4064 return FALSE;
4065
4066 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
4067 return FALSE;
4068
4069 for (i = 0; i < cmd->nmodtab; i++)
4070 {
4071 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4072 unsigned long v;
4073 unsigned char buf[56];
4074
4075 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4076 return FALSE;
4077
4078 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4079 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4080 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4081 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4082 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4083 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4084 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4085 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4086 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4087 v = bfd_h_get_32 (abfd, buf +36);
4088 module->iinit = v & 0xffff;
4089 module->iterm = (v >> 16) & 0xffff;
4090 v = bfd_h_get_32 (abfd, buf + 40);
4091 module->ninit = v & 0xffff;
4092 module->nterm = (v >> 16) & 0xffff;
4093 if (wide)
4094 {
4095 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4096 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4097 }
4098 else
4099 {
4100 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4101 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4102 }
4103 }
4104 }
4105
4106 if (cmd->ntoc != 0)
4107 {
4108 unsigned int i;
4109
4110 cmd->dylib_toc = bfd_alloc
4111 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
4112 if (cmd->dylib_toc == NULL)
4113 return FALSE;
4114
4115 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
4116 return FALSE;
4117
4118 for (i = 0; i < cmd->ntoc; i++)
4119 {
4120 struct mach_o_dylib_table_of_contents_external raw;
4121 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
4122
4123 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4124 return FALSE;
4125
4126 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4127 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4128 }
4129 }
4130
4131 if (cmd->nindirectsyms != 0)
4132 {
4133 unsigned int i;
4134
4135 cmd->indirect_syms = bfd_alloc
4136 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
4137 if (cmd->indirect_syms == NULL)
4138 return FALSE;
4139
4140 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
4141 return FALSE;
4142
4143 for (i = 0; i < cmd->nindirectsyms; i++)
4144 {
4145 unsigned char raw[4];
4146 unsigned int *is = &cmd->indirect_syms[i];
4147
4148 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4149 return FALSE;
4150
4151 *is = bfd_h_get_32 (abfd, raw);
4152 }
4153 }
4154
4155 if (cmd->nextrefsyms != 0)
4156 {
4157 unsigned long v;
4158 unsigned int i;
4159
4160 cmd->ext_refs = bfd_alloc
4161 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
4162 if (cmd->ext_refs == NULL)
4163 return FALSE;
4164
4165 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
4166 return FALSE;
4167
4168 for (i = 0; i < cmd->nextrefsyms; i++)
4169 {
4170 unsigned char raw[4];
4171 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4172
4173 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4174 return FALSE;
4175
4176 /* Fields isym and flags are written as bit-fields, thus we need
4177 a specific processing for endianness. */
4178 v = bfd_h_get_32 (abfd, raw);
4179 if (bfd_big_endian (abfd))
4180 {
4181 ref->isym = (v >> 8) & 0xffffff;
4182 ref->flags = v & 0xff;
4183 }
4184 else
4185 {
4186 ref->isym = v & 0xffffff;
4187 ref->flags = (v >> 24) & 0xff;
4188 }
4189 }
4190 }
4191
4192 if (mdata->dysymtab)
4193 return FALSE;
4194 mdata->dysymtab = cmd;
4195
4196 return TRUE;
4197 }
4198
4199 static bfd_boolean
4200 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
4201 {
4202 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4203 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4204 struct mach_o_symtab_command_external raw;
4205
4206 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4207
4208 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4209 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4210 return FALSE;
4211
4212 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4213 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4214 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4215 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
4216 symtab->symbols = NULL;
4217 symtab->strtab = NULL;
4218
4219 if (symtab->nsyms != 0)
4220 abfd->flags |= HAS_SYMS;
4221
4222 if (mdata->symtab)
4223 return FALSE;
4224 mdata->symtab = symtab;
4225 return TRUE;
4226 }
4227
4228 static bfd_boolean
4229 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
4230 {
4231 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
4232
4233 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4234
4235 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4236 || bfd_bread (cmd->uuid, 16, abfd) != 16)
4237 return FALSE;
4238
4239 return TRUE;
4240 }
4241
4242 static bfd_boolean
4243 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
4244 {
4245 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
4246 struct mach_o_linkedit_data_command_external raw;
4247
4248 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4249 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4250 return FALSE;
4251
4252 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4253 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
4254 return TRUE;
4255 }
4256
4257 static bfd_boolean
4258 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
4259 {
4260 bfd_mach_o_str_command *cmd = &command->command.str;
4261 struct mach_o_str_command_external raw;
4262 unsigned long off;
4263
4264 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4265 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4266 return FALSE;
4267
4268 off = bfd_get_32 (abfd, raw.str);
4269 cmd->stroff = command->offset + off;
4270 cmd->str_len = command->len - off;
4271 cmd->str = bfd_alloc (abfd, cmd->str_len);
4272 if (cmd->str == NULL)
4273 return FALSE;
4274 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
4275 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
4276 return FALSE;
4277 return TRUE;
4278 }
4279
4280 static unsigned char *
4281 bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
4282 {
4283 unsigned char *buf;
4284
4285 buf = bfd_alloc (abfd, size);
4286 if (buf == NULL)
4287 return NULL;
4288 if (bfd_seek (abfd, off, SEEK_SET) != 0
4289 || bfd_bread (buf, size, abfd) != size)
4290 return NULL;
4291 return buf;
4292 }
4293
4294 static bfd_boolean
4295 bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4296 {
4297 /* Read rebase content. */
4298 if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4299 {
4300 cmd->rebase_content =
4301 bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4302 if (cmd->rebase_content == NULL)
4303 return FALSE;
4304 }
4305
4306 /* Read bind content. */
4307 if (cmd->bind_content == NULL && cmd->bind_size != 0)
4308 {
4309 cmd->bind_content =
4310 bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4311 if (cmd->bind_content == NULL)
4312 return FALSE;
4313 }
4314
4315 /* Read weak bind content. */
4316 if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4317 {
4318 cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4319 (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4320 if (cmd->weak_bind_content == NULL)
4321 return FALSE;
4322 }
4323
4324 /* Read lazy bind content. */
4325 if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4326 {
4327 cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4328 (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4329 if (cmd->lazy_bind_content == NULL)
4330 return FALSE;
4331 }
4332
4333 /* Read export content. */
4334 if (cmd->export_content == NULL && cmd->export_size != 0)
4335 {
4336 cmd->export_content = bfd_mach_o_alloc_and_read
4337 (abfd, cmd->export_off, cmd->export_size);
4338 if (cmd->export_content == NULL)
4339 return FALSE;
4340 }
4341
4342 return TRUE;
4343 }
4344
4345 static bfd_boolean
4346 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
4347 {
4348 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
4349 struct mach_o_dyld_info_command_external raw;
4350
4351 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4352 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4353 return FALSE;
4354
4355 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4356 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
4357 cmd->rebase_content = NULL;
4358 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4359 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
4360 cmd->bind_content = NULL;
4361 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4362 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
4363 cmd->weak_bind_content = NULL;
4364 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4365 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
4366 cmd->lazy_bind_content = NULL;
4367 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4368 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
4369 cmd->export_content = NULL;
4370 return TRUE;
4371 }
4372
4373 static bfd_boolean
4374 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4375 {
4376 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4377 struct mach_o_version_min_command_external raw;
4378 unsigned int ver;
4379
4380 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4381 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4382 return FALSE;
4383
4384 ver = bfd_get_32 (abfd, raw.version);
4385 cmd->rel = ver >> 16;
4386 cmd->maj = ver >> 8;
4387 cmd->min = ver;
4388 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
4389 return TRUE;
4390 }
4391
4392 static bfd_boolean
4393 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4394 {
4395 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4396 struct mach_o_encryption_info_command_external raw;
4397
4398 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4399 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4400 return FALSE;
4401
4402 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4403 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4404 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4405 return TRUE;
4406 }
4407
4408 static bfd_boolean
4409 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4410 {
4411 bfd_mach_o_main_command *cmd = &command->command.main;
4412 struct mach_o_entry_point_command_external raw;
4413
4414 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4415 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4416 return FALSE;
4417
4418 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4419 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4420 return TRUE;
4421 }
4422
4423 static bfd_boolean
4424 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4425 {
4426 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4427 struct mach_o_source_version_command_external raw;
4428 bfd_uint64_t ver;
4429
4430 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4431 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4432 return FALSE;
4433
4434 ver = bfd_get_64 (abfd, raw.version);
4435 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4436 generates warnings) in case of the host doesn't support 64 bit
4437 integers. */
4438 cmd->e = ver & 0x3ff;
4439 ver >>= 10;
4440 cmd->d = ver & 0x3ff;
4441 ver >>= 10;
4442 cmd->c = ver & 0x3ff;
4443 ver >>= 10;
4444 cmd->b = ver & 0x3ff;
4445 ver >>= 10;
4446 cmd->a = ver & 0xffffff;
4447 return TRUE;
4448 }
4449
4450 static bfd_boolean
4451 bfd_mach_o_read_segment (bfd *abfd,
4452 bfd_mach_o_load_command *command,
4453 unsigned int wide)
4454 {
4455 bfd_mach_o_segment_command *seg = &command->command.segment;
4456 unsigned long i;
4457
4458 if (wide)
4459 {
4460 struct mach_o_segment_command_64_external raw;
4461
4462 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
4463
4464 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4465 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4466 return FALSE;
4467
4468 memcpy (seg->segname, raw.segname, 16);
4469 seg->segname[16] = '\0';
4470
4471 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4472 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4473 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4474 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4475 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4476 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4477 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4478 seg->flags = bfd_h_get_32 (abfd, raw.flags);
4479 }
4480 else
4481 {
4482 struct mach_o_segment_command_32_external raw;
4483
4484 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4485
4486 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
4487 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4488 return FALSE;
4489
4490 memcpy (seg->segname, raw.segname, 16);
4491 seg->segname[16] = '\0';
4492
4493 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4494 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4495 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4496 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4497 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4498 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4499 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4500 seg->flags = bfd_h_get_32 (abfd, raw.flags);
4501 }
4502 seg->sect_head = NULL;
4503 seg->sect_tail = NULL;
4504
4505 for (i = 0; i < seg->nsects; i++)
4506 {
4507 bfd_vma segoff;
4508 asection *sec;
4509
4510 if (wide)
4511 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
4512 + (i * BFD_MACH_O_SECTION_64_SIZE);
4513 else
4514 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
4515 + (i * BFD_MACH_O_SECTION_SIZE);
4516
4517 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
4518 if (sec == NULL)
4519 return FALSE;
4520
4521 bfd_mach_o_append_section_to_segment
4522 (seg, bfd_mach_o_get_mach_o_section (sec));
4523 }
4524
4525 return TRUE;
4526 }
4527
4528 static bfd_boolean
4529 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
4530 {
4531 return bfd_mach_o_read_segment (abfd, command, 0);
4532 }
4533
4534 static bfd_boolean
4535 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
4536 {
4537 return bfd_mach_o_read_segment (abfd, command, 1);
4538 }
4539
4540 static bfd_boolean
4541 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
4542 {
4543 struct mach_o_load_command_external raw;
4544 unsigned int cmd;
4545
4546 /* Read command type and length. */
4547 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
4548 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
4549 return FALSE;
4550
4551 cmd = bfd_h_get_32 (abfd, raw.cmd);
4552 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4553 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
4554 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
4555
4556 switch (command->type)
4557 {
4558 case BFD_MACH_O_LC_SEGMENT:
4559 if (!bfd_mach_o_read_segment_32 (abfd, command))
4560 return FALSE;
4561 break;
4562 case BFD_MACH_O_LC_SEGMENT_64:
4563 if (!bfd_mach_o_read_segment_64 (abfd, command))
4564 return FALSE;
4565 break;
4566 case BFD_MACH_O_LC_SYMTAB:
4567 if (!bfd_mach_o_read_symtab (abfd, command))
4568 return FALSE;
4569 break;
4570 case BFD_MACH_O_LC_SYMSEG:
4571 break;
4572 case BFD_MACH_O_LC_THREAD:
4573 case BFD_MACH_O_LC_UNIXTHREAD:
4574 if (!bfd_mach_o_read_thread (abfd, command))
4575 return FALSE;
4576 break;
4577 case BFD_MACH_O_LC_LOAD_DYLINKER:
4578 case BFD_MACH_O_LC_ID_DYLINKER:
4579 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
4580 if (!bfd_mach_o_read_dylinker (abfd, command))
4581 return FALSE;
4582 break;
4583 case BFD_MACH_O_LC_LOAD_DYLIB:
4584 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4585 case BFD_MACH_O_LC_ID_DYLIB:
4586 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4587 case BFD_MACH_O_LC_REEXPORT_DYLIB:
4588 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4589 if (!bfd_mach_o_read_dylib (abfd, command))
4590 return FALSE;
4591 break;
4592 case BFD_MACH_O_LC_PREBOUND_DYLIB:
4593 if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4594 return FALSE;
4595 break;
4596 case BFD_MACH_O_LC_LOADFVMLIB:
4597 case BFD_MACH_O_LC_IDFVMLIB:
4598 if (!bfd_mach_o_read_fvmlib (abfd, command))
4599 return FALSE;
4600 break;
4601 case BFD_MACH_O_LC_IDENT:
4602 case BFD_MACH_O_LC_FVMFILE:
4603 case BFD_MACH_O_LC_PREPAGE:
4604 case BFD_MACH_O_LC_ROUTINES:
4605 case BFD_MACH_O_LC_ROUTINES_64:
4606 break;
4607 case BFD_MACH_O_LC_SUB_FRAMEWORK:
4608 case BFD_MACH_O_LC_SUB_UMBRELLA:
4609 case BFD_MACH_O_LC_SUB_LIBRARY:
4610 case BFD_MACH_O_LC_SUB_CLIENT:
4611 case BFD_MACH_O_LC_RPATH:
4612 if (!bfd_mach_o_read_str (abfd, command))
4613 return FALSE;
4614 break;
4615 case BFD_MACH_O_LC_DYSYMTAB:
4616 if (!bfd_mach_o_read_dysymtab (abfd, command))
4617 return FALSE;
4618 break;
4619 case BFD_MACH_O_LC_PREBIND_CKSUM:
4620 if (!bfd_mach_o_read_prebind_cksum (abfd, command))
4621 return FALSE;
4622 break;
4623 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
4624 if (!bfd_mach_o_read_twolevel_hints (abfd, command))
4625 return FALSE;
4626 break;
4627 case BFD_MACH_O_LC_UUID:
4628 if (!bfd_mach_o_read_uuid (abfd, command))
4629 return FALSE;
4630 break;
4631 case BFD_MACH_O_LC_CODE_SIGNATURE:
4632 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
4633 case BFD_MACH_O_LC_FUNCTION_STARTS:
4634 case BFD_MACH_O_LC_DATA_IN_CODE:
4635 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
4636 if (!bfd_mach_o_read_linkedit (abfd, command))
4637 return FALSE;
4638 break;
4639 case BFD_MACH_O_LC_ENCRYPTION_INFO:
4640 if (!bfd_mach_o_read_encryption_info (abfd, command))
4641 return FALSE;
4642 break;
4643 case BFD_MACH_O_LC_DYLD_INFO:
4644 if (!bfd_mach_o_read_dyld_info (abfd, command))
4645 return FALSE;
4646 break;
4647 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
4648 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
4649 if (!bfd_mach_o_read_version_min (abfd, command))
4650 return FALSE;
4651 break;
4652 case BFD_MACH_O_LC_MAIN:
4653 if (!bfd_mach_o_read_main (abfd, command))
4654 return FALSE;
4655 break;
4656 case BFD_MACH_O_LC_SOURCE_VERSION:
4657 if (!bfd_mach_o_read_source_version (abfd, command))
4658 return FALSE;
4659 break;
4660 default:
4661 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
4662 abfd, (unsigned long) command->type);
4663 break;
4664 }
4665
4666 return TRUE;
4667 }
4668
4669 static void
4670 bfd_mach_o_flatten_sections (bfd *abfd)
4671 {
4672 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4673 bfd_mach_o_load_command *cmd;
4674 long csect = 0;
4675
4676 /* Count total number of sections. */
4677 mdata->nsects = 0;
4678
4679 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4680 {
4681 if (cmd->type == BFD_MACH_O_LC_SEGMENT
4682 || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4683 {
4684 bfd_mach_o_segment_command *seg = &cmd->command.segment;
4685
4686 mdata->nsects += seg->nsects;
4687 }
4688 }
4689
4690 /* Allocate sections array. */
4691 mdata->sections = bfd_alloc (abfd,
4692 mdata->nsects * sizeof (bfd_mach_o_section *));
4693
4694 /* Fill the array. */
4695 csect = 0;
4696
4697 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4698 {
4699 if (cmd->type == BFD_MACH_O_LC_SEGMENT
4700 || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
4701 {
4702 bfd_mach_o_segment_command *seg = &cmd->command.segment;
4703 bfd_mach_o_section *sec;
4704
4705 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4706
4707 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4708 mdata->sections[csect++] = sec;
4709 }
4710 }
4711 }
4712
4713 static bfd_boolean
4714 bfd_mach_o_scan_start_address (bfd *abfd)
4715 {
4716 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4717 bfd_mach_o_thread_command *thr = NULL;
4718 bfd_mach_o_load_command *cmd;
4719 unsigned long i;
4720
4721 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
4722 if (cmd->type == BFD_MACH_O_LC_THREAD
4723 || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
4724 {
4725 thr = &cmd->command.thread;
4726 break;
4727 }
4728 else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
4729 {
4730 bfd_mach_o_main_command *main_cmd = &cmd->command.main;
4731 bfd_mach_o_section *text_sect = mdata->sections[0];
4732
4733 if (text_sect)
4734 {
4735 abfd->start_address = main_cmd->entryoff
4736 + (text_sect->addr - text_sect->offset);
4737 return TRUE;
4738 }
4739 }
4740
4741 /* An object file has no start address, so do not fail if not found. */
4742 if (thr == NULL)
4743 return TRUE;
4744
4745 /* FIXME: create a subtarget hook ? */
4746 for (i = 0; i < thr->nflavours; i++)
4747 {
4748 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4749 && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
4750 {
4751 unsigned char buf[4];
4752
4753 if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
4754 || bfd_bread (buf, 4, abfd) != 4)
4755 return FALSE;
4756
4757 abfd->start_address = bfd_h_get_32 (abfd, buf);
4758 }
4759 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4760 && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4761 {
4762 unsigned char buf[4];
4763
4764 if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4765 || bfd_bread (buf, 4, abfd) != 4)
4766 return FALSE;
4767
4768 abfd->start_address = bfd_h_get_32 (abfd, buf);
4769 }
4770 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4771 && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4772 {
4773 unsigned char buf[8];
4774
4775 if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
4776 || bfd_bread (buf, 8, abfd) != 8)
4777 return FALSE;
4778
4779 abfd->start_address = bfd_h_get_64 (abfd, buf);
4780 }
4781 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4782 && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4783 {
4784 unsigned char buf[8];
4785
4786 if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4787 || bfd_bread (buf, 8, abfd) != 8)
4788 return FALSE;
4789
4790 abfd->start_address = bfd_h_get_64 (abfd, buf);
4791 }
4792 }
4793
4794 return TRUE;
4795 }
4796
4797 bfd_boolean
4798 bfd_mach_o_set_arch_mach (bfd *abfd,
4799 enum bfd_architecture arch,
4800 unsigned long machine)
4801 {
4802 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4803
4804 /* If this isn't the right architecture for this backend, and this
4805 isn't the generic backend, fail. */
4806 if (arch != bed->arch
4807 && arch != bfd_arch_unknown
4808 && bed->arch != bfd_arch_unknown)
4809 return FALSE;
4810
4811 return bfd_default_set_arch_mach (abfd, arch, machine);
4812 }
4813
4814 static bfd_boolean
4815 bfd_mach_o_scan (bfd *abfd,
4816 bfd_mach_o_header *header,
4817 bfd_mach_o_data_struct *mdata)
4818 {
4819 unsigned int i;
4820 enum bfd_architecture cputype;
4821 unsigned long cpusubtype;
4822 unsigned int hdrsize;
4823
4824 hdrsize = mach_o_wide_p (header) ?
4825 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4826
4827 mdata->header = *header;
4828
4829 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4830 switch (header->filetype)
4831 {
4832 case BFD_MACH_O_MH_OBJECT:
4833 abfd->flags |= HAS_RELOC;
4834 break;
4835 case BFD_MACH_O_MH_EXECUTE:
4836 abfd->flags |= EXEC_P;
4837 break;
4838 case BFD_MACH_O_MH_DYLIB:
4839 case BFD_MACH_O_MH_BUNDLE:
4840 abfd->flags |= DYNAMIC;
4841 break;
4842 }
4843
4844 abfd->tdata.mach_o_data = mdata;
4845
4846 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4847 &cputype, &cpusubtype);
4848 if (cputype == bfd_arch_unknown)
4849 {
4850 (*_bfd_error_handler)
4851 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4852 header->cputype, header->cpusubtype);
4853 return FALSE;
4854 }
4855
4856 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4857
4858 if (header->ncmds != 0)
4859 {
4860 bfd_mach_o_load_command *cmd;
4861
4862 mdata->first_command = NULL;
4863 mdata->last_command = NULL;
4864 cmd = bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4865 if (cmd == NULL)
4866 return FALSE;
4867
4868 for (i = 0; i < header->ncmds; i++)
4869 {
4870 bfd_mach_o_load_command *cur = &cmd[i];
4871
4872 bfd_mach_o_append_command (abfd, cur);
4873
4874 if (i == 0)
4875 cur->offset = hdrsize;
4876 else
4877 {
4878 bfd_mach_o_load_command *prev = &cmd[i - 1];
4879 cur->offset = prev->offset + prev->len;
4880 }
4881
4882 if (!bfd_mach_o_read_command (abfd, cur))
4883 return FALSE;
4884 }
4885 }
4886
4887 /* Sections should be flatten before scanning start address. */
4888 bfd_mach_o_flatten_sections (abfd);
4889 if (!bfd_mach_o_scan_start_address (abfd))
4890 return FALSE;
4891
4892 return TRUE;
4893 }
4894
4895 bfd_boolean
4896 bfd_mach_o_mkobject_init (bfd *abfd)
4897 {
4898 bfd_mach_o_data_struct *mdata = NULL;
4899
4900 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4901 if (mdata == NULL)
4902 return FALSE;
4903 abfd->tdata.mach_o_data = mdata;
4904
4905 mdata->header.magic = 0;
4906 mdata->header.cputype = 0;
4907 mdata->header.cpusubtype = 0;
4908 mdata->header.filetype = 0;
4909 mdata->header.ncmds = 0;
4910 mdata->header.sizeofcmds = 0;
4911 mdata->header.flags = 0;
4912 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4913 mdata->first_command = NULL;
4914 mdata->last_command = NULL;
4915 mdata->nsects = 0;
4916 mdata->sections = NULL;
4917 mdata->dyn_reloc_cache = NULL;
4918
4919 return TRUE;
4920 }
4921
4922 static bfd_boolean
4923 bfd_mach_o_gen_mkobject (bfd *abfd)
4924 {
4925 bfd_mach_o_data_struct *mdata;
4926
4927 if (!bfd_mach_o_mkobject_init (abfd))
4928 return FALSE;
4929
4930 mdata = bfd_mach_o_get_data (abfd);
4931 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4932 mdata->header.cputype = 0;
4933 mdata->header.cpusubtype = 0;
4934 mdata->header.byteorder = abfd->xvec->byteorder;
4935 mdata->header.version = 1;
4936
4937 return TRUE;
4938 }
4939
4940 const bfd_target *
4941 bfd_mach_o_header_p (bfd *abfd,
4942 bfd_mach_o_filetype filetype,
4943 bfd_mach_o_cpu_type cputype)
4944 {
4945 bfd_mach_o_header header;
4946 bfd_mach_o_data_struct *mdata;
4947
4948 if (!bfd_mach_o_read_header (abfd, &header))
4949 goto wrong;
4950
4951 if (! (header.byteorder == BFD_ENDIAN_BIG
4952 || header.byteorder == BFD_ENDIAN_LITTLE))
4953 {
4954 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4955 (unsigned long) header.byteorder);
4956 goto wrong;
4957 }
4958
4959 if (! ((header.byteorder == BFD_ENDIAN_BIG
4960 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4961 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4962 || (header.byteorder == BFD_ENDIAN_LITTLE
4963 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4964 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4965 goto wrong;
4966
4967 /* Check cputype and filetype.
4968 In case of wildcard, do not accept magics that are handled by existing
4969 targets. */
4970 if (cputype)
4971 {
4972 if (header.cputype != cputype)
4973 goto wrong;
4974 }
4975 else
4976 {
4977 #ifndef BFD64
4978 /* Do not recognize 64 architectures if not configured for 64bit targets.
4979 This could happen only for generic targets. */
4980 if (mach_o_wide_p (&header))
4981 goto wrong;
4982 #endif
4983 }
4984
4985 if (filetype)
4986 {
4987 if (header.filetype != filetype)
4988 goto wrong;
4989 }
4990 else
4991 {
4992 switch (header.filetype)
4993 {
4994 case BFD_MACH_O_MH_CORE:
4995 /* Handled by core_p */
4996 goto wrong;
4997 default:
4998 break;
4999 }
5000 }
5001
5002 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5003 if (mdata == NULL)
5004 goto fail;
5005
5006 if (!bfd_mach_o_scan (abfd, &header, mdata))
5007 goto wrong;
5008
5009 return abfd->xvec;
5010
5011 wrong:
5012 bfd_set_error (bfd_error_wrong_format);
5013
5014 fail:
5015 return NULL;
5016 }
5017
5018 static const bfd_target *
5019 bfd_mach_o_gen_object_p (bfd *abfd)
5020 {
5021 return bfd_mach_o_header_p (abfd, 0, 0);
5022 }
5023
5024 static const bfd_target *
5025 bfd_mach_o_gen_core_p (bfd *abfd)
5026 {
5027 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
5028 }
5029
5030 /* Return the base address of ABFD, ie the address at which the image is
5031 mapped. The possible initial pagezero is ignored. */
5032
5033 bfd_vma
5034 bfd_mach_o_get_base_address (bfd *abfd)
5035 {
5036 bfd_mach_o_data_struct *mdata;
5037 bfd_mach_o_load_command *cmd;
5038
5039 /* Check for Mach-O. */
5040 if (!bfd_mach_o_valid (abfd))
5041 return 0;
5042 mdata = bfd_mach_o_get_data (abfd);
5043
5044 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5045 {
5046 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5047 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5048 {
5049 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5050
5051 if (segcmd->initprot != 0)
5052 return segcmd->vmaddr;
5053 }
5054 }
5055 return 0;
5056 }
5057
5058 typedef struct mach_o_fat_archentry
5059 {
5060 unsigned long cputype;
5061 unsigned long cpusubtype;
5062 unsigned long offset;
5063 unsigned long size;
5064 unsigned long align;
5065 } mach_o_fat_archentry;
5066
5067 typedef struct mach_o_fat_data_struct
5068 {
5069 unsigned long magic;
5070 unsigned long nfat_arch;
5071 mach_o_fat_archentry *archentries;
5072 } mach_o_fat_data_struct;
5073
5074 const bfd_target *
5075 bfd_mach_o_archive_p (bfd *abfd)
5076 {
5077 mach_o_fat_data_struct *adata = NULL;
5078 struct mach_o_fat_header_external hdr;
5079 unsigned long i;
5080
5081 if (bfd_seek (abfd, 0, SEEK_SET) != 0
5082 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
5083 goto error;
5084
5085 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
5086 if (adata == NULL)
5087 goto error;
5088
5089 adata->magic = bfd_getb32 (hdr.magic);
5090 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
5091 if (adata->magic != 0xcafebabe)
5092 goto error;
5093 /* Avoid matching Java bytecode files, which have the same magic number.
5094 In the Java bytecode file format this field contains the JVM version,
5095 which starts at 43.0. */
5096 if (adata->nfat_arch > 30)
5097 goto error;
5098
5099 adata->archentries =
5100 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
5101 if (adata->archentries == NULL)
5102 goto error;
5103
5104 for (i = 0; i < adata->nfat_arch; i++)
5105 {
5106 struct mach_o_fat_arch_external arch;
5107 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
5108 goto error;
5109 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5110 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5111 adata->archentries[i].offset = bfd_getb32 (arch.offset);
5112 adata->archentries[i].size = bfd_getb32 (arch.size);
5113 adata->archentries[i].align = bfd_getb32 (arch.align);
5114 }
5115
5116 abfd->tdata.mach_o_fat_data = adata;
5117 return abfd->xvec;
5118
5119 error:
5120 if (adata != NULL)
5121 bfd_release (abfd, adata);
5122 bfd_set_error (bfd_error_wrong_format);
5123 return NULL;
5124 }
5125
5126 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
5127 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5128 Set arelt_data and origin fields too. */
5129
5130 static void
5131 bfd_mach_o_fat_member_init (bfd *abfd,
5132 enum bfd_architecture arch_type,
5133 unsigned long arch_subtype,
5134 mach_o_fat_archentry *entry)
5135 {
5136 struct areltdata *areltdata;
5137 /* Create the member filename. Use ARCH_NAME. */
5138 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5139
5140 if (ap)
5141 {
5142 /* Use the architecture name if known. */
5143 abfd->filename = xstrdup (ap->printable_name);
5144 }
5145 else
5146 {
5147 /* Forge a uniq id. */
5148 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
5149 char *name = xmalloc (namelen);
5150 snprintf (name, namelen, "0x%lx-0x%lx",
5151 entry->cputype, entry->cpusubtype);
5152 abfd->filename = name;
5153 }
5154
5155 areltdata = bfd_zmalloc (sizeof (struct areltdata));
5156 areltdata->parsed_size = entry->size;
5157 abfd->arelt_data = areltdata;
5158 abfd->iostream = NULL;
5159 abfd->origin = entry->offset;
5160 }
5161
5162 bfd *
5163 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
5164 {
5165 mach_o_fat_data_struct *adata;
5166 mach_o_fat_archentry *entry = NULL;
5167 unsigned long i;
5168 bfd *nbfd;
5169 enum bfd_architecture arch_type;
5170 unsigned long arch_subtype;
5171
5172 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
5173 BFD_ASSERT (adata != NULL);
5174
5175 /* Find index of previous entry. */
5176 if (prev == NULL)
5177 {
5178 /* Start at first one. */
5179 i = 0;
5180 }
5181 else
5182 {
5183 /* Find index of PREV. */
5184 for (i = 0; i < adata->nfat_arch; i++)
5185 {
5186 if (adata->archentries[i].offset == prev->origin)
5187 break;
5188 }
5189
5190 if (i == adata->nfat_arch)
5191 {
5192 /* Not found. */
5193 bfd_set_error (bfd_error_bad_value);
5194 return NULL;
5195 }
5196
5197 /* Get next entry. */
5198 i++;
5199 }
5200
5201 if (i >= adata->nfat_arch)
5202 {
5203 bfd_set_error (bfd_error_no_more_archived_files);
5204 return NULL;
5205 }
5206
5207 entry = &adata->archentries[i];
5208 nbfd = _bfd_new_bfd_contained_in (archive);
5209 if (nbfd == NULL)
5210 return NULL;
5211
5212 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5213 &arch_type, &arch_subtype);
5214
5215 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
5216
5217 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
5218
5219 return nbfd;
5220 }
5221
5222 /* Analogous to stat call. */
5223
5224 static int
5225 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5226 {
5227 if (abfd->arelt_data == NULL)
5228 {
5229 bfd_set_error (bfd_error_invalid_operation);
5230 return -1;
5231 }
5232
5233 buf->st_mtime = 0;
5234 buf->st_uid = 0;
5235 buf->st_gid = 0;
5236 buf->st_mode = 0644;
5237 buf->st_size = arelt_size (abfd);
5238
5239 return 0;
5240 }
5241
5242 /* If ABFD format is FORMAT and architecture is ARCH, return it.
5243 If ABFD is a fat image containing a member that corresponds to FORMAT
5244 and ARCH, returns it.
5245 In other case, returns NULL.
5246 This function allows transparent uses of fat images. */
5247
5248 bfd *
5249 bfd_mach_o_fat_extract (bfd *abfd,
5250 bfd_format format,
5251 const bfd_arch_info_type *arch)
5252 {
5253 bfd *res;
5254 mach_o_fat_data_struct *adata;
5255 unsigned int i;
5256
5257 if (bfd_check_format (abfd, format))
5258 {
5259 if (bfd_get_arch_info (abfd) == arch)
5260 return abfd;
5261 return NULL;
5262 }
5263 if (!bfd_check_format (abfd, bfd_archive)
5264 || abfd->xvec != &mach_o_fat_vec)
5265 return NULL;
5266
5267 /* This is a Mach-O fat image. */
5268 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5269 BFD_ASSERT (adata != NULL);
5270
5271 for (i = 0; i < adata->nfat_arch; i++)
5272 {
5273 struct mach_o_fat_archentry *e = &adata->archentries[i];
5274 enum bfd_architecture cpu_type;
5275 unsigned long cpu_subtype;
5276
5277 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5278 &cpu_type, &cpu_subtype);
5279 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5280 continue;
5281
5282 /* The architecture is found. */
5283 res = _bfd_new_bfd_contained_in (abfd);
5284 if (res == NULL)
5285 return NULL;
5286
5287 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
5288
5289 if (bfd_check_format (res, format))
5290 {
5291 BFD_ASSERT (bfd_get_arch_info (res) == arch);
5292 return res;
5293 }
5294 bfd_close (res);
5295 return NULL;
5296 }
5297
5298 return NULL;
5299 }
5300
5301 int
5302 bfd_mach_o_lookup_command (bfd *abfd,
5303 bfd_mach_o_load_command_type type,
5304 bfd_mach_o_load_command **mcommand)
5305 {
5306 struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5307 struct bfd_mach_o_load_command *cmd;
5308 unsigned int num;
5309
5310 BFD_ASSERT (mdata != NULL);
5311 BFD_ASSERT (mcommand != NULL);
5312
5313 num = 0;
5314 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5315 {
5316 if (cmd->type != type)
5317 continue;
5318
5319 if (num == 0)
5320 *mcommand = cmd;
5321 num++;
5322 }
5323
5324 return num;
5325 }
5326
5327 unsigned long
5328 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
5329 {
5330 switch (type)
5331 {
5332 case BFD_MACH_O_CPU_TYPE_MC680x0:
5333 return 0x04000000;
5334 case BFD_MACH_O_CPU_TYPE_MC88000:
5335 return 0xffffe000;
5336 case BFD_MACH_O_CPU_TYPE_POWERPC:
5337 return 0xc0000000;
5338 case BFD_MACH_O_CPU_TYPE_I386:
5339 return 0xc0000000;
5340 case BFD_MACH_O_CPU_TYPE_SPARC:
5341 return 0xf0000000;
5342 case BFD_MACH_O_CPU_TYPE_I860:
5343 return 0;
5344 case BFD_MACH_O_CPU_TYPE_HPPA:
5345 return 0xc0000000 - 0x04000000;
5346 default:
5347 return 0;
5348 }
5349 }
5350
5351 /* The following two tables should be kept, as far as possible, in order of
5352 most frequently used entries to optimize their use from gas. */
5353
5354 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
5355 {
5356 { "regular", BFD_MACH_O_S_REGULAR},
5357 { "coalesced", BFD_MACH_O_S_COALESCED},
5358 { "zerofill", BFD_MACH_O_S_ZEROFILL},
5359 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5360 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5361 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
5362 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
5363 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
5364 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5365 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
5366 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5367 { "interposing", BFD_MACH_O_S_INTERPOSING},
5368 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
5369 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5370 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
5371 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
5372 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5373 { NULL, 0}
5374 };
5375
5376 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
5377 {
5378 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5379 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
5380 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5381 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
5382 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
5383 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5384 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5385 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5386 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
5387 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5388 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5389 { NULL, 0}
5390 };
5391
5392 /* Get the section type from NAME. Return 256 if NAME is unknown. */
5393
5394 unsigned int
5395 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
5396 {
5397 const bfd_mach_o_xlat_name *x;
5398 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5399
5400 for (x = bfd_mach_o_section_type_name; x->name; x++)
5401 if (strcmp (x->name, name) == 0)
5402 {
5403 /* We found it... does the target support it? */
5404 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5405 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5406 return x->val; /* OK. */
5407 else
5408 break; /* Not supported. */
5409 }
5410 /* Maximum section ID = 0xff. */
5411 return 256;
5412 }
5413
5414 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5415
5416 unsigned int
5417 bfd_mach_o_get_section_attribute_from_name (const char *name)
5418 {
5419 const bfd_mach_o_xlat_name *x;
5420
5421 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5422 if (strcmp (x->name, name) == 0)
5423 return x->val;
5424 return (unsigned int)-1;
5425 }
5426
5427 int
5428 bfd_mach_o_core_fetch_environment (bfd *abfd,
5429 unsigned char **rbuf,
5430 unsigned int *rlen)
5431 {
5432 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5433 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
5434 bfd_mach_o_load_command *cmd;
5435
5436 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5437 {
5438 bfd_mach_o_segment_command *seg;
5439
5440 if (cmd->type != BFD_MACH_O_LC_SEGMENT)
5441 continue;
5442
5443 seg = &cmd->command.segment;
5444
5445 if ((seg->vmaddr + seg->vmsize) == stackaddr)
5446 {
5447 unsigned long start = seg->fileoff;
5448 unsigned long end = seg->fileoff + seg->filesize;
5449 unsigned char *buf = bfd_malloc (1024);
5450 unsigned long size = 1024;
5451
5452 for (;;)
5453 {
5454 bfd_size_type nread = 0;
5455 unsigned long offset;
5456 int found_nonnull = 0;
5457
5458 if (size > (end - start))
5459 size = (end - start);
5460
5461 buf = bfd_realloc_or_free (buf, size);
5462 if (buf == NULL)
5463 return -1;
5464
5465 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
5466 {
5467 free (buf);
5468 return -1;
5469 }
5470
5471 nread = bfd_bread (buf, size, abfd);
5472
5473 if (nread != size)
5474 {
5475 free (buf);
5476 return -1;
5477 }
5478
5479 for (offset = 4; offset <= size; offset += 4)
5480 {
5481 unsigned long val;
5482
5483 val = *((unsigned long *) (buf + size - offset));
5484 if (! found_nonnull)
5485 {
5486 if (val != 0)
5487 found_nonnull = 1;
5488 }
5489 else if (val == 0x0)
5490 {
5491 unsigned long bottom;
5492 unsigned long top;
5493
5494 bottom = seg->fileoff + seg->filesize - offset;
5495 top = seg->fileoff + seg->filesize - 4;
5496 *rbuf = bfd_malloc (top - bottom);
5497 *rlen = top - bottom;
5498
5499 memcpy (*rbuf, buf + size - *rlen, *rlen);
5500 free (buf);
5501 return 0;
5502 }
5503 }
5504
5505 if (size == (end - start))
5506 break;
5507
5508 size *= 2;
5509 }
5510
5511 free (buf);
5512 }
5513 }
5514
5515 return -1;
5516 }
5517
5518 char *
5519 bfd_mach_o_core_file_failing_command (bfd *abfd)
5520 {
5521 unsigned char *buf = NULL;
5522 unsigned int len = 0;
5523 int ret;
5524
5525 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5526 if (ret < 0)
5527 return NULL;
5528
5529 return (char *) buf;
5530 }
5531
5532 int
5533 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
5534 {
5535 return 0;
5536 }
5537
5538 static bfd_mach_o_uuid_command *
5539 bfd_mach_o_lookup_uuid_command (bfd *abfd)
5540 {
5541 bfd_mach_o_load_command *uuid_cmd;
5542 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
5543 if (ncmd != 1)
5544 return FALSE;
5545 return &uuid_cmd->command.uuid;
5546 }
5547
5548 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5549
5550 static bfd_boolean
5551 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
5552 {
5553 bfd_mach_o_uuid_command *dsym_uuid_cmd;
5554
5555 BFD_ASSERT (abfd);
5556 BFD_ASSERT (uuid_cmd);
5557
5558 if (!bfd_check_format (abfd, bfd_object))
5559 return FALSE;
5560
5561 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
5562 || bfd_mach_o_get_data (abfd) == NULL
5563 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
5564 return FALSE;
5565
5566 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5567 if (dsym_uuid_cmd == NULL)
5568 return FALSE;
5569
5570 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
5571 sizeof (uuid_cmd->uuid)) != 0)
5572 return FALSE;
5573
5574 return TRUE;
5575 }
5576
5577 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5578 The caller is responsible for closing the returned BFD object and
5579 its my_archive if the returned BFD is in a fat dSYM. */
5580
5581 static bfd *
5582 bfd_mach_o_find_dsym (const char *dsym_filename,
5583 const bfd_mach_o_uuid_command *uuid_cmd,
5584 const bfd_arch_info_type *arch)
5585 {
5586 bfd *base_dsym_bfd, *dsym_bfd;
5587
5588 BFD_ASSERT (uuid_cmd);
5589
5590 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
5591 if (base_dsym_bfd == NULL)
5592 return NULL;
5593
5594 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
5595 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
5596 return dsym_bfd;
5597
5598 bfd_close (dsym_bfd);
5599 if (base_dsym_bfd != dsym_bfd)
5600 bfd_close (base_dsym_bfd);
5601
5602 return NULL;
5603 }
5604
5605 /* Return a BFD created from a dSYM file for ABFD.
5606 The caller is responsible for closing the returned BFD object, its
5607 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5608
5609 static bfd *
5610 bfd_mach_o_follow_dsym (bfd *abfd)
5611 {
5612 char *dsym_filename;
5613 bfd_mach_o_uuid_command *uuid_cmd;
5614 bfd *dsym_bfd, *base_bfd = abfd;
5615 const char *base_basename;
5616
5617 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
5618 return NULL;
5619
5620 if (abfd->my_archive)
5621 base_bfd = abfd->my_archive;
5622 /* BFD may have been opened from a stream. */
5623 if (base_bfd->filename == NULL)
5624 {
5625 bfd_set_error (bfd_error_invalid_operation);
5626 return NULL;
5627 }
5628 base_basename = lbasename (base_bfd->filename);
5629
5630 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5631 if (uuid_cmd == NULL)
5632 return NULL;
5633
5634 /* TODO: We assume the DWARF file has the same as the binary's.
5635 It seems apple's GDB checks all files in the dSYM bundle directory.
5636 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5637 */
5638 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
5639 + strlen (dsym_subdir) + 1
5640 + strlen (base_basename) + 1);
5641 sprintf (dsym_filename, "%s%s/%s",
5642 base_bfd->filename, dsym_subdir, base_basename);
5643
5644 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
5645 bfd_get_arch_info (abfd));
5646 if (dsym_bfd == NULL)
5647 free (dsym_filename);
5648
5649 return dsym_bfd;
5650 }
5651
5652 bfd_boolean
5653 bfd_mach_o_find_nearest_line (bfd *abfd,
5654 asymbol **symbols,
5655 asection *section,
5656 bfd_vma offset,
5657 const char **filename_ptr,
5658 const char **functionname_ptr,
5659 unsigned int *line_ptr,
5660 unsigned int *discriminator_ptr)
5661 {
5662 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5663 if (mdata == NULL)
5664 return FALSE;
5665 switch (mdata->header.filetype)
5666 {
5667 case BFD_MACH_O_MH_OBJECT:
5668 break;
5669 case BFD_MACH_O_MH_EXECUTE:
5670 case BFD_MACH_O_MH_DYLIB:
5671 case BFD_MACH_O_MH_BUNDLE:
5672 case BFD_MACH_O_MH_KEXT_BUNDLE:
5673 if (mdata->dwarf2_find_line_info == NULL)
5674 {
5675 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5676 /* When we couldn't find dSYM for this binary, we look for
5677 the debug information in the binary itself. In this way,
5678 we won't try finding separated dSYM again because
5679 mdata->dwarf2_find_line_info will be filled. */
5680 if (! mdata->dsym_bfd)
5681 break;
5682 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5683 dwarf_debug_sections, symbols,
5684 &mdata->dwarf2_find_line_info,
5685 FALSE))
5686 return FALSE;
5687 }
5688 break;
5689 default:
5690 return FALSE;
5691 }
5692 return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
5693 filename_ptr, functionname_ptr,
5694 line_ptr, discriminator_ptr,
5695 dwarf_debug_sections, 0,
5696 &mdata->dwarf2_find_line_info);
5697 }
5698
5699 bfd_boolean
5700 bfd_mach_o_close_and_cleanup (bfd *abfd)
5701 {
5702 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5703 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5704 {
5705 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5706 bfd_mach_o_free_cached_info (abfd);
5707 if (mdata->dsym_bfd != NULL)
5708 {
5709 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5710 char *dsym_filename = (char *)(fat_bfd
5711 ? fat_bfd->filename
5712 : mdata->dsym_bfd->filename);
5713 bfd_close (mdata->dsym_bfd);
5714 mdata->dsym_bfd = NULL;
5715 if (fat_bfd)
5716 bfd_close (fat_bfd);
5717 free (dsym_filename);
5718 }
5719 }
5720
5721 if (bfd_get_format (abfd) == bfd_archive
5722 && abfd->xvec == &mach_o_fat_vec)
5723 return TRUE;
5724 return _bfd_generic_close_and_cleanup (abfd);
5725 }
5726
5727 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5728 {
5729 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5730 asection *asect;
5731 free (mdata->dyn_reloc_cache);
5732 mdata->dyn_reloc_cache = NULL;
5733 for (asect = abfd->sections; asect != NULL; asect = asect->next)
5734 {
5735 free (asect->relocation);
5736 asect->relocation = NULL;
5737 }
5738
5739 return TRUE;
5740 }
5741
5742 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5743 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5744
5745 #define bfd_mach_o_swap_reloc_in NULL
5746 #define bfd_mach_o_swap_reloc_out NULL
5747 #define bfd_mach_o_print_thread NULL
5748 #define bfd_mach_o_tgt_seg_table NULL
5749 #define bfd_mach_o_section_type_valid_for_tgt NULL
5750
5751 #define TARGET_NAME mach_o_be_vec
5752 #define TARGET_STRING "mach-o-be"
5753 #define TARGET_ARCHITECTURE bfd_arch_unknown
5754 #define TARGET_PAGESIZE 1
5755 #define TARGET_BIG_ENDIAN 1
5756 #define TARGET_ARCHIVE 0
5757 #define TARGET_PRIORITY 1
5758 #include "mach-o-target.c"
5759
5760 #undef TARGET_NAME
5761 #undef TARGET_STRING
5762 #undef TARGET_ARCHITECTURE
5763 #undef TARGET_PAGESIZE
5764 #undef TARGET_BIG_ENDIAN
5765 #undef TARGET_ARCHIVE
5766 #undef TARGET_PRIORITY
5767
5768 #define TARGET_NAME mach_o_le_vec
5769 #define TARGET_STRING "mach-o-le"
5770 #define TARGET_ARCHITECTURE bfd_arch_unknown
5771 #define TARGET_PAGESIZE 1
5772 #define TARGET_BIG_ENDIAN 0
5773 #define TARGET_ARCHIVE 0
5774 #define TARGET_PRIORITY 1
5775
5776 #include "mach-o-target.c"
5777
5778 #undef TARGET_NAME
5779 #undef TARGET_STRING
5780 #undef TARGET_ARCHITECTURE
5781 #undef TARGET_PAGESIZE
5782 #undef TARGET_BIG_ENDIAN
5783 #undef TARGET_ARCHIVE
5784 #undef TARGET_PRIORITY
5785
5786 /* Not yet handled: creating an archive. */
5787 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5788
5789 /* Not used. */
5790 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5791 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5792 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5793 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5794 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5795 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5796 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5797 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5798 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5799 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5800
5801 #define TARGET_NAME mach_o_fat_vec
5802 #define TARGET_STRING "mach-o-fat"
5803 #define TARGET_ARCHITECTURE bfd_arch_unknown
5804 #define TARGET_PAGESIZE 1
5805 #define TARGET_BIG_ENDIAN 1
5806 #define TARGET_ARCHIVE 1
5807 #define TARGET_PRIORITY 0
5808
5809 #include "mach-o-target.c"
5810
5811 #undef TARGET_NAME
5812 #undef TARGET_STRING
5813 #undef TARGET_ARCHITECTURE
5814 #undef TARGET_PAGESIZE
5815 #undef TARGET_BIG_ENDIAN
5816 #undef TARGET_ARCHIVE
5817 #undef TARGET_PRIORITY