?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ld/
[binutils.git] / bfd / mach-o.c
blobf6baf3258b4430c05f3c31f9b1e3ce74cdb5b577
1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "mach-o.h"
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "libiberty.h"
26 #include <ctype.h>
27
28 #ifndef BFD_IO_FUNCS
29 #define BFD_IO_FUNCS 0
30 #endif
31
32 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
33 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
34 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
35 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
36 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
37 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
38 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
39 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
40 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
41 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
42 #define bfd_mach_o_close_and_cleanup _bfd_generic_close_and_cleanup
43 #define bfd_mach_o_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
44 #define bfd_mach_o_new_section_hook _bfd_generic_new_section_hook
45 #define bfd_mach_o_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
46 #define bfd_mach_o_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
47 #define bfd_mach_o_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
48 #define bfd_mach_o_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
49 #define bfd_mach_o_get_lineno _bfd_nosymbols_get_lineno
50 #define bfd_mach_o_find_nearest_line _bfd_nosymbols_find_nearest_line
51 #define bfd_mach_o_find_inliner_info _bfd_nosymbols_find_inliner_info
52 #define bfd_mach_o_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
53 #define bfd_mach_o_read_minisymbols _bfd_generic_read_minisymbols
54 #define bfd_mach_o_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
55 #define bfd_mach_o_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
56 #define bfd_mach_o_bfd_relax_section bfd_generic_relax_section
57 #define bfd_mach_o_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
58 #define bfd_mach_o_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
59 #define bfd_mach_o_bfd_link_add_symbols _bfd_generic_link_add_symbols
60 #define bfd_mach_o_bfd_link_just_syms _bfd_generic_link_just_syms
61 #define bfd_mach_o_bfd_final_link _bfd_generic_final_link
62 #define bfd_mach_o_bfd_link_split_section _bfd_generic_link_split_section
63 #define bfd_mach_o_set_arch_mach bfd_default_set_arch_mach
64 #define bfd_mach_o_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
65 #define bfd_mach_o_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
66 #define bfd_mach_o_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
67 #define bfd_mach_o_get_section_contents _bfd_generic_get_section_contents
68 #define bfd_mach_o_set_section_contents _bfd_generic_set_section_contents
69 #define bfd_mach_o_bfd_gc_sections bfd_generic_gc_sections
70 #define bfd_mach_o_bfd_merge_sections bfd_generic_merge_sections
71 #define bfd_mach_o_bfd_is_group_section bfd_generic_is_group_section
72 #define bfd_mach_o_bfd_discard_group bfd_generic_discard_group
73 #define bfd_mach_o_section_already_linked _bfd_generic_section_already_linked
74 #define bfd_mach_o_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
75 #define bfd_mach_o_core_file_matches_executable_p generic_core_file_matches_executable_p
76
77
78 /* The flags field of a section structure is separated into two parts a section
79 type and section attributes. The section types are mutually exclusive (it
80 can only have one type) but the section attributes are not (it may have more
81 than one attribute). */
82
83 #define SECTION_TYPE 0x000000ff /* 256 section types. */
84 #define SECTION_ATTRIBUTES 0xffffff00 /* 24 section attributes. */
85
86 /* Constants for the section attributes part of the flags field of a section
87 structure. */
88
89 #define SECTION_ATTRIBUTES_USR 0xff000000 /* User-settable attributes. */
90 #define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* Section contains only true machine instructions. */
91 #define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* System setable attributes. */
92 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* Section contains some machine instructions. */
93 #define S_ATTR_EXT_RELOC 0x00000200 /* Section has external relocation entries. */
94 #define S_ATTR_LOC_RELOC 0x00000100 /* Section has local relocation entries. */
95
96 #define N_STAB 0xe0
97 #define N_TYPE 0x1e
98 #define N_EXT 0x01
99 #define N_UNDF 0x0
100 #define N_ABS 0x2
101 #define N_SECT 0xe
102 #define N_INDR 0xa
103
104 bfd_boolean
105 bfd_mach_o_valid (bfd *abfd)
106 {
107 if (abfd == NULL || abfd->xvec == NULL)
108 return 0;
109
110 if (! ((abfd->xvec == &mach_o_be_vec)
111 || (abfd->xvec == &mach_o_le_vec)
112 || (abfd->xvec == &mach_o_fat_vec)))
113 return 0;
114
115 if (abfd->tdata.mach_o_data == NULL)
116 return 0;
117 return 1;
118 }
119
120 /* Copy any private info we understand from the input symbol
121 to the output symbol. */
122
123 static bfd_boolean
124 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
125 asymbol *isymbol ATTRIBUTE_UNUSED,
126 bfd *obfd ATTRIBUTE_UNUSED,
127 asymbol *osymbol ATTRIBUTE_UNUSED)
128 {
129 return TRUE;
130 }
131
132 /* Copy any private info we understand from the input section
133 to the output section. */
134
135 static bfd_boolean
136 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
137 asection *isection ATTRIBUTE_UNUSED,
138 bfd *obfd ATTRIBUTE_UNUSED,
139 asection *osection ATTRIBUTE_UNUSED)
140 {
141 return TRUE;
142 }
143
144 /* Copy any private info we understand from the input bfd
145 to the output bfd. */
146
147 static bfd_boolean
148 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
149 {
150 BFD_ASSERT (bfd_mach_o_valid (ibfd));
151 BFD_ASSERT (bfd_mach_o_valid (obfd));
152
153 obfd->tdata.mach_o_data = ibfd->tdata.mach_o_data;
154 obfd->tdata.mach_o_data->ibfd = ibfd;
155 return TRUE;
156 }
157
158 static long
159 bfd_mach_o_count_symbols (bfd *abfd)
160 {
161 bfd_mach_o_data_struct *mdata = NULL;
162 long nsyms = 0;
163 unsigned long i;
164
165 BFD_ASSERT (bfd_mach_o_valid (abfd));
166 mdata = abfd->tdata.mach_o_data;
167
168 for (i = 0; i < mdata->header.ncmds; i++)
169 if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB)
170 {
171 bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab;
172 nsyms += sym->nsyms;
173 }
174
175 return nsyms;
176 }
177
178 static long
179 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
180 {
181 long nsyms = bfd_mach_o_count_symbols (abfd);
182
183 if (nsyms < 0)
184 return nsyms;
185
186 return ((nsyms + 1) * sizeof (asymbol *));
187 }
188
189 static long
190 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
191 {
192 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
193 long nsyms = bfd_mach_o_count_symbols (abfd);
194 asymbol **csym = alocation;
195 unsigned long i, j;
196
197 if (nsyms < 0)
198 return nsyms;
199
200 for (i = 0; i < mdata->header.ncmds; i++)
201 {
202 if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB)
203 {
204 bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab;
205
206 if (bfd_mach_o_scan_read_symtab_symbols (abfd, &mdata->commands[i].command.symtab) != 0)
207 {
208 fprintf (stderr, "bfd_mach_o_canonicalize_symtab: unable to load symbols for section %lu\n", i);
209 return 0;
210 }
211
212 BFD_ASSERT (sym->symbols != NULL);
213
214 for (j = 0; j < sym->nsyms; j++)
215 {
216 BFD_ASSERT (csym < (alocation + nsyms));
217 *csym++ = &sym->symbols[j];
218 }
219 }
220 }
221
222 *csym++ = NULL;
223
224 return nsyms;
225 }
226
227 static void
228 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
229 asymbol *symbol,
230 symbol_info *ret)
231 {
232 bfd_symbol_info (symbol, ret);
233 }
234
235 static void
236 bfd_mach_o_print_symbol (bfd *abfd,
237 PTR afile,
238 asymbol *symbol,
239 bfd_print_symbol_type how)
240 {
241 FILE *file = (FILE *) afile;
242
243 switch (how)
244 {
245 case bfd_print_symbol_name:
246 fprintf (file, "%s", symbol->name);
247 break;
248 default:
249 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
250 fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
251 }
252 }
253
254 static void
255 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
256 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED,
257 enum bfd_architecture *type,
258 unsigned long *subtype)
259 {
260 *subtype = bfd_arch_unknown;
261
262 switch (mtype)
263 {
264 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
265 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
266 case BFD_MACH_O_CPU_TYPE_I386: *type = bfd_arch_i386; break;
267 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
268 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
269 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
270 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
271 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
272 case BFD_MACH_O_CPU_TYPE_SPARC: *type = bfd_arch_sparc; break;
273 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
274 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
275 case BFD_MACH_O_CPU_TYPE_POWERPC: *type = bfd_arch_powerpc; break;
276 default: *type = bfd_arch_unknown; break;
277 }
278
279 switch (*type)
280 {
281 case bfd_arch_i386: *subtype = bfd_mach_i386_i386; break;
282 case bfd_arch_sparc: *subtype = bfd_mach_sparc; break;
283 default:
284 *subtype = bfd_arch_unknown;
285 }
286 }
287
288 static int
289 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
290 {
291 unsigned char buf[28];
292
293 bfd_h_put_32 (abfd, header->magic, buf + 0);
294 bfd_h_put_32 (abfd, header->cputype, buf + 4);
295 bfd_h_put_32 (abfd, header->cpusubtype, buf + 8);
296 bfd_h_put_32 (abfd, header->filetype, buf + 12);
297 bfd_h_put_32 (abfd, header->ncmds, buf + 16);
298 bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20);
299 bfd_h_put_32 (abfd, header->flags, buf + 24);
300
301 bfd_seek (abfd, 0, SEEK_SET);
302 if (bfd_bwrite ((PTR) buf, 28, abfd) != 28)
303 return -1;
304
305 return 0;
306 }
307
308 static int
309 bfd_mach_o_scan_write_thread (bfd *abfd,
310 bfd_mach_o_load_command *command)
311 {
312 bfd_mach_o_thread_command *cmd = &command->command.thread;
313 unsigned int i;
314 unsigned char buf[8];
315 bfd_vma offset;
316 unsigned int nflavours;
317
318 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
319 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
320
321 offset = 8;
322 nflavours = 0;
323 for (i = 0; i < cmd->nflavours; i++)
324 {
325 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
326 BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8));
327
328 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf);
329 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
330
331 bfd_seek (abfd, command->offset + offset, SEEK_SET);
332 if (bfd_bwrite ((PTR) buf, 8, abfd) != 8)
333 return -1;
334
335 offset += cmd->flavours[i].size + 8;
336 }
337
338 return 0;
339 }
340
341 static int
342 bfd_mach_o_scan_write_section (bfd *abfd,
343 bfd_mach_o_section *section,
344 bfd_vma offset)
345 {
346 unsigned char buf[68];
347
348 memcpy (buf, section->sectname, 16);
349 memcpy (buf + 16, section->segname, 16);
350 bfd_h_put_32 (abfd, section->addr, buf + 32);
351 bfd_h_put_32 (abfd, section->size, buf + 36);
352 bfd_h_put_32 (abfd, section->offset, buf + 40);
353 bfd_h_put_32 (abfd, section->align, buf + 44);
354 bfd_h_put_32 (abfd, section->reloff, buf + 48);
355 bfd_h_put_32 (abfd, section->nreloc, buf + 52);
356 bfd_h_put_32 (abfd, section->flags, buf + 56);
357 /* bfd_h_put_32 (abfd, section->reserved1, buf + 60); */
358 /* bfd_h_put_32 (abfd, section->reserved2, buf + 64); */
359
360 bfd_seek (abfd, offset, SEEK_SET);
361 if (bfd_bwrite ((PTR) buf, 68, abfd) != 68)
362 return -1;
363
364 return 0;
365 }
366
367 static int
368 bfd_mach_o_scan_write_segment (bfd *abfd, bfd_mach_o_load_command *command)
369 {
370 unsigned char buf[48];
371 bfd_mach_o_segment_command *seg = &command->command.segment;
372 unsigned long i;
373
374 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
375
376 memcpy (buf, seg->segname, 16);
377 bfd_h_put_32 (abfd, seg->vmaddr, buf + 16);
378 bfd_h_put_32 (abfd, seg->vmsize, buf + 20);
379 bfd_h_put_32 (abfd, seg->fileoff, buf + 24);
380 bfd_h_put_32 (abfd, seg->filesize, buf + 28);
381 bfd_h_put_32 (abfd, 0 /* seg->maxprot */, buf + 32);
382 bfd_h_put_32 (abfd, 0 /* seg->initprot */, buf + 36);
383 bfd_h_put_32 (abfd, seg->nsects, buf + 40);
384 bfd_h_put_32 (abfd, seg->flags, buf + 44);
385
386 bfd_seek (abfd, command->offset + 8, SEEK_SET);
387 if (bfd_bwrite ((PTR) buf, 48, abfd) != 48)
388 return -1;
389
390 {
391 char buf[1024];
392 bfd_vma nbytes = seg->filesize;
393 bfd_vma curoff = seg->fileoff;
394
395 while (nbytes > 0)
396 {
397 bfd_vma thisread = nbytes;
398
399 if (thisread > 1024)
400 thisread = 1024;
401
402 bfd_seek (abfd, curoff, SEEK_SET);
403 if (bfd_bread ((PTR) buf, thisread, abfd) != thisread)
404 return -1;
405
406 bfd_seek (abfd, curoff, SEEK_SET);
407 if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread)
408 return -1;
409
410 nbytes -= thisread;
411 curoff += thisread;
412 }
413 }
414
415 for (i = 0; i < seg->nsects; i++)
416 {
417 bfd_vma segoff = command->offset + 48 + 8 + (i * 68);
418
419 if (bfd_mach_o_scan_write_section (abfd, &seg->sections[i], segoff) != 0)
420 return -1;
421 }
422
423 return 0;
424 }
425
426 static int
427 bfd_mach_o_scan_write_symtab_symbols (bfd *abfd,
428 bfd_mach_o_load_command *command)
429 {
430 bfd_mach_o_symtab_command *sym = &command->command.symtab;
431 asymbol *s = NULL;
432 unsigned long i;
433
434 for (i = 0; i < sym->nsyms; i++)
435 {
436 unsigned char buf[12];
437 bfd_vma symoff = sym->symoff + (i * 12);
438 unsigned char ntype = 0;
439 unsigned char nsect = 0;
440 short ndesc = 0;
441
442 s = &sym->symbols[i];
443
444 /* Instead just set from the stored values. */
445 ntype = (s->udata.i >> 24) & 0xff;
446 nsect = (s->udata.i >> 16) & 0xff;
447 ndesc = s->udata.i & 0xffff;
448
449 bfd_h_put_32 (abfd, s->name - sym->strtab, buf);
450 bfd_h_put_8 (abfd, ntype, buf + 4);
451 bfd_h_put_8 (abfd, nsect, buf + 5);
452 bfd_h_put_16 (abfd, ndesc, buf + 6);
453 bfd_h_put_32 (abfd, s->section->vma + s->value, buf + 8);
454
455 bfd_seek (abfd, symoff, SEEK_SET);
456 if (bfd_bwrite ((PTR) buf, 12, abfd) != 12)
457 {
458 fprintf (stderr, "bfd_mach_o_scan_write_symtab_symbols: unable to write %d bytes at %lu\n",
459 12, (unsigned long) symoff);
460 return -1;
461 }
462 }
463
464 return 0;
465 }
466
467 static int
468 bfd_mach_o_scan_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
469 {
470 bfd_mach_o_symtab_command *seg = &command->command.symtab;
471 unsigned char buf[16];
472
473 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
474
475 bfd_h_put_32 (abfd, seg->symoff, buf);
476 bfd_h_put_32 (abfd, seg->nsyms, buf + 4);
477 bfd_h_put_32 (abfd, seg->stroff, buf + 8);
478 bfd_h_put_32 (abfd, seg->strsize, buf + 12);
479
480 bfd_seek (abfd, command->offset + 8, SEEK_SET);
481 if (bfd_bwrite ((PTR) buf, 16, abfd) != 16)
482 return -1;
483
484 if (bfd_mach_o_scan_write_symtab_symbols (abfd, command) != 0)
485 return -1;
486
487 return 0;
488 }
489
490 static bfd_boolean
491 bfd_mach_o_write_contents (bfd *abfd)
492 {
493 unsigned int i;
494 asection *s;
495
496 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
497
498 /* Write data sections first in case they overlap header data to be
499 written later. */
500
501 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
502 ;
503
504 /* Now write header information. */
505 if (bfd_mach_o_write_header (abfd, &mdata->header) != 0)
506 return FALSE;
507
508 for (i = 0; i < mdata->header.ncmds; i++)
509 {
510 unsigned char buf[8];
511 bfd_mach_o_load_command *cur = &mdata->commands[i];
512 unsigned long typeflag;
513
514 typeflag = cur->type_required ? cur->type & BFD_MACH_O_LC_REQ_DYLD : cur->type;
515
516 bfd_h_put_32 (abfd, typeflag, buf);
517 bfd_h_put_32 (abfd, cur->len, buf + 4);
518
519 bfd_seek (abfd, cur->offset, SEEK_SET);
520 if (bfd_bwrite ((PTR) buf, 8, abfd) != 8)
521 return FALSE;
522
523 switch (cur->type)
524 {
525 case BFD_MACH_O_LC_SEGMENT:
526 if (bfd_mach_o_scan_write_segment (abfd, cur) != 0)
527 return FALSE;
528 break;
529 case BFD_MACH_O_LC_SYMTAB:
530 if (bfd_mach_o_scan_write_symtab (abfd, cur) != 0)
531 return FALSE;
532 break;
533 case BFD_MACH_O_LC_SYMSEG:
534 break;
535 case BFD_MACH_O_LC_THREAD:
536 case BFD_MACH_O_LC_UNIXTHREAD:
537 if (bfd_mach_o_scan_write_thread (abfd, cur) != 0)
538 return FALSE;
539 break;
540 case BFD_MACH_O_LC_LOADFVMLIB:
541 case BFD_MACH_O_LC_IDFVMLIB:
542 case BFD_MACH_O_LC_IDENT:
543 case BFD_MACH_O_LC_FVMFILE:
544 case BFD_MACH_O_LC_PREPAGE:
545 case BFD_MACH_O_LC_DYSYMTAB:
546 case BFD_MACH_O_LC_LOAD_DYLIB:
547 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
548 case BFD_MACH_O_LC_ID_DYLIB:
549 case BFD_MACH_O_LC_LOAD_DYLINKER:
550 case BFD_MACH_O_LC_ID_DYLINKER:
551 case BFD_MACH_O_LC_PREBOUND_DYLIB:
552 case BFD_MACH_O_LC_ROUTINES:
553 case BFD_MACH_O_LC_SUB_FRAMEWORK:
554 break;
555 default:
556 fprintf (stderr,
557 "unable to write unknown load command 0x%lx\n",
558 (long) cur->type);
559 return FALSE;
560 }
561 }
562
563 return TRUE;
564 }
565
566 static int
567 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
568 struct bfd_link_info *info ATTRIBUTE_UNUSED)
569 {
570 return 0;
571 }
572
573 /* Make an empty symbol. This is required only because
574 bfd_make_section_anyway wants to create a symbol for the section. */
575
576 static asymbol *
577 bfd_mach_o_make_empty_symbol (bfd *abfd)
578 {
579 asymbol *new;
580
581 new = bfd_zalloc (abfd, sizeof (* new));
582 if (new == NULL)
583 return new;
584 new->the_bfd = abfd;
585 return new;
586 }
587
588 static int
589 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
590 {
591 unsigned char buf[28];
592 bfd_vma (*get32) (const void *) = NULL;
593
594 bfd_seek (abfd, 0, SEEK_SET);
595
596 if (bfd_bread ((PTR) buf, 28, abfd) != 28)
597 return -1;
598
599 if (bfd_getb32 (buf) == 0xfeedface)
600 {
601 header->byteorder = BFD_ENDIAN_BIG;
602 header->magic = 0xfeedface;
603 get32 = bfd_getb32;
604 }
605 else if (bfd_getl32 (buf) == 0xfeedface)
606 {
607 header->byteorder = BFD_ENDIAN_LITTLE;
608 header->magic = 0xfeedface;
609 get32 = bfd_getl32;
610 }
611 else
612 {
613 header->byteorder = BFD_ENDIAN_UNKNOWN;
614 return -1;
615 }
616
617 header->cputype = (*get32) (buf + 4);
618 header->cpusubtype = (*get32) (buf + 8);
619 header->filetype = (*get32) (buf + 12);
620 header->ncmds = (*get32) (buf + 16);
621 header->sizeofcmds = (*get32) (buf + 20);
622 header->flags = (*get32) (buf + 24);
623
624 return 0;
625 }
626
627 static asection *
628 bfd_mach_o_make_bfd_section (bfd *abfd, bfd_mach_o_section *section)
629 {
630 asection *bfdsec;
631 char *sname;
632 const char *prefix = "LC_SEGMENT";
633 unsigned int snamelen;
634 flagword flags;
635
636 snamelen = strlen (prefix) + 1
637 + strlen (section->segname) + 1
638 + strlen (section->sectname) + 1;
639
640 sname = bfd_alloc (abfd, snamelen);
641 if (sname == NULL)
642 return NULL;
643 sprintf (sname, "%s.%s.%s", prefix, section->segname, section->sectname);
644
645 flags = SEC_ALLOC;
646 if (!(section->flags & BFD_MACH_O_S_ZEROFILL))
647 flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
648 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, flags);
649 if (bfdsec == NULL)
650 return NULL;
651
652 bfdsec->vma = section->addr;
653 bfdsec->lma = section->addr;
654 bfdsec->size = section->size;
655 bfdsec->filepos = section->offset;
656 bfdsec->alignment_power = section->align;
657
658 return bfdsec;
659 }
660
661 static int
662 bfd_mach_o_scan_read_section (bfd *abfd,
663 bfd_mach_o_section *section,
664 bfd_vma offset)
665 {
666 unsigned char buf[68];
667
668 bfd_seek (abfd, offset, SEEK_SET);
669 if (bfd_bread ((PTR) buf, 68, abfd) != 68)
670 return -1;
671
672 memcpy (section->sectname, buf, 16);
673 section->sectname[16] = '\0';
674 memcpy (section->segname, buf + 16, 16);
675 section->segname[16] = '\0';
676 section->addr = bfd_h_get_32 (abfd, buf + 32);
677 section->size = bfd_h_get_32 (abfd, buf + 36);
678 section->offset = bfd_h_get_32 (abfd, buf + 40);
679 section->align = bfd_h_get_32 (abfd, buf + 44);
680 section->reloff = bfd_h_get_32 (abfd, buf + 48);
681 section->nreloc = bfd_h_get_32 (abfd, buf + 52);
682 section->flags = bfd_h_get_32 (abfd, buf + 56);
683 section->reserved1 = bfd_h_get_32 (abfd, buf + 60);
684 section->reserved2 = bfd_h_get_32 (abfd, buf + 64);
685 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section);
686
687 if (section->bfdsection == NULL)
688 return -1;
689
690 return 0;
691 }
692
693 int
694 bfd_mach_o_scan_read_symtab_symbol (bfd *abfd,
695 bfd_mach_o_symtab_command *sym,
696 asymbol *s,
697 unsigned long i)
698 {
699 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
700 bfd_vma symoff = sym->symoff + (i * 12);
701 unsigned char buf[12];
702 unsigned char type = -1;
703 unsigned char section = -1;
704 short desc = -1;
705 unsigned long value = -1;
706 unsigned long stroff = -1;
707 unsigned int symtype = -1;
708
709 BFD_ASSERT (sym->strtab != NULL);
710
711 bfd_seek (abfd, symoff, SEEK_SET);
712 if (bfd_bread ((PTR) buf, 12, abfd) != 12)
713 {
714 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n",
715 12, (unsigned long) symoff);
716 return -1;
717 }
718
719 stroff = bfd_h_get_32 (abfd, buf);
720 type = bfd_h_get_8 (abfd, buf + 4);
721 symtype = (type & 0x0e);
722 section = bfd_h_get_8 (abfd, buf + 5) - 1;
723 desc = bfd_h_get_16 (abfd, buf + 6);
724 value = bfd_h_get_32 (abfd, buf + 8);
725
726 if (stroff >= sym->strsize)
727 {
728 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
729 (unsigned long) stroff, (unsigned long) sym->strsize);
730 return -1;
731 }
732
733 s->the_bfd = abfd;
734 s->name = sym->strtab + stroff;
735 s->value = value;
736 s->udata.i = (type << 24) | (section << 16) | desc;
737 s->flags = 0x0;
738
739 if (type & BFD_MACH_O_N_STAB)
740 {
741 s->flags |= BSF_DEBUGGING;
742 s->section = bfd_und_section_ptr;
743 }
744 else
745 {
746 if (type & BFD_MACH_O_N_PEXT)
747 {
748 type &= ~BFD_MACH_O_N_PEXT;
749 s->flags |= BSF_GLOBAL;
750 }
751
752 if (type & BFD_MACH_O_N_EXT)
753 {
754 type &= ~BFD_MACH_O_N_EXT;
755 s->flags |= BSF_GLOBAL;
756 }
757
758 switch (symtype)
759 {
760 case BFD_MACH_O_N_UNDF:
761 s->section = bfd_und_section_ptr;
762 break;
763 case BFD_MACH_O_N_PBUD:
764 s->section = bfd_und_section_ptr;
765 break;
766 case BFD_MACH_O_N_ABS:
767 s->section = bfd_abs_section_ptr;
768 break;
769 case BFD_MACH_O_N_SECT:
770 if ((section > 0) && (section <= mdata->nsects))
771 {
772 s->section = mdata->sections[section - 1]->bfdsection;
773 s->value = s->value - mdata->sections[section - 1]->addr;
774 }
775 else
776 {
777 /* Mach-O uses 0 to mean "no section"; not an error. */
778 if (section != 0)
779 {
780 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
781 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
782 s->name, section, mdata->nsects);
783 }
784 s->section = bfd_und_section_ptr;
785 }
786 break;
787 case BFD_MACH_O_N_INDR:
788 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
789 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
790 s->name);
791 s->section = bfd_und_section_ptr;
792 break;
793 default:
794 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
795 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
796 s->name, symtype);
797 s->section = bfd_und_section_ptr;
798 break;
799 }
800 }
801
802 return 0;
803 }
804
805 int
806 bfd_mach_o_scan_read_symtab_strtab (bfd *abfd,
807 bfd_mach_o_symtab_command *sym)
808 {
809 BFD_ASSERT (sym->strtab == NULL);
810
811 if (abfd->flags & BFD_IN_MEMORY)
812 {
813 struct bfd_in_memory *b;
814
815 b = (struct bfd_in_memory *) abfd->iostream;
816
817 if ((sym->stroff + sym->strsize) > b->size)
818 {
819 bfd_set_error (bfd_error_file_truncated);
820 return -1;
821 }
822 sym->strtab = (char *) b->buffer + sym->stroff;
823 return 0;
824 }
825
826 sym->strtab = bfd_alloc (abfd, sym->strsize);
827 if (sym->strtab == NULL)
828 return -1;
829
830 bfd_seek (abfd, sym->stroff, SEEK_SET);
831 if (bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize)
832 {
833 fprintf (stderr, "bfd_mach_o_scan_read_symtab_strtab: unable to read %lu bytes at %lu\n",
834 sym->strsize, sym->stroff);
835 return -1;
836 }
837
838 return 0;
839 }
840
841 int
842 bfd_mach_o_scan_read_symtab_symbols (bfd *abfd,
843 bfd_mach_o_symtab_command *sym)
844 {
845 unsigned long i;
846 int ret;
847
848 BFD_ASSERT (sym->symbols == NULL);
849 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (asymbol));
850
851 if (sym->symbols == NULL)
852 {
853 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n");
854 return -1;
855 }
856
857 ret = bfd_mach_o_scan_read_symtab_strtab (abfd, sym);
858 if (ret != 0)
859 return ret;
860
861 for (i = 0; i < sym->nsyms; i++)
862 {
863 ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
864 if (ret != 0)
865 return ret;
866 }
867
868 return 0;
869 }
870
871 int
872 bfd_mach_o_scan_read_dysymtab_symbol (bfd *abfd,
873 bfd_mach_o_dysymtab_command *dysym,
874 bfd_mach_o_symtab_command *sym,
875 asymbol *s,
876 unsigned long i)
877 {
878 unsigned long isymoff = dysym->indirectsymoff + (i * 4);
879 unsigned long symindex;
880 unsigned char buf[4];
881
882 BFD_ASSERT (i < dysym->nindirectsyms);
883
884 bfd_seek (abfd, isymoff, SEEK_SET);
885 if (bfd_bread ((PTR) buf, 4, abfd) != 4)
886 {
887 fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
888 (unsigned long) 4, isymoff);
889 return -1;
890 }
891 symindex = bfd_h_get_32 (abfd, buf);
892
893 return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex);
894 }
895
896 static const char *
897 bfd_mach_o_i386_flavour_string (unsigned int flavour)
898 {
899 switch ((int) flavour)
900 {
901 case BFD_MACH_O_i386_NEW_THREAD_STATE: return "i386_NEW_THREAD_STATE";
902 case BFD_MACH_O_i386_FLOAT_STATE: return "i386_FLOAT_STATE";
903 case BFD_MACH_O_i386_ISA_PORT_MAP_STATE: return "i386_ISA_PORT_MAP_STATE";
904 case BFD_MACH_O_i386_V86_ASSIST_STATE: return "i386_V86_ASSIST_STATE";
905 case BFD_MACH_O_i386_REGS_SEGS_STATE: return "i386_REGS_SEGS_STATE";
906 case BFD_MACH_O_i386_THREAD_SYSCALL_STATE: return "i386_THREAD_SYSCALL_STATE";
907 case BFD_MACH_O_i386_THREAD_STATE_NONE: return "i386_THREAD_STATE_NONE";
908 case BFD_MACH_O_i386_SAVED_STATE: return "i386_SAVED_STATE";
909 case BFD_MACH_O_i386_THREAD_STATE: return "i386_THREAD_STATE";
910 case BFD_MACH_O_i386_THREAD_FPSTATE: return "i386_THREAD_FPSTATE";
911 case BFD_MACH_O_i386_THREAD_EXCEPTSTATE: return "i386_THREAD_EXCEPTSTATE";
912 case BFD_MACH_O_i386_THREAD_CTHREADSTATE: return "i386_THREAD_CTHREADSTATE";
913 default: return "UNKNOWN";
914 }
915 }
916
917 static const char *
918 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
919 {
920 switch ((int) flavour)
921 {
922 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
923 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
924 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
925 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
926 default: return "UNKNOWN";
927 }
928 }
929
930 static int
931 bfd_mach_o_scan_read_dylinker (bfd *abfd,
932 bfd_mach_o_load_command *command)
933 {
934 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
935 unsigned char buf[4];
936 unsigned int nameoff;
937 asection *bfdsec;
938 char *sname;
939 const char *prefix;
940
941 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
942 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
943
944 bfd_seek (abfd, command->offset + 8, SEEK_SET);
945 if (bfd_bread ((PTR) buf, 4, abfd) != 4)
946 return -1;
947
948 nameoff = bfd_h_get_32 (abfd, buf + 0);
949
950 cmd->name_offset = command->offset + nameoff;
951 cmd->name_len = command->len - nameoff;
952
953 if (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)
954 prefix = "LC_LOAD_DYLINKER";
955 else if (command->type == BFD_MACH_O_LC_ID_DYLINKER)
956 prefix = "LC_ID_DYLINKER";
957 else
958 abort ();
959
960 sname = bfd_alloc (abfd, strlen (prefix) + 1);
961 if (sname == NULL)
962 return -1;
963 strcpy (sname, prefix);
964
965 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
966 if (bfdsec == NULL)
967 return -1;
968
969 bfdsec->vma = 0;
970 bfdsec->lma = 0;
971 bfdsec->size = command->len - 8;
972 bfdsec->filepos = command->offset + 8;
973 bfdsec->alignment_power = 0;
974
975 cmd->section = bfdsec;
976
977 return 0;
978 }
979
980 static int
981 bfd_mach_o_scan_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
982 {
983 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
984 unsigned char buf[16];
985 unsigned int nameoff;
986 asection *bfdsec;
987 char *sname;
988 const char *prefix;
989
990 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLIB)
991 || (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
992 || (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB));
993
994 bfd_seek (abfd, command->offset + 8, SEEK_SET);
995 if (bfd_bread ((PTR) buf, 16, abfd) != 16)
996 return -1;
997
998 nameoff = bfd_h_get_32 (abfd, buf + 0);
999 cmd->timestamp = bfd_h_get_32 (abfd, buf + 4);
1000 cmd->current_version = bfd_h_get_32 (abfd, buf + 8);
1001 cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12);
1002
1003 cmd->name_offset = command->offset + nameoff;
1004 cmd->name_len = command->len - nameoff;
1005
1006 if (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1007 prefix = "LC_LOAD_DYLIB";
1008 else if (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB)
1009 prefix = "LC_LOAD_WEAK_DYLIB";
1010 else if (command->type == BFD_MACH_O_LC_ID_DYLIB)
1011 prefix = "LC_ID_DYLIB";
1012 else
1013 abort ();
1014
1015 sname = bfd_alloc (abfd, strlen (prefix) + 1);
1016 if (sname == NULL)
1017 return -1;
1018 strcpy (sname, prefix);
1019
1020 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1021 if (bfdsec == NULL)
1022 return -1;
1023
1024 bfdsec->vma = 0;
1025 bfdsec->lma = 0;
1026 bfdsec->size = command->len - 8;
1027 bfdsec->filepos = command->offset + 8;
1028 bfdsec->alignment_power = 0;
1029
1030 cmd->section = bfdsec;
1031
1032 return 0;
1033 }
1034
1035 static int
1036 bfd_mach_o_scan_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
1037 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
1038 {
1039 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
1040
1041 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
1042 return 0;
1043 }
1044
1045 static int
1046 bfd_mach_o_scan_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
1047 {
1048 bfd_mach_o_data_struct *mdata = NULL;
1049 bfd_mach_o_thread_command *cmd = &command->command.thread;
1050 unsigned char buf[8];
1051 bfd_vma offset;
1052 unsigned int nflavours;
1053 unsigned int i;
1054
1055 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1056 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1057
1058 BFD_ASSERT (bfd_mach_o_valid (abfd));
1059 mdata = abfd->tdata.mach_o_data;
1060
1061 offset = 8;
1062 nflavours = 0;
1063 while (offset != command->len)
1064 {
1065 if (offset >= command->len)
1066 return -1;
1067
1068 bfd_seek (abfd, command->offset + offset, SEEK_SET);
1069
1070 if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1071 return -1;
1072
1073 offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
1074 nflavours++;
1075 }
1076
1077 cmd->flavours = bfd_alloc (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
1078 if (cmd->flavours == NULL)
1079 return -1;
1080 cmd->nflavours = nflavours;
1081
1082 offset = 8;
1083 nflavours = 0;
1084 while (offset != command->len)
1085 {
1086 if (offset >= command->len)
1087 return -1;
1088
1089 if (nflavours >= cmd->nflavours)
1090 return -1;
1091
1092 bfd_seek (abfd, command->offset + offset, SEEK_SET);
1093
1094 if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1095 return -1;
1096
1097 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
1098 cmd->flavours[nflavours].offset = command->offset + offset + 8;
1099 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4;
1100 offset += cmd->flavours[nflavours].size + 8;
1101 nflavours++;
1102 }
1103
1104 for (i = 0; i < nflavours; i++)
1105 {
1106 asection *bfdsec;
1107 unsigned int snamelen;
1108 char *sname;
1109 const char *flavourstr;
1110 const char *prefix = "LC_THREAD";
1111 unsigned int j = 0;
1112
1113 switch (mdata->header.cputype)
1114 {
1115 case BFD_MACH_O_CPU_TYPE_POWERPC:
1116 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
1117 break;
1118 case BFD_MACH_O_CPU_TYPE_I386:
1119 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
1120 break;
1121 default:
1122 flavourstr = "UNKNOWN_ARCHITECTURE";
1123 break;
1124 }
1125
1126 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
1127 sname = bfd_alloc (abfd, snamelen);
1128 if (sname == NULL)
1129 return -1;
1130
1131 for (;;)
1132 {
1133 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
1134 if (bfd_get_section_by_name (abfd, sname) == NULL)
1135 break;
1136 j++;
1137 }
1138
1139 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1140
1141 bfdsec->vma = 0;
1142 bfdsec->lma = 0;
1143 bfdsec->size = cmd->flavours[i].size;
1144 bfdsec->filepos = cmd->flavours[i].offset;
1145 bfdsec->alignment_power = 0x0;
1146
1147 cmd->section = bfdsec;
1148 }
1149
1150 return 0;
1151 }
1152
1153 static int
1154 bfd_mach_o_scan_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1155 {
1156 bfd_mach_o_dysymtab_command *seg = &command->command.dysymtab;
1157 unsigned char buf[72];
1158
1159 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1160
1161 bfd_seek (abfd, command->offset + 8, SEEK_SET);
1162 if (bfd_bread ((PTR) buf, 72, abfd) != 72)
1163 return -1;
1164
1165 seg->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
1166 seg->nlocalsym = bfd_h_get_32 (abfd, buf + 4);
1167 seg->iextdefsym = bfd_h_get_32 (abfd, buf + 8);
1168 seg->nextdefsym = bfd_h_get_32 (abfd, buf + 12);
1169 seg->iundefsym = bfd_h_get_32 (abfd, buf + 16);
1170 seg->nundefsym = bfd_h_get_32 (abfd, buf + 20);
1171 seg->tocoff = bfd_h_get_32 (abfd, buf + 24);
1172 seg->ntoc = bfd_h_get_32 (abfd, buf + 28);
1173 seg->modtaboff = bfd_h_get_32 (abfd, buf + 32);
1174 seg->nmodtab = bfd_h_get_32 (abfd, buf + 36);
1175 seg->extrefsymoff = bfd_h_get_32 (abfd, buf + 40);
1176 seg->nextrefsyms = bfd_h_get_32 (abfd, buf + 44);
1177 seg->indirectsymoff = bfd_h_get_32 (abfd, buf + 48);
1178 seg->nindirectsyms = bfd_h_get_32 (abfd, buf + 52);
1179 seg->extreloff = bfd_h_get_32 (abfd, buf + 56);
1180 seg->nextrel = bfd_h_get_32 (abfd, buf + 60);
1181 seg->locreloff = bfd_h_get_32 (abfd, buf + 64);
1182 seg->nlocrel = bfd_h_get_32 (abfd, buf + 68);
1183
1184 return 0;
1185 }
1186
1187 static int
1188 bfd_mach_o_scan_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1189 {
1190 bfd_mach_o_symtab_command *seg = &command->command.symtab;
1191 unsigned char buf[16];
1192 asection *bfdsec;
1193 char *sname;
1194 const char *prefix = "LC_SYMTAB.stabs";
1195
1196 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1197
1198 bfd_seek (abfd, command->offset + 8, SEEK_SET);
1199 if (bfd_bread ((PTR) buf, 16, abfd) != 16)
1200 return -1;
1201
1202 seg->symoff = bfd_h_get_32 (abfd, buf);
1203 seg->nsyms = bfd_h_get_32 (abfd, buf + 4);
1204 seg->stroff = bfd_h_get_32 (abfd, buf + 8);
1205 seg->strsize = bfd_h_get_32 (abfd, buf + 12);
1206 seg->symbols = NULL;
1207 seg->strtab = NULL;
1208
1209 sname = bfd_alloc (abfd, strlen (prefix) + 1);
1210 if (sname == NULL)
1211 return -1;
1212 strcpy (sname, prefix);
1213
1214 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1215 if (bfdsec == NULL)
1216 return -1;
1217
1218 bfdsec->vma = 0;
1219 bfdsec->lma = 0;
1220 bfdsec->size = seg->nsyms * 12;
1221 bfdsec->filepos = seg->symoff;
1222 bfdsec->alignment_power = 0;
1223
1224 seg->stabs_segment = bfdsec;
1225
1226 prefix = "LC_SYMTAB.stabstr";
1227 sname = bfd_alloc (abfd, strlen (prefix) + 1);
1228 if (sname == NULL)
1229 return -1;
1230 strcpy (sname, prefix);
1231
1232 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1233 if (bfdsec == NULL)
1234 return -1;
1235
1236 bfdsec->vma = 0;
1237 bfdsec->lma = 0;
1238 bfdsec->size = seg->strsize;
1239 bfdsec->filepos = seg->stroff;
1240 bfdsec->alignment_power = 0;
1241
1242 seg->stabstr_segment = bfdsec;
1243
1244 return 0;
1245 }
1246
1247 static int
1248 bfd_mach_o_scan_read_segment (bfd *abfd, bfd_mach_o_load_command *command)
1249 {
1250 unsigned char buf[48];
1251 bfd_mach_o_segment_command *seg = &command->command.segment;
1252 unsigned long i;
1253 asection *bfdsec;
1254 char *sname;
1255 const char *prefix = "LC_SEGMENT";
1256 unsigned int snamelen;
1257 flagword flags;
1258
1259 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1260
1261 bfd_seek (abfd, command->offset + 8, SEEK_SET);
1262 if (bfd_bread ((PTR) buf, 48, abfd) != 48)
1263 return -1;
1264
1265 memcpy (seg->segname, buf, 16);
1266 seg->vmaddr = bfd_h_get_32 (abfd, buf + 16);
1267 seg->vmsize = bfd_h_get_32 (abfd, buf + 20);
1268 seg->fileoff = bfd_h_get_32 (abfd, buf + 24);
1269 seg->filesize = bfd_h_get_32 (abfd, buf + 28);
1270 /* seg->maxprot = bfd_h_get_32 (abfd, buf + 32); */
1271 /* seg->initprot = bfd_h_get_32 (abfd, buf + 36); */
1272 seg->nsects = bfd_h_get_32 (abfd, buf + 40);
1273 seg->flags = bfd_h_get_32 (abfd, buf + 44);
1274
1275 snamelen = strlen (prefix) + 1 + strlen (seg->segname) + 1;
1276 sname = bfd_alloc (abfd, snamelen);
1277 if (sname == NULL)
1278 return -1;
1279 sprintf (sname, "%s.%s", prefix, seg->segname);
1280
1281 flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
1282 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, flags);
1283 if (bfdsec == NULL)
1284 return -1;
1285
1286 bfdsec->vma = seg->vmaddr;
1287 bfdsec->lma = seg->vmaddr;
1288 bfdsec->size = seg->filesize;
1289 bfdsec->filepos = seg->fileoff;
1290 bfdsec->alignment_power = 0x0;
1291
1292 seg->segment = bfdsec;
1293
1294 if (seg->nsects != 0)
1295 {
1296 seg->sections = bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section));
1297 if (seg->sections == NULL)
1298 return -1;
1299
1300 for (i = 0; i < seg->nsects; i++)
1301 {
1302 bfd_vma segoff = command->offset + 48 + 8 + (i * 68);
1303
1304 if (bfd_mach_o_scan_read_section (abfd, &seg->sections[i],
1305 segoff) != 0)
1306 return -1;
1307 }
1308 }
1309
1310 return 0;
1311 }
1312
1313 static int
1314 bfd_mach_o_scan_read_command (bfd *abfd, bfd_mach_o_load_command *command)
1315 {
1316 unsigned char buf[8];
1317
1318 bfd_seek (abfd, command->offset, SEEK_SET);
1319 if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1320 return -1;
1321
1322 command->type = (bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD);
1323 command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD
1324 ? 1 : 0);
1325 command->len = bfd_h_get_32 (abfd, buf + 4);
1326
1327 switch (command->type)
1328 {
1329 case BFD_MACH_O_LC_SEGMENT:
1330 if (bfd_mach_o_scan_read_segment (abfd, command) != 0)
1331 return -1;
1332 break;
1333 case BFD_MACH_O_LC_SYMTAB:
1334 if (bfd_mach_o_scan_read_symtab (abfd, command) != 0)
1335 return -1;
1336 break;
1337 case BFD_MACH_O_LC_SYMSEG:
1338 break;
1339 case BFD_MACH_O_LC_THREAD:
1340 case BFD_MACH_O_LC_UNIXTHREAD:
1341 if (bfd_mach_o_scan_read_thread (abfd, command) != 0)
1342 return -1;
1343 break;
1344 case BFD_MACH_O_LC_LOAD_DYLINKER:
1345 case BFD_MACH_O_LC_ID_DYLINKER:
1346 if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0)
1347 return -1;
1348 break;
1349 case BFD_MACH_O_LC_LOAD_DYLIB:
1350 case BFD_MACH_O_LC_ID_DYLIB:
1351 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1352 if (bfd_mach_o_scan_read_dylib (abfd, command) != 0)
1353 return -1;
1354 break;
1355 case BFD_MACH_O_LC_PREBOUND_DYLIB:
1356 if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0)
1357 return -1;
1358 break;
1359 case BFD_MACH_O_LC_LOADFVMLIB:
1360 case BFD_MACH_O_LC_IDFVMLIB:
1361 case BFD_MACH_O_LC_IDENT:
1362 case BFD_MACH_O_LC_FVMFILE:
1363 case BFD_MACH_O_LC_PREPAGE:
1364 case BFD_MACH_O_LC_ROUTINES:
1365 case BFD_MACH_O_LC_SUB_FRAMEWORK:
1366 break;
1367 case BFD_MACH_O_LC_DYSYMTAB:
1368 if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0)
1369 return -1;
1370 break;
1371 case BFD_MACH_O_LC_SUB_UMBRELLA:
1372 case BFD_MACH_O_LC_SUB_CLIENT:
1373 case BFD_MACH_O_LC_SUB_LIBRARY:
1374 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
1375 case BFD_MACH_O_LC_PREBIND_CKSUM:
1376 break;
1377 default:
1378 fprintf (stderr, "unable to read unknown load command 0x%lx\n",
1379 (unsigned long) command->type);
1380 break;
1381 }
1382
1383 return 0;
1384 }
1385
1386 static void
1387 bfd_mach_o_flatten_sections (bfd *abfd)
1388 {
1389 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1390 long csect = 0;
1391 unsigned long i, j;
1392
1393 mdata->nsects = 0;
1394
1395 for (i = 0; i < mdata->header.ncmds; i++)
1396 {
1397 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT)
1398 {
1399 bfd_mach_o_segment_command *seg;
1400
1401 seg = &mdata->commands[i].command.segment;
1402 mdata->nsects += seg->nsects;
1403 }
1404 }
1405
1406 mdata->sections = bfd_alloc (abfd,
1407 mdata->nsects * sizeof (bfd_mach_o_section *));
1408 csect = 0;
1409
1410 for (i = 0; i < mdata->header.ncmds; i++)
1411 {
1412 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT)
1413 {
1414 bfd_mach_o_segment_command *seg;
1415
1416 seg = &mdata->commands[i].command.segment;
1417 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
1418
1419 for (j = 0; j < seg->nsects; j++)
1420 mdata->sections[csect++] = &seg->sections[j];
1421 }
1422 }
1423 }
1424
1425 int
1426 bfd_mach_o_scan_start_address (bfd *abfd)
1427 {
1428 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1429 bfd_mach_o_thread_command *cmd = NULL;
1430 unsigned long i;
1431
1432 for (i = 0; i < mdata->header.ncmds; i++)
1433 {
1434 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
1435 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
1436 {
1437 if (cmd == NULL)
1438 cmd = &mdata->commands[i].command.thread;
1439 else
1440 return 0;
1441 }
1442 }
1443
1444 if (cmd == NULL)
1445 return 0;
1446
1447 for (i = 0; i < cmd->nflavours; i++)
1448 {
1449 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
1450 && (cmd->flavours[i].flavour
1451 == (unsigned long) BFD_MACH_O_i386_THREAD_STATE))
1452 {
1453 unsigned char buf[4];
1454
1455 bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET);
1456
1457 if (bfd_bread (buf, 4, abfd) != 4)
1458 return -1;
1459
1460 abfd->start_address = bfd_h_get_32 (abfd, buf);
1461 }
1462 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
1463 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
1464 {
1465 unsigned char buf[4];
1466
1467 bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET);
1468
1469 if (bfd_bread (buf, 4, abfd) != 4)
1470 return -1;
1471
1472 abfd->start_address = bfd_h_get_32 (abfd, buf);
1473 }
1474 }
1475
1476 return 0;
1477 }
1478
1479 int
1480 bfd_mach_o_scan (bfd *abfd,
1481 bfd_mach_o_header *header,
1482 bfd_mach_o_data_struct *mdata)
1483 {
1484 unsigned int i;
1485 enum bfd_architecture cputype;
1486 unsigned long cpusubtype;
1487
1488 mdata->header = *header;
1489 mdata->symbols = NULL;
1490
1491 abfd->flags = (abfd->xvec->object_flags
1492 | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
1493 abfd->tdata.mach_o_data = mdata;
1494
1495 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
1496 &cputype, &cpusubtype);
1497 if (cputype == bfd_arch_unknown)
1498 {
1499 fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
1500 header->cputype, header->cpusubtype);
1501 return -1;
1502 }
1503
1504 bfd_set_arch_mach (abfd, cputype, cpusubtype);
1505
1506 if (header->ncmds != 0)
1507 {
1508 mdata->commands = bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
1509 if (mdata->commands == NULL)
1510 return -1;
1511
1512 for (i = 0; i < header->ncmds; i++)
1513 {
1514 bfd_mach_o_load_command *cur = &mdata->commands[i];
1515
1516 if (i == 0)
1517 cur->offset = 28;
1518 else
1519 {
1520 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
1521 cur->offset = prev->offset + prev->len;
1522 }
1523
1524 if (bfd_mach_o_scan_read_command (abfd, cur) < 0)
1525 return -1;
1526 }
1527 }
1528
1529 if (bfd_mach_o_scan_start_address (abfd) < 0)
1530 return -1;
1531
1532 bfd_mach_o_flatten_sections (abfd);
1533 return 0;
1534 }
1535
1536 bfd_boolean
1537 bfd_mach_o_mkobject (bfd *abfd)
1538 {
1539 bfd_mach_o_data_struct *mdata = NULL;
1540
1541 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
1542 if (mdata == NULL)
1543 return FALSE;
1544 abfd->tdata.mach_o_data = mdata;
1545
1546 mdata->header.magic = 0;
1547 mdata->header.cputype = 0;
1548 mdata->header.cpusubtype = 0;
1549 mdata->header.filetype = 0;
1550 mdata->header.ncmds = 0;
1551 mdata->header.sizeofcmds = 0;
1552 mdata->header.flags = 0;
1553 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
1554 mdata->commands = NULL;
1555 mdata->nsymbols = 0;
1556 mdata->symbols = NULL;
1557 mdata->nsects = 0;
1558 mdata->sections = NULL;
1559 mdata->ibfd = NULL;
1560
1561 return TRUE;
1562 }
1563
1564 const bfd_target *
1565 bfd_mach_o_object_p (bfd *abfd)
1566 {
1567 struct bfd_preserve preserve;
1568 bfd_mach_o_header header;
1569
1570 preserve.marker = NULL;
1571 if (bfd_mach_o_read_header (abfd, &header) != 0)
1572 goto wrong;
1573
1574 if (! (header.byteorder == BFD_ENDIAN_BIG
1575 || header.byteorder == BFD_ENDIAN_LITTLE))
1576 {
1577 fprintf (stderr, "unknown header byte-order value 0x%lx\n",
1578 (long) header.byteorder);
1579 goto wrong;
1580 }
1581
1582 if (! ((header.byteorder == BFD_ENDIAN_BIG
1583 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
1584 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
1585 || (header.byteorder == BFD_ENDIAN_LITTLE
1586 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
1587 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
1588 goto wrong;
1589
1590 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
1591 if (preserve.marker == NULL
1592 || !bfd_preserve_save (abfd, &preserve))
1593 goto fail;
1594
1595 if (bfd_mach_o_scan (abfd, &header,
1596 (bfd_mach_o_data_struct *) preserve.marker) != 0)
1597 goto wrong;
1598
1599 bfd_preserve_finish (abfd, &preserve);
1600 return abfd->xvec;
1601
1602 wrong:
1603 bfd_set_error (bfd_error_wrong_format);
1604
1605 fail:
1606 if (preserve.marker != NULL)
1607 bfd_preserve_restore (abfd, &preserve);
1608 return NULL;
1609 }
1610
1611 const bfd_target *
1612 bfd_mach_o_core_p (bfd *abfd)
1613 {
1614 struct bfd_preserve preserve;
1615 bfd_mach_o_header header;
1616
1617 preserve.marker = NULL;
1618 if (bfd_mach_o_read_header (abfd, &header) != 0)
1619 goto wrong;
1620
1621 if (! (header.byteorder == BFD_ENDIAN_BIG
1622 || header.byteorder == BFD_ENDIAN_LITTLE))
1623 {
1624 fprintf (stderr, "unknown header byte-order value 0x%lx\n",
1625 (long) header.byteorder);
1626 abort ();
1627 }
1628
1629 if (! ((header.byteorder == BFD_ENDIAN_BIG
1630 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
1631 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
1632 || (header.byteorder == BFD_ENDIAN_LITTLE
1633 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
1634 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
1635 goto wrong;
1636
1637 if (header.filetype != BFD_MACH_O_MH_CORE)
1638 goto wrong;
1639
1640 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
1641 if (preserve.marker == NULL
1642 || !bfd_preserve_save (abfd, &preserve))
1643 goto fail;
1644
1645 if (bfd_mach_o_scan (abfd, &header,
1646 (bfd_mach_o_data_struct *) preserve.marker) != 0)
1647 goto wrong;
1648
1649 bfd_preserve_finish (abfd, &preserve);
1650 return abfd->xvec;
1651
1652 wrong:
1653 bfd_set_error (bfd_error_wrong_format);
1654
1655 fail:
1656 if (preserve.marker != NULL)
1657 bfd_preserve_restore (abfd, &preserve);
1658 return NULL;
1659 }
1660
1661 typedef struct mach_o_fat_archentry
1662 {
1663 unsigned long cputype;
1664 unsigned long cpusubtype;
1665 unsigned long offset;
1666 unsigned long size;
1667 unsigned long align;
1668 bfd *abfd;
1669 } mach_o_fat_archentry;
1670
1671 typedef struct mach_o_fat_data_struct
1672 {
1673 unsigned long magic;
1674 unsigned long nfat_arch;
1675 mach_o_fat_archentry *archentries;
1676 } mach_o_fat_data_struct;
1677
1678 const bfd_target *
1679 bfd_mach_o_archive_p (bfd *abfd)
1680 {
1681 mach_o_fat_data_struct *adata = NULL;
1682 unsigned char buf[20];
1683 unsigned long i;
1684
1685 bfd_seek (abfd, 0, SEEK_SET);
1686 if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1687 goto error;
1688
1689 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
1690 if (adata == NULL)
1691 goto error;
1692
1693 adata->magic = bfd_getb32 (buf);
1694 adata->nfat_arch = bfd_getb32 (buf + 4);
1695 if (adata->magic != 0xcafebabe)
1696 goto error;
1697
1698 adata->archentries =
1699 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
1700 if (adata->archentries == NULL)
1701 goto error;
1702
1703 for (i = 0; i < adata->nfat_arch; i++)
1704 {
1705 bfd_seek (abfd, 8 + 20 * i, SEEK_SET);
1706
1707 if (bfd_bread ((PTR) buf, 20, abfd) != 20)
1708 goto error;
1709 adata->archentries[i].cputype = bfd_getb32 (buf);
1710 adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
1711 adata->archentries[i].offset = bfd_getb32 (buf + 8);
1712 adata->archentries[i].size = bfd_getb32 (buf + 12);
1713 adata->archentries[i].align = bfd_getb32 (buf + 16);
1714 adata->archentries[i].abfd = NULL;
1715 }
1716
1717 abfd->tdata.mach_o_fat_data = adata;
1718 return abfd->xvec;
1719
1720 error:
1721 if (adata != NULL)
1722 bfd_release (abfd, adata);
1723 bfd_set_error (bfd_error_wrong_format);
1724 return NULL;
1725 }
1726
1727 bfd *
1728 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
1729 {
1730 mach_o_fat_data_struct *adata;
1731 mach_o_fat_archentry *entry = NULL;
1732 unsigned long i;
1733
1734 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
1735 BFD_ASSERT (adata != NULL);
1736
1737 /* Find index of previous entry. */
1738 if (prev == NULL)
1739 i = 0; /* Start at first one. */
1740 else
1741 {
1742 for (i = 0; i < adata->nfat_arch; i++)
1743 {
1744 if (adata->archentries[i].abfd == prev)
1745 break;
1746 }
1747
1748 if (i == adata->nfat_arch)
1749 {
1750 /* Not found. */
1751 bfd_set_error (bfd_error_bad_value);
1752 return NULL;
1753 }
1754 i++; /* Get next entry. */
1755 }
1756
1757 if (i >= adata->nfat_arch)
1758 {
1759 bfd_set_error (bfd_error_no_more_archived_files);
1760 return NULL;
1761 }
1762
1763 entry = &adata->archentries[i];
1764 if (entry->abfd == NULL)
1765 {
1766 bfd *nbfd = _bfd_new_bfd_contained_in (archive);
1767 char *s = NULL;
1768
1769 if (nbfd == NULL)
1770 return NULL;
1771
1772 nbfd->origin = entry->offset;
1773 s = bfd_malloc (strlen (archive->filename) + 1);
1774 if (s == NULL)
1775 return NULL;
1776 strcpy (s, archive->filename);
1777 nbfd->filename = s;
1778 nbfd->iostream = NULL;
1779 entry->abfd = nbfd;
1780 }
1781
1782 return entry->abfd;
1783 }
1784
1785 int
1786 bfd_mach_o_lookup_section (bfd *abfd,
1787 asection *section,
1788 bfd_mach_o_load_command **mcommand,
1789 bfd_mach_o_section **msection)
1790 {
1791 struct mach_o_data_struct *md = abfd->tdata.mach_o_data;
1792 unsigned int i, j, num;
1793
1794 bfd_mach_o_load_command *ncmd = NULL;
1795 bfd_mach_o_section *nsect = NULL;
1796
1797 BFD_ASSERT (mcommand != NULL);
1798 BFD_ASSERT (msection != NULL);
1799
1800 num = 0;
1801 for (i = 0; i < md->header.ncmds; i++)
1802 {
1803 struct bfd_mach_o_load_command *cmd = &md->commands[i];
1804 struct bfd_mach_o_segment_command *seg = NULL;
1805
1806 if (cmd->type != BFD_MACH_O_LC_SEGMENT)
1807 continue;
1808 seg = &cmd->command.segment;
1809
1810 if (seg->segment == section)
1811 {
1812 if (num == 0)
1813 ncmd = cmd;
1814 num++;
1815 }
1816
1817 for (j = 0; j < seg->nsects; j++)
1818 {
1819 struct bfd_mach_o_section *sect = &seg->sections[j];
1820
1821 if (sect->bfdsection == section)
1822 {
1823 if (num == 0)
1824 nsect = sect;
1825 num++;
1826 }
1827 }
1828 }
1829
1830 *mcommand = ncmd;
1831 *msection = nsect;
1832 return num;
1833 }
1834
1835 int
1836 bfd_mach_o_lookup_command (bfd *abfd,
1837 bfd_mach_o_load_command_type type,
1838 bfd_mach_o_load_command **mcommand)
1839 {
1840 struct mach_o_data_struct *md = NULL;
1841 bfd_mach_o_load_command *ncmd = NULL;
1842 unsigned int i, num;
1843
1844 md = abfd->tdata.mach_o_data;
1845
1846 BFD_ASSERT (md != NULL);
1847 BFD_ASSERT (mcommand != NULL);
1848
1849 num = 0;
1850 for (i = 0; i < md->header.ncmds; i++)
1851 {
1852 struct bfd_mach_o_load_command *cmd = &md->commands[i];
1853
1854 if (cmd->type != type)
1855 continue;
1856
1857 if (num == 0)
1858 ncmd = cmd;
1859 num++;
1860 }
1861
1862 *mcommand = ncmd;
1863 return num;
1864 }
1865
1866 unsigned long
1867 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
1868 {
1869 switch (type)
1870 {
1871 case BFD_MACH_O_CPU_TYPE_MC680x0:
1872 return 0x04000000;
1873 case BFD_MACH_O_CPU_TYPE_MC88000:
1874 return 0xffffe000;
1875 case BFD_MACH_O_CPU_TYPE_POWERPC:
1876 return 0xc0000000;
1877 case BFD_MACH_O_CPU_TYPE_I386:
1878 return 0xc0000000;
1879 case BFD_MACH_O_CPU_TYPE_SPARC:
1880 return 0xf0000000;
1881 case BFD_MACH_O_CPU_TYPE_I860:
1882 return 0;
1883 case BFD_MACH_O_CPU_TYPE_HPPA:
1884 return 0xc0000000 - 0x04000000;
1885 default:
1886 return 0;
1887 }
1888 }
1889
1890 int
1891 bfd_mach_o_core_fetch_environment (bfd *abfd,
1892 unsigned char **rbuf,
1893 unsigned int *rlen)
1894 {
1895 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1896 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
1897 unsigned int i = 0;
1898
1899 for (i = 0; i < mdata->header.ncmds; i++)
1900 {
1901 bfd_mach_o_load_command *cur = &mdata->commands[i];
1902 bfd_mach_o_segment_command *seg = NULL;
1903
1904 if (cur->type != BFD_MACH_O_LC_SEGMENT)
1905 continue;
1906
1907 seg = &cur->command.segment;
1908
1909 if ((seg->vmaddr + seg->vmsize) == stackaddr)
1910 {
1911 unsigned long start = seg->fileoff;
1912 unsigned long end = seg->fileoff + seg->filesize;
1913 unsigned char *buf = bfd_malloc (1024);
1914 unsigned long size = 1024;
1915
1916 for (;;)
1917 {
1918 bfd_size_type nread = 0;
1919 unsigned long offset;
1920 int found_nonnull = 0;
1921
1922 if (size > (end - start))
1923 size = (end - start);
1924
1925 buf = bfd_realloc (buf, size);
1926
1927 bfd_seek (abfd, end - size, SEEK_SET);
1928 nread = bfd_bread (buf, size, abfd);
1929
1930 if (nread != size)
1931 return -1;
1932
1933 for (offset = 4; offset <= size; offset += 4)
1934 {
1935 unsigned long val;
1936
1937 val = *((unsigned long *) (buf + size - offset));
1938 if (! found_nonnull)
1939 {
1940 if (val != 0)
1941 found_nonnull = 1;
1942 }
1943 else if (val == 0x0)
1944 {
1945 unsigned long bottom;
1946 unsigned long top;
1947
1948 bottom = seg->fileoff + seg->filesize - offset;
1949 top = seg->fileoff + seg->filesize - 4;
1950 *rbuf = bfd_malloc (top - bottom);
1951 *rlen = top - bottom;
1952
1953 memcpy (*rbuf, buf + size - *rlen, *rlen);
1954 return 0;
1955 }
1956 }
1957
1958 if (size == (end - start))
1959 break;
1960
1961 size *= 2;
1962 }
1963 }
1964 }
1965
1966 return -1;
1967 }
1968
1969 char *
1970 bfd_mach_o_core_file_failing_command (bfd *abfd)
1971 {
1972 unsigned char *buf = NULL;
1973 unsigned int len = 0;
1974 int ret = -1;
1975
1976 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
1977 if (ret < 0)
1978 return NULL;
1979
1980 return (char *) buf;
1981 }
1982
1983 int
1984 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
1985 {
1986 return 0;
1987 }
1988
1989 #define TARGET_NAME mach_o_be_vec
1990 #define TARGET_STRING "mach-o-be"
1991 #define TARGET_BIG_ENDIAN 1
1992 #define TARGET_ARCHIVE 0
1993
1994 #include "mach-o-target.c"
1995
1996 #undef TARGET_NAME
1997 #undef TARGET_STRING
1998 #undef TARGET_BIG_ENDIAN
1999 #undef TARGET_ARCHIVE
2000
2001 #define TARGET_NAME mach_o_le_vec
2002 #define TARGET_STRING "mach-o-le"
2003 #define TARGET_BIG_ENDIAN 0
2004 #define TARGET_ARCHIVE 0
2005
2006 #include "mach-o-target.c"
2007
2008 #undef TARGET_NAME
2009 #undef TARGET_STRING
2010 #undef TARGET_BIG_ENDIAN
2011 #undef TARGET_ARCHIVE
2012
2013 #define TARGET_NAME mach_o_fat_vec
2014 #define TARGET_STRING "mach-o-fat"
2015 #define TARGET_BIG_ENDIAN 1
2016 #define TARGET_ARCHIVE 1
2017
2018 #include "mach-o-target.c"
2019
2020 #undef TARGET_NAME
2021 #undef TARGET_STRING
2022 #undef TARGET_BIG_ENDIAN
2023 #undef TARGET_ARCHIVE
git-cvsimport of binutils cvsroot