?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mach-o: fix section number while writing symbols.
[binutils-gdb.git] / bfd / mach-o.c
blob43b24c9c0897b5671251955050a95594fe6a099e
1 /* Mach-O support for BFD.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "mach-o.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "libiberty.h"
26 #include "aout/stab_gnu.h"
27 #include "mach-o/reloc.h"
28 #include "mach-o/external.h"
29 #include <ctype.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
34 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
35 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
36
37 #define FILE_ALIGN(off, algn) \
38 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
39
40 unsigned int
41 bfd_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
51 bfd_boolean
52 bfd_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
65 static INLINE bfd_boolean
66 mach_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
80 static INLINE bfd_boolean
81 bfd_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. */
91 static 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. */
130 static 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. */
160 static 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. */
205 static 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
274 static 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
283 static 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
294 const mach_o_section_name_xlat *
295 bfd_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
326 const mach_o_section_name_xlat *
327 bfd_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
371 void
372 bfd_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
430 static const mach_o_section_name_xlat *
431 bfd_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
499 unsigned int
500 bfd_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
519 unsigned int
520 bfd_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
535 bfd_boolean
536 bfd_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
554 bfd_boolean
555 bfd_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
576 bfd_boolean
577 bfd_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
595 bfd_boolean
596 bfd_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
609 static long
610 bfd_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
619 long
620 bfd_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
627 long
628 bfd_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
664 long
665 bfd_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
767 void
768 bfd_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
775 void
776 bfd_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
830 static void
831 bfd_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
918 static bfd_boolean
919 bfd_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
945 static int
946 bfd_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
976 long
977 bfd_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
986 static void
987 bfd_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
1012 static int
1013 bfd_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
1123 static int
1124 bfd_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
1156 long
1157 bfd_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
1194 long
1195 bfd_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
1205 long
1206 bfd_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
1259 static void
1260 bfd_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
1291 static bfd_boolean
1292 bfd_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
1349 static int
1350 bfd_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
1373 static int
1374 bfd_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
1398 static int
1399 bfd_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
1432 static int
1433 bfd_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
1466 static bfd_boolean
1467 bfd_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
1575 static bfd_boolean
1576 bfd_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
1753 static unsigned
1754 bfd_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
1775 static int
1776 bfd_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
1825 static bfd_boolean
1826 bfd_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->output_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
1898 static bfd_boolean
1899 bfd_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
1949 bfd_boolean
1950 bfd_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
2030 static void
2031 bfd_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
2044 static void
2045 bfd_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
2079 static unsigned long
2080 bfd_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
2104 static bfd_boolean
2105 bfd_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 /* Note: follow alignment even for object file. */
2170 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2171 s->offset = mdata->filelen;
2172 }
2173
2174 sec->filepos = s->offset;
2175 mdata->filelen += s->size;
2176 }
2177
2178 /* Be sure the file offset of the segment is the file offset of its first
2179 section (may have changed due to alignment). */
2180 if (seg->sect_head != NULL)
2181 seg->fileoff = seg->sect_head->offset;
2182
2183 /* Now pass through again, for zerofill, only now we just update the
2184 vmsize. */
2185 for (i = 0; i < mdata->nsects; ++i)
2186 {
2187 bfd_mach_o_section *s = mdata->sections[i];
2188
2189 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL)
2190 continue;
2191
2192 if (! is_mho
2193 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2194 continue;
2195
2196 if (s->size > 0)
2197 {
2198 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2199 seg->vmsize += s->size;
2200 }
2201 }
2202
2203 /* Now pass through again, for zerofill_GB. */
2204 for (i = 0; i < mdata->nsects; ++i)
2205 {
2206 bfd_mach_o_section *s = mdata->sections[i];
2207
2208 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_GB_ZEROFILL)
2209 continue;
2210
2211 if (! is_mho
2212 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2213 continue;
2214
2215 if (s->size > 0)
2216 {
2217 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2218 seg->vmsize += s->size;
2219 }
2220 }
2221
2222 /* Allocate space for the relocations. */
2223 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2224
2225 for (i = 0; i < mdata->nsects; ++i)
2226 {
2227 bfd_mach_o_section *ms = mdata->sections[i];
2228 asection *sec = ms->bfdsection;
2229
2230 if ((ms->nreloc = sec->reloc_count) == 0)
2231 {
2232 ms->reloff = 0;
2233 continue;
2234 }
2235 sec->rel_filepos = mdata->filelen;
2236 ms->reloff = sec->rel_filepos;
2237 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2238 }
2239
2240 return TRUE;
2241 }
2242
2243 /* Count the number of indirect symbols in the image.
2244 Requires that the sections are in their final order. */
2245
2246 static unsigned int
2247 bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2248 {
2249 unsigned int i;
2250 unsigned int nisyms = 0;
2251
2252 for (i = 0; i < mdata->nsects; ++i)
2253 {
2254 bfd_mach_o_section *sec = mdata->sections[i];
2255
2256 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2257 {
2258 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2259 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2260 case BFD_MACH_O_S_SYMBOL_STUBS:
2261 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2262 break;
2263 default:
2264 break;
2265 }
2266 }
2267 return nisyms;
2268 }
2269
2270 static bfd_boolean
2271 bfd_mach_o_build_dysymtab_command (bfd *abfd,
2272 bfd_mach_o_data_struct *mdata,
2273 bfd_mach_o_load_command *cmd)
2274 {
2275 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2276
2277 /* TODO:
2278 We are not going to try and fill these in yet and, moreover, we are
2279 going to bail if they are already set. */
2280 if (dsym->nmodtab != 0
2281 || dsym->ntoc != 0
2282 || dsym->nextrefsyms != 0)
2283 {
2284 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2285 " implemented for dysymtab commands."));
2286 return FALSE;
2287 }
2288
2289 dsym->ilocalsym = 0;
2290
2291 if (bfd_get_symcount (abfd) > 0)
2292 {
2293 asymbol **symbols = bfd_get_outsymbols (abfd);
2294 unsigned long i;
2295
2296 /* Count the number of each kind of symbol. */
2297 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2298 {
2299 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2300 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2301 break;
2302 }
2303 dsym->nlocalsym = i;
2304 dsym->iextdefsym = i;
2305 for (; i < bfd_get_symcount (abfd); ++i)
2306 {
2307 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2308 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2309 break;
2310 }
2311 dsym->nextdefsym = i - dsym->nlocalsym;
2312 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2313 dsym->nundefsym = bfd_get_symcount (abfd)
2314 - dsym->nlocalsym
2315 - dsym->nextdefsym;
2316 }
2317 else
2318 {
2319 dsym->nlocalsym = 0;
2320 dsym->iextdefsym = 0;
2321 dsym->nextdefsym = 0;
2322 dsym->iundefsym = 0;
2323 dsym->nundefsym = 0;
2324 }
2325
2326 dsym->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2327 if (dsym->nindirectsyms > 0)
2328 {
2329 unsigned i;
2330 unsigned n;
2331
2332 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2333 dsym->indirectsymoff = mdata->filelen;
2334 mdata->filelen += dsym->nindirectsyms * 4;
2335
2336 dsym->indirect_syms = bfd_zalloc (abfd, dsym->nindirectsyms * 4);
2337 if (dsym->indirect_syms == NULL)
2338 return FALSE;
2339
2340 n = 0;
2341 for (i = 0; i < mdata->nsects; ++i)
2342 {
2343 bfd_mach_o_section *sec = mdata->sections[i];
2344
2345 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2346 {
2347 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2348 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2349 case BFD_MACH_O_S_SYMBOL_STUBS:
2350 {
2351 unsigned j, num;
2352 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2353
2354 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2355 if (isyms == NULL || num == 0)
2356 break;
2357 /* Record the starting index in the reserved1 field. */
2358 sec->reserved1 = n;
2359 for (j = 0; j < num; j++, n++)
2360 {
2361 if (isyms[j] == NULL)
2362 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2363 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2364 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2365 dsym->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2366 | BFD_MACH_O_INDIRECT_SYM_ABS;
2367 else
2368 dsym->indirect_syms[n] = isyms[j]->symbol.udata.i;
2369 }
2370 }
2371 break;
2372 default:
2373 break;
2374 }
2375 }
2376 }
2377
2378 return TRUE;
2379 }
2380
2381 /* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2382 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2383 and copy functionality. */
2384
2385 bfd_boolean
2386 bfd_mach_o_build_commands (bfd *abfd)
2387 {
2388 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2389 unsigned wide = mach_o_wide_p (&mdata->header);
2390 int segcmd_idx = -1;
2391 int symtab_idx = -1;
2392 int dysymtab_idx = -1;
2393 unsigned long base_offset = 0;
2394
2395 /* Return now if commands are already present. */
2396 if (mdata->header.ncmds)
2397 return FALSE;
2398
2399 /* Fill in the file type, if not already set. */
2400
2401 if (mdata->header.filetype == 0)
2402 {
2403 if (abfd->flags & EXEC_P)
2404 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2405 else if (abfd->flags & DYNAMIC)
2406 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2407 else
2408 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
2409 }
2410
2411 /* If hasn't already been done, flatten sections list, and sort
2412 if/when required. Must be done before the symbol table is adjusted,
2413 since that depends on properly numbered sections. */
2414 if (mdata->nsects == 0 || mdata->sections == NULL)
2415 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2416 return FALSE;
2417
2418 /* Order the symbol table, fill-in/check mach-o specific fields and
2419 partition out any indirect symbols. */
2420 if (!bfd_mach_o_mangle_symbols (abfd))
2421 return FALSE;
2422
2423 /* Very simple command set (only really applicable to MH_OBJECTs):
2424 All the commands are optional - present only when there is suitable data.
2425 (i.e. it is valid to have an empty file)
2426
2427 a command (segment) to contain all the sections,
2428 command for the symbol table,
2429 a command for the dysymtab.
2430
2431 ??? maybe we should assert that this is an MH_OBJECT? */
2432
2433 if (mdata->nsects > 0)
2434 {
2435 segcmd_idx = 0;
2436 mdata->header.ncmds = 1;
2437 }
2438
2439 if (bfd_get_symcount (abfd) > 0)
2440 {
2441 mdata->header.ncmds++;
2442 symtab_idx = segcmd_idx + 1; /* 0 if the seg command is absent. */
2443 }
2444
2445 /* FIXME:
2446 This is a rather crude test for whether we should build a dysymtab. */
2447 if (bfd_mach_o_should_emit_dysymtab ()
2448 && bfd_get_symcount (abfd))
2449 {
2450 mdata->header.ncmds++;
2451 /* If there should be a case where a dysymtab could be emitted without
2452 a symtab (seems improbable), this would need amending. */
2453 dysymtab_idx = symtab_idx + 1;
2454 }
2455
2456 if (wide)
2457 base_offset = BFD_MACH_O_HEADER_64_SIZE;
2458 else
2459 base_offset = BFD_MACH_O_HEADER_SIZE;
2460
2461 /* Well, we must have a header, at least. */
2462 mdata->filelen = base_offset;
2463
2464 /* A bit unusual, but no content is valid;
2465 as -n empty.s -o empty.o */
2466 if (mdata->header.ncmds == 0)
2467 return TRUE;
2468
2469 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2470 * sizeof (bfd_mach_o_load_command));
2471 if (mdata->commands == NULL)
2472 return FALSE;
2473
2474 if (segcmd_idx >= 0)
2475 {
2476 bfd_mach_o_load_command *cmd = &mdata->commands[segcmd_idx];
2477 bfd_mach_o_segment_command *seg = &cmd->command.segment;
2478
2479 /* Count the segctions in the special blank segment used
2480 for MH_OBJECT. */
2481 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2482 if (seg->nsects == (unsigned long) -1)
2483 return FALSE;
2484
2485 /* Init segment command. */
2486 cmd->offset = base_offset;
2487 if (wide)
2488 {
2489 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2490 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2491 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2492 }
2493 else
2494 {
2495 cmd->type = BFD_MACH_O_LC_SEGMENT;
2496 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2497 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2498 }
2499
2500 cmd->type_required = FALSE;
2501 mdata->header.sizeofcmds = cmd->len;
2502 mdata->filelen += cmd->len;
2503 }
2504
2505 if (symtab_idx >= 0)
2506 {
2507 /* Init symtab command. */
2508 bfd_mach_o_load_command *cmd = &mdata->commands[symtab_idx];
2509
2510 cmd->type = BFD_MACH_O_LC_SYMTAB;
2511 cmd->offset = base_offset;
2512 if (segcmd_idx >= 0)
2513 cmd->offset += mdata->commands[segcmd_idx].len;
2514
2515 cmd->len = sizeof (struct mach_o_symtab_command_external)
2516 + BFD_MACH_O_LC_SIZE;
2517 cmd->type_required = FALSE;
2518 mdata->header.sizeofcmds += cmd->len;
2519 mdata->filelen += cmd->len;
2520 }
2521
2522 /* If required, setup symtab command, see comment above about the quality
2523 of this test. */
2524 if (dysymtab_idx >= 0)
2525 {
2526 bfd_mach_o_load_command *cmd = &mdata->commands[dysymtab_idx];
2527
2528 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2529 if (symtab_idx >= 0)
2530 cmd->offset = mdata->commands[symtab_idx].offset
2531 + mdata->commands[symtab_idx].len;
2532 else if (segcmd_idx >= 0)
2533 cmd->offset = mdata->commands[segcmd_idx].offset
2534 + mdata->commands[segcmd_idx].len;
2535 else
2536 cmd->offset = base_offset;
2537
2538 cmd->type_required = FALSE;
2539 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
2540 + BFD_MACH_O_LC_SIZE;
2541
2542 mdata->header.sizeofcmds += cmd->len;
2543 mdata->filelen += cmd->len;
2544 }
2545
2546 /* So, now we have sized the commands and the filelen set to that.
2547 Now we can build the segment command and set the section file offsets. */
2548 if (segcmd_idx >= 0
2549 && ! bfd_mach_o_build_seg_command
2550 (NULL, mdata, &mdata->commands[segcmd_idx].command.segment))
2551 return FALSE;
2552
2553 /* If we're doing a dysymtab, cmd points to its load command. */
2554 if (dysymtab_idx >= 0
2555 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2556 &mdata->commands[dysymtab_idx]))
2557 return FALSE;
2558
2559 /* The symtab command is filled in when the symtab is written. */
2560 return TRUE;
2561 }
2562
2563 /* Set the contents of a section. */
2564
2565 bfd_boolean
2566 bfd_mach_o_set_section_contents (bfd *abfd,
2567 asection *section,
2568 const void * location,
2569 file_ptr offset,
2570 bfd_size_type count)
2571 {
2572 file_ptr pos;
2573
2574 /* Trying to write the first section contents will trigger the creation of
2575 the load commands if they are not already present. */
2576 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2577 return FALSE;
2578
2579 if (count == 0)
2580 return TRUE;
2581
2582 pos = section->filepos + offset;
2583 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2584 || bfd_bwrite (location, count, abfd) != count)
2585 return FALSE;
2586
2587 return TRUE;
2588 }
2589
2590 int
2591 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
2592 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2593 {
2594 return 0;
2595 }
2596
2597 /* Make an empty symbol. This is required only because
2598 bfd_make_section_anyway wants to create a symbol for the section. */
2599
2600 asymbol *
2601 bfd_mach_o_make_empty_symbol (bfd *abfd)
2602 {
2603 asymbol *new_symbol;
2604
2605 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2606 if (new_symbol == NULL)
2607 return new_symbol;
2608 new_symbol->the_bfd = abfd;
2609 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
2610 return new_symbol;
2611 }
2612
2613 static bfd_boolean
2614 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
2615 {
2616 struct mach_o_header_external raw;
2617 unsigned int size;
2618 bfd_vma (*get32) (const void *) = NULL;
2619
2620 /* Just read the magic number. */
2621 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2622 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
2623 return FALSE;
2624
2625 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2626 {
2627 header->byteorder = BFD_ENDIAN_BIG;
2628 header->magic = BFD_MACH_O_MH_MAGIC;
2629 header->version = 1;
2630 get32 = bfd_getb32;
2631 }
2632 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
2633 {
2634 header->byteorder = BFD_ENDIAN_LITTLE;
2635 header->magic = BFD_MACH_O_MH_MAGIC;
2636 header->version = 1;
2637 get32 = bfd_getl32;
2638 }
2639 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2640 {
2641 header->byteorder = BFD_ENDIAN_BIG;
2642 header->magic = BFD_MACH_O_MH_MAGIC_64;
2643 header->version = 2;
2644 get32 = bfd_getb32;
2645 }
2646 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
2647 {
2648 header->byteorder = BFD_ENDIAN_LITTLE;
2649 header->magic = BFD_MACH_O_MH_MAGIC_64;
2650 header->version = 2;
2651 get32 = bfd_getl32;
2652 }
2653 else
2654 {
2655 header->byteorder = BFD_ENDIAN_UNKNOWN;
2656 return FALSE;
2657 }
2658
2659 /* Once the size of the header is known, read the full header. */
2660 size = mach_o_wide_p (header) ?
2661 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2662
2663 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2664 || bfd_bread (&raw, size, abfd) != size)
2665 return FALSE;
2666
2667 header->cputype = (*get32) (raw.cputype);
2668 header->cpusubtype = (*get32) (raw.cpusubtype);
2669 header->filetype = (*get32) (raw.filetype);
2670 header->ncmds = (*get32) (raw.ncmds);
2671 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2672 header->flags = (*get32) (raw.flags);
2673
2674 if (mach_o_wide_p (header))
2675 header->reserved = (*get32) (raw.reserved);
2676 else
2677 header->reserved = 0;
2678
2679 return TRUE;
2680 }
2681
2682 bfd_boolean
2683 bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2684 {
2685 bfd_mach_o_section *s;
2686 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
2687
2688 s = bfd_mach_o_get_mach_o_section (sec);
2689 if (s == NULL)
2690 {
2691 flagword bfd_flags;
2692 static const mach_o_section_name_xlat * xlat;
2693
2694 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2695 if (s == NULL)
2696 return FALSE;
2697 sec->used_by_bfd = s;
2698 s->bfdsection = sec;
2699
2700 /* Create the Darwin seg/sect name pair from the bfd name.
2701 If this is a canonical name for which a specific paiting exists
2702 there will also be defined flags, type, attribute and alignment
2703 values. */
2704 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2705 if (xlat != NULL)
2706 {
2707 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2708 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2709 : bfdalign;
2710 (void) bfd_set_section_alignment (abfd, sec, s->align);
2711 bfd_flags = bfd_get_section_flags (abfd, sec);
2712 if (bfd_flags == SEC_NO_FLAGS)
2713 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2714 }
2715 else
2716 /* Create default flags. */
2717 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
2718 }
2719
2720 return _bfd_generic_new_section_hook (abfd, sec);
2721 }
2722
2723 static void
2724 bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2725 unsigned long prot)
2726 {
2727 flagword flags;
2728 bfd_mach_o_section *section;
2729
2730 flags = bfd_get_section_flags (abfd, sec);
2731 section = bfd_mach_o_get_mach_o_section (sec);
2732
2733 /* TODO: see if we should use the xlat system for doing this by
2734 preference and fall back to this for unknown sections. */
2735
2736 if (flags == SEC_NO_FLAGS)
2737 {
2738 /* Try to guess flags. */
2739 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2740 flags = SEC_DEBUGGING;
2741 else
2742 {
2743 flags = SEC_ALLOC;
2744 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2745 != BFD_MACH_O_S_ZEROFILL)
2746 {
2747 flags |= SEC_LOAD;
2748 if (prot & BFD_MACH_O_PROT_EXECUTE)
2749 flags |= SEC_CODE;
2750 if (prot & BFD_MACH_O_PROT_WRITE)
2751 flags |= SEC_DATA;
2752 else if (prot & BFD_MACH_O_PROT_READ)
2753 flags |= SEC_READONLY;
2754 }
2755 }
2756 }
2757 else
2758 {
2759 if ((flags & SEC_DEBUGGING) == 0)
2760 flags |= SEC_ALLOC;
2761 }
2762
2763 if (section->offset != 0)
2764 flags |= SEC_HAS_CONTENTS;
2765 if (section->nreloc != 0)
2766 flags |= SEC_RELOC;
2767
2768 bfd_set_section_flags (abfd, sec, flags);
2769
2770 sec->vma = section->addr;
2771 sec->lma = section->addr;
2772 sec->size = section->size;
2773 sec->filepos = section->offset;
2774 sec->alignment_power = section->align;
2775 sec->segment_mark = 0;
2776 sec->reloc_count = section->nreloc;
2777 sec->rel_filepos = section->reloff;
2778 }
2779
2780 static asection *
2781 bfd_mach_o_make_bfd_section (bfd *abfd,
2782 const unsigned char *segname,
2783 const unsigned char *sectname)
2784 {
2785 const char *sname;
2786 flagword flags;
2787
2788 bfd_mach_o_convert_section_name_to_bfd
2789 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2790 if (sname == NULL)
2791 return NULL;
2792
2793 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
2794 }
2795
2796 static asection *
2797 bfd_mach_o_read_section_32 (bfd *abfd,
2798 unsigned int offset,
2799 unsigned long prot)
2800 {
2801 struct mach_o_section_32_external raw;
2802 asection *sec;
2803 bfd_mach_o_section *section;
2804
2805 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2806 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
2807 != BFD_MACH_O_SECTION_SIZE))
2808 return NULL;
2809
2810 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2811 if (sec == NULL)
2812 return NULL;
2813
2814 section = bfd_mach_o_get_mach_o_section (sec);
2815 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2816 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2817 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2818 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2819 section->addr = bfd_h_get_32 (abfd, raw.addr);
2820 section->size = bfd_h_get_32 (abfd, raw.size);
2821 section->offset = bfd_h_get_32 (abfd, raw.offset);
2822 section->align = bfd_h_get_32 (abfd, raw.align);
2823 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2824 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2825 section->flags = bfd_h_get_32 (abfd, raw.flags);
2826 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2827 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2828 section->reserved3 = 0;
2829
2830 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2831
2832 return sec;
2833 }
2834
2835 static asection *
2836 bfd_mach_o_read_section_64 (bfd *abfd,
2837 unsigned int offset,
2838 unsigned long prot)
2839 {
2840 struct mach_o_section_64_external raw;
2841 asection *sec;
2842 bfd_mach_o_section *section;
2843
2844 if (bfd_seek (abfd, offset, SEEK_SET) != 0
2845 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
2846 != BFD_MACH_O_SECTION_64_SIZE))
2847 return NULL;
2848
2849 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
2850 if (sec == NULL)
2851 return NULL;
2852
2853 section = bfd_mach_o_get_mach_o_section (sec);
2854 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2855 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2856 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
2857 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
2858 section->addr = bfd_h_get_64 (abfd, raw.addr);
2859 section->size = bfd_h_get_64 (abfd, raw.size);
2860 section->offset = bfd_h_get_32 (abfd, raw.offset);
2861 section->align = bfd_h_get_32 (abfd, raw.align);
2862 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2863 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2864 section->flags = bfd_h_get_32 (abfd, raw.flags);
2865 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2866 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2867 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
2868
2869 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
2870
2871 return sec;
2872 }
2873
2874 static asection *
2875 bfd_mach_o_read_section (bfd *abfd,
2876 unsigned int offset,
2877 unsigned long prot,
2878 unsigned int wide)
2879 {
2880 if (wide)
2881 return bfd_mach_o_read_section_64 (abfd, offset, prot);
2882 else
2883 return bfd_mach_o_read_section_32 (abfd, offset, prot);
2884 }
2885
2886 static bfd_boolean
2887 bfd_mach_o_read_symtab_symbol (bfd *abfd,
2888 bfd_mach_o_symtab_command *sym,
2889 bfd_mach_o_asymbol *s,
2890 unsigned long i)
2891 {
2892 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2893 unsigned int wide = mach_o_wide_p (&mdata->header);
2894 unsigned int symwidth =
2895 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2896 unsigned int symoff = sym->symoff + (i * symwidth);
2897 struct mach_o_nlist_64_external raw;
2898 unsigned char type = -1;
2899 unsigned char section = -1;
2900 short desc = -1;
2901 symvalue value = -1;
2902 unsigned long stroff = -1;
2903 unsigned int symtype = -1;
2904
2905 BFD_ASSERT (sym->strtab != NULL);
2906
2907 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
2908 || bfd_bread (&raw, symwidth, abfd) != symwidth)
2909 {
2910 (*_bfd_error_handler)
2911 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2912 symwidth, (unsigned long) symoff);
2913 return FALSE;
2914 }
2915
2916 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2917 type = bfd_h_get_8 (abfd, raw.n_type);
2918 symtype = type & BFD_MACH_O_N_TYPE;
2919 section = bfd_h_get_8 (abfd, raw.n_sect);
2920 desc = bfd_h_get_16 (abfd, raw.n_desc);
2921 if (wide)
2922 value = bfd_h_get_64 (abfd, raw.n_value);
2923 else
2924 value = bfd_h_get_32 (abfd, raw.n_value);
2925
2926 if (stroff >= sym->strsize)
2927 {
2928 (*_bfd_error_handler)
2929 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2930 (unsigned long) stroff,
2931 (unsigned long) sym->strsize);
2932 return FALSE;
2933 }
2934
2935 s->symbol.the_bfd = abfd;
2936 s->symbol.name = sym->strtab + stroff;
2937 s->symbol.value = value;
2938 s->symbol.flags = 0x0;
2939 s->symbol.udata.i = i;
2940 s->n_type = type;
2941 s->n_sect = section;
2942 s->n_desc = desc;
2943
2944 if (type & BFD_MACH_O_N_STAB)
2945 {
2946 s->symbol.flags |= BSF_DEBUGGING;
2947 s->symbol.section = bfd_und_section_ptr;
2948 switch (type)
2949 {
2950 case N_FUN:
2951 case N_STSYM:
2952 case N_LCSYM:
2953 case N_BNSYM:
2954 case N_SLINE:
2955 case N_ENSYM:
2956 case N_ECOMM:
2957 case N_ECOML:
2958 case N_GSYM:
2959 if ((section > 0) && (section <= mdata->nsects))
2960 {
2961 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2962 s->symbol.value =
2963 s->symbol.value - mdata->sections[section - 1]->addr;
2964 }
2965 break;
2966 }
2967 }
2968 else
2969 {
2970 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
2971 s->symbol.flags |= BSF_GLOBAL;
2972 else
2973 s->symbol.flags |= BSF_LOCAL;
2974
2975 switch (symtype)
2976 {
2977 case BFD_MACH_O_N_UNDF:
2978 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
2979 && s->symbol.value != 0)
2980 {
2981 /* A common symbol. */
2982 s->symbol.section = bfd_com_section_ptr;
2983 s->symbol.flags = BSF_NO_FLAGS;
2984 }
2985 else
2986 {
2987 s->symbol.section = bfd_und_section_ptr;
2988 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2989 s->symbol.flags |= BSF_WEAK;
2990 }
2991 break;
2992 case BFD_MACH_O_N_PBUD:
2993 s->symbol.section = bfd_und_section_ptr;
2994 break;
2995 case BFD_MACH_O_N_ABS:
2996 s->symbol.section = bfd_abs_section_ptr;
2997 break;
2998 case BFD_MACH_O_N_SECT:
2999 if ((section > 0) && (section <= mdata->nsects))
3000 {
3001 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3002 s->symbol.value =
3003 s->symbol.value - mdata->sections[section - 1]->addr;
3004 }
3005 else
3006 {
3007 /* Mach-O uses 0 to mean "no section"; not an error. */
3008 if (section != 0)
3009 {
3010 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3011 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
3012 s->symbol.name, section, mdata->nsects);
3013 }
3014 s->symbol.section = bfd_und_section_ptr;
3015 }
3016 break;
3017 case BFD_MACH_O_N_INDR:
3018 /* FIXME: we don't follow the BFD convention as this indirect symbol
3019 won't be followed by the referenced one. This looks harmless
3020 unless we start using the linker. */
3021 s->symbol.flags |= BSF_INDIRECT;
3022 s->symbol.section = bfd_ind_section_ptr;
3023 s->symbol.value = 0;
3024 break;
3025 default:
3026 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
3027 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
3028 s->symbol.name, symtype);
3029 s->symbol.section = bfd_und_section_ptr;
3030 break;
3031 }
3032 }
3033
3034 return TRUE;
3035 }
3036
3037 bfd_boolean
3038 bfd_mach_o_read_symtab_strtab (bfd *abfd)
3039 {
3040 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3041 bfd_mach_o_symtab_command *sym = mdata->symtab;
3042
3043 /* Fail if there is no symtab. */
3044 if (sym == NULL)
3045 return FALSE;
3046
3047 /* Success if already loaded. */
3048 if (sym->strtab)
3049 return TRUE;
3050
3051 if (abfd->flags & BFD_IN_MEMORY)
3052 {
3053 struct bfd_in_memory *b;
3054
3055 b = (struct bfd_in_memory *) abfd->iostream;
3056
3057 if ((sym->stroff + sym->strsize) > b->size)
3058 {
3059 bfd_set_error (bfd_error_file_truncated);
3060 return FALSE;
3061 }
3062 sym->strtab = (char *) b->buffer + sym->stroff;
3063 }
3064 else
3065 {
3066 sym->strtab = bfd_alloc (abfd, sym->strsize);
3067 if (sym->strtab == NULL)
3068 return FALSE;
3069
3070 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
3071 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3072 {
3073 bfd_set_error (bfd_error_file_truncated);
3074 return FALSE;
3075 }
3076 }
3077
3078 return TRUE;
3079 }
3080
3081 bfd_boolean
3082 bfd_mach_o_read_symtab_symbols (bfd *abfd)
3083 {
3084 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3085 bfd_mach_o_symtab_command *sym = mdata->symtab;
3086 unsigned long i;
3087
3088 if (sym == NULL || sym->symbols)
3089 {
3090 /* Return now if there are no symbols or if already loaded. */
3091 return TRUE;
3092 }
3093
3094 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3095
3096 if (sym->symbols == NULL)
3097 {
3098 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
3099 return FALSE;
3100 }
3101
3102 if (!bfd_mach_o_read_symtab_strtab (abfd))
3103 return FALSE;
3104
3105 for (i = 0; i < sym->nsyms; i++)
3106 {
3107 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3108 return FALSE;
3109 }
3110
3111 return TRUE;
3112 }
3113
3114 static const char *
3115 bfd_mach_o_i386_flavour_string (unsigned int flavour)
3116 {
3117 switch ((int) flavour)
3118 {
3119 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3120 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3121 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3122 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3123 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3124 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3125 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3126 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3127 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3128 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3129 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3130 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
3131 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3132 default: return "UNKNOWN";
3133 }
3134 }
3135
3136 static const char *
3137 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3138 {
3139 switch ((int) flavour)
3140 {
3141 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3142 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3143 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3144 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3145 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3146 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3147 default: return "UNKNOWN";
3148 }
3149 }
3150
3151 static int
3152 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3153 {
3154 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
3155 struct mach_o_str_command_external raw;
3156 unsigned int nameoff;
3157
3158 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3159 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3160 return -1;
3161
3162 nameoff = bfd_h_get_32 (abfd, raw.str);
3163
3164 cmd->name_offset = command->offset + nameoff;
3165 cmd->name_len = command->len - nameoff;
3166 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3167 if (cmd->name_str == NULL)
3168 return -1;
3169 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3170 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3171 return -1;
3172 return 0;
3173 }
3174
3175 static int
3176 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3177 {
3178 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
3179 struct mach_o_dylib_command_external raw;
3180 unsigned int nameoff;
3181
3182 switch (command->type)
3183 {
3184 case BFD_MACH_O_LC_LOAD_DYLIB:
3185 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3186 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3187 case BFD_MACH_O_LC_ID_DYLIB:
3188 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3189 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3190 break;
3191 default:
3192 BFD_FAIL ();
3193 return -1;
3194 }
3195
3196 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3197 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3198 return -1;
3199
3200 nameoff = bfd_h_get_32 (abfd, raw.name);
3201 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
3202 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
3203 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3204
3205 cmd->name_offset = command->offset + nameoff;
3206 cmd->name_len = command->len - nameoff;
3207 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
3208 if (cmd->name_str == NULL)
3209 return -1;
3210 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
3211 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3212 return -1;
3213 return 0;
3214 }
3215
3216 static int
3217 bfd_mach_o_read_prebound_dylib (bfd *abfd,
3218 bfd_mach_o_load_command *command)
3219 {
3220 bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
3221 struct mach_o_prebound_dylib_command_external raw;
3222 unsigned int nameoff;
3223 unsigned int modoff;
3224 unsigned int str_len;
3225 unsigned char *str;
3226
3227 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3228 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3229 return -1;
3230
3231 nameoff = bfd_h_get_32 (abfd, raw.name);
3232 modoff = bfd_h_get_32 (abfd, raw.linked_modules);
3233 if (nameoff > command->len || modoff > command->len)
3234 return -1;
3235
3236 str_len = command->len - sizeof (raw);
3237 str = bfd_alloc (abfd, str_len);
3238 if (str == NULL)
3239 return -1;
3240 if (bfd_bread (str, str_len, abfd) != str_len)
3241 return -1;
3242
3243 cmd->name_offset = command->offset + nameoff;
3244 cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
3245 cmd->linked_modules_offset = command->offset + modoff;
3246
3247 cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3248 cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
3249 return 0;
3250 }
3251
3252 static int
3253 bfd_mach_o_read_prebind_cksum (bfd *abfd,
3254 bfd_mach_o_load_command *command)
3255 {
3256 bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
3257 struct mach_o_prebind_cksum_command_external raw;
3258
3259 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3260 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3261 return -1;
3262
3263 cmd->cksum = bfd_get_32 (abfd, raw.cksum);
3264 return 0;
3265 }
3266
3267 static int
3268 bfd_mach_o_read_twolevel_hints (bfd *abfd,
3269 bfd_mach_o_load_command *command)
3270 {
3271 bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
3272 struct mach_o_twolevel_hints_command_external raw;
3273
3274 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3275 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3276 return -1;
3277
3278 cmd->offset = bfd_get_32 (abfd, raw.offset);
3279 cmd->nhints = bfd_get_32 (abfd, raw.nhints);
3280 return 0;
3281 }
3282
3283 static int
3284 bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
3285 {
3286 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
3287 struct mach_o_fvmlib_command_external raw;
3288 unsigned int nameoff;
3289
3290 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3291 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3292 return -1;
3293
3294 nameoff = bfd_h_get_32 (abfd, raw.name);
3295 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
3296 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
3297
3298 fvm->name_offset = command->offset + nameoff;
3299 fvm->name_len = command->len - nameoff;
3300 fvm->name_str = bfd_alloc (abfd, fvm->name_len);
3301 if (fvm->name_str == NULL)
3302 return -1;
3303 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
3304 || bfd_bread (fvm->name_str, fvm->name_len, abfd) != fvm->name_len)
3305 return -1;
3306 return 0;
3307 }
3308
3309 static int
3310 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3311 {
3312 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3313 bfd_mach_o_thread_command *cmd = &command->command.thread;
3314 unsigned int offset;
3315 unsigned int nflavours;
3316 unsigned int i;
3317
3318 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3319 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3320
3321 /* Count the number of threads. */
3322 offset = 8;
3323 nflavours = 0;
3324 while (offset != command->len)
3325 {
3326 struct mach_o_thread_command_external raw;
3327
3328 if (offset >= command->len)
3329 return -1;
3330
3331 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3332 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3333 return -1;
3334
3335 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3336 nflavours++;
3337 }
3338
3339 /* Allocate threads. */
3340 cmd->flavours = bfd_alloc
3341 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3342 if (cmd->flavours == NULL)
3343 return -1;
3344 cmd->nflavours = nflavours;
3345
3346 offset = 8;
3347 nflavours = 0;
3348 while (offset != command->len)
3349 {
3350 struct mach_o_thread_command_external raw;
3351
3352 if (offset >= command->len)
3353 return -1;
3354
3355 if (nflavours >= cmd->nflavours)
3356 return -1;
3357
3358 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
3359 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3360 return -1;
3361
3362 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3363 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3364 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3365 offset += cmd->flavours[nflavours].size + sizeof (raw);
3366 nflavours++;
3367 }
3368
3369 for (i = 0; i < nflavours; i++)
3370 {
3371 asection *bfdsec;
3372 unsigned int snamelen;
3373 char *sname;
3374 const char *flavourstr;
3375 const char *prefix = "LC_THREAD";
3376 unsigned int j = 0;
3377
3378 switch (mdata->header.cputype)
3379 {
3380 case BFD_MACH_O_CPU_TYPE_POWERPC:
3381 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3382 flavourstr =
3383 bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3384 break;
3385 case BFD_MACH_O_CPU_TYPE_I386:
3386 case BFD_MACH_O_CPU_TYPE_X86_64:
3387 flavourstr =
3388 bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3389 break;
3390 default:
3391 flavourstr = "UNKNOWN_ARCHITECTURE";
3392 break;
3393 }
3394
3395 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
3396 sname = bfd_alloc (abfd, snamelen);
3397 if (sname == NULL)
3398 return -1;
3399
3400 for (;;)
3401 {
3402 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3403 if (bfd_get_section_by_name (abfd, sname) == NULL)
3404 break;
3405 j++;
3406 }
3407
3408 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
3409
3410 bfdsec->vma = 0;
3411 bfdsec->lma = 0;
3412 bfdsec->size = cmd->flavours[i].size;
3413 bfdsec->filepos = cmd->flavours[i].offset;
3414 bfdsec->alignment_power = 0x0;
3415
3416 cmd->section = bfdsec;
3417 }
3418
3419 return 0;
3420 }
3421
3422 static int
3423 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3424 {
3425 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
3426 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3427
3428 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3429
3430 {
3431 struct mach_o_dysymtab_command_external raw;
3432
3433 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3434 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3435 return -1;
3436
3437 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3438 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3439 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3440 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3441 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3442 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3443 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3444 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3445 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3446 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3447 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3448 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3449 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3450 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3451 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3452 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3453 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3454 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3455 }
3456
3457 if (cmd->nmodtab != 0)
3458 {
3459 unsigned int i;
3460 int wide = bfd_mach_o_wide_p (abfd);
3461 unsigned int module_len = wide ? 56 : 52;
3462
3463 cmd->dylib_module =
3464 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3465 if (cmd->dylib_module == NULL)
3466 return -1;
3467
3468 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3469 return -1;
3470
3471 for (i = 0; i < cmd->nmodtab; i++)
3472 {
3473 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3474 unsigned long v;
3475 unsigned char buf[56];
3476
3477 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
3478 return -1;
3479
3480 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3481 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3482 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3483 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3484 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3485 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3486 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3487 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3488 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3489 v = bfd_h_get_32 (abfd, buf +36);
3490 module->iinit = v & 0xffff;
3491 module->iterm = (v >> 16) & 0xffff;
3492 v = bfd_h_get_32 (abfd, buf + 40);
3493 module->ninit = v & 0xffff;
3494 module->nterm = (v >> 16) & 0xffff;
3495 if (wide)
3496 {
3497 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3498 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3499 }
3500 else
3501 {
3502 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3503 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3504 }
3505 }
3506 }
3507
3508 if (cmd->ntoc != 0)
3509 {
3510 unsigned int i;
3511
3512 cmd->dylib_toc = bfd_alloc
3513 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3514 if (cmd->dylib_toc == NULL)
3515 return -1;
3516
3517 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3518 return -1;
3519
3520 for (i = 0; i < cmd->ntoc; i++)
3521 {
3522 struct mach_o_dylib_table_of_contents_external raw;
3523 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3524
3525 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3526 return -1;
3527
3528 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3529 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
3530 }
3531 }
3532
3533 if (cmd->nindirectsyms != 0)
3534 {
3535 unsigned int i;
3536
3537 cmd->indirect_syms = bfd_alloc
3538 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3539 if (cmd->indirect_syms == NULL)
3540 return -1;
3541
3542 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3543 return -1;
3544
3545 for (i = 0; i < cmd->nindirectsyms; i++)
3546 {
3547 unsigned char raw[4];
3548 unsigned int *is = &cmd->indirect_syms[i];
3549
3550 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3551 return -1;
3552
3553 *is = bfd_h_get_32 (abfd, raw);
3554 }
3555 }
3556
3557 if (cmd->nextrefsyms != 0)
3558 {
3559 unsigned long v;
3560 unsigned int i;
3561
3562 cmd->ext_refs = bfd_alloc
3563 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3564 if (cmd->ext_refs == NULL)
3565 return -1;
3566
3567 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3568 return -1;
3569
3570 for (i = 0; i < cmd->nextrefsyms; i++)
3571 {
3572 unsigned char raw[4];
3573 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3574
3575 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
3576 return -1;
3577
3578 /* Fields isym and flags are written as bit-fields, thus we need
3579 a specific processing for endianness. */
3580 v = bfd_h_get_32 (abfd, raw);
3581 if (bfd_big_endian (abfd))
3582 {
3583 ref->isym = (v >> 8) & 0xffffff;
3584 ref->flags = v & 0xff;
3585 }
3586 else
3587 {
3588 ref->isym = v & 0xffffff;
3589 ref->flags = (v >> 24) & 0xff;
3590 }
3591 }
3592 }
3593
3594 if (mdata->dysymtab)
3595 return -1;
3596 mdata->dysymtab = cmd;
3597
3598 return 0;
3599 }
3600
3601 static int
3602 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3603 {
3604 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3605 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3606 struct mach_o_symtab_command_external raw;
3607
3608 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3609
3610 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3611 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3612 return -1;
3613
3614 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3615 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3616 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3617 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
3618 symtab->symbols = NULL;
3619 symtab->strtab = NULL;
3620
3621 if (symtab->nsyms != 0)
3622 abfd->flags |= HAS_SYMS;
3623
3624 if (mdata->symtab)
3625 return -1;
3626 mdata->symtab = symtab;
3627 return 0;
3628 }
3629
3630 static int
3631 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
3632 {
3633 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
3634
3635 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3636
3637 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3638 || bfd_bread (cmd->uuid, 16, abfd) != 16)
3639 return -1;
3640
3641 return 0;
3642 }
3643
3644 static int
3645 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
3646 {
3647 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
3648 struct mach_o_linkedit_data_command_external raw;
3649
3650 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3651 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3652 return -1;
3653
3654 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3655 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
3656 return 0;
3657 }
3658
3659 static int
3660 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
3661 {
3662 bfd_mach_o_str_command *cmd = &command->command.str;
3663 struct mach_o_str_command_external raw;
3664 unsigned long off;
3665
3666 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3667 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3668 return -1;
3669
3670 off = bfd_get_32 (abfd, raw.str);
3671 cmd->stroff = command->offset + off;
3672 cmd->str_len = command->len - off;
3673 cmd->str = bfd_alloc (abfd, cmd->str_len);
3674 if (cmd->str == NULL)
3675 return -1;
3676 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
3677 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
3678 return -1;
3679 return 0;
3680 }
3681
3682 static int
3683 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
3684 {
3685 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
3686 struct mach_o_dyld_info_command_external raw;
3687
3688 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3689 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3690 return -1;
3691
3692 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3693 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3694 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3695 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3696 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3697 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3698 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3699 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3700 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3701 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
3702 return 0;
3703 }
3704
3705 static bfd_boolean
3706 bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3707 {
3708 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3709 struct mach_o_version_min_command_external raw;
3710 unsigned int ver;
3711
3712 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3713 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3714 return FALSE;
3715
3716 ver = bfd_get_32 (abfd, raw.version);
3717 cmd->rel = ver >> 16;
3718 cmd->maj = ver >> 8;
3719 cmd->min = ver;
3720 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3721 return TRUE;
3722 }
3723
3724 static bfd_boolean
3725 bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3726 {
3727 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3728 struct mach_o_encryption_info_command_external raw;
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 FALSE;
3733
3734 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3735 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3736 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3737 return TRUE;
3738 }
3739
3740 static bfd_boolean
3741 bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
3742 {
3743 bfd_mach_o_main_command *cmd = &command->command.main;
3744 struct mach_o_entry_point_command_external raw;
3745
3746 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3747 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3748 return FALSE;
3749
3750 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
3751 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
3752 return TRUE;
3753 }
3754
3755 static bfd_boolean
3756 bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
3757 {
3758 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
3759 struct mach_o_source_version_command_external raw;
3760 bfd_uint64_t ver;
3761
3762 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3763 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3764 return FALSE;
3765
3766 ver = bfd_get_64 (abfd, raw.version);
3767 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
3768 generates warnings) in case of the host doesn't support 64 bit
3769 integers. */
3770 cmd->e = ver & 0x3ff;
3771 ver >>= 10;
3772 cmd->d = ver & 0x3ff;
3773 ver >>= 10;
3774 cmd->c = ver & 0x3ff;
3775 ver >>= 10;
3776 cmd->b = ver & 0x3ff;
3777 ver >>= 10;
3778 cmd->a = ver & 0xffffff;
3779 return TRUE;
3780 }
3781
3782 static int
3783 bfd_mach_o_read_segment (bfd *abfd,
3784 bfd_mach_o_load_command *command,
3785 unsigned int wide)
3786 {
3787 bfd_mach_o_segment_command *seg = &command->command.segment;
3788 unsigned long i;
3789
3790 if (wide)
3791 {
3792 struct mach_o_segment_command_64_external raw;
3793
3794 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3795
3796 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3797 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3798 return -1;
3799
3800 memcpy (seg->segname, raw.segname, 16);
3801 seg->segname[16] = '\0';
3802
3803 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3804 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3805 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3806 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3807 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3808 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3809 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3810 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3811 }
3812 else
3813 {
3814 struct mach_o_segment_command_32_external raw;
3815
3816 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3817
3818 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3819 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3820 return -1;
3821
3822 memcpy (seg->segname, raw.segname, 16);
3823 seg->segname[16] = '\0';
3824
3825 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3826 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3827 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3828 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3829 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3830 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3831 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3832 seg->flags = bfd_h_get_32 (abfd, raw.flags);
3833 }
3834 seg->sect_head = NULL;
3835 seg->sect_tail = NULL;
3836
3837 for (i = 0; i < seg->nsects; i++)
3838 {
3839 bfd_vma segoff;
3840 asection *sec;
3841
3842 if (wide)
3843 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3844 + (i * BFD_MACH_O_SECTION_64_SIZE);
3845 else
3846 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3847 + (i * BFD_MACH_O_SECTION_SIZE);
3848
3849 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3850 if (sec == NULL)
3851 return -1;
3852
3853 bfd_mach_o_append_section_to_segment (seg, sec);
3854 }
3855
3856 return 0;
3857 }
3858
3859 static int
3860 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
3861 {
3862 return bfd_mach_o_read_segment (abfd, command, 0);
3863 }
3864
3865 static int
3866 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
3867 {
3868 return bfd_mach_o_read_segment (abfd, command, 1);
3869 }
3870
3871 static int
3872 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3873 {
3874 struct mach_o_load_command_external raw;
3875 unsigned int cmd;
3876
3877 /* Read command type and length. */
3878 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
3879 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3880 return -1;
3881
3882 cmd = bfd_h_get_32 (abfd, raw.cmd);
3883 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3884 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3885 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3886
3887 switch (command->type)
3888 {
3889 case BFD_MACH_O_LC_SEGMENT:
3890 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
3891 return -1;
3892 break;
3893 case BFD_MACH_O_LC_SEGMENT_64:
3894 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3895 return -1;
3896 break;
3897 case BFD_MACH_O_LC_SYMTAB:
3898 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3899 return -1;
3900 break;
3901 case BFD_MACH_O_LC_SYMSEG:
3902 break;
3903 case BFD_MACH_O_LC_THREAD:
3904 case BFD_MACH_O_LC_UNIXTHREAD:
3905 if (bfd_mach_o_read_thread (abfd, command) != 0)
3906 return -1;
3907 break;
3908 case BFD_MACH_O_LC_LOAD_DYLINKER:
3909 case BFD_MACH_O_LC_ID_DYLINKER:
3910 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
3911 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3912 return -1;
3913 break;
3914 case BFD_MACH_O_LC_LOAD_DYLIB:
3915 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3916 case BFD_MACH_O_LC_ID_DYLIB:
3917 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3918 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3919 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3920 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3921 return -1;
3922 break;
3923 case BFD_MACH_O_LC_PREBOUND_DYLIB:
3924 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3925 return -1;
3926 break;
3927 case BFD_MACH_O_LC_LOADFVMLIB:
3928 case BFD_MACH_O_LC_IDFVMLIB:
3929 if (bfd_mach_o_read_fvmlib (abfd, command) != 0)
3930 return -1;
3931 break;
3932 case BFD_MACH_O_LC_IDENT:
3933 case BFD_MACH_O_LC_FVMFILE:
3934 case BFD_MACH_O_LC_PREPAGE:
3935 case BFD_MACH_O_LC_ROUTINES:
3936 case BFD_MACH_O_LC_ROUTINES_64:
3937 break;
3938 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3939 case BFD_MACH_O_LC_SUB_UMBRELLA:
3940 case BFD_MACH_O_LC_SUB_LIBRARY:
3941 case BFD_MACH_O_LC_SUB_CLIENT:
3942 case BFD_MACH_O_LC_RPATH:
3943 if (bfd_mach_o_read_str (abfd, command) != 0)
3944 return -1;
3945 break;
3946 case BFD_MACH_O_LC_DYSYMTAB:
3947 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3948 return -1;
3949 break;
3950 case BFD_MACH_O_LC_PREBIND_CKSUM:
3951 if (bfd_mach_o_read_prebind_cksum (abfd, command) != 0)
3952 return -1;
3953 break;
3954 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3955 if (bfd_mach_o_read_twolevel_hints (abfd, command) != 0)
3956 return -1;
3957 break;
3958 case BFD_MACH_O_LC_UUID:
3959 if (bfd_mach_o_read_uuid (abfd, command) != 0)
3960 return -1;
3961 break;
3962 case BFD_MACH_O_LC_CODE_SIGNATURE:
3963 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3964 case BFD_MACH_O_LC_FUNCTION_STARTS:
3965 case BFD_MACH_O_LC_DATA_IN_CODE:
3966 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
3967 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
3968 return -1;
3969 break;
3970 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3971 if (!bfd_mach_o_read_encryption_info (abfd, command))
3972 return -1;
3973 break;
3974 case BFD_MACH_O_LC_DYLD_INFO:
3975 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
3976 return -1;
3977 break;
3978 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3979 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3980 if (!bfd_mach_o_read_version_min (abfd, command))
3981 return -1;
3982 break;
3983 case BFD_MACH_O_LC_MAIN:
3984 if (!bfd_mach_o_read_main (abfd, command))
3985 return -1;
3986 break;
3987 case BFD_MACH_O_LC_SOURCE_VERSION:
3988 if (!bfd_mach_o_read_source_version (abfd, command))
3989 return -1;
3990 break;
3991 default:
3992 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
3993 abfd, (unsigned long) command->type);
3994 break;
3995 }
3996
3997 return 0;
3998 }
3999
4000 static void
4001 bfd_mach_o_flatten_sections (bfd *abfd)
4002 {
4003 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4004 long csect = 0;
4005 unsigned long i;
4006
4007 /* Count total number of sections. */
4008 mdata->nsects = 0;
4009
4010 for (i = 0; i < mdata->header.ncmds; i++)
4011 {
4012 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4013 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4014 {
4015 bfd_mach_o_segment_command *seg;
4016
4017 seg = &mdata->commands[i].command.segment;
4018 mdata->nsects += seg->nsects;
4019 }
4020 }
4021
4022 /* Allocate sections array. */
4023 mdata->sections = bfd_alloc (abfd,
4024 mdata->nsects * sizeof (bfd_mach_o_section *));
4025
4026 /* Fill the array. */
4027 csect = 0;
4028
4029 for (i = 0; i < mdata->header.ncmds; i++)
4030 {
4031 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
4032 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
4033 {
4034 bfd_mach_o_segment_command *seg;
4035 bfd_mach_o_section *sec;
4036
4037 seg = &mdata->commands[i].command.segment;
4038 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4039
4040 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
4041 mdata->sections[csect++] = sec;
4042 }
4043 }
4044 }
4045
4046 static bfd_boolean
4047 bfd_mach_o_scan_start_address (bfd *abfd)
4048 {
4049 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4050 bfd_mach_o_thread_command *cmd = NULL;
4051 unsigned long i;
4052
4053 for (i = 0; i < mdata->header.ncmds; i++)
4054 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
4055 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
4056 {
4057 cmd = &mdata->commands[i].command.thread;
4058 break;
4059 }
4060 else if (mdata->commands[i].type == BFD_MACH_O_LC_MAIN
4061 && mdata->nsects > 1)
4062 {
4063 bfd_mach_o_main_command *main_cmd = &mdata->commands[i].command.main;
4064 bfd_mach_o_section *text_sect = mdata->sections[0];
4065 if (text_sect)
4066 {
4067 abfd->start_address = main_cmd->entryoff
4068 + (text_sect->addr - text_sect->offset);
4069 return TRUE;
4070 }
4071 }
4072
4073 /* An object file has no start address, so do not fail if not found. */
4074 if (cmd == NULL)
4075 return TRUE;
4076
4077 /* FIXME: create a subtarget hook ? */
4078 for (i = 0; i < cmd->nflavours; i++)
4079 {
4080 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
4081 && (cmd->flavours[i].flavour
4082 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
4083 {
4084 unsigned char buf[4];
4085
4086 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
4087 || bfd_bread (buf, 4, abfd) != 4)
4088 return FALSE;
4089
4090 abfd->start_address = bfd_h_get_32 (abfd, buf);
4091 }
4092 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
4093 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
4094 {
4095 unsigned char buf[4];
4096
4097 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4098 || bfd_bread (buf, 4, abfd) != 4)
4099 return FALSE;
4100
4101 abfd->start_address = bfd_h_get_32 (abfd, buf);
4102 }
4103 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
4104 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
4105 {
4106 unsigned char buf[8];
4107
4108 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
4109 || bfd_bread (buf, 8, abfd) != 8)
4110 return FALSE;
4111
4112 abfd->start_address = bfd_h_get_64 (abfd, buf);
4113 }
4114 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
4115 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
4116 {
4117 unsigned char buf[8];
4118
4119 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
4120 || bfd_bread (buf, 8, abfd) != 8)
4121 return FALSE;
4122
4123 abfd->start_address = bfd_h_get_64 (abfd, buf);
4124 }
4125 }
4126
4127 return TRUE;
4128 }
4129
4130 bfd_boolean
4131 bfd_mach_o_set_arch_mach (bfd *abfd,
4132 enum bfd_architecture arch,
4133 unsigned long machine)
4134 {
4135 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4136
4137 /* If this isn't the right architecture for this backend, and this
4138 isn't the generic backend, fail. */
4139 if (arch != bed->arch
4140 && arch != bfd_arch_unknown
4141 && bed->arch != bfd_arch_unknown)
4142 return FALSE;
4143
4144 return bfd_default_set_arch_mach (abfd, arch, machine);
4145 }
4146
4147 static bfd_boolean
4148 bfd_mach_o_scan (bfd *abfd,
4149 bfd_mach_o_header *header,
4150 bfd_mach_o_data_struct *mdata)
4151 {
4152 unsigned int i;
4153 enum bfd_architecture cputype;
4154 unsigned long cpusubtype;
4155 unsigned int hdrsize;
4156
4157 hdrsize = mach_o_wide_p (header) ?
4158 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
4159
4160 mdata->header = *header;
4161
4162 abfd->flags = abfd->flags & BFD_IN_MEMORY;
4163 switch (header->filetype)
4164 {
4165 case BFD_MACH_O_MH_OBJECT:
4166 abfd->flags |= HAS_RELOC;
4167 break;
4168 case BFD_MACH_O_MH_EXECUTE:
4169 abfd->flags |= EXEC_P;
4170 break;
4171 case BFD_MACH_O_MH_DYLIB:
4172 case BFD_MACH_O_MH_BUNDLE:
4173 abfd->flags |= DYNAMIC;
4174 break;
4175 }
4176
4177 abfd->tdata.mach_o_data = mdata;
4178
4179 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
4180 &cputype, &cpusubtype);
4181 if (cputype == bfd_arch_unknown)
4182 {
4183 (*_bfd_error_handler)
4184 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
4185 header->cputype, header->cpusubtype);
4186 return FALSE;
4187 }
4188
4189 bfd_set_arch_mach (abfd, cputype, cpusubtype);
4190
4191 if (header->ncmds != 0)
4192 {
4193 mdata->commands = bfd_alloc
4194 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
4195 if (mdata->commands == NULL)
4196 return FALSE;
4197
4198 for (i = 0; i < header->ncmds; i++)
4199 {
4200 bfd_mach_o_load_command *cur = &mdata->commands[i];
4201
4202 if (i == 0)
4203 cur->offset = hdrsize;
4204 else
4205 {
4206 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
4207 cur->offset = prev->offset + prev->len;
4208 }
4209
4210 if (bfd_mach_o_read_command (abfd, cur) < 0)
4211 return FALSE;
4212 }
4213 }
4214
4215 /* Sections should be flatten before scanning start address. */
4216 bfd_mach_o_flatten_sections (abfd);
4217 if (!bfd_mach_o_scan_start_address (abfd))
4218 return FALSE;
4219
4220 return TRUE;
4221 }
4222
4223 bfd_boolean
4224 bfd_mach_o_mkobject_init (bfd *abfd)
4225 {
4226 bfd_mach_o_data_struct *mdata = NULL;
4227
4228 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
4229 if (mdata == NULL)
4230 return FALSE;
4231 abfd->tdata.mach_o_data = mdata;
4232
4233 mdata->header.magic = 0;
4234 mdata->header.cputype = 0;
4235 mdata->header.cpusubtype = 0;
4236 mdata->header.filetype = 0;
4237 mdata->header.ncmds = 0;
4238 mdata->header.sizeofcmds = 0;
4239 mdata->header.flags = 0;
4240 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
4241 mdata->commands = NULL;
4242 mdata->nsects = 0;
4243 mdata->sections = NULL;
4244 mdata->dyn_reloc_cache = NULL;
4245
4246 return TRUE;
4247 }
4248
4249 static bfd_boolean
4250 bfd_mach_o_gen_mkobject (bfd *abfd)
4251 {
4252 bfd_mach_o_data_struct *mdata;
4253
4254 if (!bfd_mach_o_mkobject_init (abfd))
4255 return FALSE;
4256
4257 mdata = bfd_mach_o_get_data (abfd);
4258 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
4259 mdata->header.cputype = 0;
4260 mdata->header.cpusubtype = 0;
4261 mdata->header.byteorder = abfd->xvec->byteorder;
4262 mdata->header.version = 1;
4263
4264 return TRUE;
4265 }
4266
4267 const bfd_target *
4268 bfd_mach_o_header_p (bfd *abfd,
4269 bfd_mach_o_filetype filetype,
4270 bfd_mach_o_cpu_type cputype)
4271 {
4272 bfd_mach_o_header header;
4273 bfd_mach_o_data_struct *mdata;
4274
4275 if (!bfd_mach_o_read_header (abfd, &header))
4276 goto wrong;
4277
4278 if (! (header.byteorder == BFD_ENDIAN_BIG
4279 || header.byteorder == BFD_ENDIAN_LITTLE))
4280 {
4281 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
4282 (unsigned long) header.byteorder);
4283 goto wrong;
4284 }
4285
4286 if (! ((header.byteorder == BFD_ENDIAN_BIG
4287 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
4288 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
4289 || (header.byteorder == BFD_ENDIAN_LITTLE
4290 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
4291 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
4292 goto wrong;
4293
4294 /* Check cputype and filetype.
4295 In case of wildcard, do not accept magics that are handled by existing
4296 targets. */
4297 if (cputype)
4298 {
4299 if (header.cputype != cputype)
4300 goto wrong;
4301 }
4302
4303 if (filetype)
4304 {
4305 if (header.filetype != filetype)
4306 goto wrong;
4307 }
4308 else
4309 {
4310 switch (header.filetype)
4311 {
4312 case BFD_MACH_O_MH_CORE:
4313 /* Handled by core_p */
4314 goto wrong;
4315 default:
4316 break;
4317 }
4318 }
4319
4320 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
4321 if (mdata == NULL)
4322 goto fail;
4323
4324 if (!bfd_mach_o_scan (abfd, &header, mdata))
4325 goto wrong;
4326
4327 return abfd->xvec;
4328
4329 wrong:
4330 bfd_set_error (bfd_error_wrong_format);
4331
4332 fail:
4333 return NULL;
4334 }
4335
4336 static const bfd_target *
4337 bfd_mach_o_gen_object_p (bfd *abfd)
4338 {
4339 return bfd_mach_o_header_p (abfd, 0, 0);
4340 }
4341
4342 static const bfd_target *
4343 bfd_mach_o_gen_core_p (bfd *abfd)
4344 {
4345 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
4346 }
4347
4348 /* Return the base address of ABFD, ie the address at which the image is
4349 mapped. The possible initial pagezero is ignored. */
4350
4351 bfd_vma
4352 bfd_mach_o_get_base_address (bfd *abfd)
4353 {
4354 bfd_mach_o_data_struct *mdata;
4355 unsigned int i;
4356
4357 /* Check for Mach-O. */
4358 if (!bfd_mach_o_valid (abfd))
4359 return 0;
4360 mdata = bfd_mach_o_get_data (abfd);
4361
4362 for (i = 0; i < mdata->header.ncmds; i++)
4363 {
4364 bfd_mach_o_load_command *cmd = &mdata->commands[i];
4365 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
4366 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
4367 {
4368 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
4369
4370 if (segcmd->initprot != 0)
4371 return segcmd->vmaddr;
4372 }
4373 }
4374 return 0;
4375 }
4376
4377 typedef struct mach_o_fat_archentry
4378 {
4379 unsigned long cputype;
4380 unsigned long cpusubtype;
4381 unsigned long offset;
4382 unsigned long size;
4383 unsigned long align;
4384 } mach_o_fat_archentry;
4385
4386 typedef struct mach_o_fat_data_struct
4387 {
4388 unsigned long magic;
4389 unsigned long nfat_arch;
4390 mach_o_fat_archentry *archentries;
4391 } mach_o_fat_data_struct;
4392
4393 const bfd_target *
4394 bfd_mach_o_archive_p (bfd *abfd)
4395 {
4396 mach_o_fat_data_struct *adata = NULL;
4397 struct mach_o_fat_header_external hdr;
4398 unsigned long i;
4399
4400 if (bfd_seek (abfd, 0, SEEK_SET) != 0
4401 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
4402 goto error;
4403
4404 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
4405 if (adata == NULL)
4406 goto error;
4407
4408 adata->magic = bfd_getb32 (hdr.magic);
4409 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
4410 if (adata->magic != 0xcafebabe)
4411 goto error;
4412 /* Avoid matching Java bytecode files, which have the same magic number.
4413 In the Java bytecode file format this field contains the JVM version,
4414 which starts at 43.0. */
4415 if (adata->nfat_arch > 30)
4416 goto error;
4417
4418 adata->archentries =
4419 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4420 if (adata->archentries == NULL)
4421 goto error;
4422
4423 for (i = 0; i < adata->nfat_arch; i++)
4424 {
4425 struct mach_o_fat_arch_external arch;
4426 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
4427 goto error;
4428 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4429 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4430 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4431 adata->archentries[i].size = bfd_getb32 (arch.size);
4432 adata->archentries[i].align = bfd_getb32 (arch.align);
4433 }
4434
4435 abfd->tdata.mach_o_fat_data = adata;
4436 return abfd->xvec;
4437
4438 error:
4439 if (adata != NULL)
4440 bfd_release (abfd, adata);
4441 bfd_set_error (bfd_error_wrong_format);
4442 return NULL;
4443 }
4444
4445 /* Set the filename for a fat binary member ABFD, whose bfd architecture is
4446 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
4447 Set arelt_data and origin fields too. */
4448
4449 static void
4450 bfd_mach_o_fat_member_init (bfd *abfd,
4451 enum bfd_architecture arch_type,
4452 unsigned long arch_subtype,
4453 mach_o_fat_archentry *entry)
4454 {
4455 struct areltdata *areltdata;
4456 /* Create the member filename. Use ARCH_NAME. */
4457 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
4458
4459 if (ap)
4460 {
4461 /* Use the architecture name if known. */
4462 abfd->filename = xstrdup (ap->printable_name);
4463 }
4464 else
4465 {
4466 /* Forge a uniq id. */
4467 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
4468 char *name = xmalloc (namelen);
4469 snprintf (name, namelen, "0x%lx-0x%lx",
4470 entry->cputype, entry->cpusubtype);
4471 abfd->filename = name;
4472 }
4473
4474 areltdata = bfd_zmalloc (sizeof (struct areltdata));
4475 areltdata->parsed_size = entry->size;
4476 abfd->arelt_data = areltdata;
4477 abfd->iostream = NULL;
4478 abfd->origin = entry->offset;
4479 }
4480
4481 bfd *
4482 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
4483 {
4484 mach_o_fat_data_struct *adata;
4485 mach_o_fat_archentry *entry = NULL;
4486 unsigned long i;
4487 bfd *nbfd;
4488 enum bfd_architecture arch_type;
4489 unsigned long arch_subtype;
4490
4491 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
4492 BFD_ASSERT (adata != NULL);
4493
4494 /* Find index of previous entry. */
4495 if (prev == NULL)
4496 {
4497 /* Start at first one. */
4498 i = 0;
4499 }
4500 else
4501 {
4502 /* Find index of PREV. */
4503 for (i = 0; i < adata->nfat_arch; i++)
4504 {
4505 if (adata->archentries[i].offset == prev->origin)
4506 break;
4507 }
4508
4509 if (i == adata->nfat_arch)
4510 {
4511 /* Not found. */
4512 bfd_set_error (bfd_error_bad_value);
4513 return NULL;
4514 }
4515
4516 /* Get next entry. */
4517 i++;
4518 }
4519
4520 if (i >= adata->nfat_arch)
4521 {
4522 bfd_set_error (bfd_error_no_more_archived_files);
4523 return NULL;
4524 }
4525
4526 entry = &adata->archentries[i];
4527 nbfd = _bfd_new_bfd_contained_in (archive);
4528 if (nbfd == NULL)
4529 return NULL;
4530
4531 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4532 &arch_type, &arch_subtype);
4533
4534 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
4535
4536 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
4537
4538 return nbfd;
4539 }
4540
4541 /* Analogous to stat call. */
4542
4543 static int
4544 bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
4545 {
4546 if (abfd->arelt_data == NULL)
4547 {
4548 bfd_set_error (bfd_error_invalid_operation);
4549 return -1;
4550 }
4551
4552 buf->st_mtime = 0;
4553 buf->st_uid = 0;
4554 buf->st_gid = 0;
4555 buf->st_mode = 0644;
4556 buf->st_size = arelt_size (abfd);
4557
4558 return 0;
4559 }
4560
4561 /* If ABFD format is FORMAT and architecture is ARCH, return it.
4562 If ABFD is a fat image containing a member that corresponds to FORMAT
4563 and ARCH, returns it.
4564 In other case, returns NULL.
4565 This function allows transparent uses of fat images. */
4566
4567 bfd *
4568 bfd_mach_o_fat_extract (bfd *abfd,
4569 bfd_format format,
4570 const bfd_arch_info_type *arch)
4571 {
4572 bfd *res;
4573 mach_o_fat_data_struct *adata;
4574 unsigned int i;
4575
4576 if (bfd_check_format (abfd, format))
4577 {
4578 if (bfd_get_arch_info (abfd) == arch)
4579 return abfd;
4580 return NULL;
4581 }
4582 if (!bfd_check_format (abfd, bfd_archive)
4583 || abfd->xvec != &mach_o_fat_vec)
4584 return NULL;
4585
4586 /* This is a Mach-O fat image. */
4587 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4588 BFD_ASSERT (adata != NULL);
4589
4590 for (i = 0; i < adata->nfat_arch; i++)
4591 {
4592 struct mach_o_fat_archentry *e = &adata->archentries[i];
4593 enum bfd_architecture cpu_type;
4594 unsigned long cpu_subtype;
4595
4596 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4597 &cpu_type, &cpu_subtype);
4598 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4599 continue;
4600
4601 /* The architecture is found. */
4602 res = _bfd_new_bfd_contained_in (abfd);
4603 if (res == NULL)
4604 return NULL;
4605
4606 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
4607
4608 if (bfd_check_format (res, format))
4609 {
4610 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4611 return res;
4612 }
4613 bfd_close (res);
4614 return NULL;
4615 }
4616
4617 return NULL;
4618 }
4619
4620 int
4621 bfd_mach_o_lookup_command (bfd *abfd,
4622 bfd_mach_o_load_command_type type,
4623 bfd_mach_o_load_command **mcommand)
4624 {
4625 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
4626 bfd_mach_o_load_command *ncmd = NULL;
4627 unsigned int i, num;
4628
4629 BFD_ASSERT (md != NULL);
4630 BFD_ASSERT (mcommand != NULL);
4631
4632 num = 0;
4633 for (i = 0; i < md->header.ncmds; i++)
4634 {
4635 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4636
4637 if (cmd->type != type)
4638 continue;
4639
4640 if (num == 0)
4641 ncmd = cmd;
4642 num++;
4643 }
4644
4645 *mcommand = ncmd;
4646 return num;
4647 }
4648
4649 unsigned long
4650 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
4651 {
4652 switch (type)
4653 {
4654 case BFD_MACH_O_CPU_TYPE_MC680x0:
4655 return 0x04000000;
4656 case BFD_MACH_O_CPU_TYPE_MC88000:
4657 return 0xffffe000;
4658 case BFD_MACH_O_CPU_TYPE_POWERPC:
4659 return 0xc0000000;
4660 case BFD_MACH_O_CPU_TYPE_I386:
4661 return 0xc0000000;
4662 case BFD_MACH_O_CPU_TYPE_SPARC:
4663 return 0xf0000000;
4664 case BFD_MACH_O_CPU_TYPE_I860:
4665 return 0;
4666 case BFD_MACH_O_CPU_TYPE_HPPA:
4667 return 0xc0000000 - 0x04000000;
4668 default:
4669 return 0;
4670 }
4671 }
4672
4673 /* The following two tables should be kept, as far as possible, in order of
4674 most frequently used entries to optimize their use from gas. */
4675
4676 const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
4677 {
4678 { "regular", BFD_MACH_O_S_REGULAR},
4679 { "coalesced", BFD_MACH_O_S_COALESCED},
4680 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4681 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4682 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4683 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
4684 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
4685 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
4686 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4687 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
4688 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4689 { "interposing", BFD_MACH_O_S_INTERPOSING},
4690 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
4691 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4692 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
4693 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
4694 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4695 { NULL, 0}
4696 };
4697
4698 const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
4699 {
4700 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4701 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
4702 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4703 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
4704 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
4705 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4706 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4707 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4708 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
4709 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4710 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
4711 { NULL, 0}
4712 };
4713
4714 /* Get the section type from NAME. Return 256 if NAME is unknown. */
4715
4716 unsigned int
4717 bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
4718 {
4719 const bfd_mach_o_xlat_name *x;
4720 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
4721
4722 for (x = bfd_mach_o_section_type_name; x->name; x++)
4723 if (strcmp (x->name, name) == 0)
4724 {
4725 /* We found it... does the target support it? */
4726 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4727 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4728 return x->val; /* OK. */
4729 else
4730 break; /* Not supported. */
4731 }
4732 /* Maximum section ID = 0xff. */
4733 return 256;
4734 }
4735
4736 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4737
4738 unsigned int
4739 bfd_mach_o_get_section_attribute_from_name (const char *name)
4740 {
4741 const bfd_mach_o_xlat_name *x;
4742
4743 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4744 if (strcmp (x->name, name) == 0)
4745 return x->val;
4746 return (unsigned int)-1;
4747 }
4748
4749 int
4750 bfd_mach_o_core_fetch_environment (bfd *abfd,
4751 unsigned char **rbuf,
4752 unsigned int *rlen)
4753 {
4754 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4755 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4756 unsigned int i = 0;
4757
4758 for (i = 0; i < mdata->header.ncmds; i++)
4759 {
4760 bfd_mach_o_load_command *cur = &mdata->commands[i];
4761 bfd_mach_o_segment_command *seg = NULL;
4762
4763 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4764 continue;
4765
4766 seg = &cur->command.segment;
4767
4768 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4769 {
4770 unsigned long start = seg->fileoff;
4771 unsigned long end = seg->fileoff + seg->filesize;
4772 unsigned char *buf = bfd_malloc (1024);
4773 unsigned long size = 1024;
4774
4775 for (;;)
4776 {
4777 bfd_size_type nread = 0;
4778 unsigned long offset;
4779 int found_nonnull = 0;
4780
4781 if (size > (end - start))
4782 size = (end - start);
4783
4784 buf = bfd_realloc_or_free (buf, size);
4785 if (buf == NULL)
4786 return -1;
4787
4788 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4789 {
4790 free (buf);
4791 return -1;
4792 }
4793
4794 nread = bfd_bread (buf, size, abfd);
4795
4796 if (nread != size)
4797 {
4798 free (buf);
4799 return -1;
4800 }
4801
4802 for (offset = 4; offset <= size; offset += 4)
4803 {
4804 unsigned long val;
4805
4806 val = *((unsigned long *) (buf + size - offset));
4807 if (! found_nonnull)
4808 {
4809 if (val != 0)
4810 found_nonnull = 1;
4811 }
4812 else if (val == 0x0)
4813 {
4814 unsigned long bottom;
4815 unsigned long top;
4816
4817 bottom = seg->fileoff + seg->filesize - offset;
4818 top = seg->fileoff + seg->filesize - 4;
4819 *rbuf = bfd_malloc (top - bottom);
4820 *rlen = top - bottom;
4821
4822 memcpy (*rbuf, buf + size - *rlen, *rlen);
4823 free (buf);
4824 return 0;
4825 }
4826 }
4827
4828 if (size == (end - start))
4829 break;
4830
4831 size *= 2;
4832 }
4833
4834 free (buf);
4835 }
4836 }
4837
4838 return -1;
4839 }
4840
4841 char *
4842 bfd_mach_o_core_file_failing_command (bfd *abfd)
4843 {
4844 unsigned char *buf = NULL;
4845 unsigned int len = 0;
4846 int ret = -1;
4847
4848 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4849 if (ret < 0)
4850 return NULL;
4851
4852 return (char *) buf;
4853 }
4854
4855 int
4856 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4857 {
4858 return 0;
4859 }
4860
4861 static bfd_mach_o_uuid_command *
4862 bfd_mach_o_lookup_uuid_command (bfd *abfd)
4863 {
4864 bfd_mach_o_load_command *uuid_cmd;
4865 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4866 if (ncmd != 1)
4867 return FALSE;
4868 return &uuid_cmd->command.uuid;
4869 }
4870
4871 /* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4872
4873 static bfd_boolean
4874 bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4875 {
4876 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4877
4878 BFD_ASSERT (abfd);
4879 BFD_ASSERT (uuid_cmd);
4880
4881 if (!bfd_check_format (abfd, bfd_object))
4882 return FALSE;
4883
4884 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4885 || bfd_mach_o_get_data (abfd) == NULL
4886 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4887 return FALSE;
4888
4889 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4890 if (dsym_uuid_cmd == NULL)
4891 return FALSE;
4892
4893 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4894 sizeof (uuid_cmd->uuid)) != 0)
4895 return FALSE;
4896
4897 return TRUE;
4898 }
4899
4900 /* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4901 The caller is responsible for closing the returned BFD object and
4902 its my_archive if the returned BFD is in a fat dSYM. */
4903
4904 static bfd *
4905 bfd_mach_o_find_dsym (const char *dsym_filename,
4906 const bfd_mach_o_uuid_command *uuid_cmd,
4907 const bfd_arch_info_type *arch)
4908 {
4909 bfd *base_dsym_bfd, *dsym_bfd;
4910
4911 BFD_ASSERT (uuid_cmd);
4912
4913 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4914 if (base_dsym_bfd == NULL)
4915 return NULL;
4916
4917 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4918 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4919 return dsym_bfd;
4920
4921 bfd_close (dsym_bfd);
4922 if (base_dsym_bfd != dsym_bfd)
4923 bfd_close (base_dsym_bfd);
4924
4925 return NULL;
4926 }
4927
4928 /* Return a BFD created from a dSYM file for ABFD.
4929 The caller is responsible for closing the returned BFD object, its
4930 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4931
4932 static bfd *
4933 bfd_mach_o_follow_dsym (bfd *abfd)
4934 {
4935 char *dsym_filename;
4936 bfd_mach_o_uuid_command *uuid_cmd;
4937 bfd *dsym_bfd, *base_bfd = abfd;
4938 const char *base_basename;
4939
4940 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4941 return NULL;
4942
4943 if (abfd->my_archive)
4944 base_bfd = abfd->my_archive;
4945 /* BFD may have been opened from a stream. */
4946 if (base_bfd->filename == NULL)
4947 {
4948 bfd_set_error (bfd_error_invalid_operation);
4949 return NULL;
4950 }
4951 base_basename = lbasename (base_bfd->filename);
4952
4953 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4954 if (uuid_cmd == NULL)
4955 return NULL;
4956
4957 /* TODO: We assume the DWARF file has the same as the binary's.
4958 It seems apple's GDB checks all files in the dSYM bundle directory.
4959 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4960 */
4961 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4962 + strlen (dsym_subdir) + 1
4963 + strlen (base_basename) + 1);
4964 sprintf (dsym_filename, "%s%s/%s",
4965 base_bfd->filename, dsym_subdir, base_basename);
4966
4967 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4968 bfd_get_arch_info (abfd));
4969 if (dsym_bfd == NULL)
4970 free (dsym_filename);
4971
4972 return dsym_bfd;
4973 }
4974
4975 bfd_boolean
4976 bfd_mach_o_find_nearest_line (bfd *abfd,
4977 asection *section,
4978 asymbol **symbols,
4979 bfd_vma offset,
4980 const char **filename_ptr,
4981 const char **functionname_ptr,
4982 unsigned int *line_ptr)
4983 {
4984 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4985 if (mdata == NULL)
4986 return FALSE;
4987 switch (mdata->header.filetype)
4988 {
4989 case BFD_MACH_O_MH_OBJECT:
4990 break;
4991 case BFD_MACH_O_MH_EXECUTE:
4992 case BFD_MACH_O_MH_DYLIB:
4993 case BFD_MACH_O_MH_BUNDLE:
4994 case BFD_MACH_O_MH_KEXT_BUNDLE:
4995 if (mdata->dwarf2_find_line_info == NULL)
4996 {
4997 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4998 /* When we couldn't find dSYM for this binary, we look for
4999 the debug information in the binary itself. In this way,
5000 we won't try finding separated dSYM again because
5001 mdata->dwarf2_find_line_info will be filled. */
5002 if (! mdata->dsym_bfd)
5003 break;
5004 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5005 dwarf_debug_sections, symbols,
5006 &mdata->dwarf2_find_line_info))
5007 return FALSE;
5008 }
5009 break;
5010 default:
5011 return FALSE;
5012 }
5013 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
5014 section, symbols, offset,
5015 filename_ptr, functionname_ptr,
5016 line_ptr, NULL, 0,
5017 &mdata->dwarf2_find_line_info))
5018 return TRUE;
5019 return FALSE;
5020 }
5021
5022 bfd_boolean
5023 bfd_mach_o_close_and_cleanup (bfd *abfd)
5024 {
5025 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5026 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
5027 {
5028 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5029 bfd_mach_o_free_cached_info (abfd);
5030 if (mdata->dsym_bfd != NULL)
5031 {
5032 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
5033 char *dsym_filename = (char *)(fat_bfd
5034 ? fat_bfd->filename
5035 : mdata->dsym_bfd->filename);
5036 bfd_close (mdata->dsym_bfd);
5037 mdata->dsym_bfd = NULL;
5038 if (fat_bfd)
5039 bfd_close (fat_bfd);
5040 free (dsym_filename);
5041 }
5042 }
5043
5044 if (bfd_get_format (abfd) == bfd_archive
5045 && abfd->xvec == &mach_o_fat_vec)
5046 return TRUE;
5047 return _bfd_generic_close_and_cleanup (abfd);
5048 }
5049
5050 bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
5051 {
5052 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5053 asection *asect;
5054 free (mdata->dyn_reloc_cache);
5055 mdata->dyn_reloc_cache = NULL;
5056 for (asect = abfd->sections; asect != NULL; asect = asect->next)
5057 {
5058 free (asect->relocation);
5059 asect->relocation = NULL;
5060 }
5061
5062 return TRUE;
5063 }
5064
5065 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5066 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5067
5068 #define bfd_mach_o_swap_reloc_in NULL
5069 #define bfd_mach_o_swap_reloc_out NULL
5070 #define bfd_mach_o_print_thread NULL
5071 #define bfd_mach_o_tgt_seg_table NULL
5072 #define bfd_mach_o_section_type_valid_for_tgt NULL
5073
5074 #define TARGET_NAME mach_o_be_vec
5075 #define TARGET_STRING "mach-o-be"
5076 #define TARGET_ARCHITECTURE bfd_arch_unknown
5077 #define TARGET_BIG_ENDIAN 1
5078 #define TARGET_ARCHIVE 0
5079 #define TARGET_PRIORITY 1
5080 #include "mach-o-target.c"
5081
5082 #undef TARGET_NAME
5083 #undef TARGET_STRING
5084 #undef TARGET_ARCHITECTURE
5085 #undef TARGET_BIG_ENDIAN
5086 #undef TARGET_ARCHIVE
5087 #undef TARGET_PRIORITY
5088
5089 #define TARGET_NAME mach_o_le_vec
5090 #define TARGET_STRING "mach-o-le"
5091 #define TARGET_ARCHITECTURE bfd_arch_unknown
5092 #define TARGET_BIG_ENDIAN 0
5093 #define TARGET_ARCHIVE 0
5094 #define TARGET_PRIORITY 1
5095
5096 #include "mach-o-target.c"
5097
5098 #undef TARGET_NAME
5099 #undef TARGET_STRING
5100 #undef TARGET_ARCHITECTURE
5101 #undef TARGET_BIG_ENDIAN
5102 #undef TARGET_ARCHIVE
5103 #undef TARGET_PRIORITY
5104
5105 /* Not yet handled: creating an archive. */
5106 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
5107
5108 /* Not used. */
5109 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
5110 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
5111 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
5112 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
5113 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
5114 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
5115 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
5116 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
5117 #define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
5118 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
5119
5120 #define TARGET_NAME mach_o_fat_vec
5121 #define TARGET_STRING "mach-o-fat"
5122 #define TARGET_ARCHITECTURE bfd_arch_unknown
5123 #define TARGET_BIG_ENDIAN 1
5124 #define TARGET_ARCHIVE 1
5125 #define TARGET_PRIORITY 0
5126
5127 #include "mach-o-target.c"
5128
5129 #undef TARGET_NAME
5130 #undef TARGET_STRING
5131 #undef TARGET_ARCHITECTURE
5132 #undef TARGET_BIG_ENDIAN
5133 #undef TARGET_ARCHIVE
5134 #undef TARGET_PRIORITY
The GNU Binutils are a collection of binary tools.