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