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