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