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