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