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