1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
27 #include "libiberty.h"
28 #include "aout/stab_gnu.h"
29 #include "mach-o/reloc.h"
30 #include "mach-o/external.h"
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
37 #define FILE_ALIGN(off, algn) \
38 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
40 static int bfd_mach_o_read_symtab_symbols (bfd
*);
43 bfd_mach_o_version (bfd
*abfd
)
45 bfd_mach_o_data_struct
*mdata
= NULL
;
47 BFD_ASSERT (bfd_mach_o_valid (abfd
));
48 mdata
= bfd_mach_o_get_data (abfd
);
50 return mdata
->header
.version
;
54 bfd_mach_o_valid (bfd
*abfd
)
56 if (abfd
== NULL
|| abfd
->xvec
== NULL
)
59 if (abfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
62 if (bfd_mach_o_get_data (abfd
) == NULL
)
67 static INLINE bfd_boolean
68 mach_o_wide_p (bfd_mach_o_header
*header
)
70 switch (header
->version
)
82 static INLINE bfd_boolean
83 bfd_mach_o_wide_p (bfd
*abfd
)
85 return mach_o_wide_p (&bfd_mach_o_get_data (abfd
)->header
);
88 /* Tables to translate well known Mach-O segment/section names to bfd
89 names. Use of canonical names (such as .text or .debug_frame) is required
92 struct mach_o_section_name_xlat
95 const char *mach_o_name
;
99 static const struct mach_o_section_name_xlat dwarf_section_names_xlat
[] =
101 { ".debug_frame", "__debug_frame", SEC_DEBUGGING
},
102 { ".debug_info", "__debug_info", SEC_DEBUGGING
},
103 { ".debug_abbrev", "__debug_abbrev", SEC_DEBUGGING
},
104 { ".debug_aranges", "__debug_aranges", SEC_DEBUGGING
},
105 { ".debug_macinfo", "__debug_macinfo", SEC_DEBUGGING
},
106 { ".debug_line", "__debug_line", SEC_DEBUGGING
},
107 { ".debug_loc", "__debug_loc", SEC_DEBUGGING
},
108 { ".debug_pubnames", "__debug_pubnames", SEC_DEBUGGING
},
109 { ".debug_pubtypes", "__debug_pubtypes", SEC_DEBUGGING
},
110 { ".debug_str", "__debug_str", SEC_DEBUGGING
},
111 { ".debug_ranges", "__debug_ranges", SEC_DEBUGGING
},
115 static const struct mach_o_section_name_xlat text_section_names_xlat
[] =
117 { ".text", "__text", SEC_CODE
| SEC_LOAD
},
118 { ".const", "__const", SEC_READONLY
| SEC_DATA
| SEC_LOAD
},
119 { ".cstring", "__cstring", SEC_READONLY
| SEC_DATA
| SEC_LOAD
},
120 { ".eh_frame", "__eh_frame", SEC_READONLY
| SEC_LOAD
},
124 static const struct mach_o_section_name_xlat data_section_names_xlat
[] =
126 { ".data", "__data", SEC_DATA
| SEC_LOAD
},
127 { ".const_data", "__const", SEC_DATA
| SEC_LOAD
},
128 { ".dyld", "__dyld", SEC_DATA
| SEC_LOAD
},
129 { ".lazy_symbol_ptr", "__la_symbol_ptr", SEC_DATA
| SEC_LOAD
},
130 { ".non_lazy_symbol_ptr", "__nl_symbol_ptr", SEC_DATA
| SEC_LOAD
},
131 { ".bss", "__bss", SEC_NO_FLAGS
},
135 struct mach_o_segment_name_xlat
140 /* List of known sections for the segment. */
141 const struct mach_o_section_name_xlat
*sections
;
144 /* List of known segment names. */
146 static const struct mach_o_segment_name_xlat segsec_names_xlat
[] =
148 { "__TEXT", text_section_names_xlat
},
149 { "__DATA", data_section_names_xlat
},
150 { "__DWARF", dwarf_section_names_xlat
},
154 /* Mach-O to bfd names. */
157 bfd_mach_o_normalize_section_name (const char *segname
, const char *sectname
,
158 const char **name
, flagword
*flags
)
160 const struct mach_o_segment_name_xlat
*seg
;
163 *flags
= SEC_NO_FLAGS
;
165 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
167 if (strncmp (seg
->segname
, segname
, BFD_MACH_O_SEGNAME_SIZE
) == 0)
169 const struct mach_o_section_name_xlat
*sec
;
171 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
173 if (strncmp (sec
->mach_o_name
, sectname
,
174 BFD_MACH_O_SECTNAME_SIZE
) == 0)
176 *name
= sec
->bfd_name
;
187 bfd_mach_o_convert_section_name_to_bfd
188 (bfd
*abfd
, const char *segname
, const char *sectname
,
189 const char **name
, flagword
*flags
)
193 const char *pfx
= "";
195 /* First search for a canonical name. */
196 bfd_mach_o_normalize_section_name (segname
, sectname
, name
, flags
);
198 /* Return now if found. */
202 len
= strlen (segname
) + 1 + strlen (sectname
) + 1;
204 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
205 with an underscore. */
206 if (segname
[0] != '_')
208 static const char seg_pfx
[] = "LC_SEGMENT.";
211 len
+= sizeof (seg_pfx
) - 1;
214 res
= bfd_alloc (abfd
, len
);
217 snprintf (res
, len
, "%s%s.%s", pfx
, segname
, sectname
);
219 *flags
= SEC_NO_FLAGS
;
222 /* Convert a bfd section name to a Mach-O segment + section name. */
225 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
227 bfd_mach_o_section
*section
)
229 const struct mach_o_segment_name_xlat
*seg
;
230 const char *name
= bfd_get_section_name (abfd
, sect
);
236 /* List of well known names. They all start with a dot. */
238 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
240 const struct mach_o_section_name_xlat
*sec
;
242 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
244 if (strcmp (sec
->bfd_name
, name
) == 0)
246 strcpy (section
->segname
, seg
->segname
);
247 strcpy (section
->sectname
, sec
->mach_o_name
);
253 /* Strip LC_SEGMENT. prefix. */
254 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
258 dot
= strchr (name
, '.');
261 /* Try to split name into segment and section names. */
262 if (dot
&& dot
!= name
)
265 seclen
= len
- (dot
+ 1 - name
);
267 if (seglen
< 16 && seclen
< 16)
269 memcpy (section
->segname
, name
, seglen
);
270 section
->segname
[seglen
] = 0;
271 memcpy (section
->sectname
, dot
+ 1, seclen
);
272 section
->sectname
[seclen
] = 0;
279 memcpy (section
->segname
, name
, len
);
280 section
->segname
[len
] = 0;
281 memcpy (section
->sectname
, name
, len
);
282 section
->sectname
[len
] = 0;
285 /* Return the size of an entry for section SEC.
286 Must be called only for symbol pointer section and symbol stubs
290 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
292 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
294 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
295 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
296 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
297 case BFD_MACH_O_S_SYMBOL_STUBS
:
298 return sec
->reserved2
;
305 /* Return the number of indirect symbols for a section.
306 Must be called only for symbol pointer section and symbol stubs
310 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
314 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
318 return sec
->size
/ elsz
;
322 /* Copy any private info we understand from the input symbol
323 to the output symbol. */
326 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
327 asymbol
*isymbol ATTRIBUTE_UNUSED
,
328 bfd
*obfd ATTRIBUTE_UNUSED
,
329 asymbol
*osymbol ATTRIBUTE_UNUSED
)
334 /* Copy any private info we understand from the input section
335 to the output section. */
338 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
339 asection
*isection ATTRIBUTE_UNUSED
,
340 bfd
*obfd ATTRIBUTE_UNUSED
,
341 asection
*osection ATTRIBUTE_UNUSED
)
346 /* Copy any private info we understand from the input bfd
347 to the output bfd. */
350 bfd_mach_o_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
352 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
353 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
356 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
357 BFD_ASSERT (bfd_mach_o_valid (obfd
));
359 /* FIXME: copy commands. */
364 /* Count the total number of symbols. */
367 bfd_mach_o_count_symbols (bfd
*abfd
)
369 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
371 if (mdata
->symtab
== NULL
)
373 return mdata
->symtab
->nsyms
;
377 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
379 long nsyms
= bfd_mach_o_count_symbols (abfd
);
381 return ((nsyms
+ 1) * sizeof (asymbol
*));
385 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
387 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
388 long nsyms
= bfd_mach_o_count_symbols (abfd
);
389 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
397 /* Do not try to read symbols if there are none. */
402 if (bfd_mach_o_read_symtab_symbols (abfd
) != 0)
404 (*_bfd_error_handler
) (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
408 BFD_ASSERT (sym
->symbols
!= NULL
);
410 for (j
= 0; j
< sym
->nsyms
; j
++)
411 alocation
[j
] = &sym
->symbols
[j
].symbol
;
419 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
420 long symcount ATTRIBUTE_UNUSED
,
421 asymbol
**syms ATTRIBUTE_UNUSED
,
422 long dynsymcount ATTRIBUTE_UNUSED
,
423 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
426 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
427 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
428 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
430 unsigned long count
, i
, j
, n
;
437 if (dysymtab
== NULL
|| symtab
== NULL
|| symtab
->symbols
== NULL
)
440 if (dysymtab
->nindirectsyms
== 0)
443 count
= dysymtab
->nindirectsyms
;
444 size
= count
* sizeof (asymbol
) + 1;
446 for (j
= 0; j
< count
; j
++)
448 unsigned int isym
= dysymtab
->indirect_syms
[j
];
450 if (isym
< symtab
->nsyms
&& symtab
->symbols
[isym
].symbol
.name
)
451 size
+= strlen (symtab
->symbols
[isym
].symbol
.name
) + sizeof ("$stub");
454 s
= *ret
= (asymbol
*) bfd_malloc (size
);
457 names
= (char *) (s
+ count
);
462 for (i
= 0; i
< mdata
->nsects
; i
++)
464 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
465 unsigned int first
, last
;
469 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
471 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
472 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
473 case BFD_MACH_O_S_SYMBOL_STUBS
:
474 first
= sec
->reserved1
;
475 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
477 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
478 for (j
= first
; j
< last
; j
++)
480 unsigned int isym
= dysymtab
->indirect_syms
[j
];
482 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
483 s
->section
= sec
->bfdsection
;
484 s
->value
= addr
- sec
->addr
;
487 if (isym
< symtab
->nsyms
488 && symtab
->symbols
[isym
].symbol
.name
)
490 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
495 memcpy (names
, sym
, len
);
497 memcpy (names
, "$stub", sizeof ("$stub"));
498 names
+= sizeof ("$stub");
517 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
521 bfd_symbol_info (symbol
, ret
);
525 bfd_mach_o_print_symbol (bfd
*abfd
,
528 bfd_print_symbol_type how
)
530 FILE *file
= (FILE *) afile
;
532 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
536 case bfd_print_symbol_name
:
537 fprintf (file
, "%s", symbol
->name
);
540 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
541 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
542 name
= bfd_get_stab_name (asym
->n_type
);
544 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
546 case BFD_MACH_O_N_UNDF
:
549 case BFD_MACH_O_N_ABS
:
552 case BFD_MACH_O_N_INDR
:
555 case BFD_MACH_O_N_PBUD
:
558 case BFD_MACH_O_N_SECT
:
567 fprintf (file
, " %02x %-6s %02x %04x",
568 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
569 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
570 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
571 fprintf (file
, " %-5s", symbol
->section
->name
);
572 fprintf (file
, " %s", symbol
->name
);
577 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
578 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED
,
579 enum bfd_architecture
*type
,
580 unsigned long *subtype
)
582 *subtype
= bfd_arch_unknown
;
586 case BFD_MACH_O_CPU_TYPE_VAX
: *type
= bfd_arch_vax
; break;
587 case BFD_MACH_O_CPU_TYPE_MC680x0
: *type
= bfd_arch_m68k
; break;
588 case BFD_MACH_O_CPU_TYPE_I386
:
589 *type
= bfd_arch_i386
;
590 *subtype
= bfd_mach_i386_i386
;
592 case BFD_MACH_O_CPU_TYPE_X86_64
:
593 *type
= bfd_arch_i386
;
594 *subtype
= bfd_mach_x86_64
;
596 case BFD_MACH_O_CPU_TYPE_MIPS
: *type
= bfd_arch_mips
; break;
597 case BFD_MACH_O_CPU_TYPE_MC98000
: *type
= bfd_arch_m98k
; break;
598 case BFD_MACH_O_CPU_TYPE_HPPA
: *type
= bfd_arch_hppa
; break;
599 case BFD_MACH_O_CPU_TYPE_ARM
: *type
= bfd_arch_arm
; break;
600 case BFD_MACH_O_CPU_TYPE_MC88000
: *type
= bfd_arch_m88k
; break;
601 case BFD_MACH_O_CPU_TYPE_SPARC
:
602 *type
= bfd_arch_sparc
;
603 *subtype
= bfd_mach_sparc
;
605 case BFD_MACH_O_CPU_TYPE_I860
: *type
= bfd_arch_i860
; break;
606 case BFD_MACH_O_CPU_TYPE_ALPHA
: *type
= bfd_arch_alpha
; break;
607 case BFD_MACH_O_CPU_TYPE_POWERPC
:
608 *type
= bfd_arch_powerpc
;
609 *subtype
= bfd_mach_ppc
;
611 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
612 *type
= bfd_arch_powerpc
;
613 *subtype
= bfd_mach_ppc64
;
616 *type
= bfd_arch_unknown
;
622 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
624 struct mach_o_header_external raw
;
627 size
= mach_o_wide_p (header
) ?
628 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
630 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
631 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
632 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
633 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
634 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
635 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
636 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
638 if (mach_o_wide_p (header
))
639 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
641 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
642 || bfd_bwrite (&raw
, size
, abfd
) != size
)
649 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
651 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
653 struct mach_o_thread_command_external raw
;
656 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
657 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
660 for (i
= 0; i
< cmd
->nflavours
; i
++)
662 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
663 BFD_ASSERT (cmd
->flavours
[i
].offset
==
664 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
666 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
667 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
669 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
670 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
673 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
680 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
683 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
687 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
688 struct mach_o_reloc_info_external
*raw
,
689 arelent
*res
, asymbol
**syms
)
691 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
692 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
693 bfd_mach_o_reloc_info reloc
;
698 addr
= bfd_get_32 (abfd
, raw
->r_address
);
699 symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
701 if (addr
& BFD_MACH_O_SR_SCATTERED
)
705 /* Scattered relocation.
706 Extract section and offset from r_value. */
707 res
->sym_ptr_ptr
= NULL
;
709 for (j
= 0; j
< mdata
->nsects
; j
++)
711 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
712 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
714 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
715 res
->addend
= symnum
- sect
->addr
;
719 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
720 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
721 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
722 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
723 reloc
.r_scattered
= 1;
727 unsigned int num
= BFD_MACH_O_GET_R_SYMBOLNUM (symnum
);
730 if (symnum
& BFD_MACH_O_R_EXTERN
)
737 BFD_ASSERT (num
!= 0);
738 BFD_ASSERT (num
<= mdata
->nsects
);
739 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
740 /* For a symbol defined in section S, the addend (stored in the
741 binary) contains the address of the section. To comply with
742 bfd conventio, substract the section address.
743 Use the address from the header, so that the user can modify
744 the vma of the section. */
745 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
748 res
->sym_ptr_ptr
= sym
;
749 reloc
.r_type
= BFD_MACH_O_GET_R_TYPE (symnum
);
750 reloc
.r_length
= BFD_MACH_O_GET_R_LENGTH (symnum
);
751 reloc
.r_pcrel
= (symnum
& BFD_MACH_O_R_PCREL
) ? 1 : 0;
752 reloc
.r_scattered
= 0;
755 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
761 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
763 arelent
*res
, asymbol
**syms
)
766 struct mach_o_reloc_info_external
*native_relocs
;
767 bfd_size_type native_size
;
769 /* Allocate and read relocs. */
770 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
772 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
773 if (native_relocs
== NULL
)
776 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
777 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
780 for (i
= 0; i
< count
; i
++)
782 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
786 free (native_relocs
);
789 free (native_relocs
);
794 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
795 arelent
**rels
, asymbol
**syms
)
797 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
801 if (asect
->reloc_count
== 0)
804 /* No need to go further if we don't know how to read relocs. */
805 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
808 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
812 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
813 asect
->reloc_count
, res
, syms
) < 0)
819 for (i
= 0; i
< asect
->reloc_count
; i
++)
822 asect
->relocation
= res
;
828 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
830 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
832 if (mdata
->dysymtab
== NULL
)
834 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
)
835 * sizeof (arelent
*);
839 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
840 struct bfd_symbol
**syms
)
842 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
843 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
844 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
848 if (dysymtab
== NULL
)
850 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
853 /* No need to go further if we don't know how to read relocs. */
854 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
857 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
) * sizeof (arelent
));
861 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
862 dysymtab
->nextrel
, res
, syms
) < 0)
868 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
870 res
+ dysymtab
->nextrel
, syms
) < 0)
876 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
883 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
885 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
889 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
891 sec
= section
->bfdsection
;
892 if (sec
->reloc_count
== 0)
895 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
898 /* Allocate relocation room. */
899 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, 2);
900 section
->nreloc
= sec
->reloc_count
;
901 sec
->rel_filepos
= mdata
->filelen
;
902 section
->reloff
= sec
->rel_filepos
;
903 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
905 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
908 /* Convert and write. */
909 entries
= section
->bfdsection
->orelocation
;
910 for (i
= 0; i
< section
->nreloc
; i
++)
912 arelent
*rel
= entries
[i
];
913 struct mach_o_reloc_info_external raw
;
914 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
916 /* Convert relocation to an intermediate representation. */
917 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
920 /* Lower the relocation info. */
921 if (pinfo
->r_scattered
)
925 v
= BFD_MACH_O_SR_SCATTERED
926 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
927 | BFD_MACH_O_SET_SR_LENGTH(pinfo
->r_length
)
928 | BFD_MACH_O_SET_SR_TYPE(pinfo
->r_type
)
929 | BFD_MACH_O_SET_SR_ADDRESS(pinfo
->r_address
);
930 /* Note: scattered relocs have field in reverse order... */
931 bfd_put_32 (abfd
, v
, raw
.r_address
);
932 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
938 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
939 v
= BFD_MACH_O_SET_R_SYMBOLNUM (pinfo
->r_value
)
940 | (pinfo
->r_pcrel
? BFD_MACH_O_R_PCREL
: 0)
941 | BFD_MACH_O_SET_R_LENGTH (pinfo
->r_length
)
942 | (pinfo
->r_extern
? BFD_MACH_O_R_EXTERN
: 0)
943 | BFD_MACH_O_SET_R_TYPE (pinfo
->r_type
);
944 bfd_put_32 (abfd
, v
, raw
.r_symbolnum
);
947 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
948 != BFD_MACH_O_RELENT_SIZE
)
955 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
957 struct mach_o_section_32_external raw
;
959 memcpy (raw
.sectname
, section
->sectname
, 16);
960 memcpy (raw
.segname
, section
->segname
, 16);
961 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
962 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
963 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
964 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
965 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
966 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
967 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
968 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
969 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
971 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
972 != BFD_MACH_O_SECTION_SIZE
)
979 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
981 struct mach_o_section_64_external raw
;
983 memcpy (raw
.sectname
, section
->sectname
, 16);
984 memcpy (raw
.segname
, section
->segname
, 16);
985 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
986 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
987 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
988 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
989 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
990 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
991 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
992 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
993 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
994 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
996 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
997 != BFD_MACH_O_SECTION_64_SIZE
)
1004 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1006 struct mach_o_segment_command_32_external raw
;
1007 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1008 bfd_mach_o_section
*sec
;
1010 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1012 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1013 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1016 memcpy (raw
.segname
, seg
->segname
, 16);
1017 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1018 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1019 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1020 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1021 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1022 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1023 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1024 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1026 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1027 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1030 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1031 if (bfd_mach_o_write_section_32 (abfd
, sec
))
1038 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1040 struct mach_o_segment_command_64_external raw
;
1041 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1042 bfd_mach_o_section
*sec
;
1044 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1046 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1047 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1050 memcpy (raw
.segname
, seg
->segname
, 16);
1051 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1052 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1053 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1054 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1055 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1056 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1057 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1058 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1060 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1061 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1064 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1065 if (bfd_mach_o_write_section_64 (abfd
, sec
))
1072 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1074 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1075 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1077 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1078 unsigned int symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1079 struct bfd_strtab_hash
*strtab
;
1080 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1082 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1084 /* Write the symbols first. */
1085 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, wide
? 3 : 2);
1086 sym
->symoff
= mdata
->filelen
;
1087 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1090 sym
->nsyms
= bfd_get_symcount (abfd
);
1091 mdata
->filelen
+= sym
->nsyms
* symlen
;
1093 strtab
= _bfd_stringtab_init ();
1097 for (i
= 0; i
< sym
->nsyms
; i
++)
1099 bfd_size_type str_index
;
1100 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1102 /* Compute name index. */
1103 /* An index of 0 always means the empty string. */
1104 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1108 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1109 if (str_index
== (bfd_size_type
) -1)
1115 struct mach_o_nlist_64_external raw
;
1117 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1118 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1119 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1120 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1121 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1124 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1129 struct mach_o_nlist_external raw
;
1131 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1132 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1133 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1134 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1135 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1138 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1142 sym
->strsize
= _bfd_stringtab_size (strtab
);
1143 sym
->stroff
= mdata
->filelen
;
1144 mdata
->filelen
+= sym
->strsize
;
1146 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1148 _bfd_stringtab_free (strtab
);
1152 struct mach_o_symtab_command_external raw
;
1154 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1155 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1156 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1157 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1159 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1160 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1167 _bfd_stringtab_free (strtab
);
1171 /* Process the symbols and generate Mach-O specific fields.
1175 bfd_mach_o_mangle_symbols (bfd
*abfd
)
1178 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1180 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
1182 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1184 if (s
->n_type
== BFD_MACH_O_N_UNDF
&& !(s
->symbol
.flags
& BSF_DEBUGGING
))
1186 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1187 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1188 values haven't been set. */
1189 if (s
->symbol
.section
== bfd_abs_section_ptr
)
1190 s
->n_type
= BFD_MACH_O_N_ABS
;
1191 else if (s
->symbol
.section
== bfd_und_section_ptr
)
1193 s
->n_type
= BFD_MACH_O_N_UNDF
;
1194 if (s
->symbol
.flags
& BSF_WEAK
)
1195 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
1197 else if (s
->symbol
.section
== bfd_com_section_ptr
)
1198 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
1200 s
->n_type
= BFD_MACH_O_N_SECT
;
1202 if (s
->symbol
.flags
& BSF_GLOBAL
)
1203 s
->n_type
|= BFD_MACH_O_N_EXT
;
1206 /* Compute section index. */
1207 if (s
->symbol
.section
!= bfd_abs_section_ptr
1208 && s
->symbol
.section
!= bfd_und_section_ptr
1209 && s
->symbol
.section
!= bfd_com_section_ptr
)
1210 s
->n_sect
= s
->symbol
.section
->target_index
;
1212 /* Number symbols. */
1213 s
->symbol
.udata
.i
= i
;
1219 bfd_mach_o_write_contents (bfd
*abfd
)
1222 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1224 if (mdata
->header
.ncmds
== 0)
1225 if (!bfd_mach_o_build_commands (abfd
))
1228 /* Now write header information. */
1229 if (mdata
->header
.filetype
== 0)
1231 if (abfd
->flags
& EXEC_P
)
1232 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
1233 else if (abfd
->flags
& DYNAMIC
)
1234 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
1236 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
1238 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
1241 /* Assign a number to each symbols. */
1242 if (!bfd_mach_o_mangle_symbols (abfd
))
1245 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
1247 struct mach_o_load_command_external raw
;
1248 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
1249 unsigned long typeflag
;
1251 typeflag
= cur
->type
| (cur
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
1253 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
1254 bfd_h_put_32 (abfd
, cur
->len
, raw
.cmdsize
);
1256 if (bfd_seek (abfd
, cur
->offset
, SEEK_SET
) != 0
1257 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
1262 case BFD_MACH_O_LC_SEGMENT
:
1263 if (bfd_mach_o_write_segment_32 (abfd
, cur
) != 0)
1266 case BFD_MACH_O_LC_SEGMENT_64
:
1267 if (bfd_mach_o_write_segment_64 (abfd
, cur
) != 0)
1270 case BFD_MACH_O_LC_SYMTAB
:
1271 if (!bfd_mach_o_write_symtab (abfd
, cur
))
1274 case BFD_MACH_O_LC_SYMSEG
:
1276 case BFD_MACH_O_LC_THREAD
:
1277 case BFD_MACH_O_LC_UNIXTHREAD
:
1278 if (bfd_mach_o_write_thread (abfd
, cur
) != 0)
1281 case BFD_MACH_O_LC_LOADFVMLIB
:
1282 case BFD_MACH_O_LC_IDFVMLIB
:
1283 case BFD_MACH_O_LC_IDENT
:
1284 case BFD_MACH_O_LC_FVMFILE
:
1285 case BFD_MACH_O_LC_PREPAGE
:
1286 case BFD_MACH_O_LC_DYSYMTAB
:
1287 case BFD_MACH_O_LC_LOAD_DYLIB
:
1288 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
1289 case BFD_MACH_O_LC_ID_DYLIB
:
1290 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
1291 case BFD_MACH_O_LC_LOAD_DYLINKER
:
1292 case BFD_MACH_O_LC_ID_DYLINKER
:
1293 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
1294 case BFD_MACH_O_LC_ROUTINES
:
1295 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
1298 (*_bfd_error_handler
) (_("unable to write unknown load command 0x%lx"),
1299 (unsigned long) cur
->type
);
1308 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
1311 bfd_mach_o_section
*s
= (bfd_mach_o_section
*)sec
->used_by_bfd
;
1312 if (seg
->sect_head
== NULL
)
1315 seg
->sect_tail
->next
= s
;
1319 /* Create section Mach-O flags from BFD flags. */
1322 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
1325 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
1327 /* Create default flags. */
1328 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1329 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1330 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1331 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1332 | BFD_MACH_O_S_REGULAR
;
1333 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1334 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1335 else if (bfd_flags
& SEC_DEBUGGING
)
1336 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1338 s
->flags
= BFD_MACH_O_S_REGULAR
;
1341 /* Build Mach-O load commands from the sections. */
1344 bfd_mach_o_build_commands (bfd
*abfd
)
1346 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1347 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1348 bfd_mach_o_segment_command
*seg
;
1350 bfd_mach_o_load_command
*cmd
;
1351 bfd_mach_o_load_command
*symtab_cmd
;
1354 /* Return now if commands are already built. */
1355 if (mdata
->header
.ncmds
)
1358 /* Very simple version: a command (segment) to contain all the sections and
1359 a command for the symbol table. */
1360 mdata
->header
.ncmds
= 2;
1361 mdata
->commands
= bfd_alloc (abfd
, mdata
->header
.ncmds
1362 * sizeof (bfd_mach_o_load_command
));
1363 if (mdata
->commands
== NULL
)
1365 cmd
= &mdata
->commands
[0];
1366 seg
= &cmd
->command
.segment
;
1368 seg
->nsects
= bfd_count_sections (abfd
);
1370 /* Set segment command. */
1373 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
1374 cmd
->offset
= BFD_MACH_O_HEADER_64_SIZE
;
1375 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
1376 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
1380 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
1381 cmd
->offset
= BFD_MACH_O_HEADER_SIZE
;
1382 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
1383 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
1385 cmd
->type_required
= FALSE
;
1386 mdata
->header
.sizeofcmds
= cmd
->len
;
1387 mdata
->filelen
= cmd
->offset
+ cmd
->len
;
1389 /* Set symtab command. */
1390 symtab_cmd
= &mdata
->commands
[1];
1392 symtab_cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
1393 symtab_cmd
->offset
= cmd
->offset
+ cmd
->len
;
1394 symtab_cmd
->len
= 6 * 4;
1395 symtab_cmd
->type_required
= FALSE
;
1397 mdata
->header
.sizeofcmds
+= symtab_cmd
->len
;
1398 mdata
->filelen
+= symtab_cmd
->len
;
1400 /* Fill segment command. */
1401 memset (seg
->segname
, 0, sizeof (seg
->segname
));
1403 seg
->fileoff
= mdata
->filelen
;
1405 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
1406 | BFD_MACH_O_PROT_EXECUTE
;
1407 seg
->initprot
= seg
->maxprot
;
1410 /* Create Mach-O sections. */
1412 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1414 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
1416 bfd_mach_o_append_section_to_segment (seg
, sec
);
1418 if (msect
->flags
== 0)
1420 /* We suppose it hasn't been set. Convert from BFD flags. */
1421 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
1423 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
1424 msect
->size
= bfd_get_section_size (sec
);
1425 msect
->align
= bfd_get_section_alignment (abfd
, sec
);
1427 if (msect
->size
!= 0)
1429 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, msect
->align
);
1430 msect
->offset
= mdata
->filelen
;
1435 sec
->filepos
= msect
->offset
;
1436 sec
->target_index
= ++target_index
;
1438 mdata
->filelen
+= msect
->size
;
1440 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
1441 seg
->vmsize
= seg
->filesize
;
1446 /* Set the contents of a section. */
1449 bfd_mach_o_set_section_contents (bfd
*abfd
,
1451 const void * location
,
1453 bfd_size_type count
)
1457 /* This must be done first, because bfd_set_section_contents is
1458 going to set output_has_begun to TRUE. */
1459 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
1465 pos
= section
->filepos
+ offset
;
1466 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1467 || bfd_bwrite (location
, count
, abfd
) != count
)
1474 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
1475 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1480 /* Make an empty symbol. This is required only because
1481 bfd_make_section_anyway wants to create a symbol for the section. */
1484 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
1486 asymbol
*new_symbol
;
1488 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
1489 if (new_symbol
== NULL
)
1491 new_symbol
->the_bfd
= abfd
;
1492 new_symbol
->udata
.i
= 0;
1497 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1499 struct mach_o_header_external raw
;
1501 bfd_vma (*get32
) (const void *) = NULL
;
1503 /* Just read the magic number. */
1504 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1505 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
1508 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
1510 header
->byteorder
= BFD_ENDIAN_BIG
;
1511 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1512 header
->version
= 1;
1515 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
1517 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1518 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1519 header
->version
= 1;
1522 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
1524 header
->byteorder
= BFD_ENDIAN_BIG
;
1525 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1526 header
->version
= 2;
1529 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
1531 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1532 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1533 header
->version
= 2;
1538 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
1542 /* Once the size of the header is known, read the full header. */
1543 size
= mach_o_wide_p (header
) ?
1544 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1546 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1547 || bfd_bread (&raw
, size
, abfd
) != size
)
1550 header
->cputype
= (*get32
) (raw
.cputype
);
1551 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
1552 header
->filetype
= (*get32
) (raw
.filetype
);
1553 header
->ncmds
= (*get32
) (raw
.ncmds
);
1554 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
1555 header
->flags
= (*get32
) (raw
.flags
);
1557 if (mach_o_wide_p (header
))
1558 header
->reserved
= (*get32
) (raw
.reserved
);
1564 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
1566 bfd_mach_o_section
*s
;
1568 s
= bfd_mach_o_get_mach_o_section (sec
);
1573 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
1576 sec
->used_by_bfd
= s
;
1577 s
->bfdsection
= sec
;
1579 /* Create default name. */
1580 bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
1582 /* Create default flags. */
1583 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1584 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1585 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1586 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1587 | BFD_MACH_O_S_REGULAR
;
1588 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1589 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1590 else if (bfd_flags
& SEC_DEBUGGING
)
1591 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1593 s
->flags
= BFD_MACH_O_S_REGULAR
;
1596 return _bfd_generic_new_section_hook (abfd
, sec
);
1600 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
1604 bfd_mach_o_section
*section
;
1606 flags
= bfd_get_section_flags (abfd
, sec
);
1607 section
= bfd_mach_o_get_mach_o_section (sec
);
1609 if (flags
== SEC_NO_FLAGS
)
1611 /* Try to guess flags. */
1612 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
1613 flags
= SEC_DEBUGGING
;
1617 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1618 != BFD_MACH_O_S_ZEROFILL
)
1621 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
1623 if (prot
& BFD_MACH_O_PROT_WRITE
)
1625 else if (prot
& BFD_MACH_O_PROT_READ
)
1626 flags
|= SEC_READONLY
;
1632 if ((flags
& SEC_DEBUGGING
) == 0)
1636 if (section
->offset
!= 0)
1637 flags
|= SEC_HAS_CONTENTS
;
1638 if (section
->nreloc
!= 0)
1641 bfd_set_section_flags (abfd
, sec
, flags
);
1643 sec
->vma
= section
->addr
;
1644 sec
->lma
= section
->addr
;
1645 sec
->size
= section
->size
;
1646 sec
->filepos
= section
->offset
;
1647 sec
->alignment_power
= section
->align
;
1648 sec
->segment_mark
= 0;
1649 sec
->reloc_count
= section
->nreloc
;
1650 sec
->rel_filepos
= section
->reloff
;
1654 bfd_mach_o_make_bfd_section (bfd
*abfd
,
1655 const unsigned char *segname
,
1656 const unsigned char *sectname
)
1661 bfd_mach_o_convert_section_name_to_bfd
1662 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
1666 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
1670 bfd_mach_o_read_section_32 (bfd
*abfd
,
1671 unsigned int offset
,
1674 struct mach_o_section_32_external raw
;
1676 bfd_mach_o_section
*section
;
1678 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1679 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1680 != BFD_MACH_O_SECTION_SIZE
))
1683 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
1687 section
= bfd_mach_o_get_mach_o_section (sec
);
1688 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
1689 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
1690 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
1691 section
->segname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
1692 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
1693 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
1694 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
1695 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
1696 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
1697 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
1698 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
1699 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
1700 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
1701 section
->reserved3
= 0;
1703 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
1709 bfd_mach_o_read_section_64 (bfd
*abfd
,
1710 unsigned int offset
,
1713 struct mach_o_section_64_external raw
;
1715 bfd_mach_o_section
*section
;
1717 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1718 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1719 != BFD_MACH_O_SECTION_64_SIZE
))
1722 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
1726 section
= bfd_mach_o_get_mach_o_section (sec
);
1727 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
1728 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
1729 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
1730 section
->segname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
1731 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
1732 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
1733 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
1734 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
1735 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
1736 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
1737 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
1738 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
1739 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
1740 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
1742 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
1748 bfd_mach_o_read_section (bfd
*abfd
,
1749 unsigned int offset
,
1754 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
1756 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
1760 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
1761 bfd_mach_o_symtab_command
*sym
,
1762 bfd_mach_o_asymbol
*s
,
1765 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1766 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1767 unsigned int symwidth
=
1768 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1769 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
1770 struct mach_o_nlist_64_external raw
;
1771 unsigned char type
= -1;
1772 unsigned char section
= -1;
1774 symvalue value
= -1;
1775 unsigned long stroff
= -1;
1776 unsigned int symtype
= -1;
1778 BFD_ASSERT (sym
->strtab
!= NULL
);
1780 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
1781 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
1783 (*_bfd_error_handler
)
1784 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
1785 symwidth
, (unsigned long) symoff
);
1789 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
1790 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
1791 symtype
= type
& BFD_MACH_O_N_TYPE
;
1792 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
1793 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
1795 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
1797 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
1799 if (stroff
>= sym
->strsize
)
1801 (*_bfd_error_handler
)
1802 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
1803 (unsigned long) stroff
,
1804 (unsigned long) sym
->strsize
);
1808 s
->symbol
.the_bfd
= abfd
;
1809 s
->symbol
.name
= sym
->strtab
+ stroff
;
1810 s
->symbol
.value
= value
;
1811 s
->symbol
.flags
= 0x0;
1812 s
->symbol
.udata
.i
= 0;
1814 s
->n_sect
= section
;
1817 if (type
& BFD_MACH_O_N_STAB
)
1819 s
->symbol
.flags
|= BSF_DEBUGGING
;
1820 s
->symbol
.section
= bfd_und_section_ptr
;
1832 if ((section
> 0) && (section
<= mdata
->nsects
))
1834 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1836 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1843 if (type
& BFD_MACH_O_N_PEXT
)
1844 s
->symbol
.flags
|= BSF_GLOBAL
;
1846 if (type
& BFD_MACH_O_N_EXT
)
1847 s
->symbol
.flags
|= BSF_GLOBAL
;
1849 if (!(type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
)))
1850 s
->symbol
.flags
|= BSF_LOCAL
;
1854 case BFD_MACH_O_N_UNDF
:
1855 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
1856 && s
->symbol
.value
!= 0)
1858 /* A common symbol. */
1859 s
->symbol
.section
= bfd_com_section_ptr
;
1860 s
->symbol
.flags
= BSF_NO_FLAGS
;
1864 s
->symbol
.section
= bfd_und_section_ptr
;
1865 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
1866 s
->symbol
.flags
|= BSF_WEAK
;
1869 case BFD_MACH_O_N_PBUD
:
1870 s
->symbol
.section
= bfd_und_section_ptr
;
1872 case BFD_MACH_O_N_ABS
:
1873 s
->symbol
.section
= bfd_abs_section_ptr
;
1875 case BFD_MACH_O_N_SECT
:
1876 if ((section
> 0) && (section
<= mdata
->nsects
))
1878 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1880 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1884 /* Mach-O uses 0 to mean "no section"; not an error. */
1887 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1888 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
1889 s
->symbol
.name
, section
, mdata
->nsects
);
1891 s
->symbol
.section
= bfd_und_section_ptr
;
1894 case BFD_MACH_O_N_INDR
:
1895 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1896 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined"),
1898 s
->symbol
.section
= bfd_und_section_ptr
;
1901 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1902 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
1903 s
->symbol
.name
, symtype
);
1904 s
->symbol
.section
= bfd_und_section_ptr
;
1913 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
1915 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1916 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1918 /* Fail if there is no symtab. */
1922 /* Success if already loaded. */
1926 if (abfd
->flags
& BFD_IN_MEMORY
)
1928 struct bfd_in_memory
*b
;
1930 b
= (struct bfd_in_memory
*) abfd
->iostream
;
1932 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
1934 bfd_set_error (bfd_error_file_truncated
);
1937 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
1941 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
1942 if (sym
->strtab
== NULL
)
1945 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
1946 || bfd_bread ((void *) sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
1948 bfd_set_error (bfd_error_file_truncated
);
1957 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
1959 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1960 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1964 if (sym
== NULL
|| sym
->symbols
)
1966 /* Return now if there are no symbols or if already loaded. */
1970 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
1972 if (sym
->symbols
== NULL
)
1974 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
1978 ret
= bfd_mach_o_read_symtab_strtab (abfd
);
1982 for (i
= 0; i
< sym
->nsyms
; i
++)
1984 ret
= bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
);
1993 bfd_mach_o_read_dysymtab_symbol (bfd
*abfd
,
1994 bfd_mach_o_dysymtab_command
*dysym
,
1995 bfd_mach_o_symtab_command
*sym
,
1996 bfd_mach_o_asymbol
*s
,
1999 unsigned long isymoff
= dysym
->indirectsymoff
+ (i
* 4);
2000 unsigned long sym_index
;
2001 unsigned char raw
[4];
2003 BFD_ASSERT (i
< dysym
->nindirectsyms
);
2005 if (bfd_seek (abfd
, isymoff
, SEEK_SET
) != 0
2006 || bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2008 (*_bfd_error_handler
)
2009 (_("bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu"),
2010 (unsigned long) sizeof (raw
), isymoff
);
2013 sym_index
= bfd_h_get_32 (abfd
, raw
);
2015 return bfd_mach_o_read_symtab_symbol (abfd
, sym
, s
, sym_index
);
2019 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2021 switch ((int) flavour
)
2023 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2024 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2025 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2026 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2027 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2028 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2029 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2030 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2031 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2032 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2033 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2034 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2035 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2036 default: return "UNKNOWN";
2041 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2043 switch ((int) flavour
)
2045 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2046 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2047 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2048 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2049 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2050 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2051 default: return "UNKNOWN";
2056 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2058 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2059 struct mach_o_str_command_external raw
;
2060 unsigned int nameoff
;
2062 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
2063 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
2065 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2066 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2069 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
2071 cmd
->name_offset
= command
->offset
+ nameoff
;
2072 cmd
->name_len
= command
->len
- nameoff
;
2073 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2074 if (cmd
->name_str
== NULL
)
2076 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2077 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2083 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2085 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
2086 struct mach_o_dylib_command_external raw
;
2087 unsigned int nameoff
;
2089 switch (command
->type
)
2091 case BFD_MACH_O_LC_LOAD_DYLIB
:
2092 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2093 case BFD_MACH_O_LC_ID_DYLIB
:
2094 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2101 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2102 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2105 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
2106 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
2107 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
2108 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
2110 cmd
->name_offset
= command
->offset
+ nameoff
;
2111 cmd
->name_len
= command
->len
- nameoff
;
2112 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2113 if (cmd
->name_str
== NULL
)
2115 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2116 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2122 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
2123 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
2125 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2127 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
2132 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2134 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2135 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
2136 unsigned int offset
;
2137 unsigned int nflavours
;
2140 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
2141 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
2143 /* Count the number of threads. */
2146 while (offset
!= command
->len
)
2148 struct mach_o_thread_command_external raw
;
2150 if (offset
>= command
->len
)
2153 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2154 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2157 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
2161 /* Allocate threads. */
2162 cmd
->flavours
= bfd_alloc
2163 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
2164 if (cmd
->flavours
== NULL
)
2166 cmd
->nflavours
= nflavours
;
2170 while (offset
!= command
->len
)
2172 struct mach_o_thread_command_external raw
;
2174 if (offset
>= command
->len
)
2177 if (nflavours
>= cmd
->nflavours
)
2180 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2181 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2184 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
2185 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
2186 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
2187 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
2191 for (i
= 0; i
< nflavours
; i
++)
2194 unsigned int snamelen
;
2196 const char *flavourstr
;
2197 const char *prefix
= "LC_THREAD";
2200 switch (mdata
->header
.cputype
)
2202 case BFD_MACH_O_CPU_TYPE_POWERPC
:
2203 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
2204 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
2206 case BFD_MACH_O_CPU_TYPE_I386
:
2207 case BFD_MACH_O_CPU_TYPE_X86_64
:
2208 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
2211 flavourstr
= "UNKNOWN_ARCHITECTURE";
2215 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
2216 sname
= bfd_alloc (abfd
, snamelen
);
2222 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
2223 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
2228 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
2232 bfdsec
->size
= cmd
->flavours
[i
].size
;
2233 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
2234 bfdsec
->alignment_power
= 0x0;
2236 cmd
->section
= bfdsec
;
2243 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2245 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2246 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2248 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2251 struct mach_o_dysymtab_command_external raw
;
2253 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2254 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2257 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
2258 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
2259 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
2260 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
2261 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
2262 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
2263 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
2264 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
2265 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
2266 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
2267 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
2268 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
2269 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
2270 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
2271 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
2272 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
2273 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
2274 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
2277 if (cmd
->nmodtab
!= 0)
2280 int wide
= bfd_mach_o_wide_p (abfd
);
2281 unsigned int module_len
= wide
? 56 : 52;
2284 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
2285 if (cmd
->dylib_module
== NULL
)
2288 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2291 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2293 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2295 unsigned char buf
[56];
2297 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
2300 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
2301 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
2302 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
2303 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
2304 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
2305 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
2306 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
2307 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
2308 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
2309 v
= bfd_h_get_32 (abfd
, buf
+36);
2310 module
->iinit
= v
& 0xffff;
2311 module
->iterm
= (v
>> 16) & 0xffff;
2312 v
= bfd_h_get_32 (abfd
, buf
+ 40);
2313 module
->ninit
= v
& 0xffff;
2314 module
->nterm
= (v
>> 16) & 0xffff;
2317 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
2318 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
2322 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
2323 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
2332 cmd
->dylib_toc
= bfd_alloc
2333 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
2334 if (cmd
->dylib_toc
== NULL
)
2337 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2340 for (i
= 0; i
< cmd
->ntoc
; i
++)
2342 struct mach_o_dylib_table_of_contents_external raw
;
2343 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2345 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2348 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
2349 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
2353 if (cmd
->nindirectsyms
!= 0)
2357 cmd
->indirect_syms
= bfd_alloc
2358 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
2359 if (cmd
->indirect_syms
== NULL
)
2362 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2365 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
2367 unsigned char raw
[4];
2368 unsigned int *is
= &cmd
->indirect_syms
[i
];
2370 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2373 *is
= bfd_h_get_32 (abfd
, raw
);
2377 if (cmd
->nextrefsyms
!= 0)
2382 cmd
->ext_refs
= bfd_alloc
2383 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
2384 if (cmd
->ext_refs
== NULL
)
2387 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2390 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2392 unsigned char raw
[4];
2393 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2395 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2398 /* Fields isym and flags are written as bit-fields, thus we need
2399 a specific processing for endianness. */
2400 v
= bfd_h_get_32 (abfd
, raw
);
2401 if (bfd_big_endian (abfd
))
2403 ref
->isym
= (v
>> 8) & 0xffffff;
2404 ref
->flags
= v
& 0xff;
2408 ref
->isym
= v
& 0xffffff;
2409 ref
->flags
= (v
>> 24) & 0xff;
2414 if (mdata
->dysymtab
)
2416 mdata
->dysymtab
= cmd
;
2422 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2424 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
2425 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2426 struct mach_o_symtab_command_external raw
;
2428 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2430 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2431 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2434 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
2435 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
2436 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
2437 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
2438 symtab
->symbols
= NULL
;
2439 symtab
->strtab
= NULL
;
2441 if (symtab
->nsyms
!= 0)
2442 abfd
->flags
|= HAS_SYMS
;
2446 mdata
->symtab
= symtab
;
2451 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2453 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
2455 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
2457 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2458 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
2465 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2467 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
2468 struct mach_o_linkedit_data_command_external raw
;
2470 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2471 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2474 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
2475 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
2480 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2482 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
2483 struct mach_o_str_command_external raw
;
2486 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2487 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2490 off
= bfd_get_32 (abfd
, raw
.str
);
2491 cmd
->stroff
= command
->offset
+ off
;
2492 cmd
->str_len
= command
->len
- off
;
2493 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
2494 if (cmd
->str
== NULL
)
2496 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
2497 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
2503 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2505 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
2506 struct mach_o_dyld_info_command_external raw
;
2508 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2509 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2512 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
2513 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
2514 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
2515 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
2516 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
2517 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
2518 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
2519 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
2520 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
2521 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
2526 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2528 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
2529 struct mach_o_version_min_command_external raw
;
2532 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2533 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2536 ver
= bfd_get_32 (abfd
, raw
.version
);
2537 cmd
->rel
= ver
>> 16;
2538 cmd
->maj
= ver
>> 8;
2540 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
2545 bfd_mach_o_read_segment (bfd
*abfd
,
2546 bfd_mach_o_load_command
*command
,
2549 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
2554 struct mach_o_segment_command_64_external raw
;
2556 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
2558 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2559 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2562 memcpy (seg
->segname
, raw
.segname
, 16);
2563 seg
->segname
[16] = '\0';
2565 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
2566 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
2567 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
2568 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
2569 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
2570 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
2571 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
2572 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2576 struct mach_o_segment_command_32_external raw
;
2578 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
2580 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2581 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2584 memcpy (seg
->segname
, raw
.segname
, 16);
2585 seg
->segname
[16] = '\0';
2587 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
2588 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
2589 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
2590 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
2591 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
2592 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
2593 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
2594 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2596 seg
->sect_head
= NULL
;
2597 seg
->sect_tail
= NULL
;
2599 for (i
= 0; i
< seg
->nsects
; i
++)
2605 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
2606 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
2608 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
2609 + (i
* BFD_MACH_O_SECTION_SIZE
);
2611 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
2615 bfd_mach_o_append_section_to_segment (seg
, sec
);
2622 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2624 return bfd_mach_o_read_segment (abfd
, command
, 0);
2628 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2630 return bfd_mach_o_read_segment (abfd
, command
, 1);
2634 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2636 struct mach_o_load_command_external raw
;
2639 /* Read command type and length. */
2640 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
2641 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
2644 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
2645 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
2646 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
2647 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
2649 switch (command
->type
)
2651 case BFD_MACH_O_LC_SEGMENT
:
2652 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
2655 case BFD_MACH_O_LC_SEGMENT_64
:
2656 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
2659 case BFD_MACH_O_LC_SYMTAB
:
2660 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
2663 case BFD_MACH_O_LC_SYMSEG
:
2665 case BFD_MACH_O_LC_THREAD
:
2666 case BFD_MACH_O_LC_UNIXTHREAD
:
2667 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
2670 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2671 case BFD_MACH_O_LC_ID_DYLINKER
:
2672 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
2675 case BFD_MACH_O_LC_LOAD_DYLIB
:
2676 case BFD_MACH_O_LC_ID_DYLIB
:
2677 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2678 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2679 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
2682 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
2683 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
2686 case BFD_MACH_O_LC_LOADFVMLIB
:
2687 case BFD_MACH_O_LC_IDFVMLIB
:
2688 case BFD_MACH_O_LC_IDENT
:
2689 case BFD_MACH_O_LC_FVMFILE
:
2690 case BFD_MACH_O_LC_PREPAGE
:
2691 case BFD_MACH_O_LC_ROUTINES
:
2692 case BFD_MACH_O_LC_ROUTINES_64
:
2694 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
2695 case BFD_MACH_O_LC_SUB_UMBRELLA
:
2696 case BFD_MACH_O_LC_SUB_LIBRARY
:
2697 case BFD_MACH_O_LC_SUB_CLIENT
:
2698 case BFD_MACH_O_LC_RPATH
:
2699 if (bfd_mach_o_read_str (abfd
, command
) != 0)
2702 case BFD_MACH_O_LC_DYSYMTAB
:
2703 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
2706 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
2707 case BFD_MACH_O_LC_PREBIND_CKSUM
:
2709 case BFD_MACH_O_LC_UUID
:
2710 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
2713 case BFD_MACH_O_LC_CODE_SIGNATURE
:
2714 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
2715 case BFD_MACH_O_LC_FUNCTION_STARTS
:
2716 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
2719 case BFD_MACH_O_LC_DYLD_INFO
:
2720 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
2723 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
2724 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
2725 if (!bfd_mach_o_read_version_min (abfd
, command
))
2729 (*_bfd_error_handler
) (_("unable to read unknown load command 0x%lx"),
2730 (unsigned long) command
->type
);
2738 bfd_mach_o_flatten_sections (bfd
*abfd
)
2740 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2744 /* Count total number of sections. */
2747 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2749 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2750 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2752 bfd_mach_o_segment_command
*seg
;
2754 seg
= &mdata
->commands
[i
].command
.segment
;
2755 mdata
->nsects
+= seg
->nsects
;
2759 /* Allocate sections array. */
2760 mdata
->sections
= bfd_alloc (abfd
,
2761 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2763 /* Fill the array. */
2766 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2768 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2769 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2771 bfd_mach_o_segment_command
*seg
;
2772 bfd_mach_o_section
*sec
;
2774 seg
= &mdata
->commands
[i
].command
.segment
;
2775 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
2777 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
2778 mdata
->sections
[csect
++] = sec
;
2784 bfd_mach_o_scan_start_address (bfd
*abfd
)
2786 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2787 bfd_mach_o_thread_command
*cmd
= NULL
;
2790 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2792 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
2793 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
2796 cmd
= &mdata
->commands
[i
].command
.thread
;
2805 for (i
= 0; i
< cmd
->nflavours
; i
++)
2807 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
2808 && (cmd
->flavours
[i
].flavour
2809 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
2811 unsigned char buf
[4];
2813 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
2814 || bfd_bread (buf
, 4, abfd
) != 4)
2817 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2819 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
2820 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
2822 unsigned char buf
[4];
2824 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2825 || bfd_bread (buf
, 4, abfd
) != 4)
2828 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2830 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
2831 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
2833 unsigned char buf
[8];
2835 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2836 || bfd_bread (buf
, 8, abfd
) != 8)
2839 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2841 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
2842 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
2844 unsigned char buf
[8];
2846 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
2847 || bfd_bread (buf
, 8, abfd
) != 8)
2850 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2858 bfd_mach_o_set_arch_mach (bfd
*abfd
,
2859 enum bfd_architecture arch
,
2860 unsigned long machine
)
2862 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
2864 /* If this isn't the right architecture for this backend, and this
2865 isn't the generic backend, fail. */
2866 if (arch
!= bed
->arch
2867 && arch
!= bfd_arch_unknown
2868 && bed
->arch
!= bfd_arch_unknown
)
2871 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
2875 bfd_mach_o_scan (bfd
*abfd
,
2876 bfd_mach_o_header
*header
,
2877 bfd_mach_o_data_struct
*mdata
)
2880 enum bfd_architecture cputype
;
2881 unsigned long cpusubtype
;
2882 unsigned int hdrsize
;
2884 hdrsize
= mach_o_wide_p (header
) ?
2885 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2887 mdata
->header
= *header
;
2889 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
2890 switch (header
->filetype
)
2892 case BFD_MACH_O_MH_OBJECT
:
2893 abfd
->flags
|= HAS_RELOC
;
2895 case BFD_MACH_O_MH_EXECUTE
:
2896 abfd
->flags
|= EXEC_P
;
2898 case BFD_MACH_O_MH_DYLIB
:
2899 case BFD_MACH_O_MH_BUNDLE
:
2900 abfd
->flags
|= DYNAMIC
;
2904 abfd
->tdata
.mach_o_data
= mdata
;
2906 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
2907 &cputype
, &cpusubtype
);
2908 if (cputype
== bfd_arch_unknown
)
2910 (*_bfd_error_handler
) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
2911 header
->cputype
, header
->cpusubtype
);
2915 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
2917 if (header
->ncmds
!= 0)
2919 mdata
->commands
= bfd_alloc
2920 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
2921 if (mdata
->commands
== NULL
)
2924 for (i
= 0; i
< header
->ncmds
; i
++)
2926 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
2929 cur
->offset
= hdrsize
;
2932 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
2933 cur
->offset
= prev
->offset
+ prev
->len
;
2936 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
2941 if (bfd_mach_o_scan_start_address (abfd
) < 0)
2944 bfd_mach_o_flatten_sections (abfd
);
2949 bfd_mach_o_mkobject_init (bfd
*abfd
)
2951 bfd_mach_o_data_struct
*mdata
= NULL
;
2953 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
2956 abfd
->tdata
.mach_o_data
= mdata
;
2958 mdata
->header
.magic
= 0;
2959 mdata
->header
.cputype
= 0;
2960 mdata
->header
.cpusubtype
= 0;
2961 mdata
->header
.filetype
= 0;
2962 mdata
->header
.ncmds
= 0;
2963 mdata
->header
.sizeofcmds
= 0;
2964 mdata
->header
.flags
= 0;
2965 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
2966 mdata
->commands
= NULL
;
2968 mdata
->sections
= NULL
;
2974 bfd_mach_o_gen_mkobject (bfd
*abfd
)
2976 bfd_mach_o_data_struct
*mdata
;
2978 if (!bfd_mach_o_mkobject_init (abfd
))
2981 mdata
= bfd_mach_o_get_data (abfd
);
2982 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
2983 mdata
->header
.cputype
= 0;
2984 mdata
->header
.cpusubtype
= 0;
2985 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
2986 mdata
->header
.version
= 1;
2992 bfd_mach_o_header_p (bfd
*abfd
,
2993 bfd_mach_o_filetype filetype
,
2994 bfd_mach_o_cpu_type cputype
)
2996 struct bfd_preserve preserve
;
2997 bfd_mach_o_header header
;
2999 preserve
.marker
= NULL
;
3000 if (!bfd_mach_o_read_header (abfd
, &header
))
3003 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3004 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3006 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3007 (unsigned long) header
.byteorder
);
3011 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3012 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3013 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3014 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3015 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3016 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3019 /* Check cputype and filetype.
3020 In case of wildcard, do not accept magics that are handled by existing
3024 if (header
.cputype
!= cputype
)
3029 switch (header
.cputype
)
3031 case BFD_MACH_O_CPU_TYPE_I386
:
3032 /* Handled by mach-o-i386 */
3040 if (header
.filetype
!= filetype
)
3045 switch (header
.filetype
)
3047 case BFD_MACH_O_MH_CORE
:
3048 /* Handled by core_p */
3055 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3056 if (preserve
.marker
== NULL
3057 || !bfd_preserve_save (abfd
, &preserve
))
3060 if (bfd_mach_o_scan (abfd
, &header
,
3061 (bfd_mach_o_data_struct
*) preserve
.marker
) != 0)
3064 bfd_preserve_finish (abfd
, &preserve
);
3068 bfd_set_error (bfd_error_wrong_format
);
3071 if (preserve
.marker
!= NULL
)
3072 bfd_preserve_restore (abfd
, &preserve
);
3076 static const bfd_target
*
3077 bfd_mach_o_gen_object_p (bfd
*abfd
)
3079 return bfd_mach_o_header_p (abfd
, 0, 0);
3082 static const bfd_target
*
3083 bfd_mach_o_gen_core_p (bfd
*abfd
)
3085 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
3088 typedef struct mach_o_fat_archentry
3090 unsigned long cputype
;
3091 unsigned long cpusubtype
;
3092 unsigned long offset
;
3094 unsigned long align
;
3095 } mach_o_fat_archentry
;
3097 typedef struct mach_o_fat_data_struct
3099 unsigned long magic
;
3100 unsigned long nfat_arch
;
3101 mach_o_fat_archentry
*archentries
;
3102 } mach_o_fat_data_struct
;
3105 bfd_mach_o_archive_p (bfd
*abfd
)
3107 mach_o_fat_data_struct
*adata
= NULL
;
3108 struct mach_o_fat_header_external hdr
;
3111 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3112 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
3115 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
3119 adata
->magic
= bfd_getb32 (hdr
.magic
);
3120 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
3121 if (adata
->magic
!= 0xcafebabe)
3123 /* Avoid matching Java bytecode files, which have the same magic number.
3124 In the Java bytecode file format this field contains the JVM version,
3125 which starts at 43.0. */
3126 if (adata
->nfat_arch
> 30)
3129 adata
->archentries
=
3130 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
3131 if (adata
->archentries
== NULL
)
3134 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3136 struct mach_o_fat_arch_external arch
;
3137 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
3139 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
3140 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
3141 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
3142 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
3143 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
3146 abfd
->tdata
.mach_o_fat_data
= adata
;
3151 bfd_release (abfd
, adata
);
3152 bfd_set_error (bfd_error_wrong_format
);
3157 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
3159 mach_o_fat_data_struct
*adata
;
3160 mach_o_fat_archentry
*entry
= NULL
;
3163 enum bfd_architecture arch_type
;
3164 unsigned long arch_subtype
;
3166 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
3167 BFD_ASSERT (adata
!= NULL
);
3169 /* Find index of previous entry. */
3171 i
= 0; /* Start at first one. */
3174 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3176 if (adata
->archentries
[i
].offset
== prev
->origin
)
3180 if (i
== adata
->nfat_arch
)
3183 bfd_set_error (bfd_error_bad_value
);
3186 i
++; /* Get next entry. */
3189 if (i
>= adata
->nfat_arch
)
3191 bfd_set_error (bfd_error_no_more_archived_files
);
3195 entry
= &adata
->archentries
[i
];
3196 nbfd
= _bfd_new_bfd_contained_in (archive
);
3200 nbfd
->origin
= entry
->offset
;
3202 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
3203 &arch_type
, &arch_subtype
);
3204 /* Create the member filename.
3205 Use FILENAME:ARCH_NAME. */
3208 const char *arch_name
;
3209 size_t arch_file_len
= strlen (bfd_get_filename (archive
));
3211 arch_name
= bfd_printable_arch_mach (arch_type
, arch_subtype
);
3212 s
= bfd_malloc (arch_file_len
+ 1 + strlen (arch_name
) + 1);
3215 memcpy (s
, bfd_get_filename (archive
), arch_file_len
);
3216 s
[arch_file_len
] = ':';
3217 strcpy (s
+ arch_file_len
+ 1, arch_name
);
3220 nbfd
->iostream
= NULL
;
3221 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
3226 /* If ABFD format is FORMAT and architecture is ARCH, return it.
3227 If ABFD is a fat image containing a member that corresponds to FORMAT
3228 and ARCH, returns it.
3229 In other case, returns NULL.
3230 This function allows transparent uses of fat images. */
3232 bfd_mach_o_fat_extract (bfd
*abfd
,
3234 const bfd_arch_info_type
*arch
)
3237 mach_o_fat_data_struct
*adata
;
3240 if (bfd_check_format (abfd
, format
))
3242 if (bfd_get_arch_info (abfd
) == arch
)
3246 if (!bfd_check_format (abfd
, bfd_archive
)
3247 || abfd
->xvec
!= &mach_o_fat_vec
)
3250 /* This is a Mach-O fat image. */
3251 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
3252 BFD_ASSERT (adata
!= NULL
);
3254 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3256 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
3257 enum bfd_architecture cpu_type
;
3258 unsigned long cpu_subtype
;
3260 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
3261 &cpu_type
, &cpu_subtype
);
3262 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
3265 /* The architecture is found. */
3266 res
= _bfd_new_bfd_contained_in (abfd
);
3270 res
->origin
= e
->offset
;
3272 res
->filename
= strdup (abfd
->filename
);
3273 res
->iostream
= NULL
;
3275 if (bfd_check_format (res
, format
))
3277 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
3288 bfd_mach_o_lookup_command (bfd
*abfd
,
3289 bfd_mach_o_load_command_type type
,
3290 bfd_mach_o_load_command
**mcommand
)
3292 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
3293 bfd_mach_o_load_command
*ncmd
= NULL
;
3294 unsigned int i
, num
;
3296 BFD_ASSERT (md
!= NULL
);
3297 BFD_ASSERT (mcommand
!= NULL
);
3300 for (i
= 0; i
< md
->header
.ncmds
; i
++)
3302 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
3304 if (cmd
->type
!= type
)
3317 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
3321 case BFD_MACH_O_CPU_TYPE_MC680x0
:
3323 case BFD_MACH_O_CPU_TYPE_MC88000
:
3325 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3327 case BFD_MACH_O_CPU_TYPE_I386
:
3329 case BFD_MACH_O_CPU_TYPE_SPARC
:
3331 case BFD_MACH_O_CPU_TYPE_I860
:
3333 case BFD_MACH_O_CPU_TYPE_HPPA
:
3334 return 0xc0000000 - 0x04000000;
3340 typedef struct bfd_mach_o_xlat_name
3345 bfd_mach_o_xlat_name
;
3348 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name
*table
,
3354 for (; table
->name
; table
++)
3356 if (table
->val
& val
)
3359 fprintf (file
, "+");
3360 fprintf (file
, "%s", table
->name
);
3368 fprintf (file
, "+");
3369 fprintf (file
, "0x%lx", val
);
3373 fprintf (file
, "-");
3377 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name
*table
,
3380 for (; table
->name
; table
++)
3381 if (table
->val
== val
)
3387 bfd_mach_o_get_name (const bfd_mach_o_xlat_name
*table
, unsigned long val
)
3389 const char *res
= bfd_mach_o_get_name_or_null (table
, val
);
3397 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name
[] =
3399 { "vax", BFD_MACH_O_CPU_TYPE_VAX
},
3400 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0
},
3401 { "i386", BFD_MACH_O_CPU_TYPE_I386
},
3402 { "mips", BFD_MACH_O_CPU_TYPE_MIPS
},
3403 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000
},
3404 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA
},
3405 { "arm", BFD_MACH_O_CPU_TYPE_ARM
},
3406 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000
},
3407 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC
},
3408 { "i860", BFD_MACH_O_CPU_TYPE_I860
},
3409 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA
},
3410 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC
},
3411 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64
},
3412 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64
},
3416 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name
[] =
3418 { "object", BFD_MACH_O_MH_OBJECT
},
3419 { "execute", BFD_MACH_O_MH_EXECUTE
},
3420 { "fvmlib", BFD_MACH_O_MH_FVMLIB
},
3421 { "core", BFD_MACH_O_MH_CORE
},
3422 { "preload", BFD_MACH_O_MH_PRELOAD
},
3423 { "dylib", BFD_MACH_O_MH_DYLIB
},
3424 { "dylinker", BFD_MACH_O_MH_DYLINKER
},
3425 { "bundle", BFD_MACH_O_MH_BUNDLE
},
3426 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB
},
3427 { "dym", BFD_MACH_O_MH_DSYM
},
3428 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE
},
3432 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name
[] =
3434 { "noundefs", BFD_MACH_O_MH_NOUNDEFS
},
3435 { "incrlink", BFD_MACH_O_MH_INCRLINK
},
3436 { "dyldlink", BFD_MACH_O_MH_DYLDLINK
},
3437 { "bindatload", BFD_MACH_O_MH_BINDATLOAD
},
3438 { "prebound", BFD_MACH_O_MH_PREBOUND
},
3439 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS
},
3440 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT
},
3441 { "twolevel", BFD_MACH_O_MH_TWOLEVEL
},
3442 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT
},
3443 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS
},
3444 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING
},
3445 { "prebindable", BFD_MACH_O_MH_PREBINDABLE
},
3446 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND
},
3447 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS
},
3448 { "canonical", BFD_MACH_O_MH_CANONICAL
},
3449 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES
},
3450 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK
},
3451 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION
},
3452 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE
},
3453 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE
},
3454 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS
},
3455 { "pie", BFD_MACH_O_MH_PIE
},
3459 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
3461 { "regular", BFD_MACH_O_S_REGULAR
},
3462 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
3463 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
3464 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
3465 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
3466 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
3467 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
3468 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
3469 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
3470 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
3471 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
3472 { "coalesced", BFD_MACH_O_S_COALESCED
},
3473 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
3474 { "interposing", BFD_MACH_O_S_INTERPOSING
},
3475 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
3476 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
3477 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
3481 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
3483 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
3484 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
3485 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
3486 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
3487 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
3488 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
3489 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
3490 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
3491 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
3492 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
3496 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name
[] =
3498 { "segment", BFD_MACH_O_LC_SEGMENT
},
3499 { "symtab", BFD_MACH_O_LC_SYMTAB
},
3500 { "symseg", BFD_MACH_O_LC_SYMSEG
},
3501 { "thread", BFD_MACH_O_LC_THREAD
},
3502 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD
},
3503 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB
},
3504 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB
},
3505 { "ident", BFD_MACH_O_LC_IDENT
},
3506 { "fvmfile", BFD_MACH_O_LC_FVMFILE
},
3507 { "prepage", BFD_MACH_O_LC_PREPAGE
},
3508 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB
},
3509 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB
},
3510 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB
},
3511 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER
},
3512 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER
},
3513 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB
},
3514 { "routines", BFD_MACH_O_LC_ROUTINES
},
3515 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK
},
3516 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA
},
3517 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT
},
3518 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY
},
3519 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS
},
3520 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM
},
3521 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB
},
3522 { "segment_64", BFD_MACH_O_LC_SEGMENT_64
},
3523 { "routines_64", BFD_MACH_O_LC_ROUTINES_64
},
3524 { "uuid", BFD_MACH_O_LC_UUID
},
3525 { "rpath", BFD_MACH_O_LC_RPATH
},
3526 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE
},
3527 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
},
3528 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB
},
3529 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB
},
3530 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO
},
3531 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO
},
3532 { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
},
3533 { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX
},
3534 { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
},
3535 { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS
},
3536 { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT
},
3540 /* Get the section type from NAME. Return -1 if NAME is unknown. */
3543 bfd_mach_o_get_section_type_from_name (const char *name
)
3545 bfd_mach_o_xlat_name
*x
;
3547 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
3548 if (strcmp (x
->name
, name
) == 0)
3550 return (unsigned int)-1;
3553 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
3556 bfd_mach_o_get_section_attribute_from_name (const char *name
)
3558 bfd_mach_o_xlat_name
*x
;
3560 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
3561 if (strcmp (x
->name
, name
) == 0)
3563 return (unsigned int)-1;
3567 bfd_mach_o_print_private_header (bfd
*abfd
, FILE *file
)
3569 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3570 bfd_mach_o_header
*h
= &mdata
->header
;
3572 fputs (_("Mach-O header:\n"), file
);
3573 fprintf (file
, _(" magic : %08lx\n"), h
->magic
);
3574 fprintf (file
, _(" cputype : %08lx (%s)\n"), h
->cputype
,
3575 bfd_mach_o_get_name (bfd_mach_o_cpu_name
, h
->cputype
));
3576 fprintf (file
, _(" cpusubtype: %08lx\n"), h
->cpusubtype
);
3577 fprintf (file
, _(" filetype : %08lx (%s)\n"),
3579 bfd_mach_o_get_name (bfd_mach_o_filetype_name
, h
->filetype
));
3580 fprintf (file
, _(" ncmds : %08lx (%lu)\n"), h
->ncmds
, h
->ncmds
);
3581 fprintf (file
, _(" sizeofcmds: %08lx\n"), h
->sizeofcmds
);
3582 fprintf (file
, _(" flags : %08lx ("), h
->flags
);
3583 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name
, h
->flags
, file
);
3584 fputs (_(")\n"), file
);
3585 fprintf (file
, _(" reserved : %08x\n"), h
->reserved
);
3589 bfd_mach_o_print_section_map (bfd
*abfd
, FILE *file
)
3591 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3593 unsigned int sec_nbr
= 0;
3595 fputs (_("Segments and Sections:\n"), file
);
3596 fputs (_(" #: Segment name Section name Address\n"), file
);
3598 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3600 bfd_mach_o_segment_command
*seg
;
3601 bfd_mach_o_section
*sec
;
3603 if (mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT
3604 && mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT_64
)
3607 seg
= &mdata
->commands
[i
].command
.segment
;
3609 fprintf (file
, "[Segment %-16s ", seg
->segname
);
3610 fprintf_vma (file
, seg
->vmaddr
);
3611 fprintf (file
, "-");
3612 fprintf_vma (file
, seg
->vmaddr
+ seg
->vmsize
- 1);
3614 fputc (seg
->initprot
& BFD_MACH_O_PROT_READ
? 'r' : '-', file
);
3615 fputc (seg
->initprot
& BFD_MACH_O_PROT_WRITE
? 'w' : '-', file
);
3616 fputc (seg
->initprot
& BFD_MACH_O_PROT_EXECUTE
? 'x' : '-', file
);
3617 fprintf (file
, "]\n");
3619 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3621 fprintf (file
, "%02u: %-16s %-16s ", ++sec_nbr
,
3622 sec
->segname
, sec
->sectname
);
3623 fprintf_vma (file
, sec
->addr
);
3624 fprintf (file
, " ");
3625 fprintf_vma (file
, sec
->size
);
3626 fprintf (file
, " %08lx\n", sec
->flags
);
3632 bfd_mach_o_print_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3633 bfd_mach_o_section
*sec
, FILE *file
)
3635 fprintf (file
, " Section: %-16s %-16s (bfdname: %s)\n",
3636 sec
->sectname
, sec
->segname
, sec
->bfdsection
->name
);
3637 fprintf (file
, " addr: ");
3638 fprintf_vma (file
, sec
->addr
);
3639 fprintf (file
, " size: ");
3640 fprintf_vma (file
, sec
->size
);
3641 fprintf (file
, " offset: ");
3642 fprintf_vma (file
, sec
->offset
);
3643 fprintf (file
, "\n");
3644 fprintf (file
, " align: %ld", sec
->align
);
3645 fprintf (file
, " nreloc: %lu reloff: ", sec
->nreloc
);
3646 fprintf_vma (file
, sec
->reloff
);
3647 fprintf (file
, "\n");
3648 fprintf (file
, " flags: %08lx (type: %s", sec
->flags
,
3649 bfd_mach_o_get_name (bfd_mach_o_section_type_name
,
3650 sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
));
3651 fprintf (file
, " attr: ");
3652 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name
,
3653 sec
->flags
& BFD_MACH_O_SECTION_ATTRIBUTES_MASK
,
3655 fprintf (file
, ")\n");
3656 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3658 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3659 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3660 case BFD_MACH_O_S_SYMBOL_STUBS
:
3661 fprintf (file
, " first indirect sym: %lu", sec
->reserved1
);
3662 fprintf (file
, " (%u entries)",
3663 bfd_mach_o_section_get_nbr_indirect (abfd
, sec
));
3666 fprintf (file
, " reserved1: 0x%lx", sec
->reserved1
);
3669 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3671 case BFD_MACH_O_S_SYMBOL_STUBS
:
3672 fprintf (file
, " stub size: %lu", sec
->reserved2
);
3675 fprintf (file
, " reserved2: 0x%lx", sec
->reserved2
);
3678 fprintf (file
, " reserved3: 0x%lx\n", sec
->reserved3
);
3682 bfd_mach_o_print_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
3683 bfd_mach_o_load_command
*cmd
, FILE *file
)
3685 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3686 bfd_mach_o_section
*sec
;
3688 fprintf (file
, " name: %s\n", *seg
->segname
? seg
->segname
: "*none*");
3689 fprintf (file
, " vmaddr: ");
3690 fprintf_vma (file
, seg
->vmaddr
);
3691 fprintf (file
, " vmsize: ");
3692 fprintf_vma (file
, seg
->vmsize
);
3693 fprintf (file
, "\n");
3694 fprintf (file
, " fileoff: ");
3695 fprintf_vma (file
, seg
->fileoff
);
3696 fprintf (file
, " filesize: ");
3697 fprintf_vma (file
, (bfd_vma
)seg
->filesize
);
3698 fprintf (file
, " endoff: ");
3699 fprintf_vma (file
, (bfd_vma
)(seg
->fileoff
+ seg
->filesize
));
3700 fprintf (file
, "\n");
3701 fprintf (file
, " nsects: %lu ", seg
->nsects
);
3702 fprintf (file
, " flags: %lx\n", seg
->flags
);
3703 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3704 bfd_mach_o_print_section (abfd
, sec
, file
);
3708 bfd_mach_o_print_dysymtab (bfd
*abfd ATTRIBUTE_UNUSED
,
3709 bfd_mach_o_load_command
*cmd
, FILE *file
)
3711 bfd_mach_o_dysymtab_command
*dysymtab
= &cmd
->command
.dysymtab
;
3712 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3715 fprintf (file
, " local symbols: idx: %10lu num: %-8lu",
3716 dysymtab
->ilocalsym
, dysymtab
->nlocalsym
);
3717 fprintf (file
, " (nxtidx: %lu)\n",
3718 dysymtab
->ilocalsym
+ dysymtab
->nlocalsym
);
3719 fprintf (file
, " external symbols: idx: %10lu num: %-8lu",
3720 dysymtab
->iextdefsym
, dysymtab
->nextdefsym
);
3721 fprintf (file
, " (nxtidx: %lu)\n",
3722 dysymtab
->iextdefsym
+ dysymtab
->nextdefsym
);
3723 fprintf (file
, " undefined symbols: idx: %10lu num: %-8lu",
3724 dysymtab
->iundefsym
, dysymtab
->nundefsym
);
3725 fprintf (file
, " (nxtidx: %lu)\n",
3726 dysymtab
->iundefsym
+ dysymtab
->nundefsym
);
3727 fprintf (file
, " table of content: off: 0x%08lx num: %-8lu",
3728 dysymtab
->tocoff
, dysymtab
->ntoc
);
3729 fprintf (file
, " (endoff: 0x%08lx)\n",
3731 + dysymtab
->ntoc
* BFD_MACH_O_TABLE_OF_CONTENT_SIZE
);
3732 fprintf (file
, " module table: off: 0x%08lx num: %-8lu",
3733 dysymtab
->modtaboff
, dysymtab
->nmodtab
);
3734 fprintf (file
, " (endoff: 0x%08lx)\n",
3735 dysymtab
->modtaboff
+ dysymtab
->nmodtab
3736 * (mach_o_wide_p (&mdata
->header
) ?
3737 BFD_MACH_O_DYLIB_MODULE_64_SIZE
: BFD_MACH_O_DYLIB_MODULE_SIZE
));
3738 fprintf (file
, " external reference table: off: 0x%08lx num: %-8lu",
3739 dysymtab
->extrefsymoff
, dysymtab
->nextrefsyms
);
3740 fprintf (file
, " (endoff: 0x%08lx)\n",
3741 dysymtab
->extrefsymoff
3742 + dysymtab
->nextrefsyms
* BFD_MACH_O_REFERENCE_SIZE
);
3743 fprintf (file
, " indirect symbol table: off: 0x%08lx num: %-8lu",
3744 dysymtab
->indirectsymoff
, dysymtab
->nindirectsyms
);
3745 fprintf (file
, " (endoff: 0x%08lx)\n",
3746 dysymtab
->indirectsymoff
3747 + dysymtab
->nindirectsyms
* BFD_MACH_O_INDIRECT_SYMBOL_SIZE
);
3748 fprintf (file
, " external relocation table: off: 0x%08lx num: %-8lu",
3749 dysymtab
->extreloff
, dysymtab
->nextrel
);
3750 fprintf (file
, " (endoff: 0x%08lx)\n",
3751 dysymtab
->extreloff
+ dysymtab
->nextrel
* BFD_MACH_O_RELENT_SIZE
);
3752 fprintf (file
, " local relocation table: off: 0x%08lx num: %-8lu",
3753 dysymtab
->locreloff
, dysymtab
->nlocrel
);
3754 fprintf (file
, " (endoff: 0x%08lx)\n",
3755 dysymtab
->locreloff
+ dysymtab
->nlocrel
* BFD_MACH_O_RELENT_SIZE
);
3757 if (dysymtab
->ntoc
> 0
3758 || dysymtab
->nindirectsyms
> 0
3759 || dysymtab
->nextrefsyms
> 0)
3761 /* Try to read the symbols to display the toc or indirect symbols. */
3762 bfd_mach_o_read_symtab_symbols (abfd
);
3764 else if (dysymtab
->nmodtab
> 0)
3766 /* Try to read the strtab to display modules name. */
3767 bfd_mach_o_read_symtab_strtab (abfd
);
3770 for (i
= 0; i
< dysymtab
->nmodtab
; i
++)
3772 bfd_mach_o_dylib_module
*module
= &dysymtab
->dylib_module
[i
];
3773 fprintf (file
, " module %u:\n", i
);
3774 fprintf (file
, " name: %lu", module
->module_name_idx
);
3775 if (mdata
->symtab
&& mdata
->symtab
->strtab
)
3776 fprintf (file
, ": %s",
3777 mdata
->symtab
->strtab
+ module
->module_name_idx
);
3778 fprintf (file
, "\n");
3779 fprintf (file
, " extdefsym: idx: %8lu num: %lu\n",
3780 module
->iextdefsym
, module
->nextdefsym
);
3781 fprintf (file
, " refsym: idx: %8lu num: %lu\n",
3782 module
->irefsym
, module
->nrefsym
);
3783 fprintf (file
, " localsym: idx: %8lu num: %lu\n",
3784 module
->ilocalsym
, module
->nlocalsym
);
3785 fprintf (file
, " extrel: idx: %8lu num: %lu\n",
3786 module
->iextrel
, module
->nextrel
);
3787 fprintf (file
, " init: idx: %8u num: %u\n",
3788 module
->iinit
, module
->ninit
);
3789 fprintf (file
, " term: idx: %8u num: %u\n",
3790 module
->iterm
, module
->nterm
);
3791 fprintf (file
, " objc_module_info: addr: ");
3792 fprintf_vma (file
, module
->objc_module_info_addr
);
3793 fprintf (file
, " size: %lu\n", module
->objc_module_info_size
);
3796 if (dysymtab
->ntoc
> 0)
3798 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3800 fprintf (file
, " table of content: (symbol/module)\n");
3801 for (i
= 0; i
< dysymtab
->ntoc
; i
++)
3803 bfd_mach_o_dylib_table_of_content
*toc
= &dysymtab
->dylib_toc
[i
];
3805 fprintf (file
, " %4u: ", i
);
3806 if (symtab
&& symtab
->symbols
&& toc
->symbol_index
< symtab
->nsyms
)
3808 const char *name
= symtab
->symbols
[toc
->symbol_index
].symbol
.name
;
3809 fprintf (file
, "%s (%lu)", name
? name
: "*invalid*",
3813 fprintf (file
, "%lu", toc
->symbol_index
);
3815 fprintf (file
, " / ");
3816 if (symtab
&& symtab
->strtab
3817 && toc
->module_index
< dysymtab
->nmodtab
)
3819 bfd_mach_o_dylib_module
*mod
;
3820 mod
= &dysymtab
->dylib_module
[toc
->module_index
];
3821 fprintf (file
, "%s (%lu)",
3822 symtab
->strtab
+ mod
->module_name_idx
,
3826 fprintf (file
, "%lu", toc
->module_index
);
3828 fprintf (file
, "\n");
3832 if (dysymtab
->nindirectsyms
!= 0)
3834 fprintf (file
, " indirect symbols:\n");
3836 for (i
= 0; i
< mdata
->nsects
; i
++)
3838 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
3839 unsigned int j
, first
, last
;
3840 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3844 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3846 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3847 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3848 case BFD_MACH_O_S_SYMBOL_STUBS
:
3849 first
= sec
->reserved1
;
3850 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
3852 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
3853 fprintf (file
, " for section %s.%s:\n",
3854 sec
->segname
, sec
->sectname
);
3855 for (j
= first
; j
< last
; j
++)
3857 unsigned int isym
= dysymtab
->indirect_syms
[j
];
3859 fprintf (file
, " ");
3860 fprintf_vma (file
, addr
);
3861 fprintf (file
, " %5u: 0x%08x", j
, isym
);
3862 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_LOCAL
)
3863 fprintf (file
, " LOCAL");
3864 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_ABS
)
3865 fprintf (file
, " ABSOLUTE");
3866 if (symtab
&& symtab
->symbols
3867 && isym
< symtab
->nsyms
3868 && symtab
->symbols
[isym
].symbol
.name
)
3869 fprintf (file
, " %s", symtab
->symbols
[isym
].symbol
.name
);
3870 fprintf (file
, "\n");
3879 if (dysymtab
->nextrefsyms
> 0)
3881 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3883 fprintf (file
, " external reference table: (symbol flags)\n");
3884 for (i
= 0; i
< dysymtab
->nextrefsyms
; i
++)
3886 bfd_mach_o_dylib_reference
*ref
= &dysymtab
->ext_refs
[i
];
3888 fprintf (file
, " %4u: %5lu 0x%02lx", i
, ref
->isym
, ref
->flags
);
3889 if (symtab
&& symtab
->symbols
3890 && ref
->isym
< symtab
->nsyms
3891 && symtab
->symbols
[ref
->isym
].symbol
.name
)
3892 fprintf (file
, " %s", symtab
->symbols
[ref
->isym
].symbol
.name
);
3893 fprintf (file
, "\n");
3900 bfd_mach_o_print_dyld_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3901 bfd_mach_o_load_command
*cmd
, FILE *file
)
3903 bfd_mach_o_dyld_info_command
*info
= &cmd
->command
.dyld_info
;
3905 fprintf (file
, " rebase: off: 0x%08x size: %-8u\n",
3906 info
->rebase_off
, info
->rebase_size
);
3907 fprintf (file
, " bind: off: 0x%08x size: %-8u\n",
3908 info
->bind_off
, info
->bind_size
);
3909 fprintf (file
, " weak bind: off: 0x%08x size: %-8u\n",
3910 info
->weak_bind_off
, info
->weak_bind_size
);
3911 fprintf (file
, " lazy bind: off: 0x%08x size: %-8u\n",
3912 info
->lazy_bind_off
, info
->lazy_bind_size
);
3913 fprintf (file
, " export: off: 0x%08x size: %-8u\n",
3914 info
->export_off
, info
->export_size
);
3918 bfd_mach_o_bfd_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3920 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3921 FILE *file
= (FILE *) ptr
;
3924 bfd_mach_o_print_private_header (abfd
, file
);
3927 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3929 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[i
];
3930 const char *cmd_name
;
3932 cmd_name
= bfd_mach_o_get_name_or_null
3933 (bfd_mach_o_load_command_name
, cmd
->type
);
3934 fprintf (file
, "Load command ");
3935 if (cmd_name
== NULL
)
3936 fprintf (file
, "0x%02x:", cmd
->type
);
3938 fprintf (file
, "%s:", cmd_name
);
3942 case BFD_MACH_O_LC_SEGMENT
:
3943 case BFD_MACH_O_LC_SEGMENT_64
:
3944 bfd_mach_o_print_segment (abfd
, cmd
, file
);
3946 case BFD_MACH_O_LC_UUID
:
3948 bfd_mach_o_uuid_command
*uuid
= &cmd
->command
.uuid
;
3951 for (j
= 0; j
< sizeof (uuid
->uuid
); j
++)
3952 fprintf (file
, " %02x", uuid
->uuid
[j
]);
3956 case BFD_MACH_O_LC_LOAD_DYLIB
:
3957 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3958 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3959 case BFD_MACH_O_LC_ID_DYLIB
:
3961 bfd_mach_o_dylib_command
*dylib
= &cmd
->command
.dylib
;
3962 fprintf (file
, " %s\n", dylib
->name_str
);
3963 fprintf (file
, " time stamp: 0x%08lx\n",
3965 fprintf (file
, " current version: 0x%08lx\n",
3966 dylib
->current_version
);
3967 fprintf (file
, " comptibility version: 0x%08lx\n",
3968 dylib
->compatibility_version
);
3971 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3972 case BFD_MACH_O_LC_ID_DYLINKER
:
3973 fprintf (file
, " %s\n", cmd
->command
.dylinker
.name_str
);
3975 case BFD_MACH_O_LC_SYMTAB
:
3977 bfd_mach_o_symtab_command
*symtab
= &cmd
->command
.symtab
;
3980 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
3981 symtab
->symoff
, symtab
->nsyms
,
3982 symtab
->symoff
+ symtab
->nsyms
3983 * (mach_o_wide_p (&mdata
->header
)
3984 ? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
));
3986 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
3987 symtab
->stroff
, symtab
->strsize
,
3988 symtab
->stroff
+ symtab
->strsize
);
3991 case BFD_MACH_O_LC_DYSYMTAB
:
3992 fprintf (file
, "\n");
3993 bfd_mach_o_print_dysymtab (abfd
, cmd
, file
);
3995 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3996 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3997 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3999 bfd_mach_o_linkedit_command
*linkedit
= &cmd
->command
.linkedit
;
4002 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
4003 linkedit
->dataoff
, linkedit
->datasize
,
4004 linkedit
->dataoff
+ linkedit
->datasize
);
4007 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4008 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4009 case BFD_MACH_O_LC_SUB_LIBRARY
:
4010 case BFD_MACH_O_LC_SUB_CLIENT
:
4011 case BFD_MACH_O_LC_RPATH
:
4013 bfd_mach_o_str_command
*str
= &cmd
->command
.str
;
4014 fprintf (file
, " %s\n", str
->str
);
4017 case BFD_MACH_O_LC_THREAD
:
4018 case BFD_MACH_O_LC_UNIXTHREAD
:
4020 bfd_mach_o_thread_command
*thread
= &cmd
->command
.thread
;
4022 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4024 fprintf (file
, " nflavours: %lu\n", thread
->nflavours
);
4025 for (j
= 0; j
< thread
->nflavours
; j
++)
4027 bfd_mach_o_thread_flavour
*flavour
= &thread
->flavours
[j
];
4029 fprintf (file
, " %2u: flavour: 0x%08lx offset: 0x%08lx"
4031 j
, flavour
->flavour
, flavour
->offset
,
4033 if (bed
->_bfd_mach_o_print_thread
)
4035 char *buf
= bfd_malloc (flavour
->size
);
4038 && bfd_seek (abfd
, flavour
->offset
, SEEK_SET
) == 0
4039 && (bfd_bread (buf
, flavour
->size
, abfd
)
4041 (*bed
->_bfd_mach_o_print_thread
)(abfd
, flavour
,
4048 case BFD_MACH_O_LC_DYLD_INFO
:
4049 fprintf (file
, "\n");
4050 bfd_mach_o_print_dyld_info (abfd
, cmd
, file
);
4052 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4053 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4055 bfd_mach_o_version_min_command
*ver
= &cmd
->command
.version_min
;
4057 fprintf (file
, " %u.%u.%u\n", ver
->rel
, ver
->maj
, ver
->min
);
4061 fprintf (file
, "\n");
4062 fprintf (file
, " offset: 0x%08lx\n", (unsigned long)cmd
->offset
);
4063 fprintf (file
, " size: 0x%08lx\n", (unsigned long)cmd
->len
);
4069 bfd_mach_o_print_section_map (abfd
, file
);
4075 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4076 unsigned char **rbuf
,
4079 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4080 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4083 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4085 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4086 bfd_mach_o_segment_command
*seg
= NULL
;
4088 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4091 seg
= &cur
->command
.segment
;
4093 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4095 unsigned long start
= seg
->fileoff
;
4096 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4097 unsigned char *buf
= bfd_malloc (1024);
4098 unsigned long size
= 1024;
4102 bfd_size_type nread
= 0;
4103 unsigned long offset
;
4104 int found_nonnull
= 0;
4106 if (size
> (end
- start
))
4107 size
= (end
- start
);
4109 buf
= bfd_realloc_or_free (buf
, size
);
4113 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4119 nread
= bfd_bread (buf
, size
, abfd
);
4127 for (offset
= 4; offset
<= size
; offset
+= 4)
4131 val
= *((unsigned long *) (buf
+ size
- offset
));
4132 if (! found_nonnull
)
4137 else if (val
== 0x0)
4139 unsigned long bottom
;
4142 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4143 top
= seg
->fileoff
+ seg
->filesize
- 4;
4144 *rbuf
= bfd_malloc (top
- bottom
);
4145 *rlen
= top
- bottom
;
4147 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4153 if (size
== (end
- start
))
4167 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4169 unsigned char *buf
= NULL
;
4170 unsigned int len
= 0;
4173 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4177 return (char *) buf
;
4181 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4186 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4187 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4189 #define bfd_mach_o_swap_reloc_in NULL
4190 #define bfd_mach_o_swap_reloc_out NULL
4191 #define bfd_mach_o_print_thread NULL
4193 #define TARGET_NAME mach_o_be_vec
4194 #define TARGET_STRING "mach-o-be"
4195 #define TARGET_ARCHITECTURE bfd_arch_unknown
4196 #define TARGET_BIG_ENDIAN 1
4197 #define TARGET_ARCHIVE 0
4198 #include "mach-o-target.c"
4201 #undef TARGET_STRING
4202 #undef TARGET_ARCHITECTURE
4203 #undef TARGET_BIG_ENDIAN
4204 #undef TARGET_ARCHIVE
4206 #define TARGET_NAME mach_o_le_vec
4207 #define TARGET_STRING "mach-o-le"
4208 #define TARGET_ARCHITECTURE bfd_arch_unknown
4209 #define TARGET_BIG_ENDIAN 0
4210 #define TARGET_ARCHIVE 0
4212 #include "mach-o-target.c"
4215 #undef TARGET_STRING
4216 #undef TARGET_ARCHITECTURE
4217 #undef TARGET_BIG_ENDIAN
4218 #undef TARGET_ARCHIVE
4220 /* Not yet handled: creating an archive. */
4221 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4224 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4225 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4226 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4227 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4228 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4229 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4230 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4231 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4232 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4233 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4235 #define TARGET_NAME mach_o_fat_vec
4236 #define TARGET_STRING "mach-o-fat"
4237 #define TARGET_ARCHITECTURE bfd_arch_unknown
4238 #define TARGET_BIG_ENDIAN 1
4239 #define TARGET_ARCHIVE 1
4241 #include "mach-o-target.c"
4244 #undef TARGET_STRING
4245 #undef TARGET_ARCHITECTURE
4246 #undef TARGET_BIG_ENDIAN
4247 #undef TARGET_ARCHIVE