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