projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
2011-08-03 Tristan Gingold <gingold@adacore.com>
[binutils-gdb.git] / bfd / mach-o.c
1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011
4 Free Software Foundation, Inc.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "mach-o.h"
25 #include "bfd.h"
26 #include "libbfd.h"
27 #include "libiberty.h"
28 #include "aout/stab_gnu.h"
29 #include <ctype.h>
30
31 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
32 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
33 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
34
35 #define FILE_ALIGN(off, algn) \
36 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
37
38 static int bfd_mach_o_read_symtab_symbols (bfd *);
39
40 unsigned int
41 bfd_mach_o_version (bfd *abfd)
42 {
43 bfd_mach_o_data_struct *mdata = NULL;
44
45 BFD_ASSERT (bfd_mach_o_valid (abfd));
46 mdata = bfd_mach_o_get_data (abfd);
47
48 return mdata->header.version;
49 }
50
51 bfd_boolean
52 bfd_mach_o_valid (bfd *abfd)
53 {
54 if (abfd == NULL || abfd->xvec == NULL)
55 return FALSE;
56
57 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
58 return FALSE;
59
60 if (bfd_mach_o_get_data (abfd) == NULL)
61 return FALSE;
62 return TRUE;
63 }
64
65 static INLINE bfd_boolean
66 mach_o_wide_p (bfd_mach_o_header *header)
67 {
68 switch (header->version)
69 {
70 case 1:
71 return FALSE;
72 case 2:
73 return TRUE;
74 default:
75 BFD_FAIL ();
76 return FALSE;
77 }
78 }
79
80 static INLINE bfd_boolean
81 bfd_mach_o_wide_p (bfd *abfd)
82 {
83 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
84 }
85
86 /* Tables to translate well known Mach-O segment/section names to bfd
87 names. Use of canonical names (such as .text or .debug_frame) is required
88 by gdb. */
89
90 struct mach_o_section_name_xlat
91 {
92 const char *bfd_name;
93 const char *mach_o_name;
94 flagword flags;
95 };
96
97 static const struct mach_o_section_name_xlat dwarf_section_names_xlat[] =
98 {
99 { ".debug_frame", "__debug_frame", SEC_DEBUGGING },
100 { ".debug_info", "__debug_info", SEC_DEBUGGING },
101 { ".debug_abbrev", "__debug_abbrev", SEC_DEBUGGING },
102 { ".debug_aranges", "__debug_aranges", SEC_DEBUGGING },
103 { ".debug_macinfo", "__debug_macinfo", SEC_DEBUGGING },
104 { ".debug_line", "__debug_line", SEC_DEBUGGING },
105 { ".debug_loc", "__debug_loc", SEC_DEBUGGING },
106 { ".debug_pubnames", "__debug_pubnames", SEC_DEBUGGING },
107 { ".debug_pubtypes", "__debug_pubtypes", SEC_DEBUGGING },
108 { ".debug_str", "__debug_str", SEC_DEBUGGING },
109 { ".debug_ranges", "__debug_ranges", SEC_DEBUGGING },
110 { NULL, NULL, 0}
111 };
112
113 static const struct mach_o_section_name_xlat text_section_names_xlat[] =
114 {
115 { ".text", "__text", SEC_CODE | SEC_LOAD },
116 { ".const", "__const", SEC_READONLY | SEC_DATA | SEC_LOAD },
117 { ".cstring", "__cstring", SEC_READONLY | SEC_DATA | SEC_LOAD },
118 { ".eh_frame", "__eh_frame", SEC_READONLY | SEC_LOAD },
119 { NULL, NULL, 0}
120 };
121
122 static const struct mach_o_section_name_xlat data_section_names_xlat[] =
123 {
124 { ".data", "__data", SEC_DATA | SEC_LOAD },
125 { ".const_data", "__const", SEC_DATA | SEC_LOAD },
126 { ".dyld", "__dyld", SEC_DATA | SEC_LOAD },
127 { ".lazy_symbol_ptr", "__la_symbol_ptr", SEC_DATA | SEC_LOAD },
128 { ".non_lazy_symbol_ptr", "__nl_symbol_ptr", SEC_DATA | SEC_LOAD },
129 { ".bss", "__bss", SEC_NO_FLAGS },
130 { NULL, NULL, 0}
131 };
132
133 struct mach_o_segment_name_xlat
134 {
135 const char *segname;
136 const struct mach_o_section_name_xlat *sections;
137 };
138
139 static const struct mach_o_segment_name_xlat segsec_names_xlat[] =
140 {
141 { "__DWARF", dwarf_section_names_xlat },
142 { "__TEXT", text_section_names_xlat },
143 { "__DATA", data_section_names_xlat },
144 { NULL, NULL }
145 };
146
147
148 /* Mach-O to bfd names. */
149
150 static void
151 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section,
152 char **name, flagword *flags)
153 {
154 const struct mach_o_segment_name_xlat *seg;
155 char *res;
156 unsigned int len;
157 const char *pfx = "";
158
159 *name = NULL;
160 *flags = SEC_NO_FLAGS;
161
162 for (seg = segsec_names_xlat; seg->segname; seg++)
163 {
164 if (strcmp (seg->segname, section->segname) == 0)
165 {
166 const struct mach_o_section_name_xlat *sec;
167
168 for (sec = seg->sections; sec->mach_o_name; sec++)
169 {
170 if (strcmp (sec->mach_o_name, section->sectname) == 0)
171 {
172 len = strlen (sec->bfd_name);
173 res = bfd_alloc (abfd, len + 1);
174
175 if (res == NULL)
176 return;
177 strcpy (res, sec->bfd_name);
178 *name = res;
179 *flags = sec->flags;
180 return;
181 }
182 }
183 }
184 }
185
186 len = strlen (section->segname) + 1
187 + strlen (section->sectname) + 1;
188
189 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
190 with an underscore. */
191 if (section->segname[0] != '_')
192 {
193 static const char seg_pfx[] = "LC_SEGMENT.";
194
195 pfx = seg_pfx;
196 len += sizeof (seg_pfx) - 1;
197 }
198
199 res = bfd_alloc (abfd, len);
200 if (res == NULL)
201 return;
202 snprintf (res, len, "%s%s.%s", pfx, section->segname, section->sectname);
203 *name = res;
204 }
205
206 /* Convert a bfd section name to a Mach-O segment + section name. */
207
208 static void
209 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
210 asection *sect,
211 bfd_mach_o_section *section)
212 {
213 const struct mach_o_segment_name_xlat *seg;
214 const char *name = bfd_get_section_name (abfd, sect);
215 const char *dot;
216 unsigned int len;
217 unsigned int seglen;
218 unsigned int seclen;
219
220 /* List of well known names. They all start with a dot. */
221 if (name[0] == '.')
222 for (seg = segsec_names_xlat; seg->segname; seg++)
223 {
224 const struct mach_o_section_name_xlat *sec;
225
226 for (sec = seg->sections; sec->mach_o_name; sec++)
227 {
228 if (strcmp (sec->bfd_name, name) == 0)
229 {
230 strcpy (section->segname, seg->segname);
231 strcpy (section->sectname, sec->mach_o_name);
232 return;
233 }
234 }
235 }
236
237 /* Strip LC_SEGMENT. prefix. */
238 if (strncmp (name, "LC_SEGMENT.", 11) == 0)
239 name += 11;
240
241 /* Find a dot. */
242 dot = strchr (name, '.');
243 len = strlen (name);
244
245 /* Try to split name into segment and section names. */
246 if (dot && dot != name)
247 {
248 seglen = dot - name;
249 seclen = len - (dot + 1 - name);
250
251 if (seglen < 16 && seclen < 16)
252 {
253 memcpy (section->segname, name, seglen);
254 section->segname[seglen] = 0;
255 memcpy (section->sectname, dot + 1, seclen);
256 section->sectname[seclen] = 0;
257 return;
258 }
259 }
260
261 if (len > 16)
262 len = 16;
263 memcpy (section->segname, name, len);
264 section->segname[len] = 0;
265 memcpy (section->sectname, name, len);
266 section->sectname[len] = 0;
267 }
268
269 /* Return the size of an entry for section SEC.
270 Must be called only for symbol pointer section and symbol stubs
271 sections. */
272
273 static unsigned int
274 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
275 {
276 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
277 {
278 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
279 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
280 return bfd_mach_o_wide_p (abfd) ? 8 : 4;
281 case BFD_MACH_O_S_SYMBOL_STUBS:
282 return sec->reserved2;
283 default:
284 BFD_FAIL ();
285 return 0;
286 }
287 }
288
289 /* Return the number of indirect symbols for a section.
290 Must be called only for symbol pointer section and symbol stubs
291 sections. */
292
293 static unsigned int
294 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
295 {
296 unsigned int elsz;
297
298 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
299 if (elsz == 0)
300 return 0;
301 else
302 return sec->size / elsz;
303 }
304
305
306 /* Copy any private info we understand from the input symbol
307 to the output symbol. */
308
309 bfd_boolean
310 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
311 asymbol *isymbol ATTRIBUTE_UNUSED,
312 bfd *obfd ATTRIBUTE_UNUSED,
313 asymbol *osymbol ATTRIBUTE_UNUSED)
314 {
315 return TRUE;
316 }
317
318 /* Copy any private info we understand from the input section
319 to the output section. */
320
321 bfd_boolean
322 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
323 asection *isection ATTRIBUTE_UNUSED,
324 bfd *obfd ATTRIBUTE_UNUSED,
325 asection *osection ATTRIBUTE_UNUSED)
326 {
327 return TRUE;
328 }
329
330 /* Copy any private info we understand from the input bfd
331 to the output bfd. */
332
333 bfd_boolean
334 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
335 {
336 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
337 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
338 return TRUE;
339
340 BFD_ASSERT (bfd_mach_o_valid (ibfd));
341 BFD_ASSERT (bfd_mach_o_valid (obfd));
342
343 /* FIXME: copy commands. */
344
345 return TRUE;
346 }
347
348 /* Count the total number of symbols. */
349
350 static long
351 bfd_mach_o_count_symbols (bfd *abfd)
352 {
353 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
354
355 if (mdata->symtab == NULL)
356 return 0;
357 return mdata->symtab->nsyms;
358 }
359
360 long
361 bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
362 {
363 long nsyms = bfd_mach_o_count_symbols (abfd);
364
365 return ((nsyms + 1) * sizeof (asymbol *));
366 }
367
368 long
369 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
370 {
371 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
372 long nsyms = bfd_mach_o_count_symbols (abfd);
373 bfd_mach_o_symtab_command *sym = mdata->symtab;
374 unsigned long j;
375
376 if (nsyms < 0)
377 return nsyms;
378
379 if (nsyms == 0)
380 {
381 /* Do not try to read symbols if there are none. */
382 alocation[0] = NULL;
383 return 0;
384 }
385
386 if (bfd_mach_o_read_symtab_symbols (abfd) != 0)
387 {
388 (*_bfd_error_handler) (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
389 return 0;
390 }
391
392 BFD_ASSERT (sym->symbols != NULL);
393
394 for (j = 0; j < sym->nsyms; j++)
395 alocation[j] = &sym->symbols[j].symbol;
396
397 alocation[j] = NULL;
398
399 return nsyms;
400 }
401
402 long
403 bfd_mach_o_get_synthetic_symtab (bfd *abfd,
404 long symcount ATTRIBUTE_UNUSED,
405 asymbol **syms ATTRIBUTE_UNUSED,
406 long dynsymcount ATTRIBUTE_UNUSED,
407 asymbol **dynsyms ATTRIBUTE_UNUSED,
408 asymbol **ret)
409 {
410 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
411 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
412 bfd_mach_o_symtab_command *symtab = mdata->symtab;
413 asymbol *s;
414 unsigned long count, i, j, n;
415 size_t size;
416 char *names;
417 char *nul_name;
418
419 *ret = NULL;
420
421 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
422 return 0;
423
424 if (dysymtab->nindirectsyms == 0)
425 return 0;
426
427 count = dysymtab->nindirectsyms;
428 size = count * sizeof (asymbol) + 1;
429
430 for (j = 0; j < count; j++)
431 {
432 unsigned int isym = dysymtab->indirect_syms[j];
433
434 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
435 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
436 }
437
438 s = *ret = (asymbol *) bfd_malloc (size);
439 if (s == NULL)
440 return -1;
441 names = (char *) (s + count);
442 nul_name = names;
443 *names++ = 0;
444
445 n = 0;
446 for (i = 0; i < mdata->nsects; i++)
447 {
448 bfd_mach_o_section *sec = mdata->sections[i];
449 unsigned int first, last;
450 bfd_vma addr;
451 bfd_vma entry_size;
452
453 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
454 {
455 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
456 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
457 case BFD_MACH_O_S_SYMBOL_STUBS:
458 first = sec->reserved1;
459 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
460 addr = sec->addr;
461 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
462 for (j = first; j < last; j++)
463 {
464 unsigned int isym = dysymtab->indirect_syms[j];
465
466 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
467 s->section = sec->bfdsection;
468 s->value = addr - sec->addr;
469 s->udata.p = NULL;
470
471 if (isym < symtab->nsyms
472 && symtab->symbols[isym].symbol.name)
473 {
474 const char *sym = symtab->symbols[isym].symbol.name;
475 size_t len;
476
477 s->name = names;
478 len = strlen (sym);
479 memcpy (names, sym, len);
480 names += len;
481 memcpy (names, "$stub", sizeof ("$stub"));
482 names += sizeof ("$stub");
483 }
484 else
485 s->name = nul_name;
486
487 addr += entry_size;
488 s++;
489 n++;
490 }
491 break;
492 default:
493 break;
494 }
495 }
496
497 return n;
498 }
499
500 void
501 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
502 asymbol *symbol,
503 symbol_info *ret)
504 {
505 bfd_symbol_info (symbol, ret);
506 }
507
508 void
509 bfd_mach_o_print_symbol (bfd *abfd,
510 void * afile,
511 asymbol *symbol,
512 bfd_print_symbol_type how)
513 {
514 FILE *file = (FILE *) afile;
515 const char *name;
516 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
517
518 switch (how)
519 {
520 case bfd_print_symbol_name:
521 fprintf (file, "%s", symbol->name);
522 break;
523 default:
524 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
525 if (asym->n_type & BFD_MACH_O_N_STAB)
526 name = bfd_get_stab_name (asym->n_type);
527 else
528 switch (asym->n_type & BFD_MACH_O_N_TYPE)
529 {
530 case BFD_MACH_O_N_UNDF:
531 name = "UND";
532 break;
533 case BFD_MACH_O_N_ABS:
534 name = "ABS";
535 break;
536 case BFD_MACH_O_N_INDR:
537 name = "INDR";
538 break;
539 case BFD_MACH_O_N_PBUD:
540 name = "PBUD";
541 break;
542 case BFD_MACH_O_N_SECT:
543 name = "SECT";
544 break;
545 default:
546 name = "???";
547 break;
548 }
549 if (name == NULL)
550 name = "";
551 fprintf (file, " %02x %-6s %02x %04x",
552 asym->n_type, name, asym->n_sect, asym->n_desc);
553 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
554 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
555 fprintf (file, " %-5s", symbol->section->name);
556 fprintf (file, " %s", symbol->name);
557 }
558 }
559
560 static void
561 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
562 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED,
563 enum bfd_architecture *type,
564 unsigned long *subtype)
565 {
566 *subtype = bfd_arch_unknown;
567
568 switch (mtype)
569 {
570 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
571 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
572 case BFD_MACH_O_CPU_TYPE_I386:
573 *type = bfd_arch_i386;
574 *subtype = bfd_mach_i386_i386;
575 break;
576 case BFD_MACH_O_CPU_TYPE_X86_64:
577 *type = bfd_arch_i386;
578 *subtype = bfd_mach_x86_64;
579 break;
580 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
581 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
582 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
583 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
584 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
585 case BFD_MACH_O_CPU_TYPE_SPARC:
586 *type = bfd_arch_sparc;
587 *subtype = bfd_mach_sparc;
588 break;
589 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
590 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
591 case BFD_MACH_O_CPU_TYPE_POWERPC:
592 *type = bfd_arch_powerpc;
593 *subtype = bfd_mach_ppc;
594 break;
595 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
596 *type = bfd_arch_powerpc;
597 *subtype = bfd_mach_ppc64;
598 break;
599 default:
600 *type = bfd_arch_unknown;
601 break;
602 }
603 }
604
605 static bfd_boolean
606 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
607 {
608 unsigned char buf[32];
609 unsigned int size;
610
611 size = mach_o_wide_p (header) ?
612 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
613
614 bfd_h_put_32 (abfd, header->magic, buf + 0);
615 bfd_h_put_32 (abfd, header->cputype, buf + 4);
616 bfd_h_put_32 (abfd, header->cpusubtype, buf + 8);
617 bfd_h_put_32 (abfd, header->filetype, buf + 12);
618 bfd_h_put_32 (abfd, header->ncmds, buf + 16);
619 bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20);
620 bfd_h_put_32 (abfd, header->flags, buf + 24);
621
622 if (mach_o_wide_p (header))
623 bfd_h_put_32 (abfd, header->reserved, buf + 28);
624
625 if (bfd_seek (abfd, 0, SEEK_SET) != 0
626 || bfd_bwrite ((void *) buf, size, abfd) != size)
627 return FALSE;
628
629 return TRUE;
630 }
631
632 static int
633 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
634 {
635 bfd_mach_o_thread_command *cmd = &command->command.thread;
636 unsigned int i;
637 unsigned char buf[8];
638 unsigned int offset;
639
640 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
641 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
642
643 offset = 8;
644 for (i = 0; i < cmd->nflavours; i++)
645 {
646 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
647 BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8));
648
649 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf);
650 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
651
652 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
653 || bfd_bwrite ((void *) buf, 8, abfd) != 8)
654 return -1;
655
656 offset += cmd->flavours[i].size + 8;
657 }
658
659 return 0;
660 }
661
662 long
663 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
664 asection *asect)
665 {
666 return (asect->reloc_count + 1) * sizeof (arelent *);
667 }
668
669 static int
670 bfd_mach_o_canonicalize_one_reloc (bfd *abfd, char *buf,
671 arelent *res, asymbol **syms)
672 {
673 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
674 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
675 bfd_mach_o_reloc_info reloc;
676 bfd_vma addr;
677 bfd_vma symnum;
678 asymbol **sym;
679
680 addr = bfd_get_32 (abfd, buf + 0);
681 symnum = bfd_get_32 (abfd, buf + 4);
682
683 if (addr & BFD_MACH_O_SR_SCATTERED)
684 {
685 unsigned int j;
686
687 /* Scattered relocation.
688 Extract section and offset from r_value. */
689 res->sym_ptr_ptr = NULL;
690 res->addend = 0;
691 for (j = 0; j < mdata->nsects; j++)
692 {
693 bfd_mach_o_section *sect = mdata->sections[j];
694 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
695 {
696 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
697 res->addend = symnum - sect->addr;
698 break;
699 }
700 }
701 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
702 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
703 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
704 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
705 reloc.r_scattered = 1;
706 }
707 else
708 {
709 unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);
710 res->addend = 0;
711 res->address = addr;
712 if (symnum & BFD_MACH_O_R_EXTERN)
713 {
714 sym = syms + num;
715 reloc.r_extern = 1;
716 }
717 else
718 {
719 BFD_ASSERT (num != 0);
720 BFD_ASSERT (num <= mdata->nsects);
721 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
722 /* For a symbol defined in section S, the addend (stored in the
723 binary) contains the address of the section. To comply with
724 bfd conventio, substract the section address.
725 Use the address from the header, so that the user can modify
726 the vma of the section. */
727 res->addend = -mdata->sections[num - 1]->addr;
728 reloc.r_extern = 0;
729 }
730 res->sym_ptr_ptr = sym;
731 reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
732 reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);
733 reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;
734 reloc.r_scattered = 0;
735 }
736
737 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
738 return -1;
739 return 0;
740 }
741
742 static int
743 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
744 unsigned long count,
745 arelent *res, asymbol **syms)
746 {
747 unsigned long i;
748 char *native_relocs;
749 bfd_size_type native_size;
750
751 /* Allocate and read relocs. */
752 native_size = count * BFD_MACH_O_RELENT_SIZE;
753 native_relocs = bfd_malloc (native_size);
754 if (native_relocs == NULL)
755 return -1;
756
757 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
758 || bfd_bread (native_relocs, native_size, abfd) != native_size)
759 goto err;
760
761 for (i = 0; i < count; i++)
762 {
763 char *buf = native_relocs + BFD_MACH_O_RELENT_SIZE * i;
764
765 if (bfd_mach_o_canonicalize_one_reloc (abfd, buf, &res[i], syms) < 0)
766 goto err;
767 }
768 free (native_relocs);
769 return i;
770 err:
771 free (native_relocs);
772 return -1;
773 }
774
775 long
776 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
777 arelent **rels, asymbol **syms)
778 {
779 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
780 unsigned long i;
781 arelent *res;
782
783 if (asect->reloc_count == 0)
784 return 0;
785
786 /* No need to go further if we don't know how to read relocs. */
787 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
788 return 0;
789
790 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
791 if (res == NULL)
792 return -1;
793
794 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
795 asect->reloc_count, res, syms) < 0)
796 {
797 free (res);
798 return -1;
799 }
800
801 for (i = 0; i < asect->reloc_count; i++)
802 rels[i] = &res[i];
803 rels[i] = NULL;
804 asect->relocation = res;
805
806 return i;
807 }
808
809 long
810 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
811 {
812 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
813
814 if (mdata->dysymtab == NULL)
815 return 1;
816 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel)
817 * sizeof (arelent *);
818 }
819
820 long
821 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
822 struct bfd_symbol **syms)
823 {
824 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
825 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
826 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
827 unsigned long i;
828 arelent *res;
829
830 if (dysymtab == NULL)
831 return 0;
832 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
833 return 0;
834
835 /* No need to go further if we don't know how to read relocs. */
836 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
837 return 0;
838
839 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent));
840 if (res == NULL)
841 return -1;
842
843 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
844 dysymtab->nextrel, res, syms) < 0)
845 {
846 free (res);
847 return -1;
848 }
849
850 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
851 dysymtab->nlocrel,
852 res + dysymtab->nextrel, syms) < 0)
853 {
854 free (res);
855 return -1;
856 }
857
858 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
859 rels[i] = &res[i];
860 rels[i] = NULL;
861 return i;
862 }
863
864 static bfd_boolean
865 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
866 {
867 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
868 unsigned int i;
869 arelent **entries;
870 asection *sec;
871 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
872
873 sec = section->bfdsection;
874 if (sec->reloc_count == 0)
875 return TRUE;
876
877 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
878 return TRUE;
879
880 /* Allocate relocation room. */
881 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
882 section->nreloc = sec->reloc_count;
883 sec->rel_filepos = mdata->filelen;
884 section->reloff = sec->rel_filepos;
885 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
886
887 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
888 return FALSE;
889
890 /* Convert and write. */
891 entries = section->bfdsection->orelocation;
892 for (i = 0; i < section->nreloc; i++)
893 {
894 arelent *rel = entries[i];
895 char buf[8];
896 bfd_mach_o_reloc_info info, *pinfo = &info;
897
898 /* Convert relocation to an intermediate representation. */
899 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
900 return FALSE;
901
902 /* Lower the relocation info. */
903 if (pinfo->r_scattered)
904 {
905 unsigned long v;
906
907 v = BFD_MACH_O_SR_SCATTERED
908 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
909 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
910 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
911 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
912 bfd_put_32 (abfd, v, buf);
913 bfd_put_32 (abfd, pinfo->r_value, buf + 4);
914 }
915 else
916 {
917 unsigned long v;
918
919 bfd_put_32 (abfd, pinfo->r_address, buf);
920 v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value)
921 | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0)
922 | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length)
923 | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0)
924 | BFD_MACH_O_SET_R_TYPE (pinfo->r_type);
925 bfd_put_32 (abfd, v, buf + 4);
926 }
927
928 if (bfd_bwrite ((void *) buf, BFD_MACH_O_RELENT_SIZE, abfd)
929 != BFD_MACH_O_RELENT_SIZE)
930 return FALSE;
931 }
932 return TRUE;
933 }
934
935 static int
936 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
937 {
938 unsigned char buf[BFD_MACH_O_SECTION_SIZE];
939
940 memcpy (buf, section->sectname, 16);
941 memcpy (buf + 16, section->segname, 16);
942 bfd_h_put_32 (abfd, section->addr, buf + 32);
943 bfd_h_put_32 (abfd, section->size, buf + 36);
944 bfd_h_put_32 (abfd, section->offset, buf + 40);
945 bfd_h_put_32 (abfd, section->align, buf + 44);
946 bfd_h_put_32 (abfd, section->reloff, buf + 48);
947 bfd_h_put_32 (abfd, section->nreloc, buf + 52);
948 bfd_h_put_32 (abfd, section->flags, buf + 56);
949 bfd_h_put_32 (abfd, section->reserved1, buf + 60);
950 bfd_h_put_32 (abfd, section->reserved2, buf + 64);
951
952 if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd)
953 != BFD_MACH_O_SECTION_SIZE)
954 return -1;
955
956 return 0;
957 }
958
959 static int
960 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
961 {
962 unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
963
964 memcpy (buf, section->sectname, 16);
965 memcpy (buf + 16, section->segname, 16);
966 bfd_h_put_64 (abfd, section->addr, buf + 32);
967 bfd_h_put_64 (abfd, section->size, buf + 40);
968 bfd_h_put_32 (abfd, section->offset, buf + 48);
969 bfd_h_put_32 (abfd, section->align, buf + 52);
970 bfd_h_put_32 (abfd, section->reloff, buf + 56);
971 bfd_h_put_32 (abfd, section->nreloc, buf + 60);
972 bfd_h_put_32 (abfd, section->flags, buf + 64);
973 bfd_h_put_32 (abfd, section->reserved1, buf + 68);
974 bfd_h_put_32 (abfd, section->reserved2, buf + 72);
975 bfd_h_put_32 (abfd, section->reserved3, buf + 76);
976
977 if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
978 != BFD_MACH_O_SECTION_64_SIZE)
979 return -1;
980
981 return 0;
982 }
983
984 static int
985 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
986 {
987 unsigned char buf[BFD_MACH_O_LC_SEGMENT_SIZE];
988 bfd_mach_o_segment_command *seg = &command->command.segment;
989 unsigned long i;
990
991 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
992
993 for (i = 0; i < seg->nsects; i++)
994 if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i]))
995 return -1;
996
997 memcpy (buf, seg->segname, 16);
998 bfd_h_put_32 (abfd, seg->vmaddr, buf + 16);
999 bfd_h_put_32 (abfd, seg->vmsize, buf + 20);
1000 bfd_h_put_32 (abfd, seg->fileoff, buf + 24);
1001 bfd_h_put_32 (abfd, seg->filesize, buf + 28);
1002 bfd_h_put_32 (abfd, seg->maxprot, buf + 32);
1003 bfd_h_put_32 (abfd, seg->initprot, buf + 36);
1004 bfd_h_put_32 (abfd, seg->nsects, buf + 40);
1005 bfd_h_put_32 (abfd, seg->flags, buf + 44);
1006
1007 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1008 || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_SIZE - 8, abfd)
1009 != BFD_MACH_O_LC_SEGMENT_SIZE - 8))
1010 return -1;
1011
1012 for (i = 0; i < seg->nsects; i++)
1013 if (bfd_mach_o_write_section_32 (abfd, &seg->sections[i]))
1014 return -1;
1015
1016 return 0;
1017 }
1018
1019 static int
1020 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1021 {
1022 unsigned char buf[BFD_MACH_O_LC_SEGMENT_64_SIZE];
1023 bfd_mach_o_segment_command *seg = &command->command.segment;
1024 unsigned long i;
1025
1026 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1027
1028 for (i = 0; i < seg->nsects; i++)
1029 if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i]))
1030 return -1;
1031
1032 memcpy (buf, seg->segname, 16);
1033 bfd_h_put_64 (abfd, seg->vmaddr, buf + 16);
1034 bfd_h_put_64 (abfd, seg->vmsize, buf + 24);
1035 bfd_h_put_64 (abfd, seg->fileoff, buf + 32);
1036 bfd_h_put_64 (abfd, seg->filesize, buf + 40);
1037 bfd_h_put_32 (abfd, seg->maxprot, buf + 48);
1038 bfd_h_put_32 (abfd, seg->initprot, buf + 52);
1039 bfd_h_put_32 (abfd, seg->nsects, buf + 56);
1040 bfd_h_put_32 (abfd, seg->flags, buf + 60);
1041
1042 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1043 || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_64_SIZE - 8, abfd)
1044 != BFD_MACH_O_LC_SEGMENT_64_SIZE - 8))
1045 return -1;
1046
1047 for (i = 0; i < seg->nsects; i++)
1048 if (bfd_mach_o_write_section_64 (abfd, &seg->sections[i]))
1049 return -1;
1050
1051 return 0;
1052 }
1053
1054 static bfd_boolean
1055 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1056 {
1057 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1058 bfd_mach_o_symtab_command *sym = &command->command.symtab;
1059 unsigned char buf[16];
1060 unsigned long i;
1061 unsigned int wide = bfd_mach_o_wide_p (abfd);
1062 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1063 struct bfd_strtab_hash *strtab;
1064 asymbol **symbols = bfd_get_outsymbols (abfd);
1065
1066 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1067
1068 /* Write the symbols first. */
1069 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1070 sym->symoff = mdata->filelen;
1071 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1072 return FALSE;
1073
1074 sym->nsyms = bfd_get_symcount (abfd);
1075 mdata->filelen += sym->nsyms * symlen;
1076
1077 strtab = _bfd_stringtab_init ();
1078 if (strtab == NULL)
1079 return FALSE;
1080
1081 for (i = 0; i < sym->nsyms; i++)
1082 {
1083 bfd_size_type str_index;
1084 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1085
1086 /* Compute name index. */
1087 /* An index of 0 always means the empty string. */
1088 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1089 str_index = 0;
1090 else
1091 {
1092 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1093 if (str_index == (bfd_size_type) -1)
1094 goto err;
1095 }
1096 bfd_h_put_32 (abfd, str_index, buf);
1097 bfd_h_put_8 (abfd, s->n_type, buf + 4);
1098 bfd_h_put_8 (abfd, s->n_sect, buf + 5);
1099 bfd_h_put_16 (abfd, s->n_desc, buf + 6);
1100 if (wide)
1101 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
1102 else
1103 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
1104
1105 if (bfd_bwrite ((void *) buf, symlen, abfd) != symlen)
1106 goto err;
1107 }
1108 sym->strsize = _bfd_stringtab_size (strtab);
1109 sym->stroff = mdata->filelen;
1110 mdata->filelen += sym->strsize;
1111
1112 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1113 goto err;
1114 _bfd_stringtab_free (strtab);
1115
1116 /* The command. */
1117 bfd_h_put_32 (abfd, sym->symoff, buf);
1118 bfd_h_put_32 (abfd, sym->nsyms, buf + 4);
1119 bfd_h_put_32 (abfd, sym->stroff, buf + 8);
1120 bfd_h_put_32 (abfd, sym->strsize, buf + 12);
1121
1122 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1123 || bfd_bwrite ((void *) buf, 16, abfd) != 16)
1124 return FALSE;
1125
1126 return TRUE;
1127
1128 err:
1129 _bfd_stringtab_free (strtab);
1130 return FALSE;
1131 }
1132
1133 /* Process the symbols and generate Mach-O specific fields.
1134 Number them. */
1135
1136 static bfd_boolean
1137 bfd_mach_o_mangle_symbols (bfd *abfd)
1138 {
1139 unsigned long i;
1140 asymbol **symbols = bfd_get_outsymbols (abfd);
1141
1142 for (i = 0; i < bfd_get_symcount (abfd); i++)
1143 {
1144 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1145
1146 if (s->n_type == BFD_MACH_O_N_UNDF && !(s->symbol.flags & BSF_DEBUGGING))
1147 {
1148 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1149 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1150 values haven't been set. */
1151 if (s->symbol.section == bfd_abs_section_ptr)
1152 s->n_type = BFD_MACH_O_N_ABS;
1153 else if (s->symbol.section == bfd_und_section_ptr)
1154 {
1155 s->n_type = BFD_MACH_O_N_UNDF;
1156 if (s->symbol.flags & BSF_WEAK)
1157 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1158 }
1159 else if (s->symbol.section == bfd_com_section_ptr)
1160 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1161 else
1162 s->n_type = BFD_MACH_O_N_SECT;
1163
1164 if (s->symbol.flags & BSF_GLOBAL)
1165 s->n_type |= BFD_MACH_O_N_EXT;
1166 }
1167
1168 /* Compute section index. */
1169 if (s->symbol.section != bfd_abs_section_ptr
1170 && s->symbol.section != bfd_und_section_ptr
1171 && s->symbol.section != bfd_com_section_ptr)
1172 s->n_sect = s->symbol.section->target_index;
1173
1174 /* Number symbols. */
1175 s->symbol.udata.i = i;
1176 }
1177 return TRUE;
1178 }
1179
1180 bfd_boolean
1181 bfd_mach_o_write_contents (bfd *abfd)
1182 {
1183 unsigned int i;
1184 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1185
1186 if (mdata->header.ncmds == 0)
1187 if (!bfd_mach_o_build_commands (abfd))
1188 return FALSE;
1189
1190 /* Now write header information. */
1191 if (mdata->header.filetype == 0)
1192 {
1193 if (abfd->flags & EXEC_P)
1194 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
1195 else if (abfd->flags & DYNAMIC)
1196 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
1197 else
1198 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
1199 }
1200 if (!bfd_mach_o_write_header (abfd, &mdata->header))
1201 return FALSE;
1202
1203 /* Assign a number to each symbols. */
1204 if (!bfd_mach_o_mangle_symbols (abfd))
1205 return FALSE;
1206
1207 for (i = 0; i < mdata->header.ncmds; i++)
1208 {
1209 unsigned char buf[8];
1210 bfd_mach_o_load_command *cur = &mdata->commands[i];
1211 unsigned long typeflag;
1212
1213 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1214
1215 bfd_h_put_32 (abfd, typeflag, buf);
1216 bfd_h_put_32 (abfd, cur->len, buf + 4);
1217
1218 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1219 || bfd_bwrite ((void *) buf, 8, abfd) != 8)
1220 return FALSE;
1221
1222 switch (cur->type)
1223 {
1224 case BFD_MACH_O_LC_SEGMENT:
1225 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1226 return FALSE;
1227 break;
1228 case BFD_MACH_O_LC_SEGMENT_64:
1229 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1230 return FALSE;
1231 break;
1232 case BFD_MACH_O_LC_SYMTAB:
1233 if (!bfd_mach_o_write_symtab (abfd, cur))
1234 return FALSE;
1235 break;
1236 case BFD_MACH_O_LC_SYMSEG:
1237 break;
1238 case BFD_MACH_O_LC_THREAD:
1239 case BFD_MACH_O_LC_UNIXTHREAD:
1240 if (bfd_mach_o_write_thread (abfd, cur) != 0)
1241 return FALSE;
1242 break;
1243 case BFD_MACH_O_LC_LOADFVMLIB:
1244 case BFD_MACH_O_LC_IDFVMLIB:
1245 case BFD_MACH_O_LC_IDENT:
1246 case BFD_MACH_O_LC_FVMFILE:
1247 case BFD_MACH_O_LC_PREPAGE:
1248 case BFD_MACH_O_LC_DYSYMTAB:
1249 case BFD_MACH_O_LC_LOAD_DYLIB:
1250 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1251 case BFD_MACH_O_LC_ID_DYLIB:
1252 case BFD_MACH_O_LC_REEXPORT_DYLIB:
1253 case BFD_MACH_O_LC_LOAD_DYLINKER:
1254 case BFD_MACH_O_LC_ID_DYLINKER:
1255 case BFD_MACH_O_LC_PREBOUND_DYLIB:
1256 case BFD_MACH_O_LC_ROUTINES:
1257 case BFD_MACH_O_LC_SUB_FRAMEWORK:
1258 break;
1259 default:
1260 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
1261 (unsigned long) cur->type);
1262 return FALSE;
1263 }
1264 }
1265
1266 return TRUE;
1267 }
1268
1269 /* Build Mach-O load commands from the sections. */
1270
1271 bfd_boolean
1272 bfd_mach_o_build_commands (bfd *abfd)
1273 {
1274 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1275 unsigned int wide = mach_o_wide_p (&mdata->header);
1276 bfd_mach_o_segment_command *seg;
1277 bfd_mach_o_section *sections;
1278 asection *sec;
1279 bfd_mach_o_load_command *cmd;
1280 bfd_mach_o_load_command *symtab_cmd;
1281 int target_index;
1282
1283 /* Return now if commands are already built. */
1284 if (mdata->header.ncmds)
1285 return FALSE;
1286
1287 /* Very simple version: 1 command (segment) containing all sections. */
1288 mdata->header.ncmds = 2;
1289 mdata->commands = bfd_alloc (abfd, mdata->header.ncmds
1290 * sizeof (bfd_mach_o_load_command));
1291 if (mdata->commands == NULL)
1292 return FALSE;
1293 cmd = &mdata->commands[0];
1294 seg = &cmd->command.segment;
1295
1296 seg->nsects = bfd_count_sections (abfd);
1297 sections = bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section));
1298 if (sections == NULL)
1299 return FALSE;
1300 seg->sections = sections;
1301
1302 /* Set segment command. */
1303 if (wide)
1304 {
1305 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
1306 cmd->offset = BFD_MACH_O_HEADER_64_SIZE;
1307 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
1308 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
1309 }
1310 else
1311 {
1312 cmd->type = BFD_MACH_O_LC_SEGMENT;
1313 cmd->offset = BFD_MACH_O_HEADER_SIZE;
1314 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
1315 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
1316 }
1317 cmd->type_required = FALSE;
1318 mdata->header.sizeofcmds = cmd->len;
1319 mdata->filelen = cmd->offset + cmd->len;
1320
1321 /* Set symtab command. */
1322 symtab_cmd = &mdata->commands[1];
1323
1324 symtab_cmd->type = BFD_MACH_O_LC_SYMTAB;
1325 symtab_cmd->offset = cmd->offset + cmd->len;
1326 symtab_cmd->len = 6 * 4;
1327 symtab_cmd->type_required = FALSE;
1328
1329 mdata->header.sizeofcmds += symtab_cmd->len;
1330 mdata->filelen += symtab_cmd->len;
1331
1332 /* Fill segment command. */
1333 memset (seg->segname, 0, sizeof (seg->segname));
1334 seg->vmaddr = 0;
1335 seg->fileoff = mdata->filelen;
1336 seg->filesize = 0;
1337 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
1338 | BFD_MACH_O_PROT_EXECUTE;
1339 seg->initprot = seg->maxprot;
1340 seg->flags = 0;
1341
1342 /* Create Mach-O sections. */
1343 target_index = 0;
1344 for (sec = abfd->sections; sec; sec = sec->next)
1345 {
1346 sections->bfdsection = sec;
1347 bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, sections);
1348 sections->addr = bfd_get_section_vma (abfd, sec);
1349 sections->size = bfd_get_section_size (sec);
1350 sections->align = bfd_get_section_alignment (abfd, sec);
1351
1352 if (sections->size != 0)
1353 {
1354 mdata->filelen = FILE_ALIGN (mdata->filelen, sections->align);
1355 sections->offset = mdata->filelen;
1356 }
1357 else
1358 sections->offset = 0;
1359 sections->reloff = 0;
1360 sections->nreloc = 0;
1361 sections->reserved1 = 0;
1362 sections->reserved2 = 0;
1363 sections->reserved3 = 0;
1364
1365 sec->filepos = sections->offset;
1366 sec->target_index = ++target_index;
1367
1368 mdata->filelen += sections->size;
1369 sections++;
1370 }
1371 seg->filesize = mdata->filelen - seg->fileoff;
1372 seg->vmsize = seg->filesize;
1373
1374 return TRUE;
1375 }
1376
1377 /* Set the contents of a section. */
1378
1379 bfd_boolean
1380 bfd_mach_o_set_section_contents (bfd *abfd,
1381 asection *section,
1382 const void * location,
1383 file_ptr offset,
1384 bfd_size_type count)
1385 {
1386 file_ptr pos;
1387
1388 /* This must be done first, because bfd_set_section_contents is
1389 going to set output_has_begun to TRUE. */
1390 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
1391 return FALSE;
1392
1393 if (count == 0)
1394 return TRUE;
1395
1396 pos = section->filepos + offset;
1397 if (bfd_seek (abfd, pos, SEEK_SET) != 0
1398 || bfd_bwrite (location, count, abfd) != count)
1399 return FALSE;
1400
1401 return TRUE;
1402 }
1403
1404 int
1405 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
1406 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1407 {
1408 return 0;
1409 }
1410
1411 /* Make an empty symbol. This is required only because
1412 bfd_make_section_anyway wants to create a symbol for the section. */
1413
1414 asymbol *
1415 bfd_mach_o_make_empty_symbol (bfd *abfd)
1416 {
1417 asymbol *new_symbol;
1418
1419 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
1420 if (new_symbol == NULL)
1421 return new_symbol;
1422 new_symbol->the_bfd = abfd;
1423 new_symbol->udata.i = 0;
1424 return new_symbol;
1425 }
1426
1427 static bfd_boolean
1428 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
1429 {
1430 unsigned char buf[32];
1431 unsigned int size;
1432 bfd_vma (*get32) (const void *) = NULL;
1433
1434 /* Just read the magic number. */
1435 if (bfd_seek (abfd, 0, SEEK_SET) != 0
1436 || bfd_bread ((void *) buf, 4, abfd) != 4)
1437 return FALSE;
1438
1439 if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC)
1440 {
1441 header->byteorder = BFD_ENDIAN_BIG;
1442 header->magic = BFD_MACH_O_MH_MAGIC;
1443 header->version = 1;
1444 get32 = bfd_getb32;
1445 }
1446 else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC)
1447 {
1448 header->byteorder = BFD_ENDIAN_LITTLE;
1449 header->magic = BFD_MACH_O_MH_MAGIC;
1450 header->version = 1;
1451 get32 = bfd_getl32;
1452 }
1453 else if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC_64)
1454 {
1455 header->byteorder = BFD_ENDIAN_BIG;
1456 header->magic = BFD_MACH_O_MH_MAGIC_64;
1457 header->version = 2;
1458 get32 = bfd_getb32;
1459 }
1460 else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC_64)
1461 {
1462 header->byteorder = BFD_ENDIAN_LITTLE;
1463 header->magic = BFD_MACH_O_MH_MAGIC_64;
1464 header->version = 2;
1465 get32 = bfd_getl32;
1466 }
1467 else
1468 {
1469 header->byteorder = BFD_ENDIAN_UNKNOWN;
1470 return FALSE;
1471 }
1472
1473 /* Once the size of the header is known, read the full header. */
1474 size = mach_o_wide_p (header) ?
1475 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1476
1477 if (bfd_seek (abfd, 0, SEEK_SET) != 0
1478 || bfd_bread ((void *) buf, size, abfd) != size)
1479 return FALSE;
1480
1481 header->cputype = (*get32) (buf + 4);
1482 header->cpusubtype = (*get32) (buf + 8);
1483 header->filetype = (*get32) (buf + 12);
1484 header->ncmds = (*get32) (buf + 16);
1485 header->sizeofcmds = (*get32) (buf + 20);
1486 header->flags = (*get32) (buf + 24);
1487
1488 if (mach_o_wide_p (header))
1489 header->reserved = (*get32) (buf + 28);
1490
1491 return TRUE;
1492 }
1493
1494 static asection *
1495 bfd_mach_o_make_bfd_section (bfd *abfd, bfd_mach_o_section *section,
1496 unsigned long prot)
1497 {
1498 asection *bfdsec;
1499 char *sname;
1500 flagword flags;
1501
1502 bfd_mach_o_convert_section_name_to_bfd (abfd, section, &sname, &flags);
1503 if (sname == NULL)
1504 return NULL;
1505
1506 if (flags == SEC_NO_FLAGS)
1507 {
1508 /* Try to guess flags. */
1509 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
1510 flags = SEC_DEBUGGING;
1511 else
1512 {
1513 flags = SEC_ALLOC;
1514 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1515 != BFD_MACH_O_S_ZEROFILL)
1516 {
1517 flags |= SEC_LOAD;
1518 if (prot & BFD_MACH_O_PROT_EXECUTE)
1519 flags |= SEC_CODE;
1520 if (prot & BFD_MACH_O_PROT_WRITE)
1521 flags |= SEC_DATA;
1522 else if (prot & BFD_MACH_O_PROT_READ)
1523 flags |= SEC_READONLY;
1524 }
1525 }
1526 }
1527 else
1528 {
1529 if ((flags & SEC_DEBUGGING) == 0)
1530 flags |= SEC_ALLOC;
1531 }
1532
1533 if (section->offset != 0)
1534 flags |= SEC_HAS_CONTENTS;
1535 if (section->nreloc != 0)
1536 flags |= SEC_RELOC;
1537
1538 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, flags);
1539 if (bfdsec == NULL)
1540 return NULL;
1541
1542 bfdsec->vma = section->addr;
1543 bfdsec->lma = section->addr;
1544 bfdsec->size = section->size;
1545 bfdsec->filepos = section->offset;
1546 bfdsec->alignment_power = section->align;
1547 bfdsec->segment_mark = 0;
1548 bfdsec->reloc_count = section->nreloc;
1549 bfdsec->rel_filepos = section->reloff;
1550
1551 return bfdsec;
1552 }
1553
1554 static int
1555 bfd_mach_o_read_section_32 (bfd *abfd,
1556 bfd_mach_o_section *section,
1557 unsigned int offset,
1558 unsigned long prot)
1559 {
1560 unsigned char buf[BFD_MACH_O_SECTION_SIZE];
1561
1562 if (bfd_seek (abfd, offset, SEEK_SET) != 0
1563 || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd)
1564 != BFD_MACH_O_SECTION_SIZE))
1565 return -1;
1566
1567 memcpy (section->sectname, buf, 16);
1568 section->sectname[16] = '\0';
1569 memcpy (section->segname, buf + 16, 16);
1570 section->segname[16] = '\0';
1571 section->addr = bfd_h_get_32 (abfd, buf + 32);
1572 section->size = bfd_h_get_32 (abfd, buf + 36);
1573 section->offset = bfd_h_get_32 (abfd, buf + 40);
1574 section->align = bfd_h_get_32 (abfd, buf + 44);
1575 section->reloff = bfd_h_get_32 (abfd, buf + 48);
1576 section->nreloc = bfd_h_get_32 (abfd, buf + 52);
1577 section->flags = bfd_h_get_32 (abfd, buf + 56);
1578 section->reserved1 = bfd_h_get_32 (abfd, buf + 60);
1579 section->reserved2 = bfd_h_get_32 (abfd, buf + 64);
1580 section->reserved3 = 0;
1581 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot);
1582
1583 if (section->bfdsection == NULL)
1584 return -1;
1585
1586 return 0;
1587 }
1588
1589 static int
1590 bfd_mach_o_read_section_64 (bfd *abfd,
1591 bfd_mach_o_section *section,
1592 unsigned int offset,
1593 unsigned long prot)
1594 {
1595 unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
1596
1597 if (bfd_seek (abfd, offset, SEEK_SET) != 0
1598 || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
1599 != BFD_MACH_O_SECTION_64_SIZE))
1600 return -1;
1601
1602 memcpy (section->sectname, buf, 16);
1603 section->sectname[16] = '\0';
1604 memcpy (section->segname, buf + 16, 16);
1605 section->segname[16] = '\0';
1606 section->addr = bfd_h_get_64 (abfd, buf + 32);
1607 section->size = bfd_h_get_64 (abfd, buf + 40);
1608 section->offset = bfd_h_get_32 (abfd, buf + 48);
1609 section->align = bfd_h_get_32 (abfd, buf + 52);
1610 section->reloff = bfd_h_get_32 (abfd, buf + 56);
1611 section->nreloc = bfd_h_get_32 (abfd, buf + 60);
1612 section->flags = bfd_h_get_32 (abfd, buf + 64);
1613 section->reserved1 = bfd_h_get_32 (abfd, buf + 68);
1614 section->reserved2 = bfd_h_get_32 (abfd, buf + 72);
1615 section->reserved3 = bfd_h_get_32 (abfd, buf + 76);
1616 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot);
1617
1618 if (section->bfdsection == NULL)
1619 return -1;
1620
1621 return 0;
1622 }
1623
1624 static int
1625 bfd_mach_o_read_section (bfd *abfd,
1626 bfd_mach_o_section *section,
1627 unsigned int offset,
1628 unsigned long prot,
1629 unsigned int wide)
1630 {
1631 if (wide)
1632 return bfd_mach_o_read_section_64 (abfd, section, offset, prot);
1633 else
1634 return bfd_mach_o_read_section_32 (abfd, section, offset, prot);
1635 }
1636
1637 static int
1638 bfd_mach_o_read_symtab_symbol (bfd *abfd,
1639 bfd_mach_o_symtab_command *sym,
1640 bfd_mach_o_asymbol *s,
1641 unsigned long i)
1642 {
1643 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1644 unsigned int wide = mach_o_wide_p (&mdata->header);
1645 unsigned int symwidth =
1646 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1647 unsigned int symoff = sym->symoff + (i * symwidth);
1648 unsigned char buf[16];
1649 unsigned char type = -1;
1650 unsigned char section = -1;
1651 short desc = -1;
1652 symvalue value = -1;
1653 unsigned long stroff = -1;
1654 unsigned int symtype = -1;
1655
1656 BFD_ASSERT (sym->strtab != NULL);
1657
1658 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
1659 || bfd_bread ((void *) buf, symwidth, abfd) != symwidth)
1660 {
1661 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
1662 symwidth, (unsigned long) symoff);
1663 return -1;
1664 }
1665
1666 stroff = bfd_h_get_32 (abfd, buf);
1667 type = bfd_h_get_8 (abfd, buf + 4);
1668 symtype = type & BFD_MACH_O_N_TYPE;
1669 section = bfd_h_get_8 (abfd, buf + 5);
1670 desc = bfd_h_get_16 (abfd, buf + 6);
1671 if (wide)
1672 value = bfd_h_get_64 (abfd, buf + 8);
1673 else
1674 value = bfd_h_get_32 (abfd, buf + 8);
1675
1676 if (stroff >= sym->strsize)
1677 {
1678 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: symbol name out of range (%lu >= %lu)"),
1679 (unsigned long) stroff,
1680 (unsigned long) sym->strsize);
1681 return -1;
1682 }
1683
1684 s->symbol.the_bfd = abfd;
1685 s->symbol.name = sym->strtab + stroff;
1686 s->symbol.value = value;
1687 s->symbol.flags = 0x0;
1688 s->symbol.udata.i = 0;
1689 s->n_type = type;
1690 s->n_sect = section;
1691 s->n_desc = desc;
1692
1693 if (type & BFD_MACH_O_N_STAB)
1694 {
1695 s->symbol.flags |= BSF_DEBUGGING;
1696 s->symbol.section = bfd_und_section_ptr;
1697 switch (type)
1698 {
1699 case N_FUN:
1700 case N_STSYM:
1701 case N_LCSYM:
1702 case N_BNSYM:
1703 case N_SLINE:
1704 case N_ENSYM:
1705 case N_ECOMM:
1706 case N_ECOML:
1707 case N_GSYM:
1708 if ((section > 0) && (section <= mdata->nsects))
1709 {
1710 s->symbol.section = mdata->sections[section - 1]->bfdsection;
1711 s->symbol.value =
1712 s->symbol.value - mdata->sections[section - 1]->addr;
1713 }
1714 break;
1715 }
1716 }
1717 else
1718 {
1719 if (type & BFD_MACH_O_N_PEXT)
1720 s->symbol.flags |= BSF_GLOBAL;
1721
1722 if (type & BFD_MACH_O_N_EXT)
1723 s->symbol.flags |= BSF_GLOBAL;
1724
1725 if (!(type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
1726 s->symbol.flags |= BSF_LOCAL;
1727
1728 switch (symtype)
1729 {
1730 case BFD_MACH_O_N_UNDF:
1731 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
1732 && s->symbol.value != 0)
1733 {
1734 /* A common symbol. */
1735 s->symbol.section = bfd_com_section_ptr;
1736 s->symbol.flags = BSF_NO_FLAGS;
1737 }
1738 else
1739 {
1740 s->symbol.section = bfd_und_section_ptr;
1741 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
1742 s->symbol.flags |= BSF_WEAK;
1743 }
1744 break;
1745 case BFD_MACH_O_N_PBUD:
1746 s->symbol.section = bfd_und_section_ptr;
1747 break;
1748 case BFD_MACH_O_N_ABS:
1749 s->symbol.section = bfd_abs_section_ptr;
1750 break;
1751 case BFD_MACH_O_N_SECT:
1752 if ((section > 0) && (section <= mdata->nsects))
1753 {
1754 s->symbol.section = mdata->sections[section - 1]->bfdsection;
1755 s->symbol.value =
1756 s->symbol.value - mdata->sections[section - 1]->addr;
1757 }
1758 else
1759 {
1760 /* Mach-O uses 0 to mean "no section"; not an error. */
1761 if (section != 0)
1762 {
1763 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
1764 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
1765 s->symbol.name, section, mdata->nsects);
1766 }
1767 s->symbol.section = bfd_und_section_ptr;
1768 }
1769 break;
1770 case BFD_MACH_O_N_INDR:
1771 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
1772 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined"),
1773 s->symbol.name);
1774 s->symbol.section = bfd_und_section_ptr;
1775 break;
1776 default:
1777 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
1778 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
1779 s->symbol.name, symtype);
1780 s->symbol.section = bfd_und_section_ptr;
1781 break;
1782 }
1783 }
1784
1785 return 0;
1786 }
1787
1788 static int
1789 bfd_mach_o_read_symtab_strtab (bfd *abfd)
1790 {
1791 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1792 bfd_mach_o_symtab_command *sym = mdata->symtab;
1793
1794 /* Fail if there is no symtab. */
1795 if (sym == NULL)
1796 return -1;
1797
1798 /* Success if already loaded. */
1799 if (sym->strtab)
1800 return 0;
1801
1802 if (abfd->flags & BFD_IN_MEMORY)
1803 {
1804 struct bfd_in_memory *b;
1805
1806 b = (struct bfd_in_memory *) abfd->iostream;
1807
1808 if ((sym->stroff + sym->strsize) > b->size)
1809 {
1810 bfd_set_error (bfd_error_file_truncated);
1811 return -1;
1812 }
1813 sym->strtab = (char *) b->buffer + sym->stroff;
1814 }
1815 else
1816 {
1817 sym->strtab = bfd_alloc (abfd, sym->strsize);
1818 if (sym->strtab == NULL)
1819 return -1;
1820
1821 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
1822 || bfd_bread ((void *) sym->strtab, sym->strsize, abfd) != sym->strsize)
1823 {
1824 bfd_set_error (bfd_error_file_truncated);
1825 return -1;
1826 }
1827 }
1828
1829 return 0;
1830 }
1831
1832 static int
1833 bfd_mach_o_read_symtab_symbols (bfd *abfd)
1834 {
1835 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1836 bfd_mach_o_symtab_command *sym = mdata->symtab;
1837 unsigned long i;
1838 int ret;
1839
1840 if (sym == NULL || sym->symbols)
1841 {
1842 /* Return now if there are no symbols or if already loaded. */
1843 return 0;
1844 }
1845
1846 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
1847
1848 if (sym->symbols == NULL)
1849 {
1850 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
1851 return -1;
1852 }
1853
1854 ret = bfd_mach_o_read_symtab_strtab (abfd);
1855 if (ret != 0)
1856 return ret;
1857
1858 for (i = 0; i < sym->nsyms; i++)
1859 {
1860 ret = bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
1861 if (ret != 0)
1862 return ret;
1863 }
1864
1865 return 0;
1866 }
1867
1868 int
1869 bfd_mach_o_read_dysymtab_symbol (bfd *abfd,
1870 bfd_mach_o_dysymtab_command *dysym,
1871 bfd_mach_o_symtab_command *sym,
1872 bfd_mach_o_asymbol *s,
1873 unsigned long i)
1874 {
1875 unsigned long isymoff = dysym->indirectsymoff + (i * 4);
1876 unsigned long sym_index;
1877 unsigned char buf[4];
1878
1879 BFD_ASSERT (i < dysym->nindirectsyms);
1880
1881 if (bfd_seek (abfd, isymoff, SEEK_SET) != 0
1882 || bfd_bread ((void *) buf, 4, abfd) != 4)
1883 {
1884 (*_bfd_error_handler) (_("bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu"),
1885 (unsigned long) 4, isymoff);
1886 return -1;
1887 }
1888 sym_index = bfd_h_get_32 (abfd, buf);
1889
1890 return bfd_mach_o_read_symtab_symbol (abfd, sym, s, sym_index);
1891 }
1892
1893 static const char *
1894 bfd_mach_o_i386_flavour_string (unsigned int flavour)
1895 {
1896 switch ((int) flavour)
1897 {
1898 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
1899 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
1900 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
1901 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
1902 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
1903 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
1904 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
1905 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
1906 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
1907 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
1908 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
1909 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
1910 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
1911 default: return "UNKNOWN";
1912 }
1913 }
1914
1915 static const char *
1916 bfd_mach_o_ppc_flavour_string (unsigned int flavour)
1917 {
1918 switch ((int) flavour)
1919 {
1920 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
1921 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
1922 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
1923 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
1924 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
1925 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
1926 default: return "UNKNOWN";
1927 }
1928 }
1929
1930 static int
1931 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
1932 {
1933 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1934 unsigned char buf[4];
1935 unsigned int nameoff;
1936
1937 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
1938 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
1939
1940 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1941 || bfd_bread ((void *) buf, 4, abfd) != 4)
1942 return -1;
1943
1944 nameoff = bfd_h_get_32 (abfd, buf + 0);
1945
1946 cmd->name_offset = command->offset + nameoff;
1947 cmd->name_len = command->len - nameoff;
1948 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
1949 if (cmd->name_str == NULL)
1950 return -1;
1951 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
1952 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
1953 return -1;
1954 return 0;
1955 }
1956
1957 static int
1958 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
1959 {
1960 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1961 unsigned char buf[16];
1962 unsigned int nameoff;
1963
1964 switch (command->type)
1965 {
1966 case BFD_MACH_O_LC_LOAD_DYLIB:
1967 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1968 case BFD_MACH_O_LC_ID_DYLIB:
1969 case BFD_MACH_O_LC_REEXPORT_DYLIB:
1970 break;
1971 default:
1972 BFD_FAIL ();
1973 return -1;
1974 }
1975
1976 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1977 || bfd_bread ((void *) buf, 16, abfd) != 16)
1978 return -1;
1979
1980 nameoff = bfd_h_get_32 (abfd, buf + 0);
1981 cmd->timestamp = bfd_h_get_32 (abfd, buf + 4);
1982 cmd->current_version = bfd_h_get_32 (abfd, buf + 8);
1983 cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12);
1984
1985 cmd->name_offset = command->offset + nameoff;
1986 cmd->name_len = command->len - nameoff;
1987 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
1988 if (cmd->name_str == NULL)
1989 return -1;
1990 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
1991 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
1992 return -1;
1993 return 0;
1994 }
1995
1996 static int
1997 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
1998 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
1999 {
2000 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2001
2002 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
2003 return 0;
2004 }
2005
2006 static int
2007 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
2008 {
2009 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2010 bfd_mach_o_thread_command *cmd = &command->command.thread;
2011 unsigned char buf[8];
2012 unsigned int offset;
2013 unsigned int nflavours;
2014 unsigned int i;
2015
2016 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
2017 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
2018
2019 /* Count the number of threads. */
2020 offset = 8;
2021 nflavours = 0;
2022 while (offset != command->len)
2023 {
2024 if (offset >= command->len)
2025 return -1;
2026
2027 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
2028 || bfd_bread ((void *) buf, 8, abfd) != 8)
2029 return -1;
2030
2031 offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
2032 nflavours++;
2033 }
2034
2035 /* Allocate threads. */
2036 cmd->flavours = bfd_alloc
2037 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
2038 if (cmd->flavours == NULL)
2039 return -1;
2040 cmd->nflavours = nflavours;
2041
2042 offset = 8;
2043 nflavours = 0;
2044 while (offset != command->len)
2045 {
2046 if (offset >= command->len)
2047 return -1;
2048
2049 if (nflavours >= cmd->nflavours)
2050 return -1;
2051
2052 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
2053 || bfd_bread ((void *) buf, 8, abfd) != 8)
2054 return -1;
2055
2056 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
2057 cmd->flavours[nflavours].offset = command->offset + offset + 8;
2058 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4;
2059 offset += cmd->flavours[nflavours].size + 8;
2060 nflavours++;
2061 }
2062
2063 for (i = 0; i < nflavours; i++)
2064 {
2065 asection *bfdsec;
2066 unsigned int snamelen;
2067 char *sname;
2068 const char *flavourstr;
2069 const char *prefix = "LC_THREAD";
2070 unsigned int j = 0;
2071
2072 switch (mdata->header.cputype)
2073 {
2074 case BFD_MACH_O_CPU_TYPE_POWERPC:
2075 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
2076 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
2077 break;
2078 case BFD_MACH_O_CPU_TYPE_I386:
2079 case BFD_MACH_O_CPU_TYPE_X86_64:
2080 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
2081 break;
2082 default:
2083 flavourstr = "UNKNOWN_ARCHITECTURE";
2084 break;
2085 }
2086
2087 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
2088 sname = bfd_alloc (abfd, snamelen);
2089 if (sname == NULL)
2090 return -1;
2091
2092 for (;;)
2093 {
2094 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
2095 if (bfd_get_section_by_name (abfd, sname) == NULL)
2096 break;
2097 j++;
2098 }
2099
2100 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
2101
2102 bfdsec->vma = 0;
2103 bfdsec->lma = 0;
2104 bfdsec->size = cmd->flavours[i].size;
2105 bfdsec->filepos = cmd->flavours[i].offset;
2106 bfdsec->alignment_power = 0x0;
2107
2108 cmd->section = bfdsec;
2109 }
2110
2111 return 0;
2112 }
2113
2114 static int
2115 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2116 {
2117 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2118 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2119 unsigned char buf[72];
2120
2121 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2122
2123 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2124 || bfd_bread ((void *) buf, 72, abfd) != 72)
2125 return -1;
2126
2127 cmd->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
2128 cmd->nlocalsym = bfd_h_get_32 (abfd, buf + 4);
2129 cmd->iextdefsym = bfd_h_get_32 (abfd, buf + 8);
2130 cmd->nextdefsym = bfd_h_get_32 (abfd, buf + 12);
2131 cmd->iundefsym = bfd_h_get_32 (abfd, buf + 16);
2132 cmd->nundefsym = bfd_h_get_32 (abfd, buf + 20);
2133 cmd->tocoff = bfd_h_get_32 (abfd, buf + 24);
2134 cmd->ntoc = bfd_h_get_32 (abfd, buf + 28);
2135 cmd->modtaboff = bfd_h_get_32 (abfd, buf + 32);
2136 cmd->nmodtab = bfd_h_get_32 (abfd, buf + 36);
2137 cmd->extrefsymoff = bfd_h_get_32 (abfd, buf + 40);
2138 cmd->nextrefsyms = bfd_h_get_32 (abfd, buf + 44);
2139 cmd->indirectsymoff = bfd_h_get_32 (abfd, buf + 48);
2140 cmd->nindirectsyms = bfd_h_get_32 (abfd, buf + 52);
2141 cmd->extreloff = bfd_h_get_32 (abfd, buf + 56);
2142 cmd->nextrel = bfd_h_get_32 (abfd, buf + 60);
2143 cmd->locreloff = bfd_h_get_32 (abfd, buf + 64);
2144 cmd->nlocrel = bfd_h_get_32 (abfd, buf + 68);
2145
2146 if (cmd->nmodtab != 0)
2147 {
2148 unsigned int i;
2149 int wide = bfd_mach_o_wide_p (abfd);
2150 unsigned int module_len = wide ? 56 : 52;
2151
2152 cmd->dylib_module =
2153 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
2154 if (cmd->dylib_module == NULL)
2155 return -1;
2156
2157 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2158 return -1;
2159
2160 for (i = 0; i < cmd->nmodtab; i++)
2161 {
2162 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2163 unsigned long v;
2164
2165 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
2166 return -1;
2167
2168 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
2169 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
2170 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
2171 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
2172 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
2173 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
2174 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
2175 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
2176 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
2177 v = bfd_h_get_32 (abfd, buf +36);
2178 module->iinit = v & 0xffff;
2179 module->iterm = (v >> 16) & 0xffff;
2180 v = bfd_h_get_32 (abfd, buf + 40);
2181 module->ninit = v & 0xffff;
2182 module->nterm = (v >> 16) & 0xffff;
2183 if (wide)
2184 {
2185 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
2186 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
2187 }
2188 else
2189 {
2190 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
2191 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
2192 }
2193 }
2194 }
2195
2196 if (cmd->ntoc != 0)
2197 {
2198 unsigned int i;
2199
2200 cmd->dylib_toc = bfd_alloc
2201 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
2202 if (cmd->dylib_toc == NULL)
2203 return -1;
2204
2205 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2206 return -1;
2207
2208 for (i = 0; i < cmd->ntoc; i++)
2209 {
2210 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2211
2212 if (bfd_bread ((void *) buf, 8, abfd) != 8)
2213 return -1;
2214
2215 toc->symbol_index = bfd_h_get_32 (abfd, buf + 0);
2216 toc->module_index = bfd_h_get_32 (abfd, buf + 4);
2217 }
2218 }
2219
2220 if (cmd->nindirectsyms != 0)
2221 {
2222 unsigned int i;
2223
2224 cmd->indirect_syms = bfd_alloc
2225 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
2226 if (cmd->indirect_syms == NULL)
2227 return -1;
2228
2229 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2230 return -1;
2231
2232 for (i = 0; i < cmd->nindirectsyms; i++)
2233 {
2234 unsigned int *is = &cmd->indirect_syms[i];
2235
2236 if (bfd_bread ((void *) buf, 4, abfd) != 4)
2237 return -1;
2238
2239 *is = bfd_h_get_32 (abfd, buf + 0);
2240 }
2241 }
2242
2243 if (cmd->nextrefsyms != 0)
2244 {
2245 unsigned long v;
2246 unsigned int i;
2247
2248 cmd->ext_refs = bfd_alloc
2249 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
2250 if (cmd->ext_refs == NULL)
2251 return -1;
2252
2253 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2254 return -1;
2255
2256 for (i = 0; i < cmd->nextrefsyms; i++)
2257 {
2258 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2259
2260 if (bfd_bread ((void *) buf, 4, abfd) != 4)
2261 return -1;
2262
2263 /* Fields isym and flags are written as bit-fields, thus we need
2264 a specific processing for endianness. */
2265 v = bfd_h_get_32 (abfd, buf + 0);
2266 if (bfd_big_endian (abfd))
2267 {
2268 ref->isym = (v >> 8) & 0xffffff;
2269 ref->flags = v & 0xff;
2270 }
2271 else
2272 {
2273 ref->isym = v & 0xffffff;
2274 ref->flags = (v >> 24) & 0xff;
2275 }
2276 }
2277 }
2278
2279 if (mdata->dysymtab)
2280 return -1;
2281 mdata->dysymtab = cmd;
2282
2283 return 0;
2284 }
2285
2286 static int
2287 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
2288 {
2289 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
2290 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2291 unsigned char buf[16];
2292
2293 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
2294
2295 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2296 || bfd_bread ((void *) buf, 16, abfd) != 16)
2297 return -1;
2298
2299 symtab->symoff = bfd_h_get_32 (abfd, buf);
2300 symtab->nsyms = bfd_h_get_32 (abfd, buf + 4);
2301 symtab->stroff = bfd_h_get_32 (abfd, buf + 8);
2302 symtab->strsize = bfd_h_get_32 (abfd, buf + 12);
2303 symtab->symbols = NULL;
2304 symtab->strtab = NULL;
2305
2306 if (symtab->nsyms != 0)
2307 abfd->flags |= HAS_SYMS;
2308
2309 if (mdata->symtab)
2310 return -1;
2311 mdata->symtab = symtab;
2312 return 0;
2313 }
2314
2315 static int
2316 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
2317 {
2318 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
2319
2320 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
2321
2322 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2323 || bfd_bread ((void *) cmd->uuid, 16, abfd) != 16)
2324 return -1;
2325
2326 return 0;
2327 }
2328
2329 static int
2330 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
2331 {
2332 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
2333 char buf[8];
2334
2335 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2336 || bfd_bread ((void *) buf, 8, abfd) != 8)
2337 return -1;
2338
2339 cmd->dataoff = bfd_get_32 (abfd, buf + 0);
2340 cmd->datasize = bfd_get_32 (abfd, buf + 4);
2341 return 0;
2342 }
2343
2344 static int
2345 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
2346 {
2347 bfd_mach_o_str_command *cmd = &command->command.str;
2348 char buf[4];
2349 unsigned long off;
2350
2351 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2352 || bfd_bread ((void *) buf, 4, abfd) != 4)
2353 return -1;
2354
2355 off = bfd_get_32 (abfd, buf + 0);
2356 cmd->stroff = command->offset + off;
2357 cmd->str_len = command->len - off;
2358 cmd->str = bfd_alloc (abfd, cmd->str_len);
2359 if (cmd->str == NULL)
2360 return -1;
2361 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
2362 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
2363 return -1;
2364 return 0;
2365 }
2366
2367 static int
2368 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
2369 {
2370 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
2371 char buf[40];
2372
2373 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2374 || bfd_bread ((void *) buf, sizeof (buf), abfd) != sizeof (buf))
2375 return -1;
2376
2377 cmd->rebase_off = bfd_get_32 (abfd, buf + 0);
2378 cmd->rebase_size = bfd_get_32 (abfd, buf + 4);
2379 cmd->bind_off = bfd_get_32 (abfd, buf + 8);
2380 cmd->bind_size = bfd_get_32 (abfd, buf + 12);
2381 cmd->weak_bind_off = bfd_get_32 (abfd, buf + 16);
2382 cmd->weak_bind_size = bfd_get_32 (abfd, buf + 20);
2383 cmd->lazy_bind_off = bfd_get_32 (abfd, buf + 24);
2384 cmd->lazy_bind_size = bfd_get_32 (abfd, buf + 28);
2385 cmd->export_off = bfd_get_32 (abfd, buf + 32);
2386 cmd->export_size = bfd_get_32 (abfd, buf + 36);
2387 return 0;
2388 }
2389
2390 static int
2391 bfd_mach_o_read_segment (bfd *abfd,
2392 bfd_mach_o_load_command *command,
2393 unsigned int wide)
2394 {
2395 unsigned char buf[64];
2396 bfd_mach_o_segment_command *seg = &command->command.segment;
2397 unsigned long i;
2398
2399 if (wide)
2400 {
2401 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
2402
2403 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2404 || bfd_bread ((void *) buf, 64, abfd) != 64)
2405 return -1;
2406
2407 memcpy (seg->segname, buf, 16);
2408 seg->segname[16] = '\0';
2409
2410 seg->vmaddr = bfd_h_get_64 (abfd, buf + 16);
2411 seg->vmsize = bfd_h_get_64 (abfd, buf + 24);
2412 seg->fileoff = bfd_h_get_64 (abfd, buf + 32);
2413 seg->filesize = bfd_h_get_64 (abfd, buf + 40);
2414 seg->maxprot = bfd_h_get_32 (abfd, buf + 48);
2415 seg->initprot = bfd_h_get_32 (abfd, buf + 52);
2416 seg->nsects = bfd_h_get_32 (abfd, buf + 56);
2417 seg->flags = bfd_h_get_32 (abfd, buf + 60);
2418 }
2419 else
2420 {
2421 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
2422
2423 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2424 || bfd_bread ((void *) buf, 48, abfd) != 48)
2425 return -1;
2426
2427 memcpy (seg->segname, buf, 16);
2428 seg->segname[16] = '\0';
2429
2430 seg->vmaddr = bfd_h_get_32 (abfd, buf + 16);
2431 seg->vmsize = bfd_h_get_32 (abfd, buf + 20);
2432 seg->fileoff = bfd_h_get_32 (abfd, buf + 24);
2433 seg->filesize = bfd_h_get_32 (abfd, buf + 28);
2434 seg->maxprot = bfd_h_get_32 (abfd, buf + 32);
2435 seg->initprot = bfd_h_get_32 (abfd, buf + 36);
2436 seg->nsects = bfd_h_get_32 (abfd, buf + 40);
2437 seg->flags = bfd_h_get_32 (abfd, buf + 44);
2438 }
2439
2440 if (seg->nsects != 0)
2441 {
2442 seg->sections = bfd_alloc (abfd, seg->nsects
2443 * sizeof (bfd_mach_o_section));
2444 if (seg->sections == NULL)
2445 return -1;
2446
2447 for (i = 0; i < seg->nsects; i++)
2448 {
2449 bfd_vma segoff;
2450 if (wide)
2451 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
2452 + (i * BFD_MACH_O_SECTION_64_SIZE);
2453 else
2454 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
2455 + (i * BFD_MACH_O_SECTION_SIZE);
2456
2457 if (bfd_mach_o_read_section
2458 (abfd, &seg->sections[i], segoff, seg->initprot, wide) != 0)
2459 return -1;
2460 }
2461 }
2462
2463 return 0;
2464 }
2465
2466 static int
2467 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
2468 {
2469 return bfd_mach_o_read_segment (abfd, command, 0);
2470 }
2471
2472 static int
2473 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
2474 {
2475 return bfd_mach_o_read_segment (abfd, command, 1);
2476 }
2477
2478 static int
2479 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
2480 {
2481 unsigned char buf[8];
2482
2483 /* Read command type and length. */
2484 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
2485 || bfd_bread ((void *) buf, 8, abfd) != 8)
2486 return -1;
2487
2488 command->type = bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD;
2489 command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD
2490 ? TRUE : FALSE);
2491 command->len = bfd_h_get_32 (abfd, buf + 4);
2492
2493 switch (command->type)
2494 {
2495 case BFD_MACH_O_LC_SEGMENT:
2496 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
2497 return -1;
2498 break;
2499 case BFD_MACH_O_LC_SEGMENT_64:
2500 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
2501 return -1;
2502 break;
2503 case BFD_MACH_O_LC_SYMTAB:
2504 if (bfd_mach_o_read_symtab (abfd, command) != 0)
2505 return -1;
2506 break;
2507 case BFD_MACH_O_LC_SYMSEG:
2508 break;
2509 case BFD_MACH_O_LC_THREAD:
2510 case BFD_MACH_O_LC_UNIXTHREAD:
2511 if (bfd_mach_o_read_thread (abfd, command) != 0)
2512 return -1;
2513 break;
2514 case BFD_MACH_O_LC_LOAD_DYLINKER:
2515 case BFD_MACH_O_LC_ID_DYLINKER:
2516 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
2517 return -1;
2518 break;
2519 case BFD_MACH_O_LC_LOAD_DYLIB:
2520 case BFD_MACH_O_LC_ID_DYLIB:
2521 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2522 case BFD_MACH_O_LC_REEXPORT_DYLIB:
2523 if (bfd_mach_o_read_dylib (abfd, command) != 0)
2524 return -1;
2525 break;
2526 case BFD_MACH_O_LC_PREBOUND_DYLIB:
2527 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
2528 return -1;
2529 break;
2530 case BFD_MACH_O_LC_LOADFVMLIB:
2531 case BFD_MACH_O_LC_IDFVMLIB:
2532 case BFD_MACH_O_LC_IDENT:
2533 case BFD_MACH_O_LC_FVMFILE:
2534 case BFD_MACH_O_LC_PREPAGE:
2535 case BFD_MACH_O_LC_ROUTINES:
2536 case BFD_MACH_O_LC_ROUTINES_64:
2537 break;
2538 case BFD_MACH_O_LC_SUB_FRAMEWORK:
2539 case BFD_MACH_O_LC_SUB_UMBRELLA:
2540 case BFD_MACH_O_LC_SUB_LIBRARY:
2541 case BFD_MACH_O_LC_SUB_CLIENT:
2542 case BFD_MACH_O_LC_RPATH:
2543 if (bfd_mach_o_read_str (abfd, command) != 0)
2544 return -1;
2545 break;
2546 case BFD_MACH_O_LC_DYSYMTAB:
2547 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
2548 return -1;
2549 break;
2550 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
2551 case BFD_MACH_O_LC_PREBIND_CKSUM:
2552 break;
2553 case BFD_MACH_O_LC_UUID:
2554 if (bfd_mach_o_read_uuid (abfd, command) != 0)
2555 return -1;
2556 break;
2557 case BFD_MACH_O_LC_CODE_SIGNATURE:
2558 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
2559 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
2560 return -1;
2561 break;
2562 case BFD_MACH_O_LC_DYLD_INFO:
2563 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
2564 return -1;
2565 break;
2566 default:
2567 (*_bfd_error_handler) (_("unable to read unknown load command 0x%lx"),
2568 (unsigned long) command->type);
2569 break;
2570 }
2571
2572 return 0;
2573 }
2574
2575 static void
2576 bfd_mach_o_flatten_sections (bfd *abfd)
2577 {
2578 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2579 long csect = 0;
2580 unsigned long i, j;
2581
2582 /* Count total number of sections. */
2583 mdata->nsects = 0;
2584
2585 for (i = 0; i < mdata->header.ncmds; i++)
2586 {
2587 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
2588 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
2589 {
2590 bfd_mach_o_segment_command *seg;
2591
2592 seg = &mdata->commands[i].command.segment;
2593 mdata->nsects += seg->nsects;
2594 }
2595 }
2596
2597 /* Allocate sections array. */
2598 mdata->sections = bfd_alloc (abfd,
2599 mdata->nsects * sizeof (bfd_mach_o_section *));
2600
2601 /* Fill the array. */
2602 csect = 0;
2603
2604 for (i = 0; i < mdata->header.ncmds; i++)
2605 {
2606 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
2607 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
2608 {
2609 bfd_mach_o_segment_command *seg;
2610
2611 seg = &mdata->commands[i].command.segment;
2612 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
2613
2614 for (j = 0; j < seg->nsects; j++)
2615 mdata->sections[csect++] = &seg->sections[j];
2616 }
2617 }
2618 }
2619
2620 int
2621 bfd_mach_o_scan_start_address (bfd *abfd)
2622 {
2623 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2624 bfd_mach_o_thread_command *cmd = NULL;
2625 unsigned long i;
2626
2627 for (i = 0; i < mdata->header.ncmds; i++)
2628 {
2629 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
2630 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
2631 {
2632 if (cmd == NULL)
2633 cmd = &mdata->commands[i].command.thread;
2634 else
2635 return 0;
2636 }
2637 }
2638
2639 if (cmd == NULL)
2640 return 0;
2641
2642 for (i = 0; i < cmd->nflavours; i++)
2643 {
2644 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
2645 && (cmd->flavours[i].flavour
2646 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
2647 {
2648 unsigned char buf[4];
2649
2650 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
2651 || bfd_bread (buf, 4, abfd) != 4)
2652 return -1;
2653
2654 abfd->start_address = bfd_h_get_32 (abfd, buf);
2655 }
2656 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
2657 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
2658 {
2659 unsigned char buf[4];
2660
2661 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
2662 || bfd_bread (buf, 4, abfd) != 4)
2663 return -1;
2664
2665 abfd->start_address = bfd_h_get_32 (abfd, buf);
2666 }
2667 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
2668 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
2669 {
2670 unsigned char buf[8];
2671
2672 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
2673 || bfd_bread (buf, 8, abfd) != 8)
2674 return -1;
2675
2676 abfd->start_address = bfd_h_get_64 (abfd, buf);
2677 }
2678 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
2679 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
2680 {
2681 unsigned char buf[8];
2682
2683 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
2684 || bfd_bread (buf, 8, abfd) != 8)
2685 return -1;
2686
2687 abfd->start_address = bfd_h_get_64 (abfd, buf);
2688 }
2689 }
2690
2691 return 0;
2692 }
2693
2694 bfd_boolean
2695 bfd_mach_o_set_arch_mach (bfd *abfd,
2696 enum bfd_architecture arch,
2697 unsigned long machine)
2698 {
2699 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
2700
2701 /* If this isn't the right architecture for this backend, and this
2702 isn't the generic backend, fail. */
2703 if (arch != bed->arch
2704 && arch != bfd_arch_unknown
2705 && bed->arch != bfd_arch_unknown)
2706 return FALSE;
2707
2708 return bfd_default_set_arch_mach (abfd, arch, machine);
2709 }
2710
2711 int
2712 bfd_mach_o_scan (bfd *abfd,
2713 bfd_mach_o_header *header,
2714 bfd_mach_o_data_struct *mdata)
2715 {
2716 unsigned int i;
2717 enum bfd_architecture cputype;
2718 unsigned long cpusubtype;
2719 unsigned int hdrsize;
2720
2721 hdrsize = mach_o_wide_p (header) ?
2722 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2723
2724 mdata->header = *header;
2725
2726 abfd->flags = abfd->flags & BFD_IN_MEMORY;
2727 switch (header->filetype)
2728 {
2729 case BFD_MACH_O_MH_OBJECT:
2730 abfd->flags |= HAS_RELOC;
2731 break;
2732 case BFD_MACH_O_MH_EXECUTE:
2733 abfd->flags |= EXEC_P;
2734 break;
2735 case BFD_MACH_O_MH_DYLIB:
2736 case BFD_MACH_O_MH_BUNDLE:
2737 abfd->flags |= DYNAMIC;
2738 break;
2739 }
2740
2741 abfd->tdata.mach_o_data = mdata;
2742
2743 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
2744 &cputype, &cpusubtype);
2745 if (cputype == bfd_arch_unknown)
2746 {
2747 (*_bfd_error_handler) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
2748 header->cputype, header->cpusubtype);
2749 return -1;
2750 }
2751
2752 bfd_set_arch_mach (abfd, cputype, cpusubtype);
2753
2754 if (header->ncmds != 0)
2755 {
2756 mdata->commands = bfd_alloc
2757 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
2758 if (mdata->commands == NULL)
2759 return -1;
2760
2761 for (i = 0; i < header->ncmds; i++)
2762 {
2763 bfd_mach_o_load_command *cur = &mdata->commands[i];
2764
2765 if (i == 0)
2766 cur->offset = hdrsize;
2767 else
2768 {
2769 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
2770 cur->offset = prev->offset + prev->len;
2771 }
2772
2773 if (bfd_mach_o_read_command (abfd, cur) < 0)
2774 return -1;
2775 }
2776 }
2777
2778 if (bfd_mach_o_scan_start_address (abfd) < 0)
2779 return -1;
2780
2781 bfd_mach_o_flatten_sections (abfd);
2782 return 0;
2783 }
2784
2785 bfd_boolean
2786 bfd_mach_o_mkobject_init (bfd *abfd)
2787 {
2788 bfd_mach_o_data_struct *mdata = NULL;
2789
2790 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
2791 if (mdata == NULL)
2792 return FALSE;
2793 abfd->tdata.mach_o_data = mdata;
2794
2795 mdata->header.magic = 0;
2796 mdata->header.cputype = 0;
2797 mdata->header.cpusubtype = 0;
2798 mdata->header.filetype = 0;
2799 mdata->header.ncmds = 0;
2800 mdata->header.sizeofcmds = 0;
2801 mdata->header.flags = 0;
2802 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
2803 mdata->commands = NULL;
2804 mdata->nsects = 0;
2805 mdata->sections = NULL;
2806
2807 return TRUE;
2808 }
2809
2810 static bfd_boolean
2811 bfd_mach_o_gen_mkobject (bfd *abfd)
2812 {
2813 bfd_mach_o_data_struct *mdata;
2814
2815 if (!bfd_mach_o_mkobject_init (abfd))
2816 return FALSE;
2817
2818 mdata = bfd_mach_o_get_data (abfd);
2819 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
2820 mdata->header.cputype = 0;
2821 mdata->header.cpusubtype = 0;
2822 mdata->header.byteorder = abfd->xvec->byteorder;
2823 mdata->header.version = 1;
2824
2825 return TRUE;
2826 }
2827
2828 const bfd_target *
2829 bfd_mach_o_header_p (bfd *abfd,
2830 bfd_mach_o_filetype filetype,
2831 bfd_mach_o_cpu_type cputype)
2832 {
2833 struct bfd_preserve preserve;
2834 bfd_mach_o_header header;
2835
2836 preserve.marker = NULL;
2837 if (!bfd_mach_o_read_header (abfd, &header))
2838 goto wrong;
2839
2840 if (! (header.byteorder == BFD_ENDIAN_BIG
2841 || header.byteorder == BFD_ENDIAN_LITTLE))
2842 {
2843 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
2844 (unsigned long) header.byteorder);
2845 goto wrong;
2846 }
2847
2848 if (! ((header.byteorder == BFD_ENDIAN_BIG
2849 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
2850 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
2851 || (header.byteorder == BFD_ENDIAN_LITTLE
2852 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
2853 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
2854 goto wrong;
2855
2856 /* Check cputype and filetype.
2857 In case of wildcard, do not accept magics that are handled by existing
2858 targets. */
2859 if (cputype)
2860 {
2861 if (header.cputype != cputype)
2862 goto wrong;
2863 }
2864 else
2865 {
2866 switch (header.cputype)
2867 {
2868 case BFD_MACH_O_CPU_TYPE_I386:
2869 /* Handled by mach-o-i386 */
2870 goto wrong;
2871 default:
2872 break;
2873 }
2874 }
2875 if (filetype)
2876 {
2877 if (header.filetype != filetype)
2878 goto wrong;
2879 }
2880 else
2881 {
2882 switch (header.filetype)
2883 {
2884 case BFD_MACH_O_MH_CORE:
2885 /* Handled by core_p */
2886 goto wrong;
2887 default:
2888 break;
2889 }
2890 }
2891
2892 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
2893 if (preserve.marker == NULL
2894 || !bfd_preserve_save (abfd, &preserve))
2895 goto fail;
2896
2897 if (bfd_mach_o_scan (abfd, &header,
2898 (bfd_mach_o_data_struct *) preserve.marker) != 0)
2899 goto wrong;
2900
2901 bfd_preserve_finish (abfd, &preserve);
2902 return abfd->xvec;
2903
2904 wrong:
2905 bfd_set_error (bfd_error_wrong_format);
2906
2907 fail:
2908 if (preserve.marker != NULL)
2909 bfd_preserve_restore (abfd, &preserve);
2910 return NULL;
2911 }
2912
2913 static const bfd_target *
2914 bfd_mach_o_gen_object_p (bfd *abfd)
2915 {
2916 return bfd_mach_o_header_p (abfd, 0, 0);
2917 }
2918
2919 static const bfd_target *
2920 bfd_mach_o_gen_core_p (bfd *abfd)
2921 {
2922 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
2923 }
2924
2925 typedef struct mach_o_fat_archentry
2926 {
2927 unsigned long cputype;
2928 unsigned long cpusubtype;
2929 unsigned long offset;
2930 unsigned long size;
2931 unsigned long align;
2932 } mach_o_fat_archentry;
2933
2934 typedef struct mach_o_fat_data_struct
2935 {
2936 unsigned long magic;
2937 unsigned long nfat_arch;
2938 mach_o_fat_archentry *archentries;
2939 } mach_o_fat_data_struct;
2940
2941 const bfd_target *
2942 bfd_mach_o_archive_p (bfd *abfd)
2943 {
2944 mach_o_fat_data_struct *adata = NULL;
2945 unsigned char buf[20];
2946 unsigned long i;
2947
2948 if (bfd_seek (abfd, 0, SEEK_SET) != 0
2949 || bfd_bread ((void *) buf, 8, abfd) != 8)
2950 goto error;
2951
2952 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
2953 if (adata == NULL)
2954 goto error;
2955
2956 adata->magic = bfd_getb32 (buf);
2957 adata->nfat_arch = bfd_getb32 (buf + 4);
2958 if (adata->magic != 0xcafebabe)
2959 goto error;
2960 /* Avoid matching Java bytecode files, which have the same magic number.
2961 In the Java bytecode file format this field contains the JVM version,
2962 which starts at 43.0. */
2963 if (adata->nfat_arch > 30)
2964 goto error;
2965
2966 adata->archentries =
2967 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
2968 if (adata->archentries == NULL)
2969 goto error;
2970
2971 for (i = 0; i < adata->nfat_arch; i++)
2972 {
2973 if (bfd_seek (abfd, 8 + 20 * i, SEEK_SET) != 0
2974 || bfd_bread ((void *) buf, 20, abfd) != 20)
2975 goto error;
2976 adata->archentries[i].cputype = bfd_getb32 (buf);
2977 adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
2978 adata->archentries[i].offset = bfd_getb32 (buf + 8);
2979 adata->archentries[i].size = bfd_getb32 (buf + 12);
2980 adata->archentries[i].align = bfd_getb32 (buf + 16);
2981 }
2982
2983 abfd->tdata.mach_o_fat_data = adata;
2984 return abfd->xvec;
2985
2986 error:
2987 if (adata != NULL)
2988 bfd_release (abfd, adata);
2989 bfd_set_error (bfd_error_wrong_format);
2990 return NULL;
2991 }
2992
2993 bfd *
2994 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
2995 {
2996 mach_o_fat_data_struct *adata;
2997 mach_o_fat_archentry *entry = NULL;
2998 unsigned long i;
2999 bfd *nbfd;
3000 enum bfd_architecture arch_type;
3001 unsigned long arch_subtype;
3002
3003 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
3004 BFD_ASSERT (adata != NULL);
3005
3006 /* Find index of previous entry. */
3007 if (prev == NULL)
3008 i = 0; /* Start at first one. */
3009 else
3010 {
3011 for (i = 0; i < adata->nfat_arch; i++)
3012 {
3013 if (adata->archentries[i].offset == prev->origin)
3014 break;
3015 }
3016
3017 if (i == adata->nfat_arch)
3018 {
3019 /* Not found. */
3020 bfd_set_error (bfd_error_bad_value);
3021 return NULL;
3022 }
3023 i++; /* Get next entry. */
3024 }
3025
3026 if (i >= adata->nfat_arch)
3027 {
3028 bfd_set_error (bfd_error_no_more_archived_files);
3029 return NULL;
3030 }
3031
3032 entry = &adata->archentries[i];
3033 nbfd = _bfd_new_bfd_contained_in (archive);
3034 if (nbfd == NULL)
3035 return NULL;
3036
3037 nbfd->origin = entry->offset;
3038
3039 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
3040 &arch_type, &arch_subtype);
3041 /* Create the member filename.
3042 Use FILENAME:ARCH_NAME. */
3043 {
3044 char *s = NULL;
3045 const char *arch_name;
3046 size_t arch_file_len = strlen (bfd_get_filename (archive));
3047
3048 arch_name = bfd_printable_arch_mach (arch_type, arch_subtype);
3049 s = bfd_malloc (arch_file_len + 1 + strlen (arch_name) + 1);
3050 if (s == NULL)
3051 return NULL;
3052 memcpy (s, bfd_get_filename (archive), arch_file_len);
3053 s[arch_file_len] = ':';
3054 strcpy (s + arch_file_len + 1, arch_name);
3055 nbfd->filename = s;
3056 }
3057 nbfd->iostream = NULL;
3058 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
3059
3060 return nbfd;
3061 }
3062
3063 /* If ABFD format is FORMAT and architecture is ARCH, return it.
3064 If ABFD is a fat image containing a member that corresponds to FORMAT
3065 and ARCH, returns it.
3066 In other case, returns NULL.
3067 This function allows transparent uses of fat images. */
3068 bfd *
3069 bfd_mach_o_fat_extract (bfd *abfd,
3070 bfd_format format,
3071 const bfd_arch_info_type *arch)
3072 {
3073 bfd *res;
3074 mach_o_fat_data_struct *adata;
3075 unsigned int i;
3076
3077 if (bfd_check_format (abfd, format))
3078 {
3079 if (bfd_get_arch_info (abfd) == arch)
3080 return abfd;
3081 return NULL;
3082 }
3083 if (!bfd_check_format (abfd, bfd_archive)
3084 || abfd->xvec != &mach_o_fat_vec)
3085 return NULL;
3086
3087 /* This is a Mach-O fat image. */
3088 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
3089 BFD_ASSERT (adata != NULL);
3090
3091 for (i = 0; i < adata->nfat_arch; i++)
3092 {
3093 struct mach_o_fat_archentry *e = &adata->archentries[i];
3094 enum bfd_architecture cpu_type;
3095 unsigned long cpu_subtype;
3096
3097 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
3098 &cpu_type, &cpu_subtype);
3099 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
3100 continue;
3101
3102 /* The architecture is found. */
3103 res = _bfd_new_bfd_contained_in (abfd);
3104 if (res == NULL)
3105 return NULL;
3106
3107 res->origin = e->offset;
3108
3109 res->filename = strdup (abfd->filename);
3110 res->iostream = NULL;
3111
3112 if (bfd_check_format (res, format))
3113 {
3114 BFD_ASSERT (bfd_get_arch_info (res) == arch);
3115 return res;
3116 }
3117 bfd_close (res);
3118 return NULL;
3119 }
3120
3121 return NULL;
3122 }
3123
3124 int
3125 bfd_mach_o_lookup_section (bfd *abfd,
3126 asection *section,
3127 bfd_mach_o_load_command **mcommand,
3128 bfd_mach_o_section **msection)
3129 {
3130 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
3131 unsigned int i, j, num;
3132
3133 bfd_mach_o_load_command *ncmd = NULL;
3134 bfd_mach_o_section *nsect = NULL;
3135
3136 BFD_ASSERT (mcommand != NULL);
3137 BFD_ASSERT (msection != NULL);
3138
3139 num = 0;
3140 for (i = 0; i < md->header.ncmds; i++)
3141 {
3142 struct bfd_mach_o_load_command *cmd = &md->commands[i];
3143 struct bfd_mach_o_segment_command *seg = NULL;
3144
3145 if (cmd->type != BFD_MACH_O_LC_SEGMENT
3146 || cmd->type != BFD_MACH_O_LC_SEGMENT_64)
3147 continue;
3148 seg = &cmd->command.segment;
3149
3150 for (j = 0; j < seg->nsects; j++)
3151 {
3152 struct bfd_mach_o_section *sect = &seg->sections[j];
3153
3154 if (sect->bfdsection == section)
3155 {
3156 if (num == 0)
3157 {
3158 nsect = sect;
3159 ncmd = cmd;
3160 }
3161 num++;
3162 }
3163 }
3164 }
3165
3166 *mcommand = ncmd;
3167 *msection = nsect;
3168 return num;
3169 }
3170
3171 int
3172 bfd_mach_o_lookup_command (bfd *abfd,
3173 bfd_mach_o_load_command_type type,
3174 bfd_mach_o_load_command **mcommand)
3175 {
3176 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
3177 bfd_mach_o_load_command *ncmd = NULL;
3178 unsigned int i, num;
3179
3180 BFD_ASSERT (md != NULL);
3181 BFD_ASSERT (mcommand != NULL);
3182
3183 num = 0;
3184 for (i = 0; i < md->header.ncmds; i++)
3185 {
3186 struct bfd_mach_o_load_command *cmd = &md->commands[i];
3187
3188 if (cmd->type != type)
3189 continue;
3190
3191 if (num == 0)
3192 ncmd = cmd;
3193 num++;
3194 }
3195
3196 *mcommand = ncmd;
3197 return num;
3198 }
3199
3200 unsigned long
3201 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
3202 {
3203 switch (type)
3204 {
3205 case BFD_MACH_O_CPU_TYPE_MC680x0:
3206 return 0x04000000;
3207 case BFD_MACH_O_CPU_TYPE_MC88000:
3208 return 0xffffe000;
3209 case BFD_MACH_O_CPU_TYPE_POWERPC:
3210 return 0xc0000000;
3211 case BFD_MACH_O_CPU_TYPE_I386:
3212 return 0xc0000000;
3213 case BFD_MACH_O_CPU_TYPE_SPARC:
3214 return 0xf0000000;
3215 case BFD_MACH_O_CPU_TYPE_I860:
3216 return 0;
3217 case BFD_MACH_O_CPU_TYPE_HPPA:
3218 return 0xc0000000 - 0x04000000;
3219 default:
3220 return 0;
3221 }
3222 }
3223
3224 typedef struct bfd_mach_o_xlat_name
3225 {
3226 const char *name;
3227 unsigned long val;
3228 }
3229 bfd_mach_o_xlat_name;
3230
3231 static void
3232 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table,
3233 unsigned long val,
3234 FILE *file)
3235 {
3236 int first = 1;
3237
3238 for (; table->name; table++)
3239 {
3240 if (table->val & val)
3241 {
3242 if (!first)
3243 fprintf (file, "+");
3244 fprintf (file, "%s", table->name);
3245 val &= ~table->val;
3246 first = 0;
3247 }
3248 }
3249 if (val)
3250 {
3251 if (!first)
3252 fprintf (file, "+");
3253 fprintf (file, "0x%lx", val);
3254 return;
3255 }
3256 if (first)
3257 fprintf (file, "-");
3258 }
3259
3260 static const char *
3261 bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val)
3262 {
3263 for (; table->name; table++)
3264 if (table->val == val)
3265 return table->name;
3266 return "*UNKNOWN*";
3267 }
3268
3269 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] =
3270 {
3271 { "vax", BFD_MACH_O_CPU_TYPE_VAX },
3272 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 },
3273 { "i386", BFD_MACH_O_CPU_TYPE_I386 },
3274 { "mips", BFD_MACH_O_CPU_TYPE_MIPS },
3275 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 },
3276 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA },
3277 { "arm", BFD_MACH_O_CPU_TYPE_ARM },
3278 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 },
3279 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC },
3280 { "i860", BFD_MACH_O_CPU_TYPE_I860 },
3281 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA },
3282 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC },
3283 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 },
3284 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 },
3285 { NULL, 0}
3286 };
3287
3288 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] =
3289 {
3290 { "object", BFD_MACH_O_MH_OBJECT },
3291 { "execute", BFD_MACH_O_MH_EXECUTE },
3292 { "fvmlib", BFD_MACH_O_MH_FVMLIB },
3293 { "core", BFD_MACH_O_MH_CORE },
3294 { "preload", BFD_MACH_O_MH_PRELOAD },
3295 { "dylib", BFD_MACH_O_MH_DYLIB },
3296 { "dylinker", BFD_MACH_O_MH_DYLINKER },
3297 { "bundle", BFD_MACH_O_MH_BUNDLE },
3298 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB },
3299 { "dym", BFD_MACH_O_MH_DSYM },
3300 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE },
3301 { NULL, 0}
3302 };
3303
3304 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] =
3305 {
3306 { "noundefs", BFD_MACH_O_MH_NOUNDEFS },
3307 { "incrlink", BFD_MACH_O_MH_INCRLINK },
3308 { "dyldlink", BFD_MACH_O_MH_DYLDLINK },
3309 { "bindatload", BFD_MACH_O_MH_BINDATLOAD },
3310 { "prebound", BFD_MACH_O_MH_PREBOUND },
3311 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS },
3312 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT },
3313 { "twolevel", BFD_MACH_O_MH_TWOLEVEL },
3314 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT },
3315 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS },
3316 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING },
3317 { "prebindable", BFD_MACH_O_MH_PREBINDABLE },
3318 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND },
3319 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS },
3320 { "canonical", BFD_MACH_O_MH_CANONICAL },
3321 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES },
3322 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK },
3323 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION },
3324 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE },
3325 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE },
3326 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS },
3327 { "pie", BFD_MACH_O_MH_PIE },
3328 { NULL, 0}
3329 };
3330
3331 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
3332 {
3333 { "regular", BFD_MACH_O_S_REGULAR},
3334 { "zerofill", BFD_MACH_O_S_ZEROFILL},
3335 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
3336 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
3337 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
3338 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
3339 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
3340 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
3341 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
3342 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
3343 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
3344 { "coalesced", BFD_MACH_O_S_COALESCED},
3345 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
3346 { "interposing", BFD_MACH_O_S_INTERPOSING},
3347 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
3348 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
3349 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
3350 { NULL, 0}
3351 };
3352
3353 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
3354 {
3355 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
3356 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
3357 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
3358 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
3359 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
3360 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
3361 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
3362 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
3363 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
3364 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
3365 { NULL, 0}
3366 };
3367
3368 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] =
3369 {
3370 { "segment", BFD_MACH_O_LC_SEGMENT},
3371 { "symtab", BFD_MACH_O_LC_SYMTAB},
3372 { "symseg", BFD_MACH_O_LC_SYMSEG},
3373 { "thread", BFD_MACH_O_LC_THREAD},
3374 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD},
3375 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB},
3376 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB},
3377 { "ident", BFD_MACH_O_LC_IDENT},
3378 { "fvmfile", BFD_MACH_O_LC_FVMFILE},
3379 { "prepage", BFD_MACH_O_LC_PREPAGE},
3380 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB},
3381 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB},
3382 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB},
3383 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER},
3384 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER},
3385 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB},
3386 { "routines", BFD_MACH_O_LC_ROUTINES},
3387 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK},
3388 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA},
3389 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT},
3390 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY},
3391 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS},
3392 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM},
3393 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB},
3394 { "segment_64", BFD_MACH_O_LC_SEGMENT_64},
3395 { "routines_64", BFD_MACH_O_LC_ROUTINES_64},
3396 { "uuid", BFD_MACH_O_LC_UUID},
3397 { "rpath", BFD_MACH_O_LC_RPATH},
3398 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE},
3399 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO},
3400 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB},
3401 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB},
3402 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO},
3403 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO},
3404 { NULL, 0}
3405 };
3406
3407 static void
3408 bfd_mach_o_print_private_header (bfd *abfd, FILE *file)
3409 {
3410 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3411 bfd_mach_o_header *h = &mdata->header;
3412
3413 fputs (_("Mach-O header:\n"), file);
3414 fprintf (file, _(" magic : %08lx\n"), h->magic);
3415 fprintf (file, _(" cputype : %08lx (%s)\n"), h->cputype,
3416 bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype));
3417 fprintf (file, _(" cpusubtype: %08lx\n"), h->cpusubtype);
3418 fprintf (file, _(" filetype : %08lx (%s)\n"),
3419 h->filetype,
3420 bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype));
3421 fprintf (file, _(" ncmds : %08lx (%lu)\n"), h->ncmds, h->ncmds);
3422 fprintf (file, _(" sizeofcmds: %08lx\n"), h->sizeofcmds);
3423 fprintf (file, _(" flags : %08lx ("), h->flags);
3424 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags, file);
3425 fputs (_(")\n"), file);
3426 fprintf (file, _(" reserved : %08x\n"), h->reserved);
3427 }
3428
3429 static void
3430 bfd_mach_o_print_section_map (bfd *abfd, FILE *file)
3431 {
3432 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3433 unsigned int i, j;
3434 unsigned int sec_nbr = 0;
3435
3436 fputs (_("Segments and Sections:\n"), file);
3437 fputs (_(" #: Segment name Section name Address\n"), file);
3438
3439 for (i = 0; i < mdata->header.ncmds; i++)
3440 {
3441 bfd_mach_o_segment_command *seg;
3442
3443 if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT
3444 && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64)
3445 continue;
3446
3447 seg = &mdata->commands[i].command.segment;
3448
3449 fprintf (file, "[Segment %-16s ", seg->segname);
3450 fprintf_vma (file, seg->vmaddr);
3451 fprintf (file, "-");
3452 fprintf_vma (file, seg->vmaddr + seg->vmsize - 1);
3453 fputc (' ', file);
3454 fputc (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-', file);
3455 fputc (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-', file);
3456 fputc (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-', file);
3457 fprintf (file, "]\n");
3458 for (j = 0; j < seg->nsects; j++)
3459 {
3460 bfd_mach_o_section *sec = &seg->sections[j];
3461 fprintf (file, "%02u: %-16s %-16s ", ++sec_nbr,
3462 sec->segname, sec->sectname);
3463 fprintf_vma (file, sec->addr);
3464 fprintf (file, " ");
3465 fprintf_vma (file, sec->size);
3466 fprintf (file, " %08lx\n", sec->flags);
3467 }
3468 }
3469 }
3470
3471 static void
3472 bfd_mach_o_print_section (bfd *abfd ATTRIBUTE_UNUSED,
3473 bfd_mach_o_section *sec, FILE *file)
3474 {
3475 fprintf (file, " Section: %-16s %-16s (bfdname: %s)\n",
3476 sec->sectname, sec->segname, sec->bfdsection->name);
3477 fprintf (file, " addr: ");
3478 fprintf_vma (file, sec->addr);
3479 fprintf (file, " size: ");
3480 fprintf_vma (file, sec->size);
3481 fprintf (file, " offset: ");
3482 fprintf_vma (file, sec->offset);
3483 fprintf (file, "\n");
3484 fprintf (file, " align: %ld", sec->align);
3485 fprintf (file, " nreloc: %lu reloff: ", sec->nreloc);
3486 fprintf_vma (file, sec->reloff);
3487 fprintf (file, "\n");
3488 fprintf (file, " flags: %08lx (type: %s", sec->flags,
3489 bfd_mach_o_get_name (bfd_mach_o_section_type_name,
3490 sec->flags & BFD_MACH_O_SECTION_TYPE_MASK));
3491 fprintf (file, " attr: ");
3492 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name,
3493 sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK,
3494 file);
3495 fprintf (file, ")\n");
3496 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3497 {
3498 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
3499 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
3500 case BFD_MACH_O_S_SYMBOL_STUBS:
3501 fprintf (file, " first indirect sym: %lu", sec->reserved1);
3502 fprintf (file, " (%u entries)",
3503 bfd_mach_o_section_get_nbr_indirect (abfd, sec));
3504 break;
3505 default:
3506 fprintf (file, " reserved1: 0x%lx", sec->reserved1);
3507 break;
3508 }
3509 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3510 {
3511 case BFD_MACH_O_S_SYMBOL_STUBS:
3512 fprintf (file, " stub size: %lu", sec->reserved2);
3513 break;
3514 default:
3515 fprintf (file, " reserved2: 0x%lx", sec->reserved2);
3516 break;
3517 }
3518 fprintf (file, " reserved3: 0x%lx\n", sec->reserved3);
3519 }
3520
3521 static void
3522 bfd_mach_o_print_segment (bfd *abfd ATTRIBUTE_UNUSED,
3523 bfd_mach_o_load_command *cmd, FILE *file)
3524 {
3525 bfd_mach_o_segment_command *seg = &cmd->command.segment;
3526 unsigned int i;
3527
3528 fprintf (file, " name: %s\n", *seg->segname ? seg->segname : "*none*");
3529 fprintf (file, " vmaddr: ");
3530 fprintf_vma (file, seg->vmaddr);
3531 fprintf (file, " vmsize: ");
3532 fprintf_vma (file, seg->vmsize);
3533 fprintf (file, "\n");
3534 fprintf (file, " fileoff: ");
3535 fprintf_vma (file, seg->fileoff);
3536 fprintf (file, " filesize: ");
3537 fprintf_vma (file, (bfd_vma)seg->filesize);
3538 fprintf (file, " endoff: ");
3539 fprintf_vma (file, (bfd_vma)(seg->fileoff + seg->filesize));
3540 fprintf (file, "\n");
3541 fprintf (file, " nsects: %lu ", seg->nsects);
3542 fprintf (file, " flags: %lx\n", seg->flags);
3543 for (i = 0; i < seg->nsects; i++)
3544 bfd_mach_o_print_section (abfd, &seg->sections[i], file);
3545 }
3546
3547 static void
3548 bfd_mach_o_print_dysymtab (bfd *abfd ATTRIBUTE_UNUSED,
3549 bfd_mach_o_load_command *cmd, FILE *file)
3550 {
3551 bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
3552 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3553 unsigned int i;
3554
3555 fprintf (file, " local symbols: idx: %10lu num: %-8lu",
3556 dysymtab->ilocalsym, dysymtab->nlocalsym);
3557 fprintf (file, " (nxtidx: %lu)\n",
3558 dysymtab->ilocalsym + dysymtab->nlocalsym);
3559 fprintf (file, " external symbols: idx: %10lu num: %-8lu",
3560 dysymtab->iextdefsym, dysymtab->nextdefsym);
3561 fprintf (file, " (nxtidx: %lu)\n",
3562 dysymtab->iextdefsym + dysymtab->nextdefsym);
3563 fprintf (file, " undefined symbols: idx: %10lu num: %-8lu",
3564 dysymtab->iundefsym, dysymtab->nundefsym);
3565 fprintf (file, " (nxtidx: %lu)\n",
3566 dysymtab->iundefsym + dysymtab->nundefsym);
3567 fprintf (file, " table of content: off: 0x%08lx num: %-8lu",
3568 dysymtab->tocoff, dysymtab->ntoc);
3569 fprintf (file, " (endoff: 0x%08lx)\n",
3570 dysymtab->tocoff
3571 + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE);
3572 fprintf (file, " module table: off: 0x%08lx num: %-8lu",
3573 dysymtab->modtaboff, dysymtab->nmodtab);
3574 fprintf (file, " (endoff: 0x%08lx)\n",
3575 dysymtab->modtaboff + dysymtab->nmodtab
3576 * (mach_o_wide_p (&mdata->header) ?
3577 BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE));
3578 fprintf (file, " external reference table: off: 0x%08lx num: %-8lu",
3579 dysymtab->extrefsymoff, dysymtab->nextrefsyms);
3580 fprintf (file, " (endoff: 0x%08lx)\n",
3581 dysymtab->extrefsymoff
3582 + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE);
3583 fprintf (file, " indirect symbol table: off: 0x%08lx num: %-8lu",
3584 dysymtab->indirectsymoff, dysymtab->nindirectsyms);
3585 fprintf (file, " (endoff: 0x%08lx)\n",
3586 dysymtab->indirectsymoff
3587 + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE);
3588 fprintf (file, " external relocation table: off: 0x%08lx num: %-8lu",
3589 dysymtab->extreloff, dysymtab->nextrel);
3590 fprintf (file, " (endoff: 0x%08lx)\n",
3591 dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE);
3592 fprintf (file, " local relocation table: off: 0x%08lx num: %-8lu",
3593 dysymtab->locreloff, dysymtab->nlocrel);
3594 fprintf (file, " (endoff: 0x%08lx)\n",
3595 dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE);
3596
3597 if (dysymtab->ntoc > 0
3598 || dysymtab->nindirectsyms > 0
3599 || dysymtab->nextrefsyms > 0)
3600 {
3601 /* Try to read the symbols to display the toc or indirect symbols. */
3602 bfd_mach_o_read_symtab_symbols (abfd);
3603 }
3604 else if (dysymtab->nmodtab > 0)
3605 {
3606 /* Try to read the strtab to display modules name. */
3607 bfd_mach_o_read_symtab_strtab (abfd);
3608 }
3609
3610 for (i = 0; i < dysymtab->nmodtab; i++)
3611 {
3612 bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i];
3613 fprintf (file, " module %u:\n", i);
3614 fprintf (file, " name: %lu", module->module_name_idx);
3615 if (mdata->symtab && mdata->symtab->strtab)
3616 fprintf (file, ": %s",
3617 mdata->symtab->strtab + module->module_name_idx);
3618 fprintf (file, "\n");
3619 fprintf (file, " extdefsym: idx: %8lu num: %lu\n",
3620 module->iextdefsym, module->nextdefsym);
3621 fprintf (file, " refsym: idx: %8lu num: %lu\n",
3622 module->irefsym, module->nrefsym);
3623 fprintf (file, " localsym: idx: %8lu num: %lu\n",
3624 module->ilocalsym, module->nlocalsym);
3625 fprintf (file, " extrel: idx: %8lu num: %lu\n",
3626 module->iextrel, module->nextrel);
3627 fprintf (file, " init: idx: %8u num: %u\n",
3628 module->iinit, module->ninit);
3629 fprintf (file, " term: idx: %8u num: %u\n",
3630 module->iterm, module->nterm);
3631 fprintf (file, " objc_module_info: addr: ");
3632 fprintf_vma (file, module->objc_module_info_addr);
3633 fprintf (file, " size: %lu\n", module->objc_module_info_size);
3634 }
3635
3636 if (dysymtab->ntoc > 0)
3637 {
3638 bfd_mach_o_symtab_command *symtab = mdata->symtab;
3639
3640 fprintf (file, " table of content: (symbol/module)\n");
3641 for (i = 0; i < dysymtab->ntoc; i++)
3642 {
3643 bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i];
3644
3645 fprintf (file, " %4u: ", i);
3646 if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms)
3647 {
3648 const char *name = symtab->symbols[toc->symbol_index].symbol.name;
3649 fprintf (file, "%s (%lu)", name ? name : "*invalid*",
3650 toc->symbol_index);
3651 }
3652 else
3653 fprintf (file, "%lu", toc->symbol_index);
3654
3655 fprintf (file, " / ");
3656 if (symtab && symtab->strtab
3657 && toc->module_index < dysymtab->nmodtab)
3658 {
3659 bfd_mach_o_dylib_module *mod;
3660 mod = &dysymtab->dylib_module[toc->module_index];
3661 fprintf (file, "%s (%lu)",
3662 symtab->strtab + mod->module_name_idx,
3663 toc->module_index);
3664 }
3665 else
3666 fprintf (file, "%lu", toc->module_index);
3667
3668 fprintf (file, "\n");
3669 }
3670 }
3671
3672 if (dysymtab->nindirectsyms != 0)
3673 {
3674 fprintf (file, " indirect symbols:\n");
3675
3676 for (i = 0; i < mdata->nsects; i++)
3677 {
3678 bfd_mach_o_section *sec = mdata->sections[i];
3679 unsigned int j, first, last;
3680 bfd_mach_o_symtab_command *symtab = mdata->symtab;
3681 bfd_vma addr;
3682 bfd_vma entry_size;
3683
3684 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3685 {
3686 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
3687 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
3688 case BFD_MACH_O_S_SYMBOL_STUBS:
3689 first = sec->reserved1;
3690 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
3691 addr = sec->addr;
3692 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
3693 fprintf (file, " for section %s.%s:\n",
3694 sec->segname, sec->sectname);
3695 for (j = first; j < last; j++)
3696 {
3697 unsigned int isym = dysymtab->indirect_syms[j];
3698
3699 fprintf (file, " ");
3700 fprintf_vma (file, addr);
3701 fprintf (file, " %5u: 0x%08x", j, isym);
3702 if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL)
3703 fprintf (file, " LOCAL");
3704 if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS)
3705 fprintf (file, " ABSOLUTE");
3706 if (symtab && symtab->symbols
3707 && isym < symtab->nsyms
3708 && symtab->symbols[isym].symbol.name)
3709 fprintf (file, " %s", symtab->symbols[isym].symbol.name);
3710 fprintf (file, "\n");
3711 addr += entry_size;
3712 }
3713 break;
3714 default:
3715 break;
3716 }
3717 }
3718 }
3719 if (dysymtab->nextrefsyms > 0)
3720 {
3721 bfd_mach_o_symtab_command *symtab = mdata->symtab;
3722
3723 fprintf (file, " external reference table: (symbol flags)\n");
3724 for (i = 0; i < dysymtab->nextrefsyms; i++)
3725 {
3726 bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i];
3727
3728 fprintf (file, " %4u: %5lu 0x%02lx", i, ref->isym, ref->flags);
3729 if (symtab && symtab->symbols
3730 && ref->isym < symtab->nsyms
3731 && symtab->symbols[ref->isym].symbol.name)
3732 fprintf (file, " %s", symtab->symbols[ref->isym].symbol.name);
3733 fprintf (file, "\n");
3734 }
3735 }
3736
3737 }
3738
3739 static void
3740 bfd_mach_o_print_dyld_info (bfd *abfd ATTRIBUTE_UNUSED,
3741 bfd_mach_o_load_command *cmd, FILE *file)
3742 {
3743 bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info;
3744
3745 fprintf (file, " rebase: off: 0x%08x size: %-8u\n",
3746 info->rebase_off, info->rebase_size);
3747 fprintf (file, " bind: off: 0x%08x size: %-8u\n",
3748 info->bind_off, info->bind_size);
3749 fprintf (file, " weak bind: off: 0x%08x size: %-8u\n",
3750 info->weak_bind_off, info->weak_bind_size);
3751 fprintf (file, " lazy bind: off: 0x%08x size: %-8u\n",
3752 info->lazy_bind_off, info->lazy_bind_size);
3753 fprintf (file, " export: off: 0x%08x size: %-8u\n",
3754 info->export_off, info->export_size);
3755 }
3756
3757 bfd_boolean
3758 bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, void * ptr)
3759 {
3760 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3761 FILE *file = (FILE *) ptr;
3762 unsigned int i;
3763
3764 bfd_mach_o_print_private_header (abfd, file);
3765 fputc ('\n', file);
3766
3767 for (i = 0; i < mdata->header.ncmds; i++)
3768 {
3769 bfd_mach_o_load_command *cmd = &mdata->commands[i];
3770
3771 fprintf (file, "Load command %s:",
3772 bfd_mach_o_get_name (bfd_mach_o_load_command_name, cmd->type));
3773 switch (cmd->type)
3774 {
3775 case BFD_MACH_O_LC_SEGMENT:
3776 case BFD_MACH_O_LC_SEGMENT_64:
3777 bfd_mach_o_print_segment (abfd, cmd, file);
3778 break;
3779 case BFD_MACH_O_LC_UUID:
3780 {
3781 bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
3782 unsigned int j;
3783
3784 for (j = 0; j < sizeof (uuid->uuid); j ++)
3785 fprintf (file, " %02x", uuid->uuid[j]);
3786 fputc ('\n', file);
3787 }
3788 break;
3789 case BFD_MACH_O_LC_LOAD_DYLIB:
3790 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3791 case BFD_MACH_O_LC_REEXPORT_DYLIB:
3792 case BFD_MACH_O_LC_ID_DYLIB:
3793 {
3794 bfd_mach_o_dylib_command *dylib = &cmd->command.dylib;
3795 fprintf (file, " %s\n", dylib->name_str);
3796 fprintf (file, " time stamp: 0x%08lx\n",
3797 dylib->timestamp);
3798 fprintf (file, " current version: 0x%08lx\n",
3799 dylib->current_version);
3800 fprintf (file, " comptibility version: 0x%08lx\n",
3801 dylib->compatibility_version);
3802 break;
3803 }
3804 case BFD_MACH_O_LC_LOAD_DYLINKER:
3805 case BFD_MACH_O_LC_ID_DYLINKER:
3806 fprintf (file, " %s\n", cmd->command.dylinker.name_str);
3807 break;
3808 case BFD_MACH_O_LC_SYMTAB:
3809 {
3810 bfd_mach_o_symtab_command *symtab = &cmd->command.symtab;
3811 fprintf (file,
3812 "\n"
3813 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
3814 symtab->symoff, symtab->nsyms,
3815 symtab->symoff + symtab->nsyms
3816 * (mach_o_wide_p (&mdata->header)
3817 ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE));
3818 fprintf (file,
3819 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
3820 symtab->stroff, symtab->strsize,
3821 symtab->stroff + symtab->strsize);
3822 break;
3823 }
3824 case BFD_MACH_O_LC_DYSYMTAB:
3825 fprintf (file, "\n");
3826 bfd_mach_o_print_dysymtab (abfd, cmd, file);
3827 break;
3828 case BFD_MACH_O_LC_CODE_SIGNATURE:
3829 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3830 {
3831 bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit;
3832 fprintf
3833 (file, "\n"
3834 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
3835 linkedit->dataoff, linkedit->datasize,
3836 linkedit->dataoff + linkedit->datasize);
3837 break;
3838 }
3839 case BFD_MACH_O_LC_SUB_FRAMEWORK:
3840 case BFD_MACH_O_LC_SUB_UMBRELLA:
3841 case BFD_MACH_O_LC_SUB_LIBRARY:
3842 case BFD_MACH_O_LC_SUB_CLIENT:
3843 case BFD_MACH_O_LC_RPATH:
3844 {
3845 bfd_mach_o_str_command *str = &cmd->command.str;
3846 fprintf (file, " %s\n", str->str);
3847 break;
3848 }
3849 case BFD_MACH_O_LC_THREAD:
3850 case BFD_MACH_O_LC_UNIXTHREAD:
3851 {
3852 bfd_mach_o_thread_command *thread = &cmd->command.thread;
3853 unsigned int j;
3854 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
3855
3856 fprintf (file, " nflavours: %lu\n", thread->nflavours);
3857 for (j = 0; j < thread->nflavours; j++)
3858 {
3859 bfd_mach_o_thread_flavour *flavour = &thread->flavours[j];
3860
3861 fprintf (file, " %2u: flavour: 0x%08lx offset: 0x%08lx"
3862 " size: 0x%08lx\n",
3863 j, flavour->flavour, flavour->offset,
3864 flavour->size);
3865 if (bed->_bfd_mach_o_print_thread)
3866 {
3867 char *buf = bfd_malloc (flavour->size);
3868
3869 if (buf
3870 && bfd_seek (abfd, flavour->offset, SEEK_SET) == 0
3871 && (bfd_bread (buf, flavour->size, abfd)
3872 == flavour->size))
3873 (*bed->_bfd_mach_o_print_thread)(abfd, flavour,
3874 file, buf);
3875 free (buf);
3876 }
3877 }
3878 break;
3879 }
3880 case BFD_MACH_O_LC_DYLD_INFO:
3881 fprintf (file, "\n");
3882 bfd_mach_o_print_dyld_info (abfd, cmd, file);
3883 break;
3884 default:
3885 fprintf (file, "\n");
3886 break;
3887 }
3888 fputc ('\n', file);
3889 }
3890
3891 bfd_mach_o_print_section_map (abfd, file);
3892
3893 return TRUE;
3894 }
3895
3896 int
3897 bfd_mach_o_core_fetch_environment (bfd *abfd,
3898 unsigned char **rbuf,
3899 unsigned int *rlen)
3900 {
3901 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3902 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
3903 unsigned int i = 0;
3904
3905 for (i = 0; i < mdata->header.ncmds; i++)
3906 {
3907 bfd_mach_o_load_command *cur = &mdata->commands[i];
3908 bfd_mach_o_segment_command *seg = NULL;
3909
3910 if (cur->type != BFD_MACH_O_LC_SEGMENT)
3911 continue;
3912
3913 seg = &cur->command.segment;
3914
3915 if ((seg->vmaddr + seg->vmsize) == stackaddr)
3916 {
3917 unsigned long start = seg->fileoff;
3918 unsigned long end = seg->fileoff + seg->filesize;
3919 unsigned char *buf = bfd_malloc (1024);
3920 unsigned long size = 1024;
3921
3922 for (;;)
3923 {
3924 bfd_size_type nread = 0;
3925 unsigned long offset;
3926 int found_nonnull = 0;
3927
3928 if (size > (end - start))
3929 size = (end - start);
3930
3931 buf = bfd_realloc_or_free (buf, size);
3932 if (buf == NULL)
3933 return -1;
3934
3935 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
3936 {
3937 free (buf);
3938 return -1;
3939 }
3940
3941 nread = bfd_bread (buf, size, abfd);
3942
3943 if (nread != size)
3944 {
3945 free (buf);
3946 return -1;
3947 }
3948
3949 for (offset = 4; offset <= size; offset += 4)
3950 {
3951 unsigned long val;
3952
3953 val = *((unsigned long *) (buf + size - offset));
3954 if (! found_nonnull)
3955 {
3956 if (val != 0)
3957 found_nonnull = 1;
3958 }
3959 else if (val == 0x0)
3960 {
3961 unsigned long bottom;
3962 unsigned long top;
3963
3964 bottom = seg->fileoff + seg->filesize - offset;
3965 top = seg->fileoff + seg->filesize - 4;
3966 *rbuf = bfd_malloc (top - bottom);
3967 *rlen = top - bottom;
3968
3969 memcpy (*rbuf, buf + size - *rlen, *rlen);
3970 free (buf);
3971 return 0;
3972 }
3973 }
3974
3975 if (size == (end - start))
3976 break;
3977
3978 size *= 2;
3979 }
3980
3981 free (buf);
3982 }
3983 }
3984
3985 return -1;
3986 }
3987
3988 char *
3989 bfd_mach_o_core_file_failing_command (bfd *abfd)
3990 {
3991 unsigned char *buf = NULL;
3992 unsigned int len = 0;
3993 int ret = -1;
3994
3995 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
3996 if (ret < 0)
3997 return NULL;
3998
3999 return (char *) buf;
4000 }
4001
4002 int
4003 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
4004 {
4005 return 0;
4006 }
4007
4008 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4009 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4010
4011 #define bfd_mach_o_swap_reloc_in NULL
4012 #define bfd_mach_o_swap_reloc_out NULL
4013 #define bfd_mach_o_print_thread NULL
4014
4015 #define TARGET_NAME mach_o_be_vec
4016 #define TARGET_STRING "mach-o-be"
4017 #define TARGET_ARCHITECTURE bfd_arch_unknown
4018 #define TARGET_BIG_ENDIAN 1
4019 #define TARGET_ARCHIVE 0
4020 #include "mach-o-target.c"
4021
4022 #undef TARGET_NAME
4023 #undef TARGET_STRING
4024 #undef TARGET_ARCHITECTURE
4025 #undef TARGET_BIG_ENDIAN
4026 #undef TARGET_ARCHIVE
4027
4028 #define TARGET_NAME mach_o_le_vec
4029 #define TARGET_STRING "mach-o-le"
4030 #define TARGET_ARCHITECTURE bfd_arch_unknown
4031 #define TARGET_BIG_ENDIAN 0
4032 #define TARGET_ARCHIVE 0
4033
4034 #include "mach-o-target.c"
4035
4036 #undef TARGET_NAME
4037 #undef TARGET_STRING
4038 #undef TARGET_ARCHITECTURE
4039 #undef TARGET_BIG_ENDIAN
4040 #undef TARGET_ARCHIVE
4041
4042 /* Not yet handled: creating an archive. */
4043 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4044
4045 /* Not used. */
4046 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4047 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4048 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4049 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4050 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4051 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4052 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4053 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4054 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4055 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4056
4057 #define TARGET_NAME mach_o_fat_vec
4058 #define TARGET_STRING "mach-o-fat"
4059 #define TARGET_ARCHITECTURE bfd_arch_unknown
4060 #define TARGET_BIG_ENDIAN 1
4061 #define TARGET_ARCHIVE 1
4062
4063 #include "mach-o-target.c"
4064
4065 #undef TARGET_NAME
4066 #undef TARGET_STRING
4067 #undef TARGET_ARCHITECTURE
4068 #undef TARGET_BIG_ENDIAN
4069 #undef TARGET_ARCHIVE