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