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
+ 16, 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
);
2597 for (i
= 0; i
< seg
->nsects
; i
++)
2603 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
2604 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
2606 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
2607 + (i
* BFD_MACH_O_SECTION_SIZE
);
2609 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
2613 bfd_mach_o_append_section_to_segment (seg
, sec
);
2620 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2622 return bfd_mach_o_read_segment (abfd
, command
, 0);
2626 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2628 return bfd_mach_o_read_segment (abfd
, command
, 1);
2632 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2634 struct mach_o_load_command_external raw
;
2637 /* Read command type and length. */
2638 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
2639 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
2642 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
2643 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
2644 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
2645 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
2647 switch (command
->type
)
2649 case BFD_MACH_O_LC_SEGMENT
:
2650 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
2653 case BFD_MACH_O_LC_SEGMENT_64
:
2654 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
2657 case BFD_MACH_O_LC_SYMTAB
:
2658 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
2661 case BFD_MACH_O_LC_SYMSEG
:
2663 case BFD_MACH_O_LC_THREAD
:
2664 case BFD_MACH_O_LC_UNIXTHREAD
:
2665 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
2668 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2669 case BFD_MACH_O_LC_ID_DYLINKER
:
2670 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
2673 case BFD_MACH_O_LC_LOAD_DYLIB
:
2674 case BFD_MACH_O_LC_ID_DYLIB
:
2675 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2676 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2677 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
2680 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
2681 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
2684 case BFD_MACH_O_LC_LOADFVMLIB
:
2685 case BFD_MACH_O_LC_IDFVMLIB
:
2686 case BFD_MACH_O_LC_IDENT
:
2687 case BFD_MACH_O_LC_FVMFILE
:
2688 case BFD_MACH_O_LC_PREPAGE
:
2689 case BFD_MACH_O_LC_ROUTINES
:
2690 case BFD_MACH_O_LC_ROUTINES_64
:
2692 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
2693 case BFD_MACH_O_LC_SUB_UMBRELLA
:
2694 case BFD_MACH_O_LC_SUB_LIBRARY
:
2695 case BFD_MACH_O_LC_SUB_CLIENT
:
2696 case BFD_MACH_O_LC_RPATH
:
2697 if (bfd_mach_o_read_str (abfd
, command
) != 0)
2700 case BFD_MACH_O_LC_DYSYMTAB
:
2701 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
2704 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
2705 case BFD_MACH_O_LC_PREBIND_CKSUM
:
2707 case BFD_MACH_O_LC_UUID
:
2708 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
2711 case BFD_MACH_O_LC_CODE_SIGNATURE
:
2712 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
2713 case BFD_MACH_O_LC_FUNCTION_STARTS
:
2714 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
2717 case BFD_MACH_O_LC_DYLD_INFO
:
2718 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
2721 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
2722 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
2723 if (!bfd_mach_o_read_version_min (abfd
, command
))
2727 (*_bfd_error_handler
) (_("unable to read unknown load command 0x%lx"),
2728 (unsigned long) command
->type
);
2736 bfd_mach_o_flatten_sections (bfd
*abfd
)
2738 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2742 /* Count total number of sections. */
2745 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2747 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2748 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2750 bfd_mach_o_segment_command
*seg
;
2752 seg
= &mdata
->commands
[i
].command
.segment
;
2753 mdata
->nsects
+= seg
->nsects
;
2757 /* Allocate sections array. */
2758 mdata
->sections
= bfd_alloc (abfd
,
2759 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2761 /* Fill the array. */
2764 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2766 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2767 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2769 bfd_mach_o_segment_command
*seg
;
2770 bfd_mach_o_section
*sec
;
2772 seg
= &mdata
->commands
[i
].command
.segment
;
2773 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
2775 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
2776 mdata
->sections
[csect
++] = sec
;
2782 bfd_mach_o_scan_start_address (bfd
*abfd
)
2784 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2785 bfd_mach_o_thread_command
*cmd
= NULL
;
2788 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2790 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
2791 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
2794 cmd
= &mdata
->commands
[i
].command
.thread
;
2803 for (i
= 0; i
< cmd
->nflavours
; i
++)
2805 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
2806 && (cmd
->flavours
[i
].flavour
2807 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
2809 unsigned char buf
[4];
2811 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
2812 || bfd_bread (buf
, 4, abfd
) != 4)
2815 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2817 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
2818 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
2820 unsigned char buf
[4];
2822 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2823 || bfd_bread (buf
, 4, abfd
) != 4)
2826 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2828 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
2829 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
2831 unsigned char buf
[8];
2833 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2834 || bfd_bread (buf
, 8, abfd
) != 8)
2837 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2839 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
2840 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
2842 unsigned char buf
[8];
2844 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
2845 || bfd_bread (buf
, 8, abfd
) != 8)
2848 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2856 bfd_mach_o_set_arch_mach (bfd
*abfd
,
2857 enum bfd_architecture arch
,
2858 unsigned long machine
)
2860 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
2862 /* If this isn't the right architecture for this backend, and this
2863 isn't the generic backend, fail. */
2864 if (arch
!= bed
->arch
2865 && arch
!= bfd_arch_unknown
2866 && bed
->arch
!= bfd_arch_unknown
)
2869 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
2873 bfd_mach_o_scan (bfd
*abfd
,
2874 bfd_mach_o_header
*header
,
2875 bfd_mach_o_data_struct
*mdata
)
2878 enum bfd_architecture cputype
;
2879 unsigned long cpusubtype
;
2880 unsigned int hdrsize
;
2882 hdrsize
= mach_o_wide_p (header
) ?
2883 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2885 mdata
->header
= *header
;
2887 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
2888 switch (header
->filetype
)
2890 case BFD_MACH_O_MH_OBJECT
:
2891 abfd
->flags
|= HAS_RELOC
;
2893 case BFD_MACH_O_MH_EXECUTE
:
2894 abfd
->flags
|= EXEC_P
;
2896 case BFD_MACH_O_MH_DYLIB
:
2897 case BFD_MACH_O_MH_BUNDLE
:
2898 abfd
->flags
|= DYNAMIC
;
2902 abfd
->tdata
.mach_o_data
= mdata
;
2904 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
2905 &cputype
, &cpusubtype
);
2906 if (cputype
== bfd_arch_unknown
)
2908 (*_bfd_error_handler
) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
2909 header
->cputype
, header
->cpusubtype
);
2913 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
2915 if (header
->ncmds
!= 0)
2917 mdata
->commands
= bfd_alloc
2918 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
2919 if (mdata
->commands
== NULL
)
2922 for (i
= 0; i
< header
->ncmds
; i
++)
2924 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
2927 cur
->offset
= hdrsize
;
2930 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
2931 cur
->offset
= prev
->offset
+ prev
->len
;
2934 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
2939 if (bfd_mach_o_scan_start_address (abfd
) < 0)
2942 bfd_mach_o_flatten_sections (abfd
);
2947 bfd_mach_o_mkobject_init (bfd
*abfd
)
2949 bfd_mach_o_data_struct
*mdata
= NULL
;
2951 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
2954 abfd
->tdata
.mach_o_data
= mdata
;
2956 mdata
->header
.magic
= 0;
2957 mdata
->header
.cputype
= 0;
2958 mdata
->header
.cpusubtype
= 0;
2959 mdata
->header
.filetype
= 0;
2960 mdata
->header
.ncmds
= 0;
2961 mdata
->header
.sizeofcmds
= 0;
2962 mdata
->header
.flags
= 0;
2963 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
2964 mdata
->commands
= NULL
;
2966 mdata
->sections
= NULL
;
2972 bfd_mach_o_gen_mkobject (bfd
*abfd
)
2974 bfd_mach_o_data_struct
*mdata
;
2976 if (!bfd_mach_o_mkobject_init (abfd
))
2979 mdata
= bfd_mach_o_get_data (abfd
);
2980 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
2981 mdata
->header
.cputype
= 0;
2982 mdata
->header
.cpusubtype
= 0;
2983 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
2984 mdata
->header
.version
= 1;
2990 bfd_mach_o_header_p (bfd
*abfd
,
2991 bfd_mach_o_filetype filetype
,
2992 bfd_mach_o_cpu_type cputype
)
2994 struct bfd_preserve preserve
;
2995 bfd_mach_o_header header
;
2997 preserve
.marker
= NULL
;
2998 if (!bfd_mach_o_read_header (abfd
, &header
))
3001 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3002 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3004 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3005 (unsigned long) header
.byteorder
);
3009 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3010 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3011 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3012 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3013 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3014 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3017 /* Check cputype and filetype.
3018 In case of wildcard, do not accept magics that are handled by existing
3022 if (header
.cputype
!= cputype
)
3027 switch (header
.cputype
)
3029 case BFD_MACH_O_CPU_TYPE_I386
:
3030 /* Handled by mach-o-i386 */
3038 if (header
.filetype
!= filetype
)
3043 switch (header
.filetype
)
3045 case BFD_MACH_O_MH_CORE
:
3046 /* Handled by core_p */
3053 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3054 if (preserve
.marker
== NULL
3055 || !bfd_preserve_save (abfd
, &preserve
))
3058 if (bfd_mach_o_scan (abfd
, &header
,
3059 (bfd_mach_o_data_struct
*) preserve
.marker
) != 0)
3062 bfd_preserve_finish (abfd
, &preserve
);
3066 bfd_set_error (bfd_error_wrong_format
);
3069 if (preserve
.marker
!= NULL
)
3070 bfd_preserve_restore (abfd
, &preserve
);
3074 static const bfd_target
*
3075 bfd_mach_o_gen_object_p (bfd
*abfd
)
3077 return bfd_mach_o_header_p (abfd
, 0, 0);
3080 static const bfd_target
*
3081 bfd_mach_o_gen_core_p (bfd
*abfd
)
3083 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
3086 typedef struct mach_o_fat_archentry
3088 unsigned long cputype
;
3089 unsigned long cpusubtype
;
3090 unsigned long offset
;
3092 unsigned long align
;
3093 } mach_o_fat_archentry
;
3095 typedef struct mach_o_fat_data_struct
3097 unsigned long magic
;
3098 unsigned long nfat_arch
;
3099 mach_o_fat_archentry
*archentries
;
3100 } mach_o_fat_data_struct
;
3103 bfd_mach_o_archive_p (bfd
*abfd
)
3105 mach_o_fat_data_struct
*adata
= NULL
;
3106 struct mach_o_fat_header_external hdr
;
3109 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3110 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
3113 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
3117 adata
->magic
= bfd_getb32 (hdr
.magic
);
3118 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
3119 if (adata
->magic
!= 0xcafebabe)
3121 /* Avoid matching Java bytecode files, which have the same magic number.
3122 In the Java bytecode file format this field contains the JVM version,
3123 which starts at 43.0. */
3124 if (adata
->nfat_arch
> 30)
3127 adata
->archentries
=
3128 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
3129 if (adata
->archentries
== NULL
)
3132 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3134 struct mach_o_fat_arch_external arch
;
3135 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
3137 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
3138 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
3139 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
3140 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
3141 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
3144 abfd
->tdata
.mach_o_fat_data
= adata
;
3149 bfd_release (abfd
, adata
);
3150 bfd_set_error (bfd_error_wrong_format
);
3155 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
3157 mach_o_fat_data_struct
*adata
;
3158 mach_o_fat_archentry
*entry
= NULL
;
3161 enum bfd_architecture arch_type
;
3162 unsigned long arch_subtype
;
3164 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
3165 BFD_ASSERT (adata
!= NULL
);
3167 /* Find index of previous entry. */
3169 i
= 0; /* Start at first one. */
3172 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3174 if (adata
->archentries
[i
].offset
== prev
->origin
)
3178 if (i
== adata
->nfat_arch
)
3181 bfd_set_error (bfd_error_bad_value
);
3184 i
++; /* Get next entry. */
3187 if (i
>= adata
->nfat_arch
)
3189 bfd_set_error (bfd_error_no_more_archived_files
);
3193 entry
= &adata
->archentries
[i
];
3194 nbfd
= _bfd_new_bfd_contained_in (archive
);
3198 nbfd
->origin
= entry
->offset
;
3200 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
3201 &arch_type
, &arch_subtype
);
3202 /* Create the member filename.
3203 Use FILENAME:ARCH_NAME. */
3206 const char *arch_name
;
3207 size_t arch_file_len
= strlen (bfd_get_filename (archive
));
3209 arch_name
= bfd_printable_arch_mach (arch_type
, arch_subtype
);
3210 s
= bfd_malloc (arch_file_len
+ 1 + strlen (arch_name
) + 1);
3213 memcpy (s
, bfd_get_filename (archive
), arch_file_len
);
3214 s
[arch_file_len
] = ':';
3215 strcpy (s
+ arch_file_len
+ 1, arch_name
);
3218 nbfd
->iostream
= NULL
;
3219 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
3224 /* If ABFD format is FORMAT and architecture is ARCH, return it.
3225 If ABFD is a fat image containing a member that corresponds to FORMAT
3226 and ARCH, returns it.
3227 In other case, returns NULL.
3228 This function allows transparent uses of fat images. */
3230 bfd_mach_o_fat_extract (bfd
*abfd
,
3232 const bfd_arch_info_type
*arch
)
3235 mach_o_fat_data_struct
*adata
;
3238 if (bfd_check_format (abfd
, format
))
3240 if (bfd_get_arch_info (abfd
) == arch
)
3244 if (!bfd_check_format (abfd
, bfd_archive
)
3245 || abfd
->xvec
!= &mach_o_fat_vec
)
3248 /* This is a Mach-O fat image. */
3249 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
3250 BFD_ASSERT (adata
!= NULL
);
3252 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3254 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
3255 enum bfd_architecture cpu_type
;
3256 unsigned long cpu_subtype
;
3258 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
3259 &cpu_type
, &cpu_subtype
);
3260 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
3263 /* The architecture is found. */
3264 res
= _bfd_new_bfd_contained_in (abfd
);
3268 res
->origin
= e
->offset
;
3270 res
->filename
= strdup (abfd
->filename
);
3271 res
->iostream
= NULL
;
3273 if (bfd_check_format (res
, format
))
3275 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
3286 bfd_mach_o_lookup_command (bfd
*abfd
,
3287 bfd_mach_o_load_command_type type
,
3288 bfd_mach_o_load_command
**mcommand
)
3290 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
3291 bfd_mach_o_load_command
*ncmd
= NULL
;
3292 unsigned int i
, num
;
3294 BFD_ASSERT (md
!= NULL
);
3295 BFD_ASSERT (mcommand
!= NULL
);
3298 for (i
= 0; i
< md
->header
.ncmds
; i
++)
3300 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
3302 if (cmd
->type
!= type
)
3315 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
3319 case BFD_MACH_O_CPU_TYPE_MC680x0
:
3321 case BFD_MACH_O_CPU_TYPE_MC88000
:
3323 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3325 case BFD_MACH_O_CPU_TYPE_I386
:
3327 case BFD_MACH_O_CPU_TYPE_SPARC
:
3329 case BFD_MACH_O_CPU_TYPE_I860
:
3331 case BFD_MACH_O_CPU_TYPE_HPPA
:
3332 return 0xc0000000 - 0x04000000;
3338 typedef struct bfd_mach_o_xlat_name
3343 bfd_mach_o_xlat_name
;
3346 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name
*table
,
3352 for (; table
->name
; table
++)
3354 if (table
->val
& val
)
3357 fprintf (file
, "+");
3358 fprintf (file
, "%s", table
->name
);
3366 fprintf (file
, "+");
3367 fprintf (file
, "0x%lx", val
);
3371 fprintf (file
, "-");
3375 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name
*table
,
3378 for (; table
->name
; table
++)
3379 if (table
->val
== val
)
3385 bfd_mach_o_get_name (const bfd_mach_o_xlat_name
*table
, unsigned long val
)
3387 const char *res
= bfd_mach_o_get_name_or_null (table
, val
);
3395 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name
[] =
3397 { "vax", BFD_MACH_O_CPU_TYPE_VAX
},
3398 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0
},
3399 { "i386", BFD_MACH_O_CPU_TYPE_I386
},
3400 { "mips", BFD_MACH_O_CPU_TYPE_MIPS
},
3401 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000
},
3402 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA
},
3403 { "arm", BFD_MACH_O_CPU_TYPE_ARM
},
3404 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000
},
3405 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC
},
3406 { "i860", BFD_MACH_O_CPU_TYPE_I860
},
3407 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA
},
3408 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC
},
3409 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64
},
3410 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64
},
3414 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name
[] =
3416 { "object", BFD_MACH_O_MH_OBJECT
},
3417 { "execute", BFD_MACH_O_MH_EXECUTE
},
3418 { "fvmlib", BFD_MACH_O_MH_FVMLIB
},
3419 { "core", BFD_MACH_O_MH_CORE
},
3420 { "preload", BFD_MACH_O_MH_PRELOAD
},
3421 { "dylib", BFD_MACH_O_MH_DYLIB
},
3422 { "dylinker", BFD_MACH_O_MH_DYLINKER
},
3423 { "bundle", BFD_MACH_O_MH_BUNDLE
},
3424 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB
},
3425 { "dym", BFD_MACH_O_MH_DSYM
},
3426 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE
},
3430 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name
[] =
3432 { "noundefs", BFD_MACH_O_MH_NOUNDEFS
},
3433 { "incrlink", BFD_MACH_O_MH_INCRLINK
},
3434 { "dyldlink", BFD_MACH_O_MH_DYLDLINK
},
3435 { "bindatload", BFD_MACH_O_MH_BINDATLOAD
},
3436 { "prebound", BFD_MACH_O_MH_PREBOUND
},
3437 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS
},
3438 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT
},
3439 { "twolevel", BFD_MACH_O_MH_TWOLEVEL
},
3440 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT
},
3441 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS
},
3442 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING
},
3443 { "prebindable", BFD_MACH_O_MH_PREBINDABLE
},
3444 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND
},
3445 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS
},
3446 { "canonical", BFD_MACH_O_MH_CANONICAL
},
3447 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES
},
3448 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK
},
3449 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION
},
3450 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE
},
3451 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE
},
3452 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS
},
3453 { "pie", BFD_MACH_O_MH_PIE
},
3457 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
3459 { "regular", BFD_MACH_O_S_REGULAR
},
3460 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
3461 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
3462 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
3463 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
3464 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
3465 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
3466 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
3467 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
3468 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
3469 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
3470 { "coalesced", BFD_MACH_O_S_COALESCED
},
3471 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
3472 { "interposing", BFD_MACH_O_S_INTERPOSING
},
3473 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
3474 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
3475 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
3479 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
3481 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
3482 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
3483 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
3484 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
3485 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
3486 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
3487 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
3488 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
3489 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
3490 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
3494 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name
[] =
3496 { "segment", BFD_MACH_O_LC_SEGMENT
},
3497 { "symtab", BFD_MACH_O_LC_SYMTAB
},
3498 { "symseg", BFD_MACH_O_LC_SYMSEG
},
3499 { "thread", BFD_MACH_O_LC_THREAD
},
3500 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD
},
3501 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB
},
3502 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB
},
3503 { "ident", BFD_MACH_O_LC_IDENT
},
3504 { "fvmfile", BFD_MACH_O_LC_FVMFILE
},
3505 { "prepage", BFD_MACH_O_LC_PREPAGE
},
3506 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB
},
3507 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB
},
3508 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB
},
3509 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER
},
3510 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER
},
3511 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB
},
3512 { "routines", BFD_MACH_O_LC_ROUTINES
},
3513 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK
},
3514 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA
},
3515 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT
},
3516 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY
},
3517 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS
},
3518 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM
},
3519 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB
},
3520 { "segment_64", BFD_MACH_O_LC_SEGMENT_64
},
3521 { "routines_64", BFD_MACH_O_LC_ROUTINES_64
},
3522 { "uuid", BFD_MACH_O_LC_UUID
},
3523 { "rpath", BFD_MACH_O_LC_RPATH
},
3524 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE
},
3525 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
},
3526 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB
},
3527 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB
},
3528 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO
},
3529 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO
},
3530 { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
},
3531 { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX
},
3532 { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
},
3533 { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS
},
3534 { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT
},
3538 /* Get the section type from NAME. Return -1 if NAME is unknown. */
3541 bfd_mach_o_get_section_type_from_name (const char *name
)
3543 bfd_mach_o_xlat_name
*x
;
3545 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
3546 if (strcmp (x
->name
, name
) == 0)
3548 return (unsigned int)-1;
3551 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
3554 bfd_mach_o_get_section_attribute_from_name (const char *name
)
3556 bfd_mach_o_xlat_name
*x
;
3558 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
3559 if (strcmp (x
->name
, name
) == 0)
3561 return (unsigned int)-1;
3565 bfd_mach_o_print_private_header (bfd
*abfd
, FILE *file
)
3567 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3568 bfd_mach_o_header
*h
= &mdata
->header
;
3570 fputs (_("Mach-O header:\n"), file
);
3571 fprintf (file
, _(" magic : %08lx\n"), h
->magic
);
3572 fprintf (file
, _(" cputype : %08lx (%s)\n"), h
->cputype
,
3573 bfd_mach_o_get_name (bfd_mach_o_cpu_name
, h
->cputype
));
3574 fprintf (file
, _(" cpusubtype: %08lx\n"), h
->cpusubtype
);
3575 fprintf (file
, _(" filetype : %08lx (%s)\n"),
3577 bfd_mach_o_get_name (bfd_mach_o_filetype_name
, h
->filetype
));
3578 fprintf (file
, _(" ncmds : %08lx (%lu)\n"), h
->ncmds
, h
->ncmds
);
3579 fprintf (file
, _(" sizeofcmds: %08lx\n"), h
->sizeofcmds
);
3580 fprintf (file
, _(" flags : %08lx ("), h
->flags
);
3581 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name
, h
->flags
, file
);
3582 fputs (_(")\n"), file
);
3583 fprintf (file
, _(" reserved : %08x\n"), h
->reserved
);
3587 bfd_mach_o_print_section_map (bfd
*abfd
, FILE *file
)
3589 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3591 unsigned int sec_nbr
= 0;
3593 fputs (_("Segments and Sections:\n"), file
);
3594 fputs (_(" #: Segment name Section name Address\n"), file
);
3596 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3598 bfd_mach_o_segment_command
*seg
;
3599 bfd_mach_o_section
*sec
;
3601 if (mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT
3602 && mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT_64
)
3605 seg
= &mdata
->commands
[i
].command
.segment
;
3607 fprintf (file
, "[Segment %-16s ", seg
->segname
);
3608 fprintf_vma (file
, seg
->vmaddr
);
3609 fprintf (file
, "-");
3610 fprintf_vma (file
, seg
->vmaddr
+ seg
->vmsize
- 1);
3612 fputc (seg
->initprot
& BFD_MACH_O_PROT_READ
? 'r' : '-', file
);
3613 fputc (seg
->initprot
& BFD_MACH_O_PROT_WRITE
? 'w' : '-', file
);
3614 fputc (seg
->initprot
& BFD_MACH_O_PROT_EXECUTE
? 'x' : '-', file
);
3615 fprintf (file
, "]\n");
3617 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3619 fprintf (file
, "%02u: %-16s %-16s ", ++sec_nbr
,
3620 sec
->segname
, sec
->sectname
);
3621 fprintf_vma (file
, sec
->addr
);
3622 fprintf (file
, " ");
3623 fprintf_vma (file
, sec
->size
);
3624 fprintf (file
, " %08lx\n", sec
->flags
);
3630 bfd_mach_o_print_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3631 bfd_mach_o_section
*sec
, FILE *file
)
3633 fprintf (file
, " Section: %-16s %-16s (bfdname: %s)\n",
3634 sec
->sectname
, sec
->segname
, sec
->bfdsection
->name
);
3635 fprintf (file
, " addr: ");
3636 fprintf_vma (file
, sec
->addr
);
3637 fprintf (file
, " size: ");
3638 fprintf_vma (file
, sec
->size
);
3639 fprintf (file
, " offset: ");
3640 fprintf_vma (file
, sec
->offset
);
3641 fprintf (file
, "\n");
3642 fprintf (file
, " align: %ld", sec
->align
);
3643 fprintf (file
, " nreloc: %lu reloff: ", sec
->nreloc
);
3644 fprintf_vma (file
, sec
->reloff
);
3645 fprintf (file
, "\n");
3646 fprintf (file
, " flags: %08lx (type: %s", sec
->flags
,
3647 bfd_mach_o_get_name (bfd_mach_o_section_type_name
,
3648 sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
));
3649 fprintf (file
, " attr: ");
3650 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name
,
3651 sec
->flags
& BFD_MACH_O_SECTION_ATTRIBUTES_MASK
,
3653 fprintf (file
, ")\n");
3654 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3656 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3657 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3658 case BFD_MACH_O_S_SYMBOL_STUBS
:
3659 fprintf (file
, " first indirect sym: %lu", sec
->reserved1
);
3660 fprintf (file
, " (%u entries)",
3661 bfd_mach_o_section_get_nbr_indirect (abfd
, sec
));
3664 fprintf (file
, " reserved1: 0x%lx", sec
->reserved1
);
3667 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3669 case BFD_MACH_O_S_SYMBOL_STUBS
:
3670 fprintf (file
, " stub size: %lu", sec
->reserved2
);
3673 fprintf (file
, " reserved2: 0x%lx", sec
->reserved2
);
3676 fprintf (file
, " reserved3: 0x%lx\n", sec
->reserved3
);
3680 bfd_mach_o_print_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
3681 bfd_mach_o_load_command
*cmd
, FILE *file
)
3683 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3684 bfd_mach_o_section
*sec
;
3686 fprintf (file
, " name: %s\n", *seg
->segname
? seg
->segname
: "*none*");
3687 fprintf (file
, " vmaddr: ");
3688 fprintf_vma (file
, seg
->vmaddr
);
3689 fprintf (file
, " vmsize: ");
3690 fprintf_vma (file
, seg
->vmsize
);
3691 fprintf (file
, "\n");
3692 fprintf (file
, " fileoff: ");
3693 fprintf_vma (file
, seg
->fileoff
);
3694 fprintf (file
, " filesize: ");
3695 fprintf_vma (file
, (bfd_vma
)seg
->filesize
);
3696 fprintf (file
, " endoff: ");
3697 fprintf_vma (file
, (bfd_vma
)(seg
->fileoff
+ seg
->filesize
));
3698 fprintf (file
, "\n");
3699 fprintf (file
, " nsects: %lu ", seg
->nsects
);
3700 fprintf (file
, " flags: %lx\n", seg
->flags
);
3701 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3702 bfd_mach_o_print_section (abfd
, sec
, file
);
3706 bfd_mach_o_print_dysymtab (bfd
*abfd ATTRIBUTE_UNUSED
,
3707 bfd_mach_o_load_command
*cmd
, FILE *file
)
3709 bfd_mach_o_dysymtab_command
*dysymtab
= &cmd
->command
.dysymtab
;
3710 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3713 fprintf (file
, " local symbols: idx: %10lu num: %-8lu",
3714 dysymtab
->ilocalsym
, dysymtab
->nlocalsym
);
3715 fprintf (file
, " (nxtidx: %lu)\n",
3716 dysymtab
->ilocalsym
+ dysymtab
->nlocalsym
);
3717 fprintf (file
, " external symbols: idx: %10lu num: %-8lu",
3718 dysymtab
->iextdefsym
, dysymtab
->nextdefsym
);
3719 fprintf (file
, " (nxtidx: %lu)\n",
3720 dysymtab
->iextdefsym
+ dysymtab
->nextdefsym
);
3721 fprintf (file
, " undefined symbols: idx: %10lu num: %-8lu",
3722 dysymtab
->iundefsym
, dysymtab
->nundefsym
);
3723 fprintf (file
, " (nxtidx: %lu)\n",
3724 dysymtab
->iundefsym
+ dysymtab
->nundefsym
);
3725 fprintf (file
, " table of content: off: 0x%08lx num: %-8lu",
3726 dysymtab
->tocoff
, dysymtab
->ntoc
);
3727 fprintf (file
, " (endoff: 0x%08lx)\n",
3729 + dysymtab
->ntoc
* BFD_MACH_O_TABLE_OF_CONTENT_SIZE
);
3730 fprintf (file
, " module table: off: 0x%08lx num: %-8lu",
3731 dysymtab
->modtaboff
, dysymtab
->nmodtab
);
3732 fprintf (file
, " (endoff: 0x%08lx)\n",
3733 dysymtab
->modtaboff
+ dysymtab
->nmodtab
3734 * (mach_o_wide_p (&mdata
->header
) ?
3735 BFD_MACH_O_DYLIB_MODULE_64_SIZE
: BFD_MACH_O_DYLIB_MODULE_SIZE
));
3736 fprintf (file
, " external reference table: off: 0x%08lx num: %-8lu",
3737 dysymtab
->extrefsymoff
, dysymtab
->nextrefsyms
);
3738 fprintf (file
, " (endoff: 0x%08lx)\n",
3739 dysymtab
->extrefsymoff
3740 + dysymtab
->nextrefsyms
* BFD_MACH_O_REFERENCE_SIZE
);
3741 fprintf (file
, " indirect symbol table: off: 0x%08lx num: %-8lu",
3742 dysymtab
->indirectsymoff
, dysymtab
->nindirectsyms
);
3743 fprintf (file
, " (endoff: 0x%08lx)\n",
3744 dysymtab
->indirectsymoff
3745 + dysymtab
->nindirectsyms
* BFD_MACH_O_INDIRECT_SYMBOL_SIZE
);
3746 fprintf (file
, " external relocation table: off: 0x%08lx num: %-8lu",
3747 dysymtab
->extreloff
, dysymtab
->nextrel
);
3748 fprintf (file
, " (endoff: 0x%08lx)\n",
3749 dysymtab
->extreloff
+ dysymtab
->nextrel
* BFD_MACH_O_RELENT_SIZE
);
3750 fprintf (file
, " local relocation table: off: 0x%08lx num: %-8lu",
3751 dysymtab
->locreloff
, dysymtab
->nlocrel
);
3752 fprintf (file
, " (endoff: 0x%08lx)\n",
3753 dysymtab
->locreloff
+ dysymtab
->nlocrel
* BFD_MACH_O_RELENT_SIZE
);
3755 if (dysymtab
->ntoc
> 0
3756 || dysymtab
->nindirectsyms
> 0
3757 || dysymtab
->nextrefsyms
> 0)
3759 /* Try to read the symbols to display the toc or indirect symbols. */
3760 bfd_mach_o_read_symtab_symbols (abfd
);
3762 else if (dysymtab
->nmodtab
> 0)
3764 /* Try to read the strtab to display modules name. */
3765 bfd_mach_o_read_symtab_strtab (abfd
);
3768 for (i
= 0; i
< dysymtab
->nmodtab
; i
++)
3770 bfd_mach_o_dylib_module
*module
= &dysymtab
->dylib_module
[i
];
3771 fprintf (file
, " module %u:\n", i
);
3772 fprintf (file
, " name: %lu", module
->module_name_idx
);
3773 if (mdata
->symtab
&& mdata
->symtab
->strtab
)
3774 fprintf (file
, ": %s",
3775 mdata
->symtab
->strtab
+ module
->module_name_idx
);
3776 fprintf (file
, "\n");
3777 fprintf (file
, " extdefsym: idx: %8lu num: %lu\n",
3778 module
->iextdefsym
, module
->nextdefsym
);
3779 fprintf (file
, " refsym: idx: %8lu num: %lu\n",
3780 module
->irefsym
, module
->nrefsym
);
3781 fprintf (file
, " localsym: idx: %8lu num: %lu\n",
3782 module
->ilocalsym
, module
->nlocalsym
);
3783 fprintf (file
, " extrel: idx: %8lu num: %lu\n",
3784 module
->iextrel
, module
->nextrel
);
3785 fprintf (file
, " init: idx: %8u num: %u\n",
3786 module
->iinit
, module
->ninit
);
3787 fprintf (file
, " term: idx: %8u num: %u\n",
3788 module
->iterm
, module
->nterm
);
3789 fprintf (file
, " objc_module_info: addr: ");
3790 fprintf_vma (file
, module
->objc_module_info_addr
);
3791 fprintf (file
, " size: %lu\n", module
->objc_module_info_size
);
3794 if (dysymtab
->ntoc
> 0)
3796 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3798 fprintf (file
, " table of content: (symbol/module)\n");
3799 for (i
= 0; i
< dysymtab
->ntoc
; i
++)
3801 bfd_mach_o_dylib_table_of_content
*toc
= &dysymtab
->dylib_toc
[i
];
3803 fprintf (file
, " %4u: ", i
);
3804 if (symtab
&& symtab
->symbols
&& toc
->symbol_index
< symtab
->nsyms
)
3806 const char *name
= symtab
->symbols
[toc
->symbol_index
].symbol
.name
;
3807 fprintf (file
, "%s (%lu)", name
? name
: "*invalid*",
3811 fprintf (file
, "%lu", toc
->symbol_index
);
3813 fprintf (file
, " / ");
3814 if (symtab
&& symtab
->strtab
3815 && toc
->module_index
< dysymtab
->nmodtab
)
3817 bfd_mach_o_dylib_module
*mod
;
3818 mod
= &dysymtab
->dylib_module
[toc
->module_index
];
3819 fprintf (file
, "%s (%lu)",
3820 symtab
->strtab
+ mod
->module_name_idx
,
3824 fprintf (file
, "%lu", toc
->module_index
);
3826 fprintf (file
, "\n");
3830 if (dysymtab
->nindirectsyms
!= 0)
3832 fprintf (file
, " indirect symbols:\n");
3834 for (i
= 0; i
< mdata
->nsects
; i
++)
3836 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
3837 unsigned int j
, first
, last
;
3838 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3842 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3844 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3845 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3846 case BFD_MACH_O_S_SYMBOL_STUBS
:
3847 first
= sec
->reserved1
;
3848 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
3850 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
3851 fprintf (file
, " for section %s.%s:\n",
3852 sec
->segname
, sec
->sectname
);
3853 for (j
= first
; j
< last
; j
++)
3855 unsigned int isym
= dysymtab
->indirect_syms
[j
];
3857 fprintf (file
, " ");
3858 fprintf_vma (file
, addr
);
3859 fprintf (file
, " %5u: 0x%08x", j
, isym
);
3860 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_LOCAL
)
3861 fprintf (file
, " LOCAL");
3862 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_ABS
)
3863 fprintf (file
, " ABSOLUTE");
3864 if (symtab
&& symtab
->symbols
3865 && isym
< symtab
->nsyms
3866 && symtab
->symbols
[isym
].symbol
.name
)
3867 fprintf (file
, " %s", symtab
->symbols
[isym
].symbol
.name
);
3868 fprintf (file
, "\n");
3877 if (dysymtab
->nextrefsyms
> 0)
3879 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3881 fprintf (file
, " external reference table: (symbol flags)\n");
3882 for (i
= 0; i
< dysymtab
->nextrefsyms
; i
++)
3884 bfd_mach_o_dylib_reference
*ref
= &dysymtab
->ext_refs
[i
];
3886 fprintf (file
, " %4u: %5lu 0x%02lx", i
, ref
->isym
, ref
->flags
);
3887 if (symtab
&& symtab
->symbols
3888 && ref
->isym
< symtab
->nsyms
3889 && symtab
->symbols
[ref
->isym
].symbol
.name
)
3890 fprintf (file
, " %s", symtab
->symbols
[ref
->isym
].symbol
.name
);
3891 fprintf (file
, "\n");
3898 bfd_mach_o_print_dyld_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3899 bfd_mach_o_load_command
*cmd
, FILE *file
)
3901 bfd_mach_o_dyld_info_command
*info
= &cmd
->command
.dyld_info
;
3903 fprintf (file
, " rebase: off: 0x%08x size: %-8u\n",
3904 info
->rebase_off
, info
->rebase_size
);
3905 fprintf (file
, " bind: off: 0x%08x size: %-8u\n",
3906 info
->bind_off
, info
->bind_size
);
3907 fprintf (file
, " weak bind: off: 0x%08x size: %-8u\n",
3908 info
->weak_bind_off
, info
->weak_bind_size
);
3909 fprintf (file
, " lazy bind: off: 0x%08x size: %-8u\n",
3910 info
->lazy_bind_off
, info
->lazy_bind_size
);
3911 fprintf (file
, " export: off: 0x%08x size: %-8u\n",
3912 info
->export_off
, info
->export_size
);
3916 bfd_mach_o_bfd_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3918 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3919 FILE *file
= (FILE *) ptr
;
3922 bfd_mach_o_print_private_header (abfd
, file
);
3925 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3927 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[i
];
3928 const char *cmd_name
;
3930 cmd_name
= bfd_mach_o_get_name_or_null
3931 (bfd_mach_o_load_command_name
, cmd
->type
);
3932 fprintf (file
, "Load command ");
3933 if (cmd_name
== NULL
)
3934 fprintf (file
, "0x%02x:", cmd
->type
);
3936 fprintf (file
, "%s:", cmd_name
);
3940 case BFD_MACH_O_LC_SEGMENT
:
3941 case BFD_MACH_O_LC_SEGMENT_64
:
3942 bfd_mach_o_print_segment (abfd
, cmd
, file
);
3944 case BFD_MACH_O_LC_UUID
:
3946 bfd_mach_o_uuid_command
*uuid
= &cmd
->command
.uuid
;
3949 for (j
= 0; j
< sizeof (uuid
->uuid
); j
++)
3950 fprintf (file
, " %02x", uuid
->uuid
[j
]);
3954 case BFD_MACH_O_LC_LOAD_DYLIB
:
3955 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3956 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3957 case BFD_MACH_O_LC_ID_DYLIB
:
3959 bfd_mach_o_dylib_command
*dylib
= &cmd
->command
.dylib
;
3960 fprintf (file
, " %s\n", dylib
->name_str
);
3961 fprintf (file
, " time stamp: 0x%08lx\n",
3963 fprintf (file
, " current version: 0x%08lx\n",
3964 dylib
->current_version
);
3965 fprintf (file
, " comptibility version: 0x%08lx\n",
3966 dylib
->compatibility_version
);
3969 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3970 case BFD_MACH_O_LC_ID_DYLINKER
:
3971 fprintf (file
, " %s\n", cmd
->command
.dylinker
.name_str
);
3973 case BFD_MACH_O_LC_SYMTAB
:
3975 bfd_mach_o_symtab_command
*symtab
= &cmd
->command
.symtab
;
3978 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
3979 symtab
->symoff
, symtab
->nsyms
,
3980 symtab
->symoff
+ symtab
->nsyms
3981 * (mach_o_wide_p (&mdata
->header
)
3982 ? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
));
3984 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
3985 symtab
->stroff
, symtab
->strsize
,
3986 symtab
->stroff
+ symtab
->strsize
);
3989 case BFD_MACH_O_LC_DYSYMTAB
:
3990 fprintf (file
, "\n");
3991 bfd_mach_o_print_dysymtab (abfd
, cmd
, file
);
3993 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3994 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3995 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3997 bfd_mach_o_linkedit_command
*linkedit
= &cmd
->command
.linkedit
;
4000 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
4001 linkedit
->dataoff
, linkedit
->datasize
,
4002 linkedit
->dataoff
+ linkedit
->datasize
);
4005 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4006 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4007 case BFD_MACH_O_LC_SUB_LIBRARY
:
4008 case BFD_MACH_O_LC_SUB_CLIENT
:
4009 case BFD_MACH_O_LC_RPATH
:
4011 bfd_mach_o_str_command
*str
= &cmd
->command
.str
;
4012 fprintf (file
, " %s\n", str
->str
);
4015 case BFD_MACH_O_LC_THREAD
:
4016 case BFD_MACH_O_LC_UNIXTHREAD
:
4018 bfd_mach_o_thread_command
*thread
= &cmd
->command
.thread
;
4020 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4022 fprintf (file
, " nflavours: %lu\n", thread
->nflavours
);
4023 for (j
= 0; j
< thread
->nflavours
; j
++)
4025 bfd_mach_o_thread_flavour
*flavour
= &thread
->flavours
[j
];
4027 fprintf (file
, " %2u: flavour: 0x%08lx offset: 0x%08lx"
4029 j
, flavour
->flavour
, flavour
->offset
,
4031 if (bed
->_bfd_mach_o_print_thread
)
4033 char *buf
= bfd_malloc (flavour
->size
);
4036 && bfd_seek (abfd
, flavour
->offset
, SEEK_SET
) == 0
4037 && (bfd_bread (buf
, flavour
->size
, abfd
)
4039 (*bed
->_bfd_mach_o_print_thread
)(abfd
, flavour
,
4046 case BFD_MACH_O_LC_DYLD_INFO
:
4047 fprintf (file
, "\n");
4048 bfd_mach_o_print_dyld_info (abfd
, cmd
, file
);
4050 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4051 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4053 bfd_mach_o_version_min_command
*ver
= &cmd
->command
.version_min
;
4055 fprintf (file
, " %u.%u.%u\n", ver
->rel
, ver
->maj
, ver
->min
);
4059 fprintf (file
, "\n");
4060 fprintf (file
, " offset: 0x%08lx\n", (unsigned long)cmd
->offset
);
4061 fprintf (file
, " size: 0x%08lx\n", (unsigned long)cmd
->len
);
4067 bfd_mach_o_print_section_map (abfd
, file
);
4073 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4074 unsigned char **rbuf
,
4077 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4078 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4081 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4083 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4084 bfd_mach_o_segment_command
*seg
= NULL
;
4086 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4089 seg
= &cur
->command
.segment
;
4091 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4093 unsigned long start
= seg
->fileoff
;
4094 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4095 unsigned char *buf
= bfd_malloc (1024);
4096 unsigned long size
= 1024;
4100 bfd_size_type nread
= 0;
4101 unsigned long offset
;
4102 int found_nonnull
= 0;
4104 if (size
> (end
- start
))
4105 size
= (end
- start
);
4107 buf
= bfd_realloc_or_free (buf
, size
);
4111 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4117 nread
= bfd_bread (buf
, size
, abfd
);
4125 for (offset
= 4; offset
<= size
; offset
+= 4)
4129 val
= *((unsigned long *) (buf
+ size
- offset
));
4130 if (! found_nonnull
)
4135 else if (val
== 0x0)
4137 unsigned long bottom
;
4140 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4141 top
= seg
->fileoff
+ seg
->filesize
- 4;
4142 *rbuf
= bfd_malloc (top
- bottom
);
4143 *rlen
= top
- bottom
;
4145 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4151 if (size
== (end
- start
))
4165 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4167 unsigned char *buf
= NULL
;
4168 unsigned int len
= 0;
4171 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4175 return (char *) buf
;
4179 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4184 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4185 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4187 #define bfd_mach_o_swap_reloc_in NULL
4188 #define bfd_mach_o_swap_reloc_out NULL
4189 #define bfd_mach_o_print_thread NULL
4191 #define TARGET_NAME mach_o_be_vec
4192 #define TARGET_STRING "mach-o-be"
4193 #define TARGET_ARCHITECTURE bfd_arch_unknown
4194 #define TARGET_BIG_ENDIAN 1
4195 #define TARGET_ARCHIVE 0
4196 #include "mach-o-target.c"
4199 #undef TARGET_STRING
4200 #undef TARGET_ARCHITECTURE
4201 #undef TARGET_BIG_ENDIAN
4202 #undef TARGET_ARCHIVE
4204 #define TARGET_NAME mach_o_le_vec
4205 #define TARGET_STRING "mach-o-le"
4206 #define TARGET_ARCHITECTURE bfd_arch_unknown
4207 #define TARGET_BIG_ENDIAN 0
4208 #define TARGET_ARCHIVE 0
4210 #include "mach-o-target.c"
4213 #undef TARGET_STRING
4214 #undef TARGET_ARCHITECTURE
4215 #undef TARGET_BIG_ENDIAN
4216 #undef TARGET_ARCHIVE
4218 /* Not yet handled: creating an archive. */
4219 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4222 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4223 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4224 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4225 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4226 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4227 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4228 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4229 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4230 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4231 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4233 #define TARGET_NAME mach_o_fat_vec
4234 #define TARGET_STRING "mach-o-fat"
4235 #define TARGET_ARCHITECTURE bfd_arch_unknown
4236 #define TARGET_BIG_ENDIAN 1
4237 #define TARGET_ARCHIVE 1
4239 #include "mach-o-target.c"
4242 #undef TARGET_STRING
4243 #undef TARGET_ARCHITECTURE
4244 #undef TARGET_BIG_ENDIAN
4245 #undef TARGET_ARCHIVE