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