?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-06-18 Dave Korn <dave.korn.cygwin@gmail.com>
[binutils.git] / bfd / mach-o.c
blobd8e702ec73b787b44ffe3ec7bba06748a7913762
1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "mach-o.h"
24 #include "bfd.h"
25 #include "libbfd.h"
26 #include "libiberty.h"
27 #include "aout/stab_gnu.h"
28 #include <ctype.h>
29
30 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
31 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
32 #define bfd_mach_o_mkobject bfd_false
33
34 #define FILE_ALIGN(off, algn) \
35 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
36
37 unsigned int
38 bfd_mach_o_version (bfd *abfd)
39 {
40 bfd_mach_o_data_struct *mdata = NULL;
41
42 BFD_ASSERT (bfd_mach_o_valid (abfd));
43 mdata = abfd->tdata.mach_o_data;
44
45 return mdata->header.version;
46 }
47
48 bfd_boolean
49 bfd_mach_o_valid (bfd *abfd)
50 {
51 if (abfd == NULL || abfd->xvec == NULL)
52 return FALSE;
53
54 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
55 return FALSE;
56
57 if (abfd->tdata.mach_o_data == NULL)
58 return FALSE;
59 return TRUE;
60 }
61
62 static INLINE bfd_boolean
63 mach_o_wide_p (bfd_mach_o_header *header)
64 {
65 switch (header->version)
66 {
67 case 1:
68 return FALSE;
69 case 2:
70 return TRUE;
71 default:
72 BFD_FAIL ();
73 return FALSE;
74 }
75 }
76
77 static INLINE bfd_boolean
78 bfd_mach_o_wide_p (bfd *abfd)
79 {
80 return mach_o_wide_p (&abfd->tdata.mach_o_data->header);
81 }
82
83 /* Tables to translate well known Mach-O segment/section names to bfd
84 names. Use of canonical names (such as .text or .debug_frame) is required
85 by gdb. */
86
87 struct mach_o_section_name_xlat
88 {
89 const char *bfd_name;
90 const char *mach_o_name;
91 };
92
93 static const struct mach_o_section_name_xlat dwarf_section_names_xlat[] =
94 {
95 { ".debug_frame", "__debug_frame" },
96 { ".debug_info", "__debug_info" },
97 { ".debug_abbrev", "__debug_abbrev" },
98 { ".debug_aranges", "__debug_aranges" },
99 { ".debug_macinfo", "__debug_macinfo" },
100 { ".debug_line", "__debug_line" },
101 { ".debug_loc", "__debug_loc" },
102 { ".debug_pubnames", "__debug_pubnames" },
103 { ".debug_pubtypes", "__debug_pubtypes" },
104 { ".debug_str", "__debug_str" },
105 { ".debug_ranges", "__debug_ranges" },
106 { NULL, NULL}
107 };
108
109 static const struct mach_o_section_name_xlat text_section_names_xlat[] =
110 {
111 { ".text", "__text" },
112 { ".cstring", "__cstring" },
113 { ".eh_frame", "__eh_frame" },
114 { NULL, NULL}
115 };
116
117 static const struct mach_o_section_name_xlat data_section_names_xlat[] =
118 {
119 { ".data", "__data" },
120 { ".bss", "__bss" },
121 { NULL, NULL}
122 };
123
124 struct mach_o_segment_name_xlat
125 {
126 const char *segname;
127 const struct mach_o_section_name_xlat *sections;
128 };
129
130 static const struct mach_o_segment_name_xlat segsec_names_xlat[] =
131 {
132 { "__DWARF", dwarf_section_names_xlat },
133 { "__TEXT", text_section_names_xlat },
134 { "__DATA", data_section_names_xlat },
135 { NULL, NULL }
136 };
137
138
139 /* Mach-O to bfd names. */
140
141 static char *
142 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section)
143 {
144 const struct mach_o_segment_name_xlat *seg;
145 char *res;
146 unsigned int len;
147 const char *pfx = "";
148
149 for (seg = segsec_names_xlat; seg->segname; seg++)
150 {
151 if (strcmp (seg->segname, section->segname) == 0)
152 {
153 const struct mach_o_section_name_xlat *sec;
154
155 for (sec = seg->sections; sec->mach_o_name; sec++)
156 {
157 if (strcmp (sec->mach_o_name, section->sectname) == 0)
158 {
159 len = strlen (sec->bfd_name);
160 res = bfd_alloc (abfd, len + 1);
161
162 if (res == NULL)
163 return NULL;
164 strcpy (res, sec->bfd_name);
165 return res;
166 }
167 }
168 }
169 }
170
171 len = strlen (section->segname) + 1
172 + strlen (section->sectname) + 1;
173
174 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
175 with an underscore. */
176 if (section->segname[0] != '_')
177 {
178 static const char seg_pfx[] = "LC_SEGMENT.";
179
180 pfx = seg_pfx;
181 len += sizeof (seg_pfx) - 1;
182 }
183
184 res = bfd_alloc (abfd, len);
185 if (res == NULL)
186 return NULL;
187 snprintf (res, len, "%s%s.%s", pfx, section->segname, section->sectname);
188 return res;
189 }
190
191 /* Convert a bfd section name to a Mach-O segment + section name. */
192
193 static void
194 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
195 asection *sect,
196 bfd_mach_o_section *section)
197 {
198 const struct mach_o_segment_name_xlat *seg;
199 const char *name = bfd_get_section_name (abfd, sect);
200 const char *dot;
201 unsigned int len;
202 unsigned int seglen;
203 unsigned int seclen;
204
205 /* List of well known names. They all start with a dot. */
206 if (name[0] == '.')
207 for (seg = segsec_names_xlat; seg->segname; seg++)
208 {
209 const struct mach_o_section_name_xlat *sec;
210
211 for (sec = seg->sections; sec->mach_o_name; sec++)
212 {
213 if (strcmp (sec->bfd_name, name) == 0)
214 {
215 strcpy (section->segname, seg->segname);
216 strcpy (section->sectname, sec->mach_o_name);
217 return;
218 }
219 }
220 }
221
222 /* Strip LC_SEGMENT. prefix. */
223 if (strncmp (name, "LC_SEGMENT.", 11) == 0)
224 name += 11;
225
226 /* Find a dot. */
227 dot = strchr (name, '.');
228 len = strlen (name);
229
230 /* Try to split name into segment and section names. */
231 if (dot && dot != name)
232 {
233 seglen = dot - name;
234 seclen = len - (dot + 1 - name);
235
236 if (seglen < 16 && seclen < 16)
237 {
238 memcpy (section->segname, name, seglen);
239 section->segname[seglen] = 0;
240 memcpy (section->sectname, dot + 1, seclen);
241 section->sectname[seclen] = 0;
242 return;
243 }
244 }
245
246 if (len > 16)
247 len = 16;
248 memcpy (section->segname, name, len);
249 section->segname[len] = 0;
250 memcpy (section->sectname, name, len);
251 section->sectname[len] = 0;
252 }
253
254 /* Copy any private info we understand from the input symbol
255 to the output symbol. */
256
257 bfd_boolean
258 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
259 asymbol *isymbol ATTRIBUTE_UNUSED,
260 bfd *obfd ATTRIBUTE_UNUSED,
261 asymbol *osymbol ATTRIBUTE_UNUSED)
262 {
263 return TRUE;
264 }
265
266 /* Copy any private info we understand from the input section
267 to the output section. */
268
269 bfd_boolean
270 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
271 asection *isection ATTRIBUTE_UNUSED,
272 bfd *obfd ATTRIBUTE_UNUSED,
273 asection *osection ATTRIBUTE_UNUSED)
274 {
275 return TRUE;
276 }
277
278 /* Copy any private info we understand from the input bfd
279 to the output bfd. */
280
281 bfd_boolean
282 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
283 {
284 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
285 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
286 return TRUE;
287
288 BFD_ASSERT (bfd_mach_o_valid (ibfd));
289 BFD_ASSERT (bfd_mach_o_valid (obfd));
290
291 /* FIXME: copy commands. */
292
293 return TRUE;
294 }
295
296 /* Count the total number of symbols. Traverse all sections. */
297
298 static long
299 bfd_mach_o_count_symbols (bfd *abfd)
300 {
301 bfd_mach_o_data_struct *mdata = NULL;
302 long nsyms = 0;
303 unsigned long i;
304
305 BFD_ASSERT (bfd_mach_o_valid (abfd));
306 mdata = abfd->tdata.mach_o_data;
307
308 for (i = 0; i < mdata->header.ncmds; i++)
309 if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB)
310 {
311 bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab;
312 nsyms += sym->nsyms;
313 }
314
315 return nsyms;
316 }
317
318 long
319 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
320 {
321 long nsyms = bfd_mach_o_count_symbols (abfd);
322
323 if (nsyms < 0)
324 return nsyms;
325
326 return ((nsyms + 1) * sizeof (asymbol *));
327 }
328
329 long
330 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
331 {
332 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
333 long nsyms = bfd_mach_o_count_symbols (abfd);
334 asymbol **csym = alocation;
335 unsigned long i, j;
336
337 if (nsyms < 0)
338 return nsyms;
339
340 for (i = 0; i < mdata->header.ncmds; i++)
341 {
342 if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB)
343 {
344 bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab;
345
346 if (bfd_mach_o_scan_read_symtab_symbols (abfd, &mdata->commands[i].command.symtab) != 0)
347 {
348 fprintf (stderr, "bfd_mach_o_canonicalize_symtab: unable to load symbols for section %lu\n", i);
349 return 0;
350 }
351
352 BFD_ASSERT (sym->symbols != NULL);
353
354 for (j = 0; j < sym->nsyms; j++)
355 {
356 BFD_ASSERT (csym < (alocation + nsyms));
357 *csym++ = &sym->symbols[j].symbol;
358 }
359 }
360 }
361
362 *csym++ = NULL;
363
364 return nsyms;
365 }
366
367 void
368 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
369 asymbol *symbol,
370 symbol_info *ret)
371 {
372 bfd_symbol_info (symbol, ret);
373 }
374
375 void
376 bfd_mach_o_print_symbol (bfd *abfd,
377 PTR afile,
378 asymbol *symbol,
379 bfd_print_symbol_type how)
380 {
381 FILE *file = (FILE *) afile;
382 const char *name;
383 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
384
385 switch (how)
386 {
387 case bfd_print_symbol_name:
388 fprintf (file, "%s", symbol->name);
389 break;
390 default:
391 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
392 if (asym->n_type & BFD_MACH_O_N_STAB)
393 name = bfd_get_stab_name (asym->n_type);
394 else
395 switch (asym->n_type & BFD_MACH_O_N_TYPE)
396 {
397 case BFD_MACH_O_N_UNDF:
398 name = "UND";
399 break;
400 case BFD_MACH_O_N_ABS:
401 name = "ABS";
402 break;
403 case BFD_MACH_O_N_INDR:
404 name = "INDR";
405 break;
406 case BFD_MACH_O_N_PBUD:
407 name = "PBUD";
408 break;
409 case BFD_MACH_O_N_SECT:
410 name = "SECT";
411 break;
412 default:
413 name = "???";
414 break;
415 }
416 if (name == NULL)
417 name = "";
418 fprintf (file, " %02x %-6s %02x %04x",
419 asym->n_type, name, asym->n_sect, asym->n_desc);
420 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
421 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
422 fprintf (file, " %-5s", symbol->section->name);
423 fprintf (file, " %s", symbol->name);
424 }
425 }
426
427 static void
428 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
429 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED,
430 enum bfd_architecture *type,
431 unsigned long *subtype)
432 {
433 *subtype = bfd_arch_unknown;
434
435 switch (mtype)
436 {
437 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
438 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
439 case BFD_MACH_O_CPU_TYPE_I386:
440 *type = bfd_arch_i386;
441 *subtype = bfd_mach_i386_i386;
442 break;
443 case BFD_MACH_O_CPU_TYPE_X86_64:
444 *type = bfd_arch_i386;
445 *subtype = bfd_mach_x86_64;
446 break;
447 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
448 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
449 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
450 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
451 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
452 case BFD_MACH_O_CPU_TYPE_SPARC:
453 *type = bfd_arch_sparc;
454 *subtype = bfd_mach_sparc;
455 break;
456 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
457 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
458 case BFD_MACH_O_CPU_TYPE_POWERPC:
459 *type = bfd_arch_powerpc;
460 *subtype = bfd_mach_ppc;
461 break;
462 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
463 *type = bfd_arch_powerpc;
464 *subtype = bfd_mach_ppc64;
465 break;
466 default:
467 *type = bfd_arch_unknown;
468 break;
469 }
470 }
471
472 static bfd_boolean
473 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
474 {
475 unsigned char buf[32];
476 unsigned int size;
477
478 size = mach_o_wide_p (header) ?
479 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
480
481 bfd_h_put_32 (abfd, header->magic, buf + 0);
482 bfd_h_put_32 (abfd, header->cputype, buf + 4);
483 bfd_h_put_32 (abfd, header->cpusubtype, buf + 8);
484 bfd_h_put_32 (abfd, header->filetype, buf + 12);
485 bfd_h_put_32 (abfd, header->ncmds, buf + 16);
486 bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20);
487 bfd_h_put_32 (abfd, header->flags, buf + 24);
488
489 if (mach_o_wide_p (header))
490 bfd_h_put_32 (abfd, header->reserved, buf + 28);
491
492 if (bfd_seek (abfd, 0, SEEK_SET) != 0
493 || bfd_bwrite ((PTR) buf, size, abfd) != size)
494 return FALSE;
495
496 return TRUE;
497 }
498
499 static int
500 bfd_mach_o_scan_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
501 {
502 bfd_mach_o_thread_command *cmd = &command->command.thread;
503 unsigned int i;
504 unsigned char buf[8];
505 unsigned int offset;
506 unsigned int nflavours;
507
508 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
509 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
510
511 offset = 8;
512 nflavours = 0;
513 for (i = 0; i < cmd->nflavours; i++)
514 {
515 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
516 BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8));
517
518 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf);
519 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
520
521 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
522 || bfd_bwrite ((PTR) buf, 8, abfd) != 8)
523 return -1;
524
525 offset += cmd->flavours[i].size + 8;
526 }
527
528 return 0;
529 }
530
531 long
532 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
533 asection *asect)
534 {
535 return (asect->reloc_count + 1) * sizeof (arelent *);
536 }
537
538 long
539 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
540 arelent **rels, asymbol **syms)
541 {
542 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
543 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
544 unsigned long i;
545 arelent *res;
546 char *native_relocs;
547 bfd_size_type native_size;
548
549 if (asect->reloc_count == 0)
550 return 0;
551
552 /* No need to go further if we don't know how to read relocs. */
553 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
554 return 0;
555
556 /* Allocate and read relocs. */
557 native_size = asect->reloc_count * BFD_MACH_O_RELENT_SIZE;
558 native_relocs = bfd_malloc (native_size);
559 if (native_relocs == NULL)
560 return -1;
561
562 if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0
563 || bfd_bread (native_relocs, native_size, abfd) != native_size)
564 {
565 free (native_relocs);
566 return -1;
567 }
568
569 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
570 if (res == NULL)
571 {
572 free (native_relocs);
573 return -1;
574 }
575
576 for (i = 0; i < asect->reloc_count; i++)
577 {
578 char *buf = native_relocs + BFD_MACH_O_RELENT_SIZE * i;
579 bfd_mach_o_reloc_info reloc;
580 bfd_vma addr;
581 bfd_vma symnum;
582 asymbol **sym;
583
584 addr = bfd_get_32 (abfd, buf + 0);
585 symnum = bfd_get_32 (abfd, buf + 4);
586
587 if (addr & BFD_MACH_O_SR_SCATTERED)
588 {
589 unsigned int j;
590
591 /* Scattered relocation.
592 Extract section and offset from r_value. */
593 res[i].sym_ptr_ptr = NULL;
594 res[i].addend = 0;
595 for (j = 0; j < mdata->nsects; j++)
596 {
597 bfd_mach_o_section *sect = mdata->sections[j];
598 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
599 {
600 res[i].sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
601 res[i].addend = symnum - sect->addr;
602 break;
603 }
604 }
605 res[i].address = BFD_MACH_O_GET_SR_ADDRESS (addr);
606 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
607 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
608 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
609 reloc.r_scattered = 1;
610 }
611 else
612 {
613 unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);
614 res[i].addend = 0;
615 res[i].address = addr;
616 if (symnum & BFD_MACH_O_R_EXTERN)
617 sym = syms + num;
618 else
619 {
620 BFD_ASSERT (num != 0);
621 BFD_ASSERT (num <= mdata->nsects);
622 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
623 }
624 res[i].sym_ptr_ptr = sym;
625 reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
626 reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);
627 reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;
628 reloc.r_scattered = 0;
629 }
630
631 if (!(*bed->_bfd_mach_o_swap_reloc_in)(&res[i], &reloc))
632 {
633 free (res);
634 free (native_relocs);
635 return -1;
636 }
637 rels[i] = &res[i];
638 }
639 asect->relocation = res;
640 free (native_relocs);
641 return i;
642 }
643
644 static bfd_boolean
645 bfd_mach_o_scan_write_relocs (bfd *abfd, bfd_mach_o_section *section)
646 {
647 bfd_mach_o_data_struct *mdata = bfd_get_mach_o_data (abfd);
648 unsigned int i;
649 arelent **entries;
650 asection *sec;
651 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
652
653 sec = section->bfdsection;
654 if (sec->reloc_count == 0)
655 return TRUE;
656
657 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
658 return TRUE;
659
660 /* Allocate relocation room. */
661 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
662 section->nreloc = sec->reloc_count;
663 sec->rel_filepos = mdata->filelen;
664 section->reloff = sec->rel_filepos;
665 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
666
667 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
668 return FALSE;
669
670 /* Convert and write. */
671 entries = section->bfdsection->orelocation;
672 for (i = 0; i < section->nreloc; i++)
673 {
674 arelent *rel = entries[i];
675 char buf[8];
676 bfd_mach_o_reloc_info info, *pinfo = &info;
677
678 /* Convert relocation to an intermediate representation. */
679 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
680 return FALSE;
681
682 /* Lower the relocation info. */
683 if (pinfo->r_scattered)
684 {
685 unsigned long v;
686
687 v = BFD_MACH_O_SR_SCATTERED
688 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
689 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
690 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
691 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
692 bfd_put_32 (abfd, v, buf);
693 bfd_put_32 (abfd, pinfo->r_value, buf + 4);
694 }
695 else
696 {
697 unsigned long v;
698
699 bfd_put_32 (abfd, pinfo->r_address, buf);
700 v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value)
701 | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0)
702 | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length)
703 | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0)
704 | BFD_MACH_O_SET_R_TYPE (pinfo->r_type);
705 bfd_put_32 (abfd, v, buf + 4);
706 }
707
708 if (bfd_bwrite ((PTR) buf, BFD_MACH_O_RELENT_SIZE, abfd)
709 != BFD_MACH_O_RELENT_SIZE)
710 return FALSE;
711 }
712 return TRUE;
713 }
714
715 static int
716 bfd_mach_o_scan_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
717 {
718 unsigned char buf[BFD_MACH_O_SECTION_SIZE];
719
720 memcpy (buf, section->sectname, 16);
721 memcpy (buf + 16, section->segname, 16);
722 bfd_h_put_32 (abfd, section->addr, buf + 32);
723 bfd_h_put_32 (abfd, section->size, buf + 36);
724 bfd_h_put_32 (abfd, section->offset, buf + 40);
725 bfd_h_put_32 (abfd, section->align, buf + 44);
726 bfd_h_put_32 (abfd, section->reloff, buf + 48);
727 bfd_h_put_32 (abfd, section->nreloc, buf + 52);
728 bfd_h_put_32 (abfd, section->flags, buf + 56);
729 bfd_h_put_32 (abfd, section->reserved1, buf + 60);
730 bfd_h_put_32 (abfd, section->reserved2, buf + 64);
731
732 if (bfd_bwrite ((PTR) buf, BFD_MACH_O_SECTION_SIZE, abfd)
733 != BFD_MACH_O_SECTION_SIZE)
734 return -1;
735
736 return 0;
737 }
738
739 static int
740 bfd_mach_o_scan_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
741 {
742 unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
743
744 memcpy (buf, section->sectname, 16);
745 memcpy (buf + 16, section->segname, 16);
746 bfd_h_put_64 (abfd, section->addr, buf + 32);
747 bfd_h_put_64 (abfd, section->size, buf + 40);
748 bfd_h_put_32 (abfd, section->offset, buf + 48);
749 bfd_h_put_32 (abfd, section->align, buf + 52);
750 bfd_h_put_32 (abfd, section->reloff, buf + 56);
751 bfd_h_put_32 (abfd, section->nreloc, buf + 60);
752 bfd_h_put_32 (abfd, section->flags, buf + 64);
753 bfd_h_put_32 (abfd, section->reserved1, buf + 68);
754 bfd_h_put_32 (abfd, section->reserved2, buf + 72);
755 bfd_h_put_32 (abfd, section->reserved3, buf + 76);
756
757 if (bfd_bwrite ((PTR) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
758 != BFD_MACH_O_SECTION_64_SIZE)
759 return -1;
760
761 return 0;
762 }
763
764 static int
765 bfd_mach_o_scan_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
766 {
767 unsigned char buf[BFD_MACH_O_LC_SEGMENT_SIZE];
768 bfd_mach_o_segment_command *seg = &command->command.segment;
769 unsigned long i;
770
771 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
772
773 for (i = 0; i < seg->nsects; i++)
774 if (!bfd_mach_o_scan_write_relocs (abfd, &seg->sections[i]))
775 return -1;
776
777 memcpy (buf, seg->segname, 16);
778 bfd_h_put_32 (abfd, seg->vmaddr, buf + 16);
779 bfd_h_put_32 (abfd, seg->vmsize, buf + 20);
780 bfd_h_put_32 (abfd, seg->fileoff, buf + 24);
781 bfd_h_put_32 (abfd, seg->filesize, buf + 28);
782 bfd_h_put_32 (abfd, seg->maxprot, buf + 32);
783 bfd_h_put_32 (abfd, seg->initprot, buf + 36);
784 bfd_h_put_32 (abfd, seg->nsects, buf + 40);
785 bfd_h_put_32 (abfd, seg->flags, buf + 44);
786
787 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
788 || (bfd_bwrite ((PTR) buf, BFD_MACH_O_LC_SEGMENT_SIZE - 8, abfd)
789 != BFD_MACH_O_LC_SEGMENT_SIZE - 8))
790 return -1;
791
792 for (i = 0; i < seg->nsects; i++)
793 if (bfd_mach_o_scan_write_section_32 (abfd, &seg->sections[i]))
794 return -1;
795
796 return 0;
797 }
798
799 static int
800 bfd_mach_o_scan_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
801 {
802 unsigned char buf[BFD_MACH_O_LC_SEGMENT_64_SIZE];
803 bfd_mach_o_segment_command *seg = &command->command.segment;
804 unsigned long i;
805
806 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
807
808 for (i = 0; i < seg->nsects; i++)
809 if (!bfd_mach_o_scan_write_relocs (abfd, &seg->sections[i]))
810 return -1;
811
812 memcpy (buf, seg->segname, 16);
813 bfd_h_put_64 (abfd, seg->vmaddr, buf + 16);
814 bfd_h_put_64 (abfd, seg->vmsize, buf + 24);
815 bfd_h_put_64 (abfd, seg->fileoff, buf + 32);
816 bfd_h_put_64 (abfd, seg->filesize, buf + 40);
817 bfd_h_put_32 (abfd, seg->maxprot, buf + 48);
818 bfd_h_put_32 (abfd, seg->initprot, buf + 52);
819 bfd_h_put_32 (abfd, seg->nsects, buf + 56);
820 bfd_h_put_32 (abfd, seg->flags, buf + 60);
821
822 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
823 || (bfd_bwrite ((PTR) buf, BFD_MACH_O_LC_SEGMENT_64_SIZE - 8, abfd)
824 != BFD_MACH_O_LC_SEGMENT_64_SIZE - 8))
825 return -1;
826
827 for (i = 0; i < seg->nsects; i++)
828 if (bfd_mach_o_scan_write_section_64 (abfd, &seg->sections[i]))
829 return -1;
830
831 return 0;
832 }
833
834 static bfd_boolean
835 bfd_mach_o_scan_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
836 {
837 bfd_mach_o_data_struct *mdata = bfd_get_mach_o_data (abfd);
838 bfd_mach_o_symtab_command *sym = &command->command.symtab;
839 unsigned char buf[16];
840 unsigned long i;
841 unsigned int wide = bfd_mach_o_wide_p (abfd);
842 unsigned int symlen = wide ? 16 : 12;
843 struct bfd_strtab_hash *strtab;
844 asymbol **symbols = bfd_get_outsymbols (abfd);
845
846 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
847
848 /* Write the symbols first. */
849 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
850 sym->symoff = mdata->filelen;
851 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
852 return FALSE;
853
854 sym->nsyms = bfd_get_symcount (abfd);
855 mdata->filelen += sym->nsyms * symlen;
856
857 strtab = _bfd_stringtab_init ();
858 if (strtab == NULL)
859 return FALSE;
860
861 for (i = 0; i < sym->nsyms; i++)
862 {
863 unsigned char buf[16];
864 bfd_size_type index;
865 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
866
867 /* Compute name index. */
868 /* An index of 0 always means the empty string. */
869 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
870 index = 0;
871 else
872 {
873 index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
874 if (index == (bfd_size_type) -1)
875 goto err;
876 }
877 bfd_h_put_32 (abfd, index, buf);
878 bfd_h_put_8 (abfd, s->n_type, buf + 4);
879 bfd_h_put_8 (abfd, s->n_sect, buf + 5);
880 bfd_h_put_16 (abfd, s->n_desc, buf + 6);
881 if (wide)
882 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
883 else
884 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
885
886 if (bfd_bwrite ((PTR) buf, symlen, abfd) != symlen)
887 goto err;
888 }
889 sym->strsize = _bfd_stringtab_size (strtab);
890 sym->stroff = mdata->filelen;
891 mdata->filelen += sym->strsize;
892
893 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
894 goto err;
895 _bfd_stringtab_free (strtab);
896
897 /* The command. */
898 bfd_h_put_32 (abfd, sym->symoff, buf);
899 bfd_h_put_32 (abfd, sym->nsyms, buf + 4);
900 bfd_h_put_32 (abfd, sym->stroff, buf + 8);
901 bfd_h_put_32 (abfd, sym->strsize, buf + 12);
902
903 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
904 || bfd_bwrite ((PTR) buf, 16, abfd) != 16)
905 return FALSE;
906
907 return TRUE;
908
909 err:
910 _bfd_stringtab_free (strtab);
911 return FALSE;
912 }
913
914 /* Process the symbols and generate Mach-O specific fields.
915 Number them. */
916
917 static bfd_boolean
918 bfd_mach_o_mangle_symbols (bfd *abfd)
919 {
920 unsigned long i;
921 asymbol **symbols = bfd_get_outsymbols (abfd);
922
923 for (i = 0; i < bfd_get_symcount (abfd); i++)
924 {
925 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
926
927 if (s->n_type == BFD_MACH_O_N_UNDF && !(s->symbol.flags & BSF_DEBUGGING))
928 {
929 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
930 symbols should be N_UNDEF | N_EXT), we suppose the back-end
931 values haven't been set. */
932 if (s->symbol.section == bfd_abs_section_ptr)
933 s->n_type = BFD_MACH_O_N_ABS;
934 else if (s->symbol.section == bfd_und_section_ptr)
935 {
936 s->n_type = BFD_MACH_O_N_UNDF;
937 if (s->symbol.flags & BSF_WEAK)
938 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
939 }
940 else if (s->symbol.section == bfd_com_section_ptr)
941 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
942 else
943 s->n_type = BFD_MACH_O_N_SECT;
944
945 if (s->symbol.flags & BSF_GLOBAL)
946 s->n_type |= BFD_MACH_O_N_EXT;
947 }
948
949 /* Compute section index. */
950 if (s->symbol.section != bfd_abs_section_ptr
951 && s->symbol.section != bfd_und_section_ptr
952 && s->symbol.section != bfd_com_section_ptr)
953 s->n_sect = s->symbol.section->target_index;
954
955 /* Number symbols. */
956 s->symbol.udata.i = i;
957 }
958 return TRUE;
959 }
960
961 bfd_boolean
962 bfd_mach_o_write_contents (bfd *abfd)
963 {
964 unsigned int i;
965 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
966
967 if (mdata->header.ncmds == 0)
968 if (!bfd_mach_o_build_commands (abfd))
969 return FALSE;
970
971 /* Now write header information. */
972 if (mdata->header.filetype == 0)
973 {
974 if (abfd->flags & EXEC_P)
975 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
976 else if (abfd->flags & DYNAMIC)
977 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
978 else
979 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
980 }
981 if (!bfd_mach_o_write_header (abfd, &mdata->header))
982 return FALSE;
983
984 /* Assign a number to each symbols. */
985 if (!bfd_mach_o_mangle_symbols (abfd))
986 return FALSE;
987
988 for (i = 0; i < mdata->header.ncmds; i++)
989 {
990 unsigned char buf[8];
991 bfd_mach_o_load_command *cur = &mdata->commands[i];
992 unsigned long typeflag;
993
994 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
995
996 bfd_h_put_32 (abfd, typeflag, buf);
997 bfd_h_put_32 (abfd, cur->len, buf + 4);
998
999 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1000 || bfd_bwrite ((PTR) buf, 8, abfd) != 8)
1001 return FALSE;
1002
1003 switch (cur->type)
1004 {
1005 case BFD_MACH_O_LC_SEGMENT:
1006 if (bfd_mach_o_scan_write_segment_32 (abfd, cur) != 0)
1007 return FALSE;
1008 break;
1009 case BFD_MACH_O_LC_SEGMENT_64:
1010 if (bfd_mach_o_scan_write_segment_64 (abfd, cur) != 0)
1011 return FALSE;
1012 break;
1013 case BFD_MACH_O_LC_SYMTAB:
1014 if (!bfd_mach_o_scan_write_symtab (abfd, cur))
1015 return FALSE;
1016 break;
1017 case BFD_MACH_O_LC_SYMSEG:
1018 break;
1019 case BFD_MACH_O_LC_THREAD:
1020 case BFD_MACH_O_LC_UNIXTHREAD:
1021 if (bfd_mach_o_scan_write_thread (abfd, cur) != 0)
1022 return FALSE;
1023 break;
1024 case BFD_MACH_O_LC_LOADFVMLIB:
1025 case BFD_MACH_O_LC_IDFVMLIB:
1026 case BFD_MACH_O_LC_IDENT:
1027 case BFD_MACH_O_LC_FVMFILE:
1028 case BFD_MACH_O_LC_PREPAGE:
1029 case BFD_MACH_O_LC_DYSYMTAB:
1030 case BFD_MACH_O_LC_LOAD_DYLIB:
1031 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1032 case BFD_MACH_O_LC_ID_DYLIB:
1033 case BFD_MACH_O_LC_LOAD_DYLINKER:
1034 case BFD_MACH_O_LC_ID_DYLINKER:
1035 case BFD_MACH_O_LC_PREBOUND_DYLIB:
1036 case BFD_MACH_O_LC_ROUTINES:
1037 case BFD_MACH_O_LC_SUB_FRAMEWORK:
1038 break;
1039 default:
1040 fprintf (stderr,
1041 "unable to write unknown load command 0x%lx\n",
1042 (unsigned long) cur->type);
1043 return FALSE;
1044 }
1045 }
1046
1047 return TRUE;
1048 }
1049
1050 /* Build Mach-O load commands from the sections. */
1051
1052 bfd_boolean
1053 bfd_mach_o_build_commands (bfd *abfd)
1054 {
1055 bfd_mach_o_data_struct *mdata = bfd_get_mach_o_data (abfd);
1056 unsigned int wide = mach_o_wide_p (&mdata->header);
1057 bfd_mach_o_segment_command *seg;
1058 bfd_mach_o_section *sections;
1059 asection *sec;
1060 bfd_mach_o_load_command *cmd;
1061 bfd_mach_o_load_command *symtab_cmd;
1062 int target_index;
1063
1064 /* Return now if commands are already built. */
1065 if (mdata->header.ncmds)
1066 return FALSE;
1067
1068 /* Very simple version: 1 command (segment) containing all sections. */
1069 mdata->header.ncmds = 2;
1070 mdata->commands = bfd_alloc (abfd, mdata->header.ncmds
1071 * sizeof (bfd_mach_o_load_command));
1072 if (mdata->commands == NULL)
1073 return FALSE;
1074 cmd = &mdata->commands[0];
1075 seg = &cmd->command.segment;
1076
1077 seg->nsects = bfd_count_sections (abfd);
1078 sections = bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section));
1079 if (sections == NULL)
1080 return FALSE;
1081 seg->sections = sections;
1082
1083 /* Set segment command. */
1084 if (wide)
1085 {
1086 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
1087 cmd->offset = BFD_MACH_O_HEADER_64_SIZE;
1088 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
1089 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
1090 }
1091 else
1092 {
1093 cmd->type = BFD_MACH_O_LC_SEGMENT;
1094 cmd->offset = BFD_MACH_O_HEADER_SIZE;
1095 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
1096 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
1097 }
1098 cmd->type_required = FALSE;
1099 mdata->header.sizeofcmds = cmd->len;
1100 mdata->filelen = cmd->offset + cmd->len;
1101
1102 /* Set symtab command. */
1103 symtab_cmd = &mdata->commands[1];
1104
1105 symtab_cmd->type = BFD_MACH_O_LC_SYMTAB;
1106 symtab_cmd->offset = cmd->offset + cmd->len;
1107 symtab_cmd->len = 6 * 4;
1108 symtab_cmd->type_required = FALSE;
1109
1110 mdata->header.sizeofcmds += symtab_cmd->len;
1111 mdata->filelen += symtab_cmd->len;
1112
1113 /* Fill segment command. */
1114 memset (seg->segname, 0, sizeof (seg->segname));
1115 seg->vmaddr = 0;
1116 seg->fileoff = mdata->filelen;
1117 seg->filesize = 0;
1118 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
1119 | BFD_MACH_O_PROT_EXECUTE;
1120 seg->initprot = seg->maxprot;
1121 seg->flags = 0;
1122
1123 /* Create Mach-O sections. */
1124 target_index = 0;
1125 for (sec = abfd->sections; sec; sec = sec->next)
1126 {
1127 sections->bfdsection = sec;
1128 bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, sections);
1129 sections->addr = bfd_get_section_vma (abfd, sec);
1130 sections->size = bfd_get_section_size (sec);
1131 sections->align = bfd_get_section_alignment (abfd, sec);
1132
1133 if (sections->size != 0)
1134 {
1135 mdata->filelen = FILE_ALIGN (mdata->filelen, sections->align);
1136 sections->offset = mdata->filelen;
1137 }
1138 else
1139 sections->offset = 0;
1140 sections->reloff = 0;
1141 sections->nreloc = 0;
1142 sections->reserved1 = 0;
1143 sections->reserved2 = 0;
1144 sections->reserved3 = 0;
1145
1146 sec->filepos = sections->offset;
1147 sec->target_index = ++target_index;
1148
1149 mdata->filelen += sections->size;
1150 sections++;
1151 }
1152 seg->filesize = mdata->filelen - seg->fileoff;
1153 seg->vmsize = seg->filesize;
1154
1155 return TRUE;
1156 }
1157
1158 /* Set the contents of a section. */
1159
1160 bfd_boolean
1161 bfd_mach_o_set_section_contents (bfd *abfd,
1162 asection *section,
1163 const void * location,
1164 file_ptr offset,
1165 bfd_size_type count)
1166 {
1167 file_ptr pos;
1168
1169 /* This must be done first, because bfd_set_section_contents is
1170 going to set output_has_begun to TRUE. */
1171 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
1172 return FALSE;
1173
1174 if (count == 0)
1175 return TRUE;
1176
1177 pos = section->filepos + offset;
1178 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1179 || bfd_bwrite (location, count, abfd) != count)
1180 return FALSE;
1181
1182 return TRUE;
1183 }
1184
1185 int
1186 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
1187 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1188 {
1189 return 0;
1190 }
1191
1192 /* Make an empty symbol. This is required only because
1193 bfd_make_section_anyway wants to create a symbol for the section. */
1194
1195 asymbol *
1196 bfd_mach_o_make_empty_symbol (bfd *abfd)
1197 {
1198 asymbol *new;
1199
1200 new = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
1201 if (new == NULL)
1202 return new;
1203 new->the_bfd = abfd;
1204 new->udata.i = 0;
1205 return new;
1206 }
1207
1208 static bfd_boolean
1209 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
1210 {
1211 unsigned char buf[32];
1212 unsigned int size;
1213 bfd_vma (*get32) (const void *) = NULL;
1214
1215 /* Just read the magic number. */
1216 if (bfd_seek (abfd, 0, SEEK_SET) != 0
1217 || bfd_bread ((PTR) buf, 4, abfd) != 4)
1218 return FALSE;
1219
1220 if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC)
1221 {
1222 header->byteorder = BFD_ENDIAN_BIG;
1223 header->magic = BFD_MACH_O_MH_MAGIC;
1224 header->version = 1;
1225 get32 = bfd_getb32;
1226 }
1227 else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC)
1228 {
1229 header->byteorder = BFD_ENDIAN_LITTLE;
1230 header->magic = BFD_MACH_O_MH_MAGIC;
1231 header->version = 1;
1232 get32 = bfd_getl32;
1233 }
1234 else if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC_64)
1235 {
1236 header->byteorder = BFD_ENDIAN_BIG;
1237 header->magic = BFD_MACH_O_MH_MAGIC_64;
1238 header->version = 2;
1239 get32 = bfd_getb32;
1240 }
1241 else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC_64)
1242 {
1243 header->byteorder = BFD_ENDIAN_LITTLE;
1244 header->magic = BFD_MACH_O_MH_MAGIC_64;
1245 header->version = 2;
1246 get32 = bfd_getl32;
1247 }
1248 else
1249 {
1250 header->byteorder = BFD_ENDIAN_UNKNOWN;
1251 return FALSE;
1252 }
1253
1254 /* Once the size of the header is known, read the full header. */
1255 size = mach_o_wide_p (header) ?
1256 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1257
1258 if (bfd_seek (abfd, 0, SEEK_SET) != 0
1259 || bfd_bread ((PTR) buf, size, abfd) != size)
1260 return FALSE;
1261
1262 header->cputype = (*get32) (buf + 4);
1263 header->cpusubtype = (*get32) (buf + 8);
1264 header->filetype = (*get32) (buf + 12);
1265 header->ncmds = (*get32) (buf + 16);
1266 header->sizeofcmds = (*get32) (buf + 20);
1267 header->flags = (*get32) (buf + 24);
1268
1269 if (mach_o_wide_p (header))
1270 header->reserved = (*get32) (buf + 28);
1271
1272 return TRUE;
1273 }
1274
1275 static asection *
1276 bfd_mach_o_make_bfd_section (bfd *abfd, bfd_mach_o_section *section,
1277 unsigned long prot)
1278 {
1279 asection *bfdsec;
1280 char *sname;
1281 flagword flags;
1282
1283 sname = bfd_mach_o_convert_section_name_to_bfd (abfd, section);
1284 if (sname == NULL)
1285 return NULL;
1286
1287 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
1288 flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
1289 else
1290 {
1291 flags = SEC_ALLOC;
1292 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1293 != BFD_MACH_O_S_ZEROFILL)
1294 {
1295 flags |= SEC_HAS_CONTENTS | SEC_LOAD;
1296 if (prot & BFD_MACH_O_PROT_EXECUTE)
1297 flags |= SEC_CODE;
1298 if (prot & BFD_MACH_O_PROT_WRITE)
1299 flags |= SEC_DATA;
1300 else if (prot & BFD_MACH_O_PROT_READ)
1301 flags |= SEC_READONLY;
1302 }
1303 }
1304 if (section->nreloc != 0)
1305 flags |= SEC_RELOC;
1306
1307 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, flags);
1308 if (bfdsec == NULL)
1309 return NULL;
1310
1311 bfdsec->vma = section->addr;
1312 bfdsec->lma = section->addr;
1313 bfdsec->size = section->size;
1314 bfdsec->filepos = section->offset;
1315 bfdsec->alignment_power = section->align;
1316 bfdsec->segment_mark = 0;
1317 bfdsec->reloc_count = section->nreloc;
1318 bfdsec->rel_filepos = section->reloff;
1319
1320 return bfdsec;
1321 }
1322
1323 static int
1324 bfd_mach_o_scan_read_section_32 (bfd *abfd,
1325 bfd_mach_o_section *section,
1326 unsigned int offset,
1327 unsigned long prot)
1328 {
1329 unsigned char buf[BFD_MACH_O_SECTION_SIZE];
1330
1331 if (bfd_seek (abfd, offset, SEEK_SET) != 0
1332 || (bfd_bread ((PTR) buf, BFD_MACH_O_SECTION_SIZE, abfd)
1333 != BFD_MACH_O_SECTION_SIZE))
1334 return -1;
1335
1336 memcpy (section->sectname, buf, 16);
1337 section->sectname[16] = '\0';
1338 memcpy (section->segname, buf + 16, 16);
1339 section->segname[16] = '\0';
1340 section->addr = bfd_h_get_32 (abfd, buf + 32);
1341 section->size = bfd_h_get_32 (abfd, buf + 36);
1342 section->offset = bfd_h_get_32 (abfd, buf + 40);
1343 section->align = bfd_h_get_32 (abfd, buf + 44);
1344 section->reloff = bfd_h_get_32 (abfd, buf + 48);
1345 section->nreloc = bfd_h_get_32 (abfd, buf + 52);
1346 section->flags = bfd_h_get_32 (abfd, buf + 56);
1347 section->reserved1 = bfd_h_get_32 (abfd, buf + 60);
1348 section->reserved2 = bfd_h_get_32 (abfd, buf + 64);
1349 section->reserved3 = 0;
1350 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot);
1351
1352 if (section->bfdsection == NULL)
1353 return -1;
1354
1355 return 0;
1356 }
1357
1358 static int
1359 bfd_mach_o_scan_read_section_64 (bfd *abfd,
1360 bfd_mach_o_section *section,
1361 unsigned int offset,
1362 unsigned long prot)
1363 {
1364 unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
1365
1366 if (bfd_seek (abfd, offset, SEEK_SET) != 0
1367 || (bfd_bread ((PTR) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
1368 != BFD_MACH_O_SECTION_64_SIZE))
1369 return -1;
1370
1371 memcpy (section->sectname, buf, 16);
1372 section->sectname[16] = '\0';
1373 memcpy (section->segname, buf + 16, 16);
1374 section->segname[16] = '\0';
1375 section->addr = bfd_h_get_64 (abfd, buf + 32);
1376 section->size = bfd_h_get_64 (abfd, buf + 40);
1377 section->offset = bfd_h_get_32 (abfd, buf + 48);
1378 section->align = bfd_h_get_32 (abfd, buf + 52);
1379 section->reloff = bfd_h_get_32 (abfd, buf + 56);
1380 section->nreloc = bfd_h_get_32 (abfd, buf + 60);
1381 section->flags = bfd_h_get_32 (abfd, buf + 64);
1382 section->reserved1 = bfd_h_get_32 (abfd, buf + 68);
1383 section->reserved2 = bfd_h_get_32 (abfd, buf + 72);
1384 section->reserved3 = bfd_h_get_32 (abfd, buf + 76);
1385 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot);
1386
1387 if (section->bfdsection == NULL)
1388 return -1;
1389
1390 return 0;
1391 }
1392
1393 static int
1394 bfd_mach_o_scan_read_section (bfd *abfd,
1395 bfd_mach_o_section *section,
1396 unsigned int offset,
1397 unsigned long prot,
1398 unsigned int wide)
1399 {
1400 if (wide)
1401 return bfd_mach_o_scan_read_section_64 (abfd, section, offset, prot);
1402 else
1403 return bfd_mach_o_scan_read_section_32 (abfd, section, offset, prot);
1404 }
1405
1406 int
1407 bfd_mach_o_scan_read_symtab_symbol (bfd *abfd,
1408 bfd_mach_o_symtab_command *sym,
1409 bfd_mach_o_asymbol *s,
1410 unsigned long i)
1411 {
1412 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1413 unsigned int wide = mach_o_wide_p (&mdata->header);
1414 unsigned int symwidth = wide ? 16 : 12;
1415 unsigned int symoff = sym->symoff + (i * symwidth);
1416 unsigned char buf[16];
1417 unsigned char type = -1;
1418 unsigned char section = -1;
1419 short desc = -1;
1420 symvalue value = -1;
1421 unsigned long stroff = -1;
1422 unsigned int symtype = -1;
1423
1424 BFD_ASSERT (sym->strtab != NULL);
1425
1426 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
1427 || bfd_bread ((PTR) buf, symwidth, abfd) != symwidth)
1428 {
1429 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n",
1430 symwidth, (unsigned long) symoff);
1431 return -1;
1432 }
1433
1434 stroff = bfd_h_get_32 (abfd, buf);
1435 type = bfd_h_get_8 (abfd, buf + 4);
1436 symtype = type & BFD_MACH_O_N_TYPE;
1437 section = bfd_h_get_8 (abfd, buf + 5);
1438 desc = bfd_h_get_16 (abfd, buf + 6);
1439 if (wide)
1440 value = bfd_h_get_64 (abfd, buf + 8);
1441 else
1442 value = bfd_h_get_32 (abfd, buf + 8);
1443
1444 if (stroff >= sym->strsize)
1445 {
1446 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
1447 (unsigned long) stroff, (unsigned long) sym->strsize);
1448 return -1;
1449 }
1450
1451 s->symbol.the_bfd = abfd;
1452 s->symbol.name = sym->strtab + stroff;
1453 s->symbol.value = value;
1454 s->symbol.flags = 0x0;
1455 s->symbol.udata.i = 0;
1456 s->n_type = type;
1457 s->n_sect = section;
1458 s->n_desc = desc;
1459
1460 if (type & BFD_MACH_O_N_STAB)
1461 {
1462 s->symbol.flags |= BSF_DEBUGGING;
1463 s->symbol.section = bfd_und_section_ptr;
1464 switch (type)
1465 {
1466 case N_FUN:
1467 case N_STSYM:
1468 case N_LCSYM:
1469 case N_BNSYM:
1470 case N_SLINE:
1471 case N_ENSYM:
1472 case N_ECOMM:
1473 case N_ECOML:
1474 case N_GSYM:
1475 if ((section > 0) && (section <= mdata->nsects))
1476 {
1477 s->symbol.section = mdata->sections[section - 1]->bfdsection;
1478 s->symbol.value =
1479 s->symbol.value - mdata->sections[section - 1]->addr;
1480 }
1481 break;
1482 }
1483 }
1484 else
1485 {
1486 if (type & BFD_MACH_O_N_PEXT)
1487 s->symbol.flags |= BSF_GLOBAL;
1488
1489 if (type & BFD_MACH_O_N_EXT)
1490 s->symbol.flags |= BSF_GLOBAL;
1491
1492 if (!(type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
1493 s->symbol.flags |= BSF_LOCAL;
1494
1495 switch (symtype)
1496 {
1497 case BFD_MACH_O_N_UNDF:
1498 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
1499 && s->symbol.value != 0)
1500 {
1501 /* A common symbol. */
1502 s->symbol.section = bfd_com_section_ptr;
1503 s->symbol.flags = BSF_NO_FLAGS;
1504 }
1505 else
1506 {
1507 s->symbol.section = bfd_und_section_ptr;
1508 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
1509 s->symbol.flags |= BSF_WEAK;
1510 }
1511 break;
1512 case BFD_MACH_O_N_PBUD:
1513 s->symbol.section = bfd_und_section_ptr;
1514 break;
1515 case BFD_MACH_O_N_ABS:
1516 s->symbol.section = bfd_abs_section_ptr;
1517 break;
1518 case BFD_MACH_O_N_SECT:
1519 if ((section > 0) && (section <= mdata->nsects))
1520 {
1521 s->symbol.section = mdata->sections[section - 1]->bfdsection;
1522 s->symbol.value =
1523 s->symbol.value - mdata->sections[section - 1]->addr;
1524 }
1525 else
1526 {
1527 /* Mach-O uses 0 to mean "no section"; not an error. */
1528 if (section != 0)
1529 {
1530 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
1531 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
1532 s->symbol.name, section, mdata->nsects);
1533 }
1534 s->symbol.section = bfd_und_section_ptr;
1535 }
1536 break;
1537 case BFD_MACH_O_N_INDR:
1538 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
1539 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
1540 s->symbol.name);
1541 s->symbol.section = bfd_und_section_ptr;
1542 break;
1543 default:
1544 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
1545 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
1546 s->symbol.name, symtype);
1547 s->symbol.section = bfd_und_section_ptr;
1548 break;
1549 }
1550 }
1551
1552 return 0;
1553 }
1554
1555 int
1556 bfd_mach_o_scan_read_symtab_strtab (bfd *abfd,
1557 bfd_mach_o_symtab_command *sym)
1558 {
1559 BFD_ASSERT (sym->strtab == NULL);
1560
1561 if (abfd->flags & BFD_IN_MEMORY)
1562 {
1563 struct bfd_in_memory *b;
1564
1565 b = (struct bfd_in_memory *) abfd->iostream;
1566
1567 if ((sym->stroff + sym->strsize) > b->size)
1568 {
1569 bfd_set_error (bfd_error_file_truncated);
1570 return -1;
1571 }
1572 sym->strtab = (char *) b->buffer + sym->stroff;
1573 return 0;
1574 }
1575
1576 sym->strtab = bfd_alloc (abfd, sym->strsize);
1577 if (sym->strtab == NULL)
1578 return -1;
1579
1580 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
1581 || bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize)
1582 {
1583 bfd_set_error (bfd_error_file_truncated);
1584 return -1;
1585 }
1586
1587 return 0;
1588 }
1589
1590 int
1591 bfd_mach_o_scan_read_symtab_symbols (bfd *abfd,
1592 bfd_mach_o_symtab_command *sym)
1593 {
1594 unsigned long i;
1595 int ret;
1596
1597 BFD_ASSERT (sym->symbols == NULL);
1598 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
1599
1600 if (sym->symbols == NULL)
1601 {
1602 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n");
1603 return -1;
1604 }
1605
1606 ret = bfd_mach_o_scan_read_symtab_strtab (abfd, sym);
1607 if (ret != 0)
1608 return ret;
1609
1610 for (i = 0; i < sym->nsyms; i++)
1611 {
1612 ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
1613 if (ret != 0)
1614 return ret;
1615 }
1616
1617 return 0;
1618 }
1619
1620 int
1621 bfd_mach_o_scan_read_dysymtab_symbol (bfd *abfd,
1622 bfd_mach_o_dysymtab_command *dysym,
1623 bfd_mach_o_symtab_command *sym,
1624 bfd_mach_o_asymbol *s,
1625 unsigned long i)
1626 {
1627 unsigned long isymoff = dysym->indirectsymoff + (i * 4);
1628 unsigned long symindex;
1629 unsigned char buf[4];
1630
1631 BFD_ASSERT (i < dysym->nindirectsyms);
1632
1633 if (bfd_seek (abfd, isymoff, SEEK_SET) != 0
1634 || bfd_bread ((PTR) buf, 4, abfd) != 4)
1635 {
1636 fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
1637 (unsigned long) 4, isymoff);
1638 return -1;
1639 }
1640 symindex = bfd_h_get_32 (abfd, buf);
1641
1642 return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex);
1643 }
1644
1645 static const char *
1646 bfd_mach_o_i386_flavour_string (unsigned int flavour)
1647 {
1648 switch ((int) flavour)
1649 {
1650 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
1651 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
1652 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
1653 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
1654 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
1655 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
1656 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
1657 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
1658 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
1659 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
1660 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
1661 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
1662 case BFD_MACH_O_THREAD_STATE_NONE: return "THREAD_STATE_NONE";
1663 default: return "UNKNOWN";
1664 }
1665 }
1666
1667 static const char *
1668 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
1669 {
1670 switch ((int) flavour)
1671 {
1672 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
1673 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
1674 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
1675 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
1676 default: return "UNKNOWN";
1677 }
1678 }
1679
1680 static int
1681 bfd_mach_o_scan_read_dylinker (bfd *abfd,
1682 bfd_mach_o_load_command *command)
1683 {
1684 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1685 unsigned char buf[4];
1686 unsigned int nameoff;
1687 asection *bfdsec;
1688 char *sname;
1689 const char *prefix;
1690
1691 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
1692 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
1693
1694 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1695 || bfd_bread ((PTR) buf, 4, abfd) != 4)
1696 return -1;
1697
1698 nameoff = bfd_h_get_32 (abfd, buf + 0);
1699
1700 cmd->name_offset = command->offset + nameoff;
1701 cmd->name_len = command->len - nameoff;
1702
1703 if (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)
1704 prefix = "LC_LOAD_DYLINKER";
1705 else if (command->type == BFD_MACH_O_LC_ID_DYLINKER)
1706 prefix = "LC_ID_DYLINKER";
1707 else
1708 abort ();
1709
1710 sname = bfd_alloc (abfd, strlen (prefix) + 1);
1711 if (sname == NULL)
1712 return -1;
1713 strcpy (sname, prefix);
1714
1715 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1716 if (bfdsec == NULL)
1717 return -1;
1718
1719 bfdsec->vma = 0;
1720 bfdsec->lma = 0;
1721 bfdsec->size = command->len - nameoff;
1722 bfdsec->filepos = command->offset + nameoff;
1723 bfdsec->alignment_power = 0;
1724
1725 cmd->section = bfdsec;
1726
1727 return 0;
1728 }
1729
1730 static int
1731 bfd_mach_o_scan_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
1732 {
1733 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1734 unsigned char buf[16];
1735 unsigned int nameoff;
1736 asection *bfdsec;
1737 char *sname;
1738 const char *prefix;
1739
1740 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLIB)
1741 || (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1742 || (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB));
1743
1744 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1745 || bfd_bread ((PTR) buf, 16, abfd) != 16)
1746 return -1;
1747
1748 nameoff = bfd_h_get_32 (abfd, buf + 0);
1749 cmd->timestamp = bfd_h_get_32 (abfd, buf + 4);
1750 cmd->current_version = bfd_h_get_32 (abfd, buf + 8);
1751 cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12);
1752
1753 cmd->name_offset = command->offset + nameoff;
1754 cmd->name_len = command->len - nameoff;
1755
1756 if (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1757 prefix = "LC_LOAD_DYLIB";
1758 else if (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB)
1759 prefix = "LC_LOAD_WEAK_DYLIB";
1760 else if (command->type == BFD_MACH_O_LC_ID_DYLIB)
1761 prefix = "LC_ID_DYLIB";
1762 else
1763 abort ();
1764
1765 sname = bfd_alloc (abfd, strlen (prefix) + 1);
1766 if (sname == NULL)
1767 return -1;
1768 strcpy (sname, prefix);
1769
1770 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1771 if (bfdsec == NULL)
1772 return -1;
1773
1774 bfdsec->vma = 0;
1775 bfdsec->lma = 0;
1776 bfdsec->size = command->len - 8;
1777 bfdsec->filepos = command->offset + 8;
1778 bfdsec->alignment_power = 0;
1779
1780 cmd->section = bfdsec;
1781
1782 return 0;
1783 }
1784
1785 static int
1786 bfd_mach_o_scan_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
1787 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
1788 {
1789 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
1790
1791 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
1792 return 0;
1793 }
1794
1795 static int
1796 bfd_mach_o_scan_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
1797 {
1798 bfd_mach_o_data_struct *mdata = NULL;
1799 bfd_mach_o_thread_command *cmd = &command->command.thread;
1800 unsigned char buf[8];
1801 unsigned int offset;
1802 unsigned int nflavours;
1803 unsigned int i;
1804
1805 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1806 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1807
1808 BFD_ASSERT (bfd_mach_o_valid (abfd));
1809 mdata = abfd->tdata.mach_o_data;
1810
1811 offset = 8;
1812 nflavours = 0;
1813 while (offset != command->len)
1814 {
1815 if (offset >= command->len)
1816 return -1;
1817
1818 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
1819 || bfd_bread ((PTR) buf, 8, abfd) != 8)
1820 return -1;
1821
1822 offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
1823 nflavours++;
1824 }
1825
1826 cmd->flavours = bfd_alloc (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
1827 if (cmd->flavours == NULL)
1828 return -1;
1829 cmd->nflavours = nflavours;
1830
1831 offset = 8;
1832 nflavours = 0;
1833 while (offset != command->len)
1834 {
1835 if (offset >= command->len)
1836 return -1;
1837
1838 if (nflavours >= cmd->nflavours)
1839 return -1;
1840
1841 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
1842 || bfd_bread ((PTR) buf, 8, abfd) != 8)
1843 return -1;
1844
1845 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
1846 cmd->flavours[nflavours].offset = command->offset + offset + 8;
1847 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4;
1848 offset += cmd->flavours[nflavours].size + 8;
1849 nflavours++;
1850 }
1851
1852 for (i = 0; i < nflavours; i++)
1853 {
1854 asection *bfdsec;
1855 unsigned int snamelen;
1856 char *sname;
1857 const char *flavourstr;
1858 const char *prefix = "LC_THREAD";
1859 unsigned int j = 0;
1860
1861 switch (mdata->header.cputype)
1862 {
1863 case BFD_MACH_O_CPU_TYPE_POWERPC:
1864 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
1865 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
1866 break;
1867 case BFD_MACH_O_CPU_TYPE_I386:
1868 case BFD_MACH_O_CPU_TYPE_X86_64:
1869 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
1870 break;
1871 default:
1872 flavourstr = "UNKNOWN_ARCHITECTURE";
1873 break;
1874 }
1875
1876 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
1877 sname = bfd_alloc (abfd, snamelen);
1878 if (sname == NULL)
1879 return -1;
1880
1881 for (;;)
1882 {
1883 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
1884 if (bfd_get_section_by_name (abfd, sname) == NULL)
1885 break;
1886 j++;
1887 }
1888
1889 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1890
1891 bfdsec->vma = 0;
1892 bfdsec->lma = 0;
1893 bfdsec->size = cmd->flavours[i].size;
1894 bfdsec->filepos = cmd->flavours[i].offset;
1895 bfdsec->alignment_power = 0x0;
1896
1897 cmd->section = bfdsec;
1898 }
1899
1900 return 0;
1901 }
1902
1903 static int
1904 bfd_mach_o_scan_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1905 {
1906 bfd_mach_o_dysymtab_command *seg = &command->command.dysymtab;
1907 unsigned char buf[72];
1908
1909 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1910
1911 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1912 || bfd_bread ((PTR) buf, 72, abfd) != 72)
1913 return -1;
1914
1915 seg->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
1916 seg->nlocalsym = bfd_h_get_32 (abfd, buf + 4);
1917 seg->iextdefsym = bfd_h_get_32 (abfd, buf + 8);
1918 seg->nextdefsym = bfd_h_get_32 (abfd, buf + 12);
1919 seg->iundefsym = bfd_h_get_32 (abfd, buf + 16);
1920 seg->nundefsym = bfd_h_get_32 (abfd, buf + 20);
1921 seg->tocoff = bfd_h_get_32 (abfd, buf + 24);
1922 seg->ntoc = bfd_h_get_32 (abfd, buf + 28);
1923 seg->modtaboff = bfd_h_get_32 (abfd, buf + 32);
1924 seg->nmodtab = bfd_h_get_32 (abfd, buf + 36);
1925 seg->extrefsymoff = bfd_h_get_32 (abfd, buf + 40);
1926 seg->nextrefsyms = bfd_h_get_32 (abfd, buf + 44);
1927 seg->indirectsymoff = bfd_h_get_32 (abfd, buf + 48);
1928 seg->nindirectsyms = bfd_h_get_32 (abfd, buf + 52);
1929 seg->extreloff = bfd_h_get_32 (abfd, buf + 56);
1930 seg->nextrel = bfd_h_get_32 (abfd, buf + 60);
1931 seg->locreloff = bfd_h_get_32 (abfd, buf + 64);
1932 seg->nlocrel = bfd_h_get_32 (abfd, buf + 68);
1933
1934 return 0;
1935 }
1936
1937 static int
1938 bfd_mach_o_scan_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1939 {
1940 bfd_mach_o_symtab_command *seg = &command->command.symtab;
1941 unsigned char buf[16];
1942
1943 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1944
1945 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1946 || bfd_bread ((PTR) buf, 16, abfd) != 16)
1947 return -1;
1948
1949 seg->symoff = bfd_h_get_32 (abfd, buf);
1950 seg->nsyms = bfd_h_get_32 (abfd, buf + 4);
1951 seg->stroff = bfd_h_get_32 (abfd, buf + 8);
1952 seg->strsize = bfd_h_get_32 (abfd, buf + 12);
1953 seg->symbols = NULL;
1954 seg->strtab = NULL;
1955
1956 if (seg->nsyms != 0)
1957 abfd->flags |= HAS_SYMS;
1958
1959 return 0;
1960 }
1961
1962 static int
1963 bfd_mach_o_scan_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
1964 {
1965 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
1966 asection *bfdsec;
1967 char *sname;
1968 static const char prefix[] = "LC_UUID";
1969
1970 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
1971
1972 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1973 || bfd_bread ((PTR) cmd->uuid, 16, abfd) != 16)
1974 return -1;
1975
1976 sname = bfd_alloc (abfd, strlen (prefix) + 1);
1977 if (sname == NULL)
1978 return -1;
1979 strcpy (sname, prefix);
1980
1981 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, SEC_HAS_CONTENTS);
1982 if (bfdsec == NULL)
1983 return -1;
1984
1985 bfdsec->vma = 0;
1986 bfdsec->lma = 0;
1987 bfdsec->size = command->len - 8;
1988 bfdsec->filepos = command->offset + 8;
1989 bfdsec->alignment_power = 0;
1990
1991 cmd->section = bfdsec;
1992
1993 return 0;
1994 }
1995
1996 static int
1997 bfd_mach_o_scan_read_segment (bfd *abfd,
1998 bfd_mach_o_load_command *command,
1999 unsigned int wide)
2000 {
2001 unsigned char buf[64];
2002 bfd_mach_o_segment_command *seg = &command->command.segment;
2003 unsigned long i;
2004
2005 if (wide)
2006 {
2007 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
2008
2009 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2010 || bfd_bread ((PTR) buf, 64, abfd) != 64)
2011 return -1;
2012
2013 memcpy (seg->segname, buf, 16);
2014 seg->segname[16] = '\0';
2015
2016 seg->vmaddr = bfd_h_get_64 (abfd, buf + 16);
2017 seg->vmsize = bfd_h_get_64 (abfd, buf + 24);
2018 seg->fileoff = bfd_h_get_64 (abfd, buf + 32);
2019 seg->filesize = bfd_h_get_64 (abfd, buf + 40);
2020 seg->maxprot = bfd_h_get_32 (abfd, buf + 48);
2021 seg->initprot = bfd_h_get_32 (abfd, buf + 52);
2022 seg->nsects = bfd_h_get_32 (abfd, buf + 56);
2023 seg->flags = bfd_h_get_32 (abfd, buf + 60);
2024 }
2025 else
2026 {
2027 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
2028
2029 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2030 || bfd_bread ((PTR) buf, 48, abfd) != 48)
2031 return -1;
2032
2033 memcpy (seg->segname, buf, 16);
2034 seg->segname[16] = '\0';
2035
2036 seg->vmaddr = bfd_h_get_32 (abfd, buf + 16);
2037 seg->vmsize = bfd_h_get_32 (abfd, buf + 20);
2038 seg->fileoff = bfd_h_get_32 (abfd, buf + 24);
2039 seg->filesize = bfd_h_get_32 (abfd, buf + 28);
2040 seg->maxprot = bfd_h_get_32 (abfd, buf + 32);
2041 seg->initprot = bfd_h_get_32 (abfd, buf + 36);
2042 seg->nsects = bfd_h_get_32 (abfd, buf + 40);
2043 seg->flags = bfd_h_get_32 (abfd, buf + 44);
2044 }
2045
2046 if (seg->nsects != 0)
2047 {
2048 seg->sections = bfd_alloc (abfd, seg->nsects
2049 * sizeof (bfd_mach_o_section));
2050 if (seg->sections == NULL)
2051 return -1;
2052
2053 for (i = 0; i < seg->nsects; i++)
2054 {
2055 bfd_vma segoff;
2056 if (wide)
2057 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
2058 + (i * BFD_MACH_O_SECTION_64_SIZE);
2059 else
2060 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
2061 + (i * BFD_MACH_O_SECTION_SIZE);
2062
2063 if (bfd_mach_o_scan_read_section
2064 (abfd, &seg->sections[i], segoff, seg->initprot, wide) != 0)
2065 return -1;
2066 }
2067 }
2068
2069 return 0;
2070 }
2071
2072 static int
2073 bfd_mach_o_scan_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
2074 {
2075 return bfd_mach_o_scan_read_segment (abfd, command, 0);
2076 }
2077
2078 static int
2079 bfd_mach_o_scan_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
2080 {
2081 return bfd_mach_o_scan_read_segment (abfd, command, 1);
2082 }
2083
2084 static int
2085 bfd_mach_o_scan_read_command (bfd *abfd, bfd_mach_o_load_command *command)
2086 {
2087 unsigned char buf[8];
2088
2089 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
2090 || bfd_bread ((PTR) buf, 8, abfd) != 8)
2091 return -1;
2092
2093 command->type = bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD;
2094 command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD
2095 ? TRUE : FALSE);
2096 command->len = bfd_h_get_32 (abfd, buf + 4);
2097
2098 switch (command->type)
2099 {
2100 case BFD_MACH_O_LC_SEGMENT:
2101 if (bfd_mach_o_scan_read_segment_32 (abfd, command) != 0)
2102 return -1;
2103 break;
2104 case BFD_MACH_O_LC_SEGMENT_64:
2105 if (bfd_mach_o_scan_read_segment_64 (abfd, command) != 0)
2106 return -1;
2107 break;
2108 case BFD_MACH_O_LC_SYMTAB:
2109 if (bfd_mach_o_scan_read_symtab (abfd, command) != 0)
2110 return -1;
2111 break;
2112 case BFD_MACH_O_LC_SYMSEG:
2113 break;
2114 case BFD_MACH_O_LC_THREAD:
2115 case BFD_MACH_O_LC_UNIXTHREAD:
2116 if (bfd_mach_o_scan_read_thread (abfd, command) != 0)
2117 return -1;
2118 break;
2119 case BFD_MACH_O_LC_LOAD_DYLINKER:
2120 case BFD_MACH_O_LC_ID_DYLINKER:
2121 if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0)
2122 return -1;
2123 break;
2124 case BFD_MACH_O_LC_LOAD_DYLIB:
2125 case BFD_MACH_O_LC_ID_DYLIB:
2126 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2127 if (bfd_mach_o_scan_read_dylib (abfd, command) != 0)
2128 return -1;
2129 break;
2130 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2131 if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0)
2132 return -1;
2133 break;
2134 case BFD_MACH_O_LC_LOADFVMLIB:
2135 case BFD_MACH_O_LC_IDFVMLIB:
2136 case BFD_MACH_O_LC_IDENT:
2137 case BFD_MACH_O_LC_FVMFILE:
2138 case BFD_MACH_O_LC_PREPAGE:
2139 case BFD_MACH_O_LC_ROUTINES:
2140 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2141 break;
2142 case BFD_MACH_O_LC_DYSYMTAB:
2143 if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0)
2144 return -1;
2145 break;
2146 case BFD_MACH_O_LC_SUB_UMBRELLA:
2147 case BFD_MACH_O_LC_SUB_CLIENT:
2148 case BFD_MACH_O_LC_SUB_LIBRARY:
2149 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
2150 case BFD_MACH_O_LC_PREBIND_CKSUM:
2151 break;
2152 case BFD_MACH_O_LC_UUID:
2153 if (bfd_mach_o_scan_read_uuid (abfd, command) != 0)
2154 return -1;
2155 break;
2156 case BFD_MACH_O_LC_CODE_SIGNATURE:
2157 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
2158 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2159 break;
2160 default:
2161 fprintf (stderr, "unable to read unknown load command 0x%lx\n",
2162 (unsigned long) command->type);
2163 break;
2164 }
2165
2166 return 0;
2167 }
2168
2169 static void
2170 bfd_mach_o_flatten_sections (bfd *abfd)
2171 {
2172 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
2173 long csect = 0;
2174 unsigned long i, j;
2175
2176 /* Count total number of sections. */
2177 mdata->nsects = 0;
2178
2179 for (i = 0; i < mdata->header.ncmds; i++)
2180 {
2181 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
2182 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
2183 {
2184 bfd_mach_o_segment_command *seg;
2185
2186 seg = &mdata->commands[i].command.segment;
2187 mdata->nsects += seg->nsects;
2188 }
2189 }
2190
2191 /* Allocate sections array. */
2192 mdata->sections = bfd_alloc (abfd,
2193 mdata->nsects * sizeof (bfd_mach_o_section *));
2194
2195 /* Fill the array. */
2196 csect = 0;
2197
2198 for (i = 0; i < mdata->header.ncmds; i++)
2199 {
2200 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
2201 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
2202 {
2203 bfd_mach_o_segment_command *seg;
2204
2205 seg = &mdata->commands[i].command.segment;
2206 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
2207
2208 for (j = 0; j < seg->nsects; j++)
2209 mdata->sections[csect++] = &seg->sections[j];
2210 }
2211 }
2212 }
2213
2214 int
2215 bfd_mach_o_scan_start_address (bfd *abfd)
2216 {
2217 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
2218 bfd_mach_o_thread_command *cmd = NULL;
2219 unsigned long i;
2220
2221 for (i = 0; i < mdata->header.ncmds; i++)
2222 {
2223 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
2224 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
2225 {
2226 if (cmd == NULL)
2227 cmd = &mdata->commands[i].command.thread;
2228 else
2229 return 0;
2230 }
2231 }
2232
2233 if (cmd == NULL)
2234 return 0;
2235
2236 for (i = 0; i < cmd->nflavours; i++)
2237 {
2238 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
2239 && (cmd->flavours[i].flavour
2240 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
2241 {
2242 unsigned char buf[4];
2243
2244 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
2245 || bfd_bread (buf, 4, abfd) != 4)
2246 return -1;
2247
2248 abfd->start_address = bfd_h_get_32 (abfd, buf);
2249 }
2250 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
2251 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
2252 {
2253 unsigned char buf[4];
2254
2255 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
2256 || bfd_bread (buf, 4, abfd) != 4)
2257 return -1;
2258
2259 abfd->start_address = bfd_h_get_32 (abfd, buf);
2260 }
2261 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
2262 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE_64))
2263 {
2264 unsigned char buf[8];
2265
2266 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
2267 || bfd_bread (buf, 8, abfd) != 8)
2268 return -1;
2269
2270 abfd->start_address = bfd_h_get_64 (abfd, buf);
2271 }
2272 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
2273 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
2274 {
2275 unsigned char buf[8];
2276
2277 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
2278 || bfd_bread (buf, 8, abfd) != 8)
2279 return -1;
2280
2281 abfd->start_address = bfd_h_get_64 (abfd, buf);
2282 }
2283 }
2284
2285 return 0;
2286 }
2287
2288 int
2289 bfd_mach_o_scan (bfd *abfd,
2290 bfd_mach_o_header *header,
2291 bfd_mach_o_data_struct *mdata)
2292 {
2293 unsigned int i;
2294 enum bfd_architecture cputype;
2295 unsigned long cpusubtype;
2296 unsigned int hdrsize;
2297
2298 hdrsize = mach_o_wide_p (header) ?
2299 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2300
2301 mdata->header = *header;
2302
2303 abfd->flags = abfd->flags & BFD_IN_MEMORY;
2304 switch (header->filetype)
2305 {
2306 case BFD_MACH_O_MH_OBJECT:
2307 abfd->flags |= HAS_RELOC;
2308 break;
2309 case BFD_MACH_O_MH_EXECUTE:
2310 abfd->flags |= EXEC_P;
2311 break;
2312 case BFD_MACH_O_MH_DYLIB:
2313 case BFD_MACH_O_MH_BUNDLE:
2314 abfd->flags |= DYNAMIC;
2315 break;
2316 }
2317
2318 abfd->tdata.mach_o_data = mdata;
2319
2320 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
2321 &cputype, &cpusubtype);
2322 if (cputype == bfd_arch_unknown)
2323 {
2324 fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
2325 header->cputype, header->cpusubtype);
2326 return -1;
2327 }
2328
2329 bfd_set_arch_mach (abfd, cputype, cpusubtype);
2330
2331 if (header->ncmds != 0)
2332 {
2333 mdata->commands = bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
2334 if (mdata->commands == NULL)
2335 return -1;
2336
2337 for (i = 0; i < header->ncmds; i++)
2338 {
2339 bfd_mach_o_load_command *cur = &mdata->commands[i];
2340
2341 if (i == 0)
2342 cur->offset = hdrsize;
2343 else
2344 {
2345 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
2346 cur->offset = prev->offset + prev->len;
2347 }
2348
2349 if (bfd_mach_o_scan_read_command (abfd, cur) < 0)
2350 return -1;
2351 }
2352 }
2353
2354 if (bfd_mach_o_scan_start_address (abfd) < 0)
2355 return -1;
2356
2357 bfd_mach_o_flatten_sections (abfd);
2358 return 0;
2359 }
2360
2361 bfd_boolean
2362 bfd_mach_o_mkobject_init (bfd *abfd)
2363 {
2364 bfd_mach_o_data_struct *mdata = NULL;
2365
2366 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
2367 if (mdata == NULL)
2368 return FALSE;
2369 abfd->tdata.mach_o_data = mdata;
2370
2371 mdata->header.magic = 0;
2372 mdata->header.cputype = 0;
2373 mdata->header.cpusubtype = 0;
2374 mdata->header.filetype = 0;
2375 mdata->header.ncmds = 0;
2376 mdata->header.sizeofcmds = 0;
2377 mdata->header.flags = 0;
2378 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
2379 mdata->commands = NULL;
2380 mdata->nsects = 0;
2381 mdata->sections = NULL;
2382
2383 return TRUE;
2384 }
2385
2386 const bfd_target *
2387 bfd_mach_o_header_p (bfd *abfd,
2388 bfd_mach_o_filetype filetype,
2389 bfd_mach_o_cpu_type cputype)
2390 {
2391 struct bfd_preserve preserve;
2392 bfd_mach_o_header header;
2393
2394 preserve.marker = NULL;
2395 if (!bfd_mach_o_read_header (abfd, &header))
2396 goto wrong;
2397
2398 if (! (header.byteorder == BFD_ENDIAN_BIG
2399 || header.byteorder == BFD_ENDIAN_LITTLE))
2400 {
2401 fprintf (stderr, "unknown header byte-order value 0x%lx\n",
2402 (unsigned long) header.byteorder);
2403 goto wrong;
2404 }
2405
2406 if (! ((header.byteorder == BFD_ENDIAN_BIG
2407 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
2408 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
2409 || (header.byteorder == BFD_ENDIAN_LITTLE
2410 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
2411 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
2412 goto wrong;
2413
2414 /* Check cputype and filetype.
2415 In case of wildcard, do not accept magics that are handled by existing
2416 targets. */
2417 if (cputype)
2418 {
2419 if (header.cputype != cputype)
2420 goto wrong;
2421 }
2422 else
2423 {
2424 switch (header.cputype)
2425 {
2426 case BFD_MACH_O_CPU_TYPE_I386:
2427 /* Handled by mach-o-i386 */
2428 goto wrong;
2429 default:
2430 break;
2431 }
2432 }
2433 if (filetype)
2434 {
2435 if (header.filetype != filetype)
2436 goto wrong;
2437 }
2438 else
2439 {
2440 switch (header.filetype)
2441 {
2442 case BFD_MACH_O_MH_CORE:
2443 /* Handled by core_p */
2444 goto wrong;
2445 default:
2446 break;
2447 }
2448 }
2449
2450 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
2451 if (preserve.marker == NULL
2452 || !bfd_preserve_save (abfd, &preserve))
2453 goto fail;
2454
2455 if (bfd_mach_o_scan (abfd, &header,
2456 (bfd_mach_o_data_struct *) preserve.marker) != 0)
2457 goto wrong;
2458
2459 bfd_preserve_finish (abfd, &preserve);
2460 return abfd->xvec;
2461
2462 wrong:
2463 bfd_set_error (bfd_error_wrong_format);
2464
2465 fail:
2466 if (preserve.marker != NULL)
2467 bfd_preserve_restore (abfd, &preserve);
2468 return NULL;
2469 }
2470
2471 static const bfd_target *
2472 bfd_mach_o_gen_object_p (bfd *abfd)
2473 {
2474 return bfd_mach_o_header_p (abfd, 0, 0);
2475 }
2476
2477 static const bfd_target *
2478 bfd_mach_o_gen_core_p (bfd *abfd)
2479 {
2480 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
2481 }
2482
2483 typedef struct mach_o_fat_archentry
2484 {
2485 unsigned long cputype;
2486 unsigned long cpusubtype;
2487 unsigned long offset;
2488 unsigned long size;
2489 unsigned long align;
2490 } mach_o_fat_archentry;
2491
2492 typedef struct mach_o_fat_data_struct
2493 {
2494 unsigned long magic;
2495 unsigned long nfat_arch;
2496 mach_o_fat_archentry *archentries;
2497 } mach_o_fat_data_struct;
2498
2499 const bfd_target *
2500 bfd_mach_o_archive_p (bfd *abfd)
2501 {
2502 mach_o_fat_data_struct *adata = NULL;
2503 unsigned char buf[20];
2504 unsigned long i;
2505
2506 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2507 || bfd_bread ((PTR) buf, 8, abfd) != 8)
2508 goto error;
2509
2510 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
2511 if (adata == NULL)
2512 goto error;
2513
2514 adata->magic = bfd_getb32 (buf);
2515 adata->nfat_arch = bfd_getb32 (buf + 4);
2516 if (adata->magic != 0xcafebabe)
2517 goto error;
2518 /* Avoid matching Java bytecode files, which have the same magic number.
2519 In the Java bytecode file format this field contains the JVM version,
2520 which starts at 43.0. */
2521 if (adata->nfat_arch > 30)
2522 goto error;
2523
2524 adata->archentries =
2525 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
2526 if (adata->archentries == NULL)
2527 goto error;
2528
2529 for (i = 0; i < adata->nfat_arch; i++)
2530 {
2531 if (bfd_seek (abfd, 8 + 20 * i, SEEK_SET) != 0
2532 || bfd_bread ((PTR) buf, 20, abfd) != 20)
2533 goto error;
2534 adata->archentries[i].cputype = bfd_getb32 (buf);
2535 adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
2536 adata->archentries[i].offset = bfd_getb32 (buf + 8);
2537 adata->archentries[i].size = bfd_getb32 (buf + 12);
2538 adata->archentries[i].align = bfd_getb32 (buf + 16);
2539 }
2540
2541 abfd->tdata.mach_o_fat_data = adata;
2542 return abfd->xvec;
2543
2544 error:
2545 if (adata != NULL)
2546 bfd_release (abfd, adata);
2547 bfd_set_error (bfd_error_wrong_format);
2548 return NULL;
2549 }
2550
2551 bfd *
2552 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
2553 {
2554 mach_o_fat_data_struct *adata;
2555 mach_o_fat_archentry *entry = NULL;
2556 unsigned long i;
2557 bfd *nbfd;
2558 enum bfd_architecture arch_type;
2559 unsigned long arch_subtype;
2560
2561 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
2562 BFD_ASSERT (adata != NULL);
2563
2564 /* Find index of previous entry. */
2565 if (prev == NULL)
2566 i = 0; /* Start at first one. */
2567 else
2568 {
2569 for (i = 0; i < adata->nfat_arch; i++)
2570 {
2571 if (adata->archentries[i].offset == prev->origin)
2572 break;
2573 }
2574
2575 if (i == adata->nfat_arch)
2576 {
2577 /* Not found. */
2578 bfd_set_error (bfd_error_bad_value);
2579 return NULL;
2580 }
2581 i++; /* Get next entry. */
2582 }
2583
2584 if (i >= adata->nfat_arch)
2585 {
2586 bfd_set_error (bfd_error_no_more_archived_files);
2587 return NULL;
2588 }
2589
2590 entry = &adata->archentries[i];
2591 nbfd = _bfd_new_bfd_contained_in (archive);
2592 if (nbfd == NULL)
2593 return NULL;
2594
2595 nbfd->origin = entry->offset;
2596
2597 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
2598 &arch_type, &arch_subtype);
2599 /* Create the member filename.
2600 Use FILENAME:ARCH_NAME. */
2601 {
2602 char *s = NULL;
2603 const char *arch_name;
2604 size_t arch_file_len = strlen (bfd_get_filename (archive));
2605
2606 arch_name = bfd_printable_arch_mach (arch_type, arch_subtype);
2607 s = bfd_malloc (arch_file_len + 1 + strlen (arch_name) + 1);
2608 if (s == NULL)
2609 return NULL;
2610 memcpy (s, bfd_get_filename (archive), arch_file_len);
2611 s[arch_file_len] = ':';
2612 strcpy (s + arch_file_len + 1, arch_name);
2613 nbfd->filename = s;
2614 }
2615 nbfd->iostream = NULL;
2616 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
2617
2618 return nbfd;
2619 }
2620
2621 /* If ABFD format is FORMAT and architecture is ARCH, return it.
2622 If ABFD is a fat image containing a member that corresponds to FORMAT
2623 and ARCH, returns it.
2624 In other case, returns NULL.
2625 This function allows transparent uses of fat images. */
2626 bfd *
2627 bfd_mach_o_fat_extract (bfd *abfd,
2628 bfd_format format,
2629 const bfd_arch_info_type *arch)
2630 {
2631 bfd *res;
2632 mach_o_fat_data_struct *adata;
2633 unsigned int i;
2634
2635 if (bfd_check_format (abfd, format))
2636 {
2637 if (bfd_get_arch_info (abfd) == arch)
2638 return abfd;
2639 return NULL;
2640 }
2641 if (!bfd_check_format (abfd, bfd_archive)
2642 || abfd->xvec != &mach_o_fat_vec)
2643 return NULL;
2644
2645 /* This is a Mach-O fat image. */
2646 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
2647 BFD_ASSERT (adata != NULL);
2648
2649 for (i = 0; i < adata->nfat_arch; i++)
2650 {
2651 struct mach_o_fat_archentry *e = &adata->archentries[i];
2652 enum bfd_architecture cpu_type;
2653 unsigned long cpu_subtype;
2654
2655 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
2656 &cpu_type, &cpu_subtype);
2657 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
2658 continue;
2659
2660 /* The architecture is found. */
2661 res = _bfd_new_bfd_contained_in (abfd);
2662 if (res == NULL)
2663 return NULL;
2664
2665 res->origin = e->offset;
2666
2667 res->filename = strdup (abfd->filename);
2668 res->iostream = NULL;
2669
2670 if (bfd_check_format (res, format))
2671 {
2672 BFD_ASSERT (bfd_get_arch_info (res) == arch);
2673 return res;
2674 }
2675 bfd_close (res);
2676 return NULL;
2677 }
2678
2679 return NULL;
2680 }
2681
2682 int
2683 bfd_mach_o_lookup_section (bfd *abfd,
2684 asection *section,
2685 bfd_mach_o_load_command **mcommand,
2686 bfd_mach_o_section **msection)
2687 {
2688 struct mach_o_data_struct *md = abfd->tdata.mach_o_data;
2689 unsigned int i, j, num;
2690
2691 bfd_mach_o_load_command *ncmd = NULL;
2692 bfd_mach_o_section *nsect = NULL;
2693
2694 BFD_ASSERT (mcommand != NULL);
2695 BFD_ASSERT (msection != NULL);
2696
2697 num = 0;
2698 for (i = 0; i < md->header.ncmds; i++)
2699 {
2700 struct bfd_mach_o_load_command *cmd = &md->commands[i];
2701 struct bfd_mach_o_segment_command *seg = NULL;
2702
2703 if (cmd->type != BFD_MACH_O_LC_SEGMENT
2704 || cmd->type != BFD_MACH_O_LC_SEGMENT_64)
2705 continue;
2706 seg = &cmd->command.segment;
2707
2708 if (seg->segment == section)
2709 {
2710 if (num == 0)
2711 ncmd = cmd;
2712 num++;
2713 }
2714
2715 for (j = 0; j < seg->nsects; j++)
2716 {
2717 struct bfd_mach_o_section *sect = &seg->sections[j];
2718
2719 if (sect->bfdsection == section)
2720 {
2721 if (num == 0)
2722 nsect = sect;
2723 num++;
2724 }
2725 }
2726 }
2727
2728 *mcommand = ncmd;
2729 *msection = nsect;
2730 return num;
2731 }
2732
2733 int
2734 bfd_mach_o_lookup_command (bfd *abfd,
2735 bfd_mach_o_load_command_type type,
2736 bfd_mach_o_load_command **mcommand)
2737 {
2738 struct mach_o_data_struct *md = NULL;
2739 bfd_mach_o_load_command *ncmd = NULL;
2740 unsigned int i, num;
2741
2742 md = abfd->tdata.mach_o_data;
2743
2744 BFD_ASSERT (md != NULL);
2745 BFD_ASSERT (mcommand != NULL);
2746
2747 num = 0;
2748 for (i = 0; i < md->header.ncmds; i++)
2749 {
2750 struct bfd_mach_o_load_command *cmd = &md->commands[i];
2751
2752 if (cmd->type != type)
2753 continue;
2754
2755 if (num == 0)
2756 ncmd = cmd;
2757 num++;
2758 }
2759
2760 *mcommand = ncmd;
2761 return num;
2762 }
2763
2764 unsigned long
2765 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
2766 {
2767 switch (type)
2768 {
2769 case BFD_MACH_O_CPU_TYPE_MC680x0:
2770 return 0x04000000;
2771 case BFD_MACH_O_CPU_TYPE_MC88000:
2772 return 0xffffe000;
2773 case BFD_MACH_O_CPU_TYPE_POWERPC:
2774 return 0xc0000000;
2775 case BFD_MACH_O_CPU_TYPE_I386:
2776 return 0xc0000000;
2777 case BFD_MACH_O_CPU_TYPE_SPARC:
2778 return 0xf0000000;
2779 case BFD_MACH_O_CPU_TYPE_I860:
2780 return 0;
2781 case BFD_MACH_O_CPU_TYPE_HPPA:
2782 return 0xc0000000 - 0x04000000;
2783 default:
2784 return 0;
2785 }
2786 }
2787
2788 bfd_boolean
2789 bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, PTR ptr)
2790 {
2791 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
2792 FILE *file = (FILE *) ptr;
2793 unsigned int i, j;
2794 unsigned int sec_nbr = 0;
2795
2796 fprintf (file, _("Segments and Sections:\n"));
2797 fprintf (file, _(" #: Segment name Section name Address\n"));
2798
2799 for (i = 0; i < mdata->header.ncmds; i++)
2800 {
2801 bfd_mach_o_segment_command *seg;
2802
2803 if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT
2804 && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64)
2805 continue;
2806
2807 seg = &mdata->commands[i].command.segment;
2808
2809 fprintf (file, "[Segment %-16s ", seg->segname);
2810 fprintf_vma (file, seg->vmaddr);
2811 fprintf (file, "-");
2812 fprintf_vma (file, seg->vmaddr + seg->vmsize - 1);
2813 fputc (' ', file);
2814 fputc (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-', file);
2815 fputc (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-', file);
2816 fputc (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-', file);
2817 fprintf (file, "]\n");
2818 for (j = 0; j < seg->nsects; j++)
2819 {
2820 bfd_mach_o_section *sec = &seg->sections[j];
2821 fprintf (file, "%02u: %-16s %-16s ", ++sec_nbr,
2822 sec->segname, sec->sectname);
2823 fprintf_vma (file, sec->addr);
2824 fprintf (file, " ");
2825 fprintf_vma (file, sec->size);
2826 fprintf (file, " %08lx\n", sec->flags);
2827 }
2828 }
2829
2830 for (i = 0; i < mdata->header.ncmds; i++)
2831 {
2832 bfd_mach_o_load_command *cmd = &mdata->commands[i];
2833
2834 switch (cmd->type)
2835 {
2836 case BFD_MACH_O_LC_SEGMENT:
2837 case BFD_MACH_O_LC_SEGMENT_64:
2838 break;
2839 case BFD_MACH_O_LC_UUID:
2840 {
2841 bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
2842 unsigned int i;
2843
2844 fprintf (file, "\n"
2845 "UUID:");
2846 for (i = 0; i < sizeof (uuid->uuid); i++)
2847 fprintf (file, " %02x", uuid->uuid[i]);
2848 fputc ('\n', file);
2849 }
2850 break;
2851 case BFD_MACH_O_LC_LOAD_DYLIB:
2852 {
2853 bfd_mach_o_dylib_command *dylib = &cmd->command.dylib;
2854 bfd_byte *data = NULL;
2855
2856 if (! bfd_malloc_and_get_section (abfd, dylib->section, &data))
2857 {
2858 if (data != NULL)
2859 free (data);
2860 break;
2861 }
2862 fprintf (file, "\n"
2863 "LOAD_DYLIB: %s\n",
2864 data + dylib->name_offset - cmd->offset - 8);
2865 fprintf (file, " time stamp: 0x%08lx\n",
2866 dylib->timestamp);
2867 fprintf (file, " current version: 0x%08lx\n",
2868 dylib->current_version);
2869 fprintf (file, " comptibility version: 0x%08lx\n",
2870 dylib->compatibility_version);
2871 free (data);
2872 break;
2873 }
2874 case BFD_MACH_O_LC_LOAD_DYLINKER:
2875 {
2876 bfd_mach_o_dylinker_command *linker = &cmd->command.dylinker;
2877 bfd_byte *data = NULL;
2878
2879 if (! bfd_malloc_and_get_section (abfd, linker->section, &data))
2880 {
2881 if (data != NULL)
2882 free (data);
2883 break;
2884 }
2885 fprintf (file, "\n"
2886 "LOAD_DYLINKER: %s\n",
2887 data + linker->name_offset - cmd->offset - 8);
2888 free (data);
2889 break;
2890 }
2891 case BFD_MACH_O_LC_SYMTAB:
2892 {
2893 bfd_mach_o_symtab_command *symtab = &cmd->command.symtab;
2894 fprintf (file, "\n"
2895 "LC_SYMTAB: nsyms: %u, strsize: %u\n",
2896 symtab->nsyms, symtab->strsize);
2897 break;
2898 }
2899 case BFD_MACH_O_LC_DYSYMTAB:
2900 {
2901 bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
2902 fprintf (file, "\n"
2903 "LC_DYSYMTAB:\n"
2904 " local symbols: index: %lu number: %lu\n",
2905 dysymtab->ilocalsym, dysymtab->nlocalsym);
2906 fprintf (file,
2907 " external symbols: index: %lu number: %lu\n",
2908 dysymtab->iextdefsym, dysymtab->nextdefsym);
2909 fprintf (file,
2910 " undefined symbols: index: %lu number: %lu\n",
2911 dysymtab->iundefsym, dysymtab->nundefsym);
2912 fprintf (file,
2913 " ntoc: offset: %lu number: %lu\n",
2914 dysymtab->tocoff, dysymtab->ntoc);
2915 fprintf (file,
2916 " module table: offset: %lu number: %lu\n",
2917 dysymtab->modtaboff, dysymtab->nmodtab);
2918 break;
2919 }
2920 default:
2921 fprintf (file, "LC_%d\n", cmd->type);
2922 break;
2923 }
2924 }
2925
2926 return TRUE;
2927 }
2928
2929 int
2930 bfd_mach_o_core_fetch_environment (bfd *abfd,
2931 unsigned char **rbuf,
2932 unsigned int *rlen)
2933 {
2934 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
2935 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
2936 unsigned int i = 0;
2937
2938 for (i = 0; i < mdata->header.ncmds; i++)
2939 {
2940 bfd_mach_o_load_command *cur = &mdata->commands[i];
2941 bfd_mach_o_segment_command *seg = NULL;
2942
2943 if (cur->type != BFD_MACH_O_LC_SEGMENT)
2944 continue;
2945
2946 seg = &cur->command.segment;
2947
2948 if ((seg->vmaddr + seg->vmsize) == stackaddr)
2949 {
2950 unsigned long start = seg->fileoff;
2951 unsigned long end = seg->fileoff + seg->filesize;
2952 unsigned char *buf = bfd_malloc (1024);
2953 unsigned long size = 1024;
2954
2955 for (;;)
2956 {
2957 bfd_size_type nread = 0;
2958 unsigned long offset;
2959 int found_nonnull = 0;
2960
2961 if (size > (end - start))
2962 size = (end - start);
2963
2964 buf = bfd_realloc_or_free (buf, size);
2965 if (buf == NULL)
2966 return -1;
2967
2968 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
2969 {
2970 free (buf);
2971 return -1;
2972 }
2973
2974 nread = bfd_bread (buf, size, abfd);
2975
2976 if (nread != size)
2977 {
2978 free (buf);
2979 return -1;
2980 }
2981
2982 for (offset = 4; offset <= size; offset += 4)
2983 {
2984 unsigned long val;
2985
2986 val = *((unsigned long *) (buf + size - offset));
2987 if (! found_nonnull)
2988 {
2989 if (val != 0)
2990 found_nonnull = 1;
2991 }
2992 else if (val == 0x0)
2993 {
2994 unsigned long bottom;
2995 unsigned long top;
2996
2997 bottom = seg->fileoff + seg->filesize - offset;
2998 top = seg->fileoff + seg->filesize - 4;
2999 *rbuf = bfd_malloc (top - bottom);
3000 *rlen = top - bottom;
3001
3002 memcpy (*rbuf, buf + size - *rlen, *rlen);
3003 free (buf);
3004 return 0;
3005 }
3006 }
3007
3008 if (size == (end - start))
3009 break;
3010
3011 size *= 2;
3012 }
3013
3014 free (buf);
3015 }
3016 }
3017
3018 return -1;
3019 }
3020
3021 char *
3022 bfd_mach_o_core_file_failing_command (bfd *abfd)
3023 {
3024 unsigned char *buf = NULL;
3025 unsigned int len = 0;
3026 int ret = -1;
3027
3028 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
3029 if (ret < 0)
3030 return NULL;
3031
3032 return (char *) buf;
3033 }
3034
3035 int
3036 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
3037 {
3038 return 0;
3039 }
3040
3041 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3042 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
3043
3044 #define bfd_mach_o_swap_reloc_in NULL
3045 #define bfd_mach_o_swap_reloc_out NULL
3046
3047 #define TARGET_NAME mach_o_be_vec
3048 #define TARGET_STRING "mach-o-be"
3049 #define TARGET_BIG_ENDIAN 1
3050 #define TARGET_ARCHIVE 0
3051 #include "mach-o-target.c"
3052
3053 #undef TARGET_NAME
3054 #undef TARGET_STRING
3055 #undef TARGET_BIG_ENDIAN
3056 #undef TARGET_ARCHIVE
3057
3058 #define TARGET_NAME mach_o_le_vec
3059 #define TARGET_STRING "mach-o-le"
3060 #define TARGET_BIG_ENDIAN 0
3061 #define TARGET_ARCHIVE 0
3062
3063 #include "mach-o-target.c"
3064
3065 #undef TARGET_NAME
3066 #undef TARGET_STRING
3067 #undef TARGET_BIG_ENDIAN
3068 #undef TARGET_ARCHIVE
3069
3070 #define TARGET_NAME mach_o_fat_vec
3071 #define TARGET_STRING "mach-o-fat"
3072 #define TARGET_BIG_ENDIAN 1
3073 #define TARGET_ARCHIVE 1
3074
3075 #include "mach-o-target.c"
3076
3077 #undef TARGET_NAME
3078 #undef TARGET_STRING
3079 #undef TARGET_BIG_ENDIAN
3080 #undef TARGET_ARCHIVE
git-cvsimport of binutils cvsroot