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