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
;
186 /* Convert Mach-O section name to BFD. Try to use standard names, otherwise
187 forge a new name. SEGNAME and SECTNAME are 16 bytes strings. */
190 bfd_mach_o_convert_section_name_to_bfd
191 (bfd
*abfd
, const char *segname
, const char *sectname
,
192 const char **name
, flagword
*flags
)
196 const char *pfx
= "";
198 /* First search for a canonical name. */
199 bfd_mach_o_normalize_section_name (segname
, sectname
, name
, flags
);
201 /* Return now if found. */
205 len
= 16 + 1 + 16 + 1;
207 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
208 with an underscore. */
209 if (segname
[0] != '_')
211 static const char seg_pfx
[] = "LC_SEGMENT.";
214 len
+= sizeof (seg_pfx
) - 1;
217 res
= bfd_alloc (abfd
, len
);
220 snprintf (res
, len
, "%s%.16s.%.16s", pfx
, segname
, sectname
);
222 *flags
= SEC_NO_FLAGS
;
225 /* Convert a bfd section name to a Mach-O segment + section name. */
228 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
230 bfd_mach_o_section
*section
)
232 const struct mach_o_segment_name_xlat
*seg
;
233 const char *name
= bfd_get_section_name (abfd
, sect
);
239 /* List of well known names. They all start with a dot. */
241 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
243 const struct mach_o_section_name_xlat
*sec
;
245 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
247 if (strcmp (sec
->bfd_name
, name
) == 0)
249 strcpy (section
->segname
, seg
->segname
);
250 strcpy (section
->sectname
, sec
->mach_o_name
);
256 /* Strip LC_SEGMENT. prefix. */
257 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
261 dot
= strchr (name
, '.');
264 /* Try to split name into segment and section names. */
265 if (dot
&& dot
!= name
)
268 seclen
= len
- (dot
+ 1 - name
);
270 if (seglen
< 16 && seclen
< 16)
272 memcpy (section
->segname
, name
, seglen
);
273 section
->segname
[seglen
] = 0;
274 memcpy (section
->sectname
, dot
+ 1, seclen
);
275 section
->sectname
[seclen
] = 0;
282 memcpy (section
->segname
, name
, len
);
283 section
->segname
[len
] = 0;
284 memcpy (section
->sectname
, name
, len
);
285 section
->sectname
[len
] = 0;
288 /* Return the size of an entry for section SEC.
289 Must be called only for symbol pointer section and symbol stubs
293 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
295 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
297 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
298 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
299 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
300 case BFD_MACH_O_S_SYMBOL_STUBS
:
301 return sec
->reserved2
;
308 /* Return the number of indirect symbols for a section.
309 Must be called only for symbol pointer section and symbol stubs
313 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
317 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
321 return sec
->size
/ elsz
;
325 /* Copy any private info we understand from the input symbol
326 to the output symbol. */
329 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
330 asymbol
*isymbol ATTRIBUTE_UNUSED
,
331 bfd
*obfd ATTRIBUTE_UNUSED
,
332 asymbol
*osymbol ATTRIBUTE_UNUSED
)
337 /* Copy any private info we understand from the input section
338 to the output section. */
341 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
342 asection
*isection ATTRIBUTE_UNUSED
,
343 bfd
*obfd ATTRIBUTE_UNUSED
,
344 asection
*osection ATTRIBUTE_UNUSED
)
349 /* Copy any private info we understand from the input bfd
350 to the output bfd. */
353 bfd_mach_o_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
355 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
356 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
359 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
360 BFD_ASSERT (bfd_mach_o_valid (obfd
));
362 /* FIXME: copy commands. */
367 /* Count the total number of symbols. */
370 bfd_mach_o_count_symbols (bfd
*abfd
)
372 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
374 if (mdata
->symtab
== NULL
)
376 return mdata
->symtab
->nsyms
;
380 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
382 long nsyms
= bfd_mach_o_count_symbols (abfd
);
384 return ((nsyms
+ 1) * sizeof (asymbol
*));
388 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
390 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
391 long nsyms
= bfd_mach_o_count_symbols (abfd
);
392 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
400 /* Do not try to read symbols if there are none. */
405 if (bfd_mach_o_read_symtab_symbols (abfd
) != 0)
407 (*_bfd_error_handler
) (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
411 BFD_ASSERT (sym
->symbols
!= NULL
);
413 for (j
= 0; j
< sym
->nsyms
; j
++)
414 alocation
[j
] = &sym
->symbols
[j
].symbol
;
422 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
423 long symcount ATTRIBUTE_UNUSED
,
424 asymbol
**syms ATTRIBUTE_UNUSED
,
425 long dynsymcount ATTRIBUTE_UNUSED
,
426 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
429 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
430 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
431 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
433 unsigned long count
, i
, j
, n
;
440 if (dysymtab
== NULL
|| symtab
== NULL
|| symtab
->symbols
== NULL
)
443 if (dysymtab
->nindirectsyms
== 0)
446 count
= dysymtab
->nindirectsyms
;
447 size
= count
* sizeof (asymbol
) + 1;
449 for (j
= 0; j
< count
; j
++)
451 unsigned int isym
= dysymtab
->indirect_syms
[j
];
453 if (isym
< symtab
->nsyms
&& symtab
->symbols
[isym
].symbol
.name
)
454 size
+= strlen (symtab
->symbols
[isym
].symbol
.name
) + sizeof ("$stub");
457 s
= *ret
= (asymbol
*) bfd_malloc (size
);
460 names
= (char *) (s
+ count
);
465 for (i
= 0; i
< mdata
->nsects
; i
++)
467 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
468 unsigned int first
, last
;
472 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
474 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
475 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
476 case BFD_MACH_O_S_SYMBOL_STUBS
:
477 first
= sec
->reserved1
;
478 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
480 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
481 for (j
= first
; j
< last
; j
++)
483 unsigned int isym
= dysymtab
->indirect_syms
[j
];
485 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
486 s
->section
= sec
->bfdsection
;
487 s
->value
= addr
- sec
->addr
;
490 if (isym
< symtab
->nsyms
491 && symtab
->symbols
[isym
].symbol
.name
)
493 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
498 memcpy (names
, sym
, len
);
500 memcpy (names
, "$stub", sizeof ("$stub"));
501 names
+= sizeof ("$stub");
520 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
524 bfd_symbol_info (symbol
, ret
);
528 bfd_mach_o_print_symbol (bfd
*abfd
,
531 bfd_print_symbol_type how
)
533 FILE *file
= (FILE *) afile
;
535 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
539 case bfd_print_symbol_name
:
540 fprintf (file
, "%s", symbol
->name
);
543 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
544 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
545 name
= bfd_get_stab_name (asym
->n_type
);
547 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
549 case BFD_MACH_O_N_UNDF
:
550 if (symbol
->value
== 0)
555 case BFD_MACH_O_N_ABS
:
558 case BFD_MACH_O_N_INDR
:
561 case BFD_MACH_O_N_PBUD
:
564 case BFD_MACH_O_N_SECT
:
573 fprintf (file
, " %02x %-6s %02x %04x",
574 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
575 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
576 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
577 fprintf (file
, " [%s]", symbol
->section
->name
);
578 fprintf (file
, " %s", symbol
->name
);
583 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
584 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED
,
585 enum bfd_architecture
*type
,
586 unsigned long *subtype
)
588 *subtype
= bfd_arch_unknown
;
592 case BFD_MACH_O_CPU_TYPE_VAX
: *type
= bfd_arch_vax
; break;
593 case BFD_MACH_O_CPU_TYPE_MC680x0
: *type
= bfd_arch_m68k
; break;
594 case BFD_MACH_O_CPU_TYPE_I386
:
595 *type
= bfd_arch_i386
;
596 *subtype
= bfd_mach_i386_i386
;
598 case BFD_MACH_O_CPU_TYPE_X86_64
:
599 *type
= bfd_arch_i386
;
600 *subtype
= bfd_mach_x86_64
;
602 case BFD_MACH_O_CPU_TYPE_MIPS
: *type
= bfd_arch_mips
; break;
603 case BFD_MACH_O_CPU_TYPE_MC98000
: *type
= bfd_arch_m98k
; break;
604 case BFD_MACH_O_CPU_TYPE_HPPA
: *type
= bfd_arch_hppa
; break;
605 case BFD_MACH_O_CPU_TYPE_ARM
: *type
= bfd_arch_arm
; break;
606 case BFD_MACH_O_CPU_TYPE_MC88000
: *type
= bfd_arch_m88k
; break;
607 case BFD_MACH_O_CPU_TYPE_SPARC
:
608 *type
= bfd_arch_sparc
;
609 *subtype
= bfd_mach_sparc
;
611 case BFD_MACH_O_CPU_TYPE_I860
: *type
= bfd_arch_i860
; break;
612 case BFD_MACH_O_CPU_TYPE_ALPHA
: *type
= bfd_arch_alpha
; break;
613 case BFD_MACH_O_CPU_TYPE_POWERPC
:
614 *type
= bfd_arch_powerpc
;
615 *subtype
= bfd_mach_ppc
;
617 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
618 *type
= bfd_arch_powerpc
;
619 *subtype
= bfd_mach_ppc64
;
622 *type
= bfd_arch_unknown
;
628 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
630 struct mach_o_header_external raw
;
633 size
= mach_o_wide_p (header
) ?
634 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
636 bfd_h_put_32 (abfd
, header
->magic
, raw
.magic
);
637 bfd_h_put_32 (abfd
, header
->cputype
, raw
.cputype
);
638 bfd_h_put_32 (abfd
, header
->cpusubtype
, raw
.cpusubtype
);
639 bfd_h_put_32 (abfd
, header
->filetype
, raw
.filetype
);
640 bfd_h_put_32 (abfd
, header
->ncmds
, raw
.ncmds
);
641 bfd_h_put_32 (abfd
, header
->sizeofcmds
, raw
.sizeofcmds
);
642 bfd_h_put_32 (abfd
, header
->flags
, raw
.flags
);
644 if (mach_o_wide_p (header
))
645 bfd_h_put_32 (abfd
, header
->reserved
, raw
.reserved
);
647 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
648 || bfd_bwrite (&raw
, size
, abfd
) != size
)
655 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
657 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
659 struct mach_o_thread_command_external raw
;
662 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
663 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
666 for (i
= 0; i
< cmd
->nflavours
; i
++)
668 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
669 BFD_ASSERT (cmd
->flavours
[i
].offset
==
670 (command
->offset
+ offset
+ BFD_MACH_O_LC_SIZE
));
672 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, raw
.flavour
);
673 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), raw
.count
);
675 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
676 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
679 offset
+= cmd
->flavours
[i
].size
+ sizeof (raw
);
686 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
689 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
693 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
,
694 struct mach_o_reloc_info_external
*raw
,
695 arelent
*res
, asymbol
**syms
)
697 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
698 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
699 bfd_mach_o_reloc_info reloc
;
704 addr
= bfd_get_32 (abfd
, raw
->r_address
);
705 symnum
= bfd_get_32 (abfd
, raw
->r_symbolnum
);
707 if (addr
& BFD_MACH_O_SR_SCATTERED
)
711 /* Scattered relocation.
712 Extract section and offset from r_value. */
713 res
->sym_ptr_ptr
= NULL
;
715 for (j
= 0; j
< mdata
->nsects
; j
++)
717 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
718 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
720 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
721 res
->addend
= symnum
- sect
->addr
;
725 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
726 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
727 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
728 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
729 reloc
.r_scattered
= 1;
733 unsigned int num
= BFD_MACH_O_GET_R_SYMBOLNUM (symnum
);
736 if (symnum
& BFD_MACH_O_R_EXTERN
)
743 BFD_ASSERT (num
!= 0);
744 BFD_ASSERT (num
<= mdata
->nsects
);
745 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
746 /* For a symbol defined in section S, the addend (stored in the
747 binary) contains the address of the section. To comply with
748 bfd conventio, substract the section address.
749 Use the address from the header, so that the user can modify
750 the vma of the section. */
751 res
->addend
= -mdata
->sections
[num
- 1]->addr
;
754 res
->sym_ptr_ptr
= sym
;
755 reloc
.r_type
= BFD_MACH_O_GET_R_TYPE (symnum
);
756 reloc
.r_length
= BFD_MACH_O_GET_R_LENGTH (symnum
);
757 reloc
.r_pcrel
= (symnum
& BFD_MACH_O_R_PCREL
) ? 1 : 0;
758 reloc
.r_scattered
= 0;
761 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
767 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
769 arelent
*res
, asymbol
**syms
)
772 struct mach_o_reloc_info_external
*native_relocs
;
773 bfd_size_type native_size
;
775 /* Allocate and read relocs. */
776 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
778 (struct mach_o_reloc_info_external
*) bfd_malloc (native_size
);
779 if (native_relocs
== NULL
)
782 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
783 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
786 for (i
= 0; i
< count
; i
++)
788 if (bfd_mach_o_canonicalize_one_reloc (abfd
, &native_relocs
[i
],
792 free (native_relocs
);
795 free (native_relocs
);
800 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
801 arelent
**rels
, asymbol
**syms
)
803 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
807 if (asect
->reloc_count
== 0)
810 /* No need to go further if we don't know how to read relocs. */
811 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
814 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
818 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
819 asect
->reloc_count
, res
, syms
) < 0)
825 for (i
= 0; i
< asect
->reloc_count
; i
++)
828 asect
->relocation
= res
;
834 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
836 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
838 if (mdata
->dysymtab
== NULL
)
840 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
)
841 * sizeof (arelent
*);
845 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
846 struct bfd_symbol
**syms
)
848 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
849 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
850 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
854 if (dysymtab
== NULL
)
856 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
859 /* No need to go further if we don't know how to read relocs. */
860 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
863 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
) * sizeof (arelent
));
867 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
868 dysymtab
->nextrel
, res
, syms
) < 0)
874 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
876 res
+ dysymtab
->nextrel
, syms
) < 0)
882 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
889 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
891 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
895 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
897 sec
= section
->bfdsection
;
898 if (sec
->reloc_count
== 0)
901 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
904 /* Allocate relocation room. */
905 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, 2);
906 section
->nreloc
= sec
->reloc_count
;
907 sec
->rel_filepos
= mdata
->filelen
;
908 section
->reloff
= sec
->rel_filepos
;
909 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
911 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
914 /* Convert and write. */
915 entries
= section
->bfdsection
->orelocation
;
916 for (i
= 0; i
< section
->nreloc
; i
++)
918 arelent
*rel
= entries
[i
];
919 struct mach_o_reloc_info_external raw
;
920 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
922 /* Convert relocation to an intermediate representation. */
923 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
926 /* Lower the relocation info. */
927 if (pinfo
->r_scattered
)
931 v
= BFD_MACH_O_SR_SCATTERED
932 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
933 | BFD_MACH_O_SET_SR_LENGTH(pinfo
->r_length
)
934 | BFD_MACH_O_SET_SR_TYPE(pinfo
->r_type
)
935 | BFD_MACH_O_SET_SR_ADDRESS(pinfo
->r_address
);
936 /* Note: scattered relocs have field in reverse order... */
937 bfd_put_32 (abfd
, v
, raw
.r_address
);
938 bfd_put_32 (abfd
, pinfo
->r_value
, raw
.r_symbolnum
);
944 bfd_put_32 (abfd
, pinfo
->r_address
, raw
.r_address
);
945 v
= BFD_MACH_O_SET_R_SYMBOLNUM (pinfo
->r_value
)
946 | (pinfo
->r_pcrel
? BFD_MACH_O_R_PCREL
: 0)
947 | BFD_MACH_O_SET_R_LENGTH (pinfo
->r_length
)
948 | (pinfo
->r_extern
? BFD_MACH_O_R_EXTERN
: 0)
949 | BFD_MACH_O_SET_R_TYPE (pinfo
->r_type
);
950 bfd_put_32 (abfd
, v
, raw
.r_symbolnum
);
953 if (bfd_bwrite (&raw
, BFD_MACH_O_RELENT_SIZE
, abfd
)
954 != BFD_MACH_O_RELENT_SIZE
)
961 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
963 struct mach_o_section_32_external raw
;
965 memcpy (raw
.sectname
, section
->sectname
, 16);
966 memcpy (raw
.segname
, section
->segname
, 16);
967 bfd_h_put_32 (abfd
, section
->addr
, raw
.addr
);
968 bfd_h_put_32 (abfd
, section
->size
, raw
.size
);
969 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
970 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
971 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
972 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
973 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
974 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
975 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
977 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
978 != BFD_MACH_O_SECTION_SIZE
)
985 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
987 struct mach_o_section_64_external raw
;
989 memcpy (raw
.sectname
, section
->sectname
, 16);
990 memcpy (raw
.segname
, section
->segname
, 16);
991 bfd_h_put_64 (abfd
, section
->addr
, raw
.addr
);
992 bfd_h_put_64 (abfd
, section
->size
, raw
.size
);
993 bfd_h_put_32 (abfd
, section
->offset
, raw
.offset
);
994 bfd_h_put_32 (abfd
, section
->align
, raw
.align
);
995 bfd_h_put_32 (abfd
, section
->reloff
, raw
.reloff
);
996 bfd_h_put_32 (abfd
, section
->nreloc
, raw
.nreloc
);
997 bfd_h_put_32 (abfd
, section
->flags
, raw
.flags
);
998 bfd_h_put_32 (abfd
, section
->reserved1
, raw
.reserved1
);
999 bfd_h_put_32 (abfd
, section
->reserved2
, raw
.reserved2
);
1000 bfd_h_put_32 (abfd
, section
->reserved3
, raw
.reserved3
);
1002 if (bfd_bwrite (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1003 != BFD_MACH_O_SECTION_64_SIZE
)
1010 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1012 struct mach_o_segment_command_32_external raw
;
1013 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1014 bfd_mach_o_section
*sec
;
1016 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
1018 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1019 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1022 memcpy (raw
.segname
, seg
->segname
, 16);
1023 bfd_h_put_32 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1024 bfd_h_put_32 (abfd
, seg
->vmsize
, raw
.vmsize
);
1025 bfd_h_put_32 (abfd
, seg
->fileoff
, raw
.fileoff
);
1026 bfd_h_put_32 (abfd
, seg
->filesize
, raw
.filesize
);
1027 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1028 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1029 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1030 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1032 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1033 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1036 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1037 if (bfd_mach_o_write_section_32 (abfd
, sec
))
1044 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1046 struct mach_o_segment_command_64_external raw
;
1047 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1048 bfd_mach_o_section
*sec
;
1050 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1052 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1053 if (!bfd_mach_o_write_relocs (abfd
, sec
))
1056 memcpy (raw
.segname
, seg
->segname
, 16);
1057 bfd_h_put_64 (abfd
, seg
->vmaddr
, raw
.vmaddr
);
1058 bfd_h_put_64 (abfd
, seg
->vmsize
, raw
.vmsize
);
1059 bfd_h_put_64 (abfd
, seg
->fileoff
, raw
.fileoff
);
1060 bfd_h_put_64 (abfd
, seg
->filesize
, raw
.filesize
);
1061 bfd_h_put_32 (abfd
, seg
->maxprot
, raw
.maxprot
);
1062 bfd_h_put_32 (abfd
, seg
->initprot
, raw
.initprot
);
1063 bfd_h_put_32 (abfd
, seg
->nsects
, raw
.nsects
);
1064 bfd_h_put_32 (abfd
, seg
->flags
, raw
.flags
);
1066 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1067 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1070 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
1071 if (bfd_mach_o_write_section_64 (abfd
, sec
))
1078 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1080 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1081 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1083 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1084 unsigned int symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1085 struct bfd_strtab_hash
*strtab
;
1086 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1088 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1090 /* Write the symbols first. */
1091 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, wide
? 3 : 2);
1092 sym
->symoff
= mdata
->filelen
;
1093 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1096 sym
->nsyms
= bfd_get_symcount (abfd
);
1097 mdata
->filelen
+= sym
->nsyms
* symlen
;
1099 strtab
= _bfd_stringtab_init ();
1103 for (i
= 0; i
< sym
->nsyms
; i
++)
1105 bfd_size_type str_index
;
1106 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1108 /* Compute name index. */
1109 /* An index of 0 always means the empty string. */
1110 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1114 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1115 if (str_index
== (bfd_size_type
) -1)
1121 struct mach_o_nlist_64_external raw
;
1123 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1124 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1125 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1126 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1127 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1130 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1135 struct mach_o_nlist_external raw
;
1137 bfd_h_put_32 (abfd
, str_index
, raw
.n_strx
);
1138 bfd_h_put_8 (abfd
, s
->n_type
, raw
.n_type
);
1139 bfd_h_put_8 (abfd
, s
->n_sect
, raw
.n_sect
);
1140 bfd_h_put_16 (abfd
, s
->n_desc
, raw
.n_desc
);
1141 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
,
1144 if (bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1148 sym
->strsize
= _bfd_stringtab_size (strtab
);
1149 sym
->stroff
= mdata
->filelen
;
1150 mdata
->filelen
+= sym
->strsize
;
1152 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1154 _bfd_stringtab_free (strtab
);
1158 struct mach_o_symtab_command_external raw
;
1160 bfd_h_put_32 (abfd
, sym
->symoff
, raw
.symoff
);
1161 bfd_h_put_32 (abfd
, sym
->nsyms
, raw
.nsyms
);
1162 bfd_h_put_32 (abfd
, sym
->stroff
, raw
.stroff
);
1163 bfd_h_put_32 (abfd
, sym
->strsize
, raw
.strsize
);
1165 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
1166 || bfd_bwrite (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
1173 _bfd_stringtab_free (strtab
);
1177 /* Process the symbols and generate Mach-O specific fields.
1181 bfd_mach_o_mangle_symbols (bfd
*abfd
)
1184 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1186 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
1188 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1190 if (s
->n_type
== BFD_MACH_O_N_UNDF
&& !(s
->symbol
.flags
& BSF_DEBUGGING
))
1192 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1193 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1194 values haven't been set. */
1195 if (s
->symbol
.section
== bfd_abs_section_ptr
)
1196 s
->n_type
= BFD_MACH_O_N_ABS
;
1197 else if (s
->symbol
.section
== bfd_und_section_ptr
)
1199 s
->n_type
= BFD_MACH_O_N_UNDF
;
1200 if (s
->symbol
.flags
& BSF_WEAK
)
1201 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
1203 else if (s
->symbol
.section
== bfd_com_section_ptr
)
1204 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
1206 s
->n_type
= BFD_MACH_O_N_SECT
;
1208 if (s
->symbol
.flags
& BSF_GLOBAL
)
1209 s
->n_type
|= BFD_MACH_O_N_EXT
;
1212 /* Compute section index. */
1213 if (s
->symbol
.section
!= bfd_abs_section_ptr
1214 && s
->symbol
.section
!= bfd_und_section_ptr
1215 && s
->symbol
.section
!= bfd_com_section_ptr
)
1216 s
->n_sect
= s
->symbol
.section
->target_index
;
1218 /* Number symbols. */
1219 s
->symbol
.udata
.i
= i
;
1225 bfd_mach_o_write_contents (bfd
*abfd
)
1228 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1230 if (mdata
->header
.ncmds
== 0)
1231 if (!bfd_mach_o_build_commands (abfd
))
1234 /* Now write header information. */
1235 if (mdata
->header
.filetype
== 0)
1237 if (abfd
->flags
& EXEC_P
)
1238 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
1239 else if (abfd
->flags
& DYNAMIC
)
1240 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
1242 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
1244 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
1247 /* Assign a number to each symbols. */
1248 if (!bfd_mach_o_mangle_symbols (abfd
))
1251 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
1253 struct mach_o_load_command_external raw
;
1254 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
1255 unsigned long typeflag
;
1257 typeflag
= cur
->type
| (cur
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
1259 bfd_h_put_32 (abfd
, typeflag
, raw
.cmd
);
1260 bfd_h_put_32 (abfd
, cur
->len
, raw
.cmdsize
);
1262 if (bfd_seek (abfd
, cur
->offset
, SEEK_SET
) != 0
1263 || bfd_bwrite (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != 8)
1268 case BFD_MACH_O_LC_SEGMENT
:
1269 if (bfd_mach_o_write_segment_32 (abfd
, cur
) != 0)
1272 case BFD_MACH_O_LC_SEGMENT_64
:
1273 if (bfd_mach_o_write_segment_64 (abfd
, cur
) != 0)
1276 case BFD_MACH_O_LC_SYMTAB
:
1277 if (!bfd_mach_o_write_symtab (abfd
, cur
))
1280 case BFD_MACH_O_LC_SYMSEG
:
1282 case BFD_MACH_O_LC_THREAD
:
1283 case BFD_MACH_O_LC_UNIXTHREAD
:
1284 if (bfd_mach_o_write_thread (abfd
, cur
) != 0)
1287 case BFD_MACH_O_LC_LOADFVMLIB
:
1288 case BFD_MACH_O_LC_IDFVMLIB
:
1289 case BFD_MACH_O_LC_IDENT
:
1290 case BFD_MACH_O_LC_FVMFILE
:
1291 case BFD_MACH_O_LC_PREPAGE
:
1292 case BFD_MACH_O_LC_DYSYMTAB
:
1293 case BFD_MACH_O_LC_LOAD_DYLIB
:
1294 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
1295 case BFD_MACH_O_LC_ID_DYLIB
:
1296 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
1297 case BFD_MACH_O_LC_LOAD_DYLINKER
:
1298 case BFD_MACH_O_LC_ID_DYLINKER
:
1299 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
1300 case BFD_MACH_O_LC_ROUTINES
:
1301 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
1304 (*_bfd_error_handler
) (_("unable to write unknown load command 0x%lx"),
1305 (unsigned long) cur
->type
);
1314 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
1317 bfd_mach_o_section
*s
= (bfd_mach_o_section
*)sec
->used_by_bfd
;
1318 if (seg
->sect_head
== NULL
)
1321 seg
->sect_tail
->next
= s
;
1325 /* Create section Mach-O flags from BFD flags. */
1328 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
1331 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
1333 /* Create default flags. */
1334 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1335 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1336 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1337 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1338 | BFD_MACH_O_S_REGULAR
;
1339 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1340 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1341 else if (bfd_flags
& SEC_DEBUGGING
)
1342 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1344 s
->flags
= BFD_MACH_O_S_REGULAR
;
1347 /* Build Mach-O load commands from the sections. */
1350 bfd_mach_o_build_commands (bfd
*abfd
)
1352 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1353 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1354 bfd_mach_o_segment_command
*seg
;
1356 bfd_mach_o_load_command
*cmd
;
1357 bfd_mach_o_load_command
*symtab_cmd
;
1360 /* Return now if commands are already built. */
1361 if (mdata
->header
.ncmds
)
1364 /* Very simple version: a command (segment) to contain all the sections and
1365 a command for the symbol table. */
1366 mdata
->header
.ncmds
= 2;
1367 mdata
->commands
= bfd_alloc (abfd
, mdata
->header
.ncmds
1368 * sizeof (bfd_mach_o_load_command
));
1369 if (mdata
->commands
== NULL
)
1371 cmd
= &mdata
->commands
[0];
1372 seg
= &cmd
->command
.segment
;
1374 seg
->nsects
= bfd_count_sections (abfd
);
1376 /* Set segment command. */
1379 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
1380 cmd
->offset
= BFD_MACH_O_HEADER_64_SIZE
;
1381 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
1382 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
1386 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
1387 cmd
->offset
= BFD_MACH_O_HEADER_SIZE
;
1388 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
1389 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
1391 cmd
->type_required
= FALSE
;
1392 mdata
->header
.sizeofcmds
= cmd
->len
;
1393 mdata
->filelen
= cmd
->offset
+ cmd
->len
;
1395 /* Set symtab command. */
1396 symtab_cmd
= &mdata
->commands
[1];
1398 symtab_cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
1399 symtab_cmd
->offset
= cmd
->offset
+ cmd
->len
;
1400 symtab_cmd
->len
= 6 * 4;
1401 symtab_cmd
->type_required
= FALSE
;
1403 mdata
->header
.sizeofcmds
+= symtab_cmd
->len
;
1404 mdata
->filelen
+= symtab_cmd
->len
;
1406 /* Fill segment command. */
1407 memset (seg
->segname
, 0, sizeof (seg
->segname
));
1409 seg
->fileoff
= mdata
->filelen
;
1411 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
1412 | BFD_MACH_O_PROT_EXECUTE
;
1413 seg
->initprot
= seg
->maxprot
;
1415 seg
->sect_head
= NULL
;
1416 seg
->sect_tail
= NULL
;
1418 /* Create Mach-O sections. */
1420 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1422 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
1424 bfd_mach_o_append_section_to_segment (seg
, sec
);
1426 if (msect
->flags
== 0)
1428 /* We suppose it hasn't been set. Convert from BFD flags. */
1429 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
1431 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
1432 msect
->size
= bfd_get_section_size (sec
);
1433 msect
->align
= bfd_get_section_alignment (abfd
, sec
);
1435 if (msect
->size
!= 0)
1437 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, msect
->align
);
1438 msect
->offset
= mdata
->filelen
;
1443 sec
->filepos
= msect
->offset
;
1444 sec
->target_index
= ++target_index
;
1446 mdata
->filelen
+= msect
->size
;
1448 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
1449 seg
->vmsize
= seg
->filesize
;
1454 /* Set the contents of a section. */
1457 bfd_mach_o_set_section_contents (bfd
*abfd
,
1459 const void * location
,
1461 bfd_size_type count
)
1465 /* This must be done first, because bfd_set_section_contents is
1466 going to set output_has_begun to TRUE. */
1467 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
1473 pos
= section
->filepos
+ offset
;
1474 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1475 || bfd_bwrite (location
, count
, abfd
) != count
)
1482 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
1483 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1488 /* Make an empty symbol. This is required only because
1489 bfd_make_section_anyway wants to create a symbol for the section. */
1492 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
1494 asymbol
*new_symbol
;
1496 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
1497 if (new_symbol
== NULL
)
1499 new_symbol
->the_bfd
= abfd
;
1500 new_symbol
->udata
.i
= 0;
1505 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1507 struct mach_o_header_external raw
;
1509 bfd_vma (*get32
) (const void *) = NULL
;
1511 /* Just read the magic number. */
1512 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1513 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
1516 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
1518 header
->byteorder
= BFD_ENDIAN_BIG
;
1519 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1520 header
->version
= 1;
1523 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
1525 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1526 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1527 header
->version
= 1;
1530 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
1532 header
->byteorder
= BFD_ENDIAN_BIG
;
1533 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1534 header
->version
= 2;
1537 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
1539 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1540 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1541 header
->version
= 2;
1546 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
1550 /* Once the size of the header is known, read the full header. */
1551 size
= mach_o_wide_p (header
) ?
1552 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1554 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1555 || bfd_bread (&raw
, size
, abfd
) != size
)
1558 header
->cputype
= (*get32
) (raw
.cputype
);
1559 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
1560 header
->filetype
= (*get32
) (raw
.filetype
);
1561 header
->ncmds
= (*get32
) (raw
.ncmds
);
1562 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
1563 header
->flags
= (*get32
) (raw
.flags
);
1565 if (mach_o_wide_p (header
))
1566 header
->reserved
= (*get32
) (raw
.reserved
);
1572 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
1574 bfd_mach_o_section
*s
;
1576 s
= bfd_mach_o_get_mach_o_section (sec
);
1581 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
1584 sec
->used_by_bfd
= s
;
1585 s
->bfdsection
= sec
;
1587 /* Create default name. */
1588 bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
1590 /* Create default flags. */
1591 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1592 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1593 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1594 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1595 | BFD_MACH_O_S_REGULAR
;
1596 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1597 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1598 else if (bfd_flags
& SEC_DEBUGGING
)
1599 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1601 s
->flags
= BFD_MACH_O_S_REGULAR
;
1604 return _bfd_generic_new_section_hook (abfd
, sec
);
1608 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
1612 bfd_mach_o_section
*section
;
1614 flags
= bfd_get_section_flags (abfd
, sec
);
1615 section
= bfd_mach_o_get_mach_o_section (sec
);
1617 if (flags
== SEC_NO_FLAGS
)
1619 /* Try to guess flags. */
1620 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
1621 flags
= SEC_DEBUGGING
;
1625 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1626 != BFD_MACH_O_S_ZEROFILL
)
1629 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
1631 if (prot
& BFD_MACH_O_PROT_WRITE
)
1633 else if (prot
& BFD_MACH_O_PROT_READ
)
1634 flags
|= SEC_READONLY
;
1640 if ((flags
& SEC_DEBUGGING
) == 0)
1644 if (section
->offset
!= 0)
1645 flags
|= SEC_HAS_CONTENTS
;
1646 if (section
->nreloc
!= 0)
1649 bfd_set_section_flags (abfd
, sec
, flags
);
1651 sec
->vma
= section
->addr
;
1652 sec
->lma
= section
->addr
;
1653 sec
->size
= section
->size
;
1654 sec
->filepos
= section
->offset
;
1655 sec
->alignment_power
= section
->align
;
1656 sec
->segment_mark
= 0;
1657 sec
->reloc_count
= section
->nreloc
;
1658 sec
->rel_filepos
= section
->reloff
;
1662 bfd_mach_o_make_bfd_section (bfd
*abfd
,
1663 const unsigned char *segname
,
1664 const unsigned char *sectname
)
1669 bfd_mach_o_convert_section_name_to_bfd
1670 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
1674 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
1678 bfd_mach_o_read_section_32 (bfd
*abfd
,
1679 unsigned int offset
,
1682 struct mach_o_section_32_external raw
;
1684 bfd_mach_o_section
*section
;
1686 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1687 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1688 != BFD_MACH_O_SECTION_SIZE
))
1691 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
1695 section
= bfd_mach_o_get_mach_o_section (sec
);
1696 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
1697 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
1698 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
1699 section
->segname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
1700 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
1701 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
1702 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
1703 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
1704 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
1705 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
1706 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
1707 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
1708 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
1709 section
->reserved3
= 0;
1711 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
1717 bfd_mach_o_read_section_64 (bfd
*abfd
,
1718 unsigned int offset
,
1721 struct mach_o_section_64_external raw
;
1723 bfd_mach_o_section
*section
;
1725 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1726 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1727 != BFD_MACH_O_SECTION_64_SIZE
))
1730 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
1734 section
= bfd_mach_o_get_mach_o_section (sec
);
1735 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
1736 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
1737 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
1738 section
->segname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
1739 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
1740 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
1741 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
1742 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
1743 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
1744 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
1745 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
1746 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
1747 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
1748 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
1750 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
1756 bfd_mach_o_read_section (bfd
*abfd
,
1757 unsigned int offset
,
1762 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
1764 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
1768 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
1769 bfd_mach_o_symtab_command
*sym
,
1770 bfd_mach_o_asymbol
*s
,
1773 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1774 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1775 unsigned int symwidth
=
1776 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1777 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
1778 struct mach_o_nlist_64_external raw
;
1779 unsigned char type
= -1;
1780 unsigned char section
= -1;
1782 symvalue value
= -1;
1783 unsigned long stroff
= -1;
1784 unsigned int symtype
= -1;
1786 BFD_ASSERT (sym
->strtab
!= NULL
);
1788 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
1789 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
1791 (*_bfd_error_handler
)
1792 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
1793 symwidth
, (unsigned long) symoff
);
1797 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
1798 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
1799 symtype
= type
& BFD_MACH_O_N_TYPE
;
1800 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
1801 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
1803 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
1805 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
1807 if (stroff
>= sym
->strsize
)
1809 (*_bfd_error_handler
)
1810 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
1811 (unsigned long) stroff
,
1812 (unsigned long) sym
->strsize
);
1816 s
->symbol
.the_bfd
= abfd
;
1817 s
->symbol
.name
= sym
->strtab
+ stroff
;
1818 s
->symbol
.value
= value
;
1819 s
->symbol
.flags
= 0x0;
1820 s
->symbol
.udata
.i
= 0;
1822 s
->n_sect
= section
;
1825 if (type
& BFD_MACH_O_N_STAB
)
1827 s
->symbol
.flags
|= BSF_DEBUGGING
;
1828 s
->symbol
.section
= bfd_und_section_ptr
;
1840 if ((section
> 0) && (section
<= mdata
->nsects
))
1842 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1844 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1851 if (type
& BFD_MACH_O_N_PEXT
)
1852 s
->symbol
.flags
|= BSF_GLOBAL
;
1854 if (type
& BFD_MACH_O_N_EXT
)
1855 s
->symbol
.flags
|= BSF_GLOBAL
;
1857 if (!(type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
)))
1858 s
->symbol
.flags
|= BSF_LOCAL
;
1862 case BFD_MACH_O_N_UNDF
:
1863 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
1864 && s
->symbol
.value
!= 0)
1866 /* A common symbol. */
1867 s
->symbol
.section
= bfd_com_section_ptr
;
1868 s
->symbol
.flags
= BSF_NO_FLAGS
;
1872 s
->symbol
.section
= bfd_und_section_ptr
;
1873 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
1874 s
->symbol
.flags
|= BSF_WEAK
;
1877 case BFD_MACH_O_N_PBUD
:
1878 s
->symbol
.section
= bfd_und_section_ptr
;
1880 case BFD_MACH_O_N_ABS
:
1881 s
->symbol
.section
= bfd_abs_section_ptr
;
1883 case BFD_MACH_O_N_SECT
:
1884 if ((section
> 0) && (section
<= mdata
->nsects
))
1886 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1888 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1892 /* Mach-O uses 0 to mean "no section"; not an error. */
1895 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1896 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
1897 s
->symbol
.name
, section
, mdata
->nsects
);
1899 s
->symbol
.section
= bfd_und_section_ptr
;
1902 case BFD_MACH_O_N_INDR
:
1903 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1904 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined"),
1906 s
->symbol
.section
= bfd_und_section_ptr
;
1909 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1910 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
1911 s
->symbol
.name
, symtype
);
1912 s
->symbol
.section
= bfd_und_section_ptr
;
1921 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
1923 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1924 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1926 /* Fail if there is no symtab. */
1930 /* Success if already loaded. */
1934 if (abfd
->flags
& BFD_IN_MEMORY
)
1936 struct bfd_in_memory
*b
;
1938 b
= (struct bfd_in_memory
*) abfd
->iostream
;
1940 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
1942 bfd_set_error (bfd_error_file_truncated
);
1945 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
1949 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
1950 if (sym
->strtab
== NULL
)
1953 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
1954 || bfd_bread ((void *) sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
1956 bfd_set_error (bfd_error_file_truncated
);
1965 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
1967 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1968 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1972 if (sym
== NULL
|| sym
->symbols
)
1974 /* Return now if there are no symbols or if already loaded. */
1978 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
1980 if (sym
->symbols
== NULL
)
1982 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
1986 ret
= bfd_mach_o_read_symtab_strtab (abfd
);
1990 for (i
= 0; i
< sym
->nsyms
; i
++)
1992 ret
= bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
);
2001 bfd_mach_o_read_dysymtab_symbol (bfd
*abfd
,
2002 bfd_mach_o_dysymtab_command
*dysym
,
2003 bfd_mach_o_symtab_command
*sym
,
2004 bfd_mach_o_asymbol
*s
,
2007 unsigned long isymoff
= dysym
->indirectsymoff
+ (i
* 4);
2008 unsigned long sym_index
;
2009 unsigned char raw
[4];
2011 BFD_ASSERT (i
< dysym
->nindirectsyms
);
2013 if (bfd_seek (abfd
, isymoff
, SEEK_SET
) != 0
2014 || bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2016 (*_bfd_error_handler
)
2017 (_("bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu"),
2018 (unsigned long) sizeof (raw
), isymoff
);
2021 sym_index
= bfd_h_get_32 (abfd
, raw
);
2023 return bfd_mach_o_read_symtab_symbol (abfd
, sym
, s
, sym_index
);
2027 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2029 switch ((int) flavour
)
2031 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2032 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2033 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2034 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2035 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2036 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2037 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2038 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2039 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2040 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2041 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2042 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2043 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2044 default: return "UNKNOWN";
2049 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2051 switch ((int) flavour
)
2053 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2054 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2055 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2056 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2057 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2058 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2059 default: return "UNKNOWN";
2064 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2066 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2067 struct mach_o_str_command_external raw
;
2068 unsigned int nameoff
;
2070 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
2071 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
2073 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2074 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2077 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
2079 cmd
->name_offset
= command
->offset
+ nameoff
;
2080 cmd
->name_len
= command
->len
- nameoff
;
2081 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2082 if (cmd
->name_str
== NULL
)
2084 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2085 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2091 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2093 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
2094 struct mach_o_dylib_command_external raw
;
2095 unsigned int nameoff
;
2097 switch (command
->type
)
2099 case BFD_MACH_O_LC_LOAD_DYLIB
:
2100 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2101 case BFD_MACH_O_LC_ID_DYLIB
:
2102 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2109 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2110 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2113 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
2114 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
2115 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
2116 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
2118 cmd
->name_offset
= command
->offset
+ nameoff
;
2119 cmd
->name_len
= command
->len
- nameoff
;
2120 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2121 if (cmd
->name_str
== NULL
)
2123 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2124 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2130 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
2131 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
2133 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2135 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
2140 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2142 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2143 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
2144 unsigned int offset
;
2145 unsigned int nflavours
;
2148 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
2149 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
2151 /* Count the number of threads. */
2154 while (offset
!= command
->len
)
2156 struct mach_o_thread_command_external raw
;
2158 if (offset
>= command
->len
)
2161 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2162 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2165 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
2169 /* Allocate threads. */
2170 cmd
->flavours
= bfd_alloc
2171 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
2172 if (cmd
->flavours
== NULL
)
2174 cmd
->nflavours
= nflavours
;
2178 while (offset
!= command
->len
)
2180 struct mach_o_thread_command_external raw
;
2182 if (offset
>= command
->len
)
2185 if (nflavours
>= cmd
->nflavours
)
2188 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2189 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2192 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
2193 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
2194 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
2195 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
2199 for (i
= 0; i
< nflavours
; i
++)
2202 unsigned int snamelen
;
2204 const char *flavourstr
;
2205 const char *prefix
= "LC_THREAD";
2208 switch (mdata
->header
.cputype
)
2210 case BFD_MACH_O_CPU_TYPE_POWERPC
:
2211 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
2212 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
2214 case BFD_MACH_O_CPU_TYPE_I386
:
2215 case BFD_MACH_O_CPU_TYPE_X86_64
:
2216 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
2219 flavourstr
= "UNKNOWN_ARCHITECTURE";
2223 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
2224 sname
= bfd_alloc (abfd
, snamelen
);
2230 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
2231 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
2236 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
2240 bfdsec
->size
= cmd
->flavours
[i
].size
;
2241 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
2242 bfdsec
->alignment_power
= 0x0;
2244 cmd
->section
= bfdsec
;
2251 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2253 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2254 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2256 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2259 struct mach_o_dysymtab_command_external raw
;
2261 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2262 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2265 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
2266 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
2267 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
2268 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
2269 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
2270 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
2271 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
2272 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
2273 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
2274 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
2275 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
2276 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
2277 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
2278 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
2279 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
2280 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
2281 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
2282 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
2285 if (cmd
->nmodtab
!= 0)
2288 int wide
= bfd_mach_o_wide_p (abfd
);
2289 unsigned int module_len
= wide
? 56 : 52;
2292 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
2293 if (cmd
->dylib_module
== NULL
)
2296 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2299 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2301 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2303 unsigned char buf
[56];
2305 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
2308 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
2309 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
2310 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
2311 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
2312 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
2313 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
2314 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
2315 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
2316 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
2317 v
= bfd_h_get_32 (abfd
, buf
+36);
2318 module
->iinit
= v
& 0xffff;
2319 module
->iterm
= (v
>> 16) & 0xffff;
2320 v
= bfd_h_get_32 (abfd
, buf
+ 40);
2321 module
->ninit
= v
& 0xffff;
2322 module
->nterm
= (v
>> 16) & 0xffff;
2325 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
2326 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
2330 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
2331 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
2340 cmd
->dylib_toc
= bfd_alloc
2341 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
2342 if (cmd
->dylib_toc
== NULL
)
2345 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2348 for (i
= 0; i
< cmd
->ntoc
; i
++)
2350 struct mach_o_dylib_table_of_contents_external raw
;
2351 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2353 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2356 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
2357 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
2361 if (cmd
->nindirectsyms
!= 0)
2365 cmd
->indirect_syms
= bfd_alloc
2366 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
2367 if (cmd
->indirect_syms
== NULL
)
2370 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2373 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
2375 unsigned char raw
[4];
2376 unsigned int *is
= &cmd
->indirect_syms
[i
];
2378 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2381 *is
= bfd_h_get_32 (abfd
, raw
);
2385 if (cmd
->nextrefsyms
!= 0)
2390 cmd
->ext_refs
= bfd_alloc
2391 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
2392 if (cmd
->ext_refs
== NULL
)
2395 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2398 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2400 unsigned char raw
[4];
2401 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2403 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2406 /* Fields isym and flags are written as bit-fields, thus we need
2407 a specific processing for endianness. */
2408 v
= bfd_h_get_32 (abfd
, raw
);
2409 if (bfd_big_endian (abfd
))
2411 ref
->isym
= (v
>> 8) & 0xffffff;
2412 ref
->flags
= v
& 0xff;
2416 ref
->isym
= v
& 0xffffff;
2417 ref
->flags
= (v
>> 24) & 0xff;
2422 if (mdata
->dysymtab
)
2424 mdata
->dysymtab
= cmd
;
2430 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2432 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
2433 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2434 struct mach_o_symtab_command_external raw
;
2436 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2438 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2439 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2442 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
2443 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
2444 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
2445 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
2446 symtab
->symbols
= NULL
;
2447 symtab
->strtab
= NULL
;
2449 if (symtab
->nsyms
!= 0)
2450 abfd
->flags
|= HAS_SYMS
;
2454 mdata
->symtab
= symtab
;
2459 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2461 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
2463 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
2465 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2466 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
2473 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2475 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
2476 struct mach_o_linkedit_data_command_external raw
;
2478 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2479 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2482 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
2483 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
2488 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2490 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
2491 struct mach_o_str_command_external raw
;
2494 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2495 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2498 off
= bfd_get_32 (abfd
, raw
.str
);
2499 cmd
->stroff
= command
->offset
+ off
;
2500 cmd
->str_len
= command
->len
- off
;
2501 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
2502 if (cmd
->str
== NULL
)
2504 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
2505 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
2511 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2513 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
2514 struct mach_o_dyld_info_command_external raw
;
2516 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2517 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2520 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
2521 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
2522 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
2523 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
2524 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
2525 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
2526 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
2527 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
2528 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
2529 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
2534 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2536 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
2537 struct mach_o_version_min_command_external raw
;
2540 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2541 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2544 ver
= bfd_get_32 (abfd
, raw
.version
);
2545 cmd
->rel
= ver
>> 16;
2546 cmd
->maj
= ver
>> 8;
2548 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
2553 bfd_mach_o_read_segment (bfd
*abfd
,
2554 bfd_mach_o_load_command
*command
,
2557 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
2562 struct mach_o_segment_command_64_external raw
;
2564 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
2566 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2567 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2570 memcpy (seg
->segname
, raw
.segname
, 16);
2571 seg
->segname
[16] = '\0';
2573 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
2574 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
2575 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
2576 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
2577 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
2578 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
2579 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
2580 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2584 struct mach_o_segment_command_32_external raw
;
2586 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
2588 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2589 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2592 memcpy (seg
->segname
, raw
.segname
, 16);
2593 seg
->segname
[16] = '\0';
2595 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
2596 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
2597 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
2598 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
2599 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
2600 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
2601 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
2602 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2604 seg
->sect_head
= NULL
;
2605 seg
->sect_tail
= NULL
;
2607 for (i
= 0; i
< seg
->nsects
; i
++)
2613 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
2614 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
2616 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
2617 + (i
* BFD_MACH_O_SECTION_SIZE
);
2619 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
2623 bfd_mach_o_append_section_to_segment (seg
, sec
);
2630 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2632 return bfd_mach_o_read_segment (abfd
, command
, 0);
2636 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2638 return bfd_mach_o_read_segment (abfd
, command
, 1);
2642 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2644 struct mach_o_load_command_external raw
;
2647 /* Read command type and length. */
2648 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
2649 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
2652 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
2653 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
2654 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
2655 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
2657 switch (command
->type
)
2659 case BFD_MACH_O_LC_SEGMENT
:
2660 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
2663 case BFD_MACH_O_LC_SEGMENT_64
:
2664 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
2667 case BFD_MACH_O_LC_SYMTAB
:
2668 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
2671 case BFD_MACH_O_LC_SYMSEG
:
2673 case BFD_MACH_O_LC_THREAD
:
2674 case BFD_MACH_O_LC_UNIXTHREAD
:
2675 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
2678 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2679 case BFD_MACH_O_LC_ID_DYLINKER
:
2680 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
2683 case BFD_MACH_O_LC_LOAD_DYLIB
:
2684 case BFD_MACH_O_LC_ID_DYLIB
:
2685 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2686 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2687 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
2690 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
2691 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
2694 case BFD_MACH_O_LC_LOADFVMLIB
:
2695 case BFD_MACH_O_LC_IDFVMLIB
:
2696 case BFD_MACH_O_LC_IDENT
:
2697 case BFD_MACH_O_LC_FVMFILE
:
2698 case BFD_MACH_O_LC_PREPAGE
:
2699 case BFD_MACH_O_LC_ROUTINES
:
2700 case BFD_MACH_O_LC_ROUTINES_64
:
2702 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
2703 case BFD_MACH_O_LC_SUB_UMBRELLA
:
2704 case BFD_MACH_O_LC_SUB_LIBRARY
:
2705 case BFD_MACH_O_LC_SUB_CLIENT
:
2706 case BFD_MACH_O_LC_RPATH
:
2707 if (bfd_mach_o_read_str (abfd
, command
) != 0)
2710 case BFD_MACH_O_LC_DYSYMTAB
:
2711 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
2714 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
2715 case BFD_MACH_O_LC_PREBIND_CKSUM
:
2717 case BFD_MACH_O_LC_UUID
:
2718 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
2721 case BFD_MACH_O_LC_CODE_SIGNATURE
:
2722 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
2723 case BFD_MACH_O_LC_FUNCTION_STARTS
:
2724 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
2727 case BFD_MACH_O_LC_DYLD_INFO
:
2728 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
2731 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
2732 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
2733 if (!bfd_mach_o_read_version_min (abfd
, command
))
2737 (*_bfd_error_handler
)(_("%B: unable to read unknown load command 0x%lx"),
2738 abfd
, (unsigned long) command
->type
);
2746 bfd_mach_o_flatten_sections (bfd
*abfd
)
2748 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2752 /* Count total number of sections. */
2755 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2757 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2758 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2760 bfd_mach_o_segment_command
*seg
;
2762 seg
= &mdata
->commands
[i
].command
.segment
;
2763 mdata
->nsects
+= seg
->nsects
;
2767 /* Allocate sections array. */
2768 mdata
->sections
= bfd_alloc (abfd
,
2769 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2771 /* Fill the array. */
2774 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2776 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2777 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2779 bfd_mach_o_segment_command
*seg
;
2780 bfd_mach_o_section
*sec
;
2782 seg
= &mdata
->commands
[i
].command
.segment
;
2783 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
2785 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
2786 mdata
->sections
[csect
++] = sec
;
2792 bfd_mach_o_scan_start_address (bfd
*abfd
)
2794 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2795 bfd_mach_o_thread_command
*cmd
= NULL
;
2798 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2800 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
2801 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
2804 cmd
= &mdata
->commands
[i
].command
.thread
;
2813 for (i
= 0; i
< cmd
->nflavours
; i
++)
2815 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
2816 && (cmd
->flavours
[i
].flavour
2817 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
2819 unsigned char buf
[4];
2821 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
2822 || bfd_bread (buf
, 4, abfd
) != 4)
2825 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2827 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
2828 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
2830 unsigned char buf
[4];
2832 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2833 || bfd_bread (buf
, 4, abfd
) != 4)
2836 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2838 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
2839 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
2841 unsigned char buf
[8];
2843 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2844 || bfd_bread (buf
, 8, abfd
) != 8)
2847 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2849 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
2850 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
2852 unsigned char buf
[8];
2854 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
2855 || bfd_bread (buf
, 8, abfd
) != 8)
2858 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2866 bfd_mach_o_set_arch_mach (bfd
*abfd
,
2867 enum bfd_architecture arch
,
2868 unsigned long machine
)
2870 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
2872 /* If this isn't the right architecture for this backend, and this
2873 isn't the generic backend, fail. */
2874 if (arch
!= bed
->arch
2875 && arch
!= bfd_arch_unknown
2876 && bed
->arch
!= bfd_arch_unknown
)
2879 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
2883 bfd_mach_o_scan (bfd
*abfd
,
2884 bfd_mach_o_header
*header
,
2885 bfd_mach_o_data_struct
*mdata
)
2888 enum bfd_architecture cputype
;
2889 unsigned long cpusubtype
;
2890 unsigned int hdrsize
;
2892 hdrsize
= mach_o_wide_p (header
) ?
2893 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2895 mdata
->header
= *header
;
2897 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
2898 switch (header
->filetype
)
2900 case BFD_MACH_O_MH_OBJECT
:
2901 abfd
->flags
|= HAS_RELOC
;
2903 case BFD_MACH_O_MH_EXECUTE
:
2904 abfd
->flags
|= EXEC_P
;
2906 case BFD_MACH_O_MH_DYLIB
:
2907 case BFD_MACH_O_MH_BUNDLE
:
2908 abfd
->flags
|= DYNAMIC
;
2912 abfd
->tdata
.mach_o_data
= mdata
;
2914 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
2915 &cputype
, &cpusubtype
);
2916 if (cputype
== bfd_arch_unknown
)
2918 (*_bfd_error_handler
) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
2919 header
->cputype
, header
->cpusubtype
);
2923 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
2925 if (header
->ncmds
!= 0)
2927 mdata
->commands
= bfd_alloc
2928 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
2929 if (mdata
->commands
== NULL
)
2932 for (i
= 0; i
< header
->ncmds
; i
++)
2934 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
2937 cur
->offset
= hdrsize
;
2940 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
2941 cur
->offset
= prev
->offset
+ prev
->len
;
2944 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
2949 if (bfd_mach_o_scan_start_address (abfd
) < 0)
2952 bfd_mach_o_flatten_sections (abfd
);
2957 bfd_mach_o_mkobject_init (bfd
*abfd
)
2959 bfd_mach_o_data_struct
*mdata
= NULL
;
2961 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
2964 abfd
->tdata
.mach_o_data
= mdata
;
2966 mdata
->header
.magic
= 0;
2967 mdata
->header
.cputype
= 0;
2968 mdata
->header
.cpusubtype
= 0;
2969 mdata
->header
.filetype
= 0;
2970 mdata
->header
.ncmds
= 0;
2971 mdata
->header
.sizeofcmds
= 0;
2972 mdata
->header
.flags
= 0;
2973 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
2974 mdata
->commands
= NULL
;
2976 mdata
->sections
= NULL
;
2982 bfd_mach_o_gen_mkobject (bfd
*abfd
)
2984 bfd_mach_o_data_struct
*mdata
;
2986 if (!bfd_mach_o_mkobject_init (abfd
))
2989 mdata
= bfd_mach_o_get_data (abfd
);
2990 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
2991 mdata
->header
.cputype
= 0;
2992 mdata
->header
.cpusubtype
= 0;
2993 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
2994 mdata
->header
.version
= 1;
3000 bfd_mach_o_header_p (bfd
*abfd
,
3001 bfd_mach_o_filetype filetype
,
3002 bfd_mach_o_cpu_type cputype
)
3004 struct bfd_preserve preserve
;
3005 bfd_mach_o_header header
;
3007 preserve
.marker
= NULL
;
3008 if (!bfd_mach_o_read_header (abfd
, &header
))
3011 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3012 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3014 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3015 (unsigned long) header
.byteorder
);
3019 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3020 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3021 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3022 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3023 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3024 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3027 /* Check cputype and filetype.
3028 In case of wildcard, do not accept magics that are handled by existing
3032 if (header
.cputype
!= cputype
)
3037 switch (header
.cputype
)
3039 case BFD_MACH_O_CPU_TYPE_I386
:
3040 /* Handled by mach-o-i386 */
3048 if (header
.filetype
!= filetype
)
3053 switch (header
.filetype
)
3055 case BFD_MACH_O_MH_CORE
:
3056 /* Handled by core_p */
3063 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3064 if (preserve
.marker
== NULL
3065 || !bfd_preserve_save (abfd
, &preserve
))
3068 if (bfd_mach_o_scan (abfd
, &header
,
3069 (bfd_mach_o_data_struct
*) preserve
.marker
) != 0)
3072 bfd_preserve_finish (abfd
, &preserve
);
3076 bfd_set_error (bfd_error_wrong_format
);
3079 if (preserve
.marker
!= NULL
)
3080 bfd_preserve_restore (abfd
, &preserve
);
3084 static const bfd_target
*
3085 bfd_mach_o_gen_object_p (bfd
*abfd
)
3087 return bfd_mach_o_header_p (abfd
, 0, 0);
3090 static const bfd_target
*
3091 bfd_mach_o_gen_core_p (bfd
*abfd
)
3093 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
3096 typedef struct mach_o_fat_archentry
3098 unsigned long cputype
;
3099 unsigned long cpusubtype
;
3100 unsigned long offset
;
3102 unsigned long align
;
3103 } mach_o_fat_archentry
;
3105 typedef struct mach_o_fat_data_struct
3107 unsigned long magic
;
3108 unsigned long nfat_arch
;
3109 mach_o_fat_archentry
*archentries
;
3110 } mach_o_fat_data_struct
;
3113 bfd_mach_o_archive_p (bfd
*abfd
)
3115 mach_o_fat_data_struct
*adata
= NULL
;
3116 struct mach_o_fat_header_external hdr
;
3119 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3120 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
3123 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
3127 adata
->magic
= bfd_getb32 (hdr
.magic
);
3128 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
3129 if (adata
->magic
!= 0xcafebabe)
3131 /* Avoid matching Java bytecode files, which have the same magic number.
3132 In the Java bytecode file format this field contains the JVM version,
3133 which starts at 43.0. */
3134 if (adata
->nfat_arch
> 30)
3137 adata
->archentries
=
3138 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
3139 if (adata
->archentries
== NULL
)
3142 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3144 struct mach_o_fat_arch_external arch
;
3145 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
3147 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
3148 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
3149 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
3150 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
3151 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
3154 abfd
->tdata
.mach_o_fat_data
= adata
;
3159 bfd_release (abfd
, adata
);
3160 bfd_set_error (bfd_error_wrong_format
);
3165 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
3167 mach_o_fat_data_struct
*adata
;
3168 mach_o_fat_archentry
*entry
= NULL
;
3171 enum bfd_architecture arch_type
;
3172 unsigned long arch_subtype
;
3174 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
3175 BFD_ASSERT (adata
!= NULL
);
3177 /* Find index of previous entry. */
3179 i
= 0; /* Start at first one. */
3182 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3184 if (adata
->archentries
[i
].offset
== prev
->origin
)
3188 if (i
== adata
->nfat_arch
)
3191 bfd_set_error (bfd_error_bad_value
);
3194 i
++; /* Get next entry. */
3197 if (i
>= adata
->nfat_arch
)
3199 bfd_set_error (bfd_error_no_more_archived_files
);
3203 entry
= &adata
->archentries
[i
];
3204 nbfd
= _bfd_new_bfd_contained_in (archive
);
3208 nbfd
->origin
= entry
->offset
;
3210 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
3211 &arch_type
, &arch_subtype
);
3213 /* Create the member filename. Use ARCH_NAME. */
3214 nbfd
->filename
= bfd_printable_arch_mach (arch_type
, arch_subtype
);
3215 nbfd
->iostream
= NULL
;
3216 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
3221 /* If ABFD format is FORMAT and architecture is ARCH, return it.
3222 If ABFD is a fat image containing a member that corresponds to FORMAT
3223 and ARCH, returns it.
3224 In other case, returns NULL.
3225 This function allows transparent uses of fat images. */
3227 bfd_mach_o_fat_extract (bfd
*abfd
,
3229 const bfd_arch_info_type
*arch
)
3232 mach_o_fat_data_struct
*adata
;
3235 if (bfd_check_format (abfd
, format
))
3237 if (bfd_get_arch_info (abfd
) == arch
)
3241 if (!bfd_check_format (abfd
, bfd_archive
)
3242 || abfd
->xvec
!= &mach_o_fat_vec
)
3245 /* This is a Mach-O fat image. */
3246 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
3247 BFD_ASSERT (adata
!= NULL
);
3249 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3251 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
3252 enum bfd_architecture cpu_type
;
3253 unsigned long cpu_subtype
;
3255 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
3256 &cpu_type
, &cpu_subtype
);
3257 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
3260 /* The architecture is found. */
3261 res
= _bfd_new_bfd_contained_in (abfd
);
3265 res
->origin
= e
->offset
;
3267 res
->filename
= bfd_printable_arch_mach (cpu_type
, cpu_subtype
);
3268 res
->iostream
= NULL
;
3270 if (bfd_check_format (res
, format
))
3272 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
3283 bfd_mach_o_lookup_command (bfd
*abfd
,
3284 bfd_mach_o_load_command_type type
,
3285 bfd_mach_o_load_command
**mcommand
)
3287 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
3288 bfd_mach_o_load_command
*ncmd
= NULL
;
3289 unsigned int i
, num
;
3291 BFD_ASSERT (md
!= NULL
);
3292 BFD_ASSERT (mcommand
!= NULL
);
3295 for (i
= 0; i
< md
->header
.ncmds
; i
++)
3297 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
3299 if (cmd
->type
!= type
)
3312 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
3316 case BFD_MACH_O_CPU_TYPE_MC680x0
:
3318 case BFD_MACH_O_CPU_TYPE_MC88000
:
3320 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3322 case BFD_MACH_O_CPU_TYPE_I386
:
3324 case BFD_MACH_O_CPU_TYPE_SPARC
:
3326 case BFD_MACH_O_CPU_TYPE_I860
:
3328 case BFD_MACH_O_CPU_TYPE_HPPA
:
3329 return 0xc0000000 - 0x04000000;
3335 typedef struct bfd_mach_o_xlat_name
3340 bfd_mach_o_xlat_name
;
3343 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name
*table
,
3349 for (; table
->name
; table
++)
3351 if (table
->val
& val
)
3354 fprintf (file
, "+");
3355 fprintf (file
, "%s", table
->name
);
3363 fprintf (file
, "+");
3364 fprintf (file
, "0x%lx", val
);
3368 fprintf (file
, "-");
3372 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name
*table
,
3375 for (; table
->name
; table
++)
3376 if (table
->val
== val
)
3382 bfd_mach_o_get_name (const bfd_mach_o_xlat_name
*table
, unsigned long val
)
3384 const char *res
= bfd_mach_o_get_name_or_null (table
, val
);
3392 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name
[] =
3394 { "vax", BFD_MACH_O_CPU_TYPE_VAX
},
3395 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0
},
3396 { "i386", BFD_MACH_O_CPU_TYPE_I386
},
3397 { "mips", BFD_MACH_O_CPU_TYPE_MIPS
},
3398 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000
},
3399 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA
},
3400 { "arm", BFD_MACH_O_CPU_TYPE_ARM
},
3401 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000
},
3402 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC
},
3403 { "i860", BFD_MACH_O_CPU_TYPE_I860
},
3404 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA
},
3405 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC
},
3406 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64
},
3407 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64
},
3411 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name
[] =
3413 { "object", BFD_MACH_O_MH_OBJECT
},
3414 { "execute", BFD_MACH_O_MH_EXECUTE
},
3415 { "fvmlib", BFD_MACH_O_MH_FVMLIB
},
3416 { "core", BFD_MACH_O_MH_CORE
},
3417 { "preload", BFD_MACH_O_MH_PRELOAD
},
3418 { "dylib", BFD_MACH_O_MH_DYLIB
},
3419 { "dylinker", BFD_MACH_O_MH_DYLINKER
},
3420 { "bundle", BFD_MACH_O_MH_BUNDLE
},
3421 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB
},
3422 { "dym", BFD_MACH_O_MH_DSYM
},
3423 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE
},
3427 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name
[] =
3429 { "noundefs", BFD_MACH_O_MH_NOUNDEFS
},
3430 { "incrlink", BFD_MACH_O_MH_INCRLINK
},
3431 { "dyldlink", BFD_MACH_O_MH_DYLDLINK
},
3432 { "bindatload", BFD_MACH_O_MH_BINDATLOAD
},
3433 { "prebound", BFD_MACH_O_MH_PREBOUND
},
3434 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS
},
3435 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT
},
3436 { "twolevel", BFD_MACH_O_MH_TWOLEVEL
},
3437 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT
},
3438 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS
},
3439 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING
},
3440 { "prebindable", BFD_MACH_O_MH_PREBINDABLE
},
3441 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND
},
3442 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS
},
3443 { "canonical", BFD_MACH_O_MH_CANONICAL
},
3444 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES
},
3445 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK
},
3446 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION
},
3447 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE
},
3448 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE
},
3449 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS
},
3450 { "pie", BFD_MACH_O_MH_PIE
},
3454 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
3456 { "regular", BFD_MACH_O_S_REGULAR
},
3457 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
3458 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
3459 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
3460 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
3461 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
3462 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
3463 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
3464 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
3465 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
3466 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
3467 { "coalesced", BFD_MACH_O_S_COALESCED
},
3468 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
3469 { "interposing", BFD_MACH_O_S_INTERPOSING
},
3470 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
3471 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
3472 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
3476 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
3478 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
3479 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
3480 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
3481 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
3482 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
3483 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
3484 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
3485 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
3486 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
3487 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
3491 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name
[] =
3493 { "segment", BFD_MACH_O_LC_SEGMENT
},
3494 { "symtab", BFD_MACH_O_LC_SYMTAB
},
3495 { "symseg", BFD_MACH_O_LC_SYMSEG
},
3496 { "thread", BFD_MACH_O_LC_THREAD
},
3497 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD
},
3498 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB
},
3499 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB
},
3500 { "ident", BFD_MACH_O_LC_IDENT
},
3501 { "fvmfile", BFD_MACH_O_LC_FVMFILE
},
3502 { "prepage", BFD_MACH_O_LC_PREPAGE
},
3503 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB
},
3504 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB
},
3505 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB
},
3506 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER
},
3507 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER
},
3508 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB
},
3509 { "routines", BFD_MACH_O_LC_ROUTINES
},
3510 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK
},
3511 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA
},
3512 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT
},
3513 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY
},
3514 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS
},
3515 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM
},
3516 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB
},
3517 { "segment_64", BFD_MACH_O_LC_SEGMENT_64
},
3518 { "routines_64", BFD_MACH_O_LC_ROUTINES_64
},
3519 { "uuid", BFD_MACH_O_LC_UUID
},
3520 { "rpath", BFD_MACH_O_LC_RPATH
},
3521 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE
},
3522 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
},
3523 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB
},
3524 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB
},
3525 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO
},
3526 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO
},
3527 { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
},
3528 { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX
},
3529 { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
},
3530 { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS
},
3531 { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT
},
3535 /* Get the section type from NAME. Return -1 if NAME is unknown. */
3538 bfd_mach_o_get_section_type_from_name (const char *name
)
3540 bfd_mach_o_xlat_name
*x
;
3542 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
3543 if (strcmp (x
->name
, name
) == 0)
3545 return (unsigned int)-1;
3548 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
3551 bfd_mach_o_get_section_attribute_from_name (const char *name
)
3553 bfd_mach_o_xlat_name
*x
;
3555 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
3556 if (strcmp (x
->name
, name
) == 0)
3558 return (unsigned int)-1;
3562 bfd_mach_o_print_private_header (bfd
*abfd
, FILE *file
)
3564 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3565 bfd_mach_o_header
*h
= &mdata
->header
;
3567 fputs (_("Mach-O header:\n"), file
);
3568 fprintf (file
, _(" magic : %08lx\n"), h
->magic
);
3569 fprintf (file
, _(" cputype : %08lx (%s)\n"), h
->cputype
,
3570 bfd_mach_o_get_name (bfd_mach_o_cpu_name
, h
->cputype
));
3571 fprintf (file
, _(" cpusubtype: %08lx\n"), h
->cpusubtype
);
3572 fprintf (file
, _(" filetype : %08lx (%s)\n"),
3574 bfd_mach_o_get_name (bfd_mach_o_filetype_name
, h
->filetype
));
3575 fprintf (file
, _(" ncmds : %08lx (%lu)\n"), h
->ncmds
, h
->ncmds
);
3576 fprintf (file
, _(" sizeofcmds: %08lx\n"), h
->sizeofcmds
);
3577 fprintf (file
, _(" flags : %08lx ("), h
->flags
);
3578 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name
, h
->flags
, file
);
3579 fputs (_(")\n"), file
);
3580 fprintf (file
, _(" reserved : %08x\n"), h
->reserved
);
3584 bfd_mach_o_print_section_map (bfd
*abfd
, FILE *file
)
3586 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3588 unsigned int sec_nbr
= 0;
3590 fputs (_("Segments and Sections:\n"), file
);
3591 fputs (_(" #: Segment name Section name Address\n"), file
);
3593 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3595 bfd_mach_o_segment_command
*seg
;
3596 bfd_mach_o_section
*sec
;
3598 if (mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT
3599 && mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT_64
)
3602 seg
= &mdata
->commands
[i
].command
.segment
;
3604 fprintf (file
, "[Segment %-16s ", seg
->segname
);
3605 fprintf_vma (file
, seg
->vmaddr
);
3606 fprintf (file
, "-");
3607 fprintf_vma (file
, seg
->vmaddr
+ seg
->vmsize
- 1);
3609 fputc (seg
->initprot
& BFD_MACH_O_PROT_READ
? 'r' : '-', file
);
3610 fputc (seg
->initprot
& BFD_MACH_O_PROT_WRITE
? 'w' : '-', file
);
3611 fputc (seg
->initprot
& BFD_MACH_O_PROT_EXECUTE
? 'x' : '-', file
);
3612 fprintf (file
, "]\n");
3614 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3616 fprintf (file
, "%02u: %-16s %-16s ", ++sec_nbr
,
3617 sec
->segname
, sec
->sectname
);
3618 fprintf_vma (file
, sec
->addr
);
3619 fprintf (file
, " ");
3620 fprintf_vma (file
, sec
->size
);
3621 fprintf (file
, " %08lx\n", sec
->flags
);
3627 bfd_mach_o_print_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3628 bfd_mach_o_section
*sec
, FILE *file
)
3630 fprintf (file
, " Section: %-16s %-16s (bfdname: %s)\n",
3631 sec
->sectname
, sec
->segname
, sec
->bfdsection
->name
);
3632 fprintf (file
, " addr: ");
3633 fprintf_vma (file
, sec
->addr
);
3634 fprintf (file
, " size: ");
3635 fprintf_vma (file
, sec
->size
);
3636 fprintf (file
, " offset: ");
3637 fprintf_vma (file
, sec
->offset
);
3638 fprintf (file
, "\n");
3639 fprintf (file
, " align: %ld", sec
->align
);
3640 fprintf (file
, " nreloc: %lu reloff: ", sec
->nreloc
);
3641 fprintf_vma (file
, sec
->reloff
);
3642 fprintf (file
, "\n");
3643 fprintf (file
, " flags: %08lx (type: %s", sec
->flags
,
3644 bfd_mach_o_get_name (bfd_mach_o_section_type_name
,
3645 sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
));
3646 fprintf (file
, " attr: ");
3647 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name
,
3648 sec
->flags
& BFD_MACH_O_SECTION_ATTRIBUTES_MASK
,
3650 fprintf (file
, ")\n");
3651 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3653 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3654 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3655 case BFD_MACH_O_S_SYMBOL_STUBS
:
3656 fprintf (file
, " first indirect sym: %lu", sec
->reserved1
);
3657 fprintf (file
, " (%u entries)",
3658 bfd_mach_o_section_get_nbr_indirect (abfd
, sec
));
3661 fprintf (file
, " reserved1: 0x%lx", sec
->reserved1
);
3664 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3666 case BFD_MACH_O_S_SYMBOL_STUBS
:
3667 fprintf (file
, " stub size: %lu", sec
->reserved2
);
3670 fprintf (file
, " reserved2: 0x%lx", sec
->reserved2
);
3673 fprintf (file
, " reserved3: 0x%lx\n", sec
->reserved3
);
3677 bfd_mach_o_print_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
3678 bfd_mach_o_load_command
*cmd
, FILE *file
)
3680 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3681 bfd_mach_o_section
*sec
;
3683 fprintf (file
, " name: %s\n", *seg
->segname
? seg
->segname
: "*none*");
3684 fprintf (file
, " vmaddr: ");
3685 fprintf_vma (file
, seg
->vmaddr
);
3686 fprintf (file
, " vmsize: ");
3687 fprintf_vma (file
, seg
->vmsize
);
3688 fprintf (file
, "\n");
3689 fprintf (file
, " fileoff: ");
3690 fprintf_vma (file
, seg
->fileoff
);
3691 fprintf (file
, " filesize: ");
3692 fprintf_vma (file
, (bfd_vma
)seg
->filesize
);
3693 fprintf (file
, " endoff: ");
3694 fprintf_vma (file
, (bfd_vma
)(seg
->fileoff
+ seg
->filesize
));
3695 fprintf (file
, "\n");
3696 fprintf (file
, " nsects: %lu ", seg
->nsects
);
3697 fprintf (file
, " flags: %lx\n", seg
->flags
);
3698 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3699 bfd_mach_o_print_section (abfd
, sec
, file
);
3703 bfd_mach_o_print_dysymtab (bfd
*abfd ATTRIBUTE_UNUSED
,
3704 bfd_mach_o_load_command
*cmd
, FILE *file
)
3706 bfd_mach_o_dysymtab_command
*dysymtab
= &cmd
->command
.dysymtab
;
3707 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3710 fprintf (file
, " local symbols: idx: %10lu num: %-8lu",
3711 dysymtab
->ilocalsym
, dysymtab
->nlocalsym
);
3712 fprintf (file
, " (nxtidx: %lu)\n",
3713 dysymtab
->ilocalsym
+ dysymtab
->nlocalsym
);
3714 fprintf (file
, " external symbols: idx: %10lu num: %-8lu",
3715 dysymtab
->iextdefsym
, dysymtab
->nextdefsym
);
3716 fprintf (file
, " (nxtidx: %lu)\n",
3717 dysymtab
->iextdefsym
+ dysymtab
->nextdefsym
);
3718 fprintf (file
, " undefined symbols: idx: %10lu num: %-8lu",
3719 dysymtab
->iundefsym
, dysymtab
->nundefsym
);
3720 fprintf (file
, " (nxtidx: %lu)\n",
3721 dysymtab
->iundefsym
+ dysymtab
->nundefsym
);
3722 fprintf (file
, " table of content: off: 0x%08lx num: %-8lu",
3723 dysymtab
->tocoff
, dysymtab
->ntoc
);
3724 fprintf (file
, " (endoff: 0x%08lx)\n",
3726 + dysymtab
->ntoc
* BFD_MACH_O_TABLE_OF_CONTENT_SIZE
);
3727 fprintf (file
, " module table: off: 0x%08lx num: %-8lu",
3728 dysymtab
->modtaboff
, dysymtab
->nmodtab
);
3729 fprintf (file
, " (endoff: 0x%08lx)\n",
3730 dysymtab
->modtaboff
+ dysymtab
->nmodtab
3731 * (mach_o_wide_p (&mdata
->header
) ?
3732 BFD_MACH_O_DYLIB_MODULE_64_SIZE
: BFD_MACH_O_DYLIB_MODULE_SIZE
));
3733 fprintf (file
, " external reference table: off: 0x%08lx num: %-8lu",
3734 dysymtab
->extrefsymoff
, dysymtab
->nextrefsyms
);
3735 fprintf (file
, " (endoff: 0x%08lx)\n",
3736 dysymtab
->extrefsymoff
3737 + dysymtab
->nextrefsyms
* BFD_MACH_O_REFERENCE_SIZE
);
3738 fprintf (file
, " indirect symbol table: off: 0x%08lx num: %-8lu",
3739 dysymtab
->indirectsymoff
, dysymtab
->nindirectsyms
);
3740 fprintf (file
, " (endoff: 0x%08lx)\n",
3741 dysymtab
->indirectsymoff
3742 + dysymtab
->nindirectsyms
* BFD_MACH_O_INDIRECT_SYMBOL_SIZE
);
3743 fprintf (file
, " external relocation table: off: 0x%08lx num: %-8lu",
3744 dysymtab
->extreloff
, dysymtab
->nextrel
);
3745 fprintf (file
, " (endoff: 0x%08lx)\n",
3746 dysymtab
->extreloff
+ dysymtab
->nextrel
* BFD_MACH_O_RELENT_SIZE
);
3747 fprintf (file
, " local relocation table: off: 0x%08lx num: %-8lu",
3748 dysymtab
->locreloff
, dysymtab
->nlocrel
);
3749 fprintf (file
, " (endoff: 0x%08lx)\n",
3750 dysymtab
->locreloff
+ dysymtab
->nlocrel
* BFD_MACH_O_RELENT_SIZE
);
3752 if (dysymtab
->ntoc
> 0
3753 || dysymtab
->nindirectsyms
> 0
3754 || dysymtab
->nextrefsyms
> 0)
3756 /* Try to read the symbols to display the toc or indirect symbols. */
3757 bfd_mach_o_read_symtab_symbols (abfd
);
3759 else if (dysymtab
->nmodtab
> 0)
3761 /* Try to read the strtab to display modules name. */
3762 bfd_mach_o_read_symtab_strtab (abfd
);
3765 for (i
= 0; i
< dysymtab
->nmodtab
; i
++)
3767 bfd_mach_o_dylib_module
*module
= &dysymtab
->dylib_module
[i
];
3768 fprintf (file
, " module %u:\n", i
);
3769 fprintf (file
, " name: %lu", module
->module_name_idx
);
3770 if (mdata
->symtab
&& mdata
->symtab
->strtab
)
3771 fprintf (file
, ": %s",
3772 mdata
->symtab
->strtab
+ module
->module_name_idx
);
3773 fprintf (file
, "\n");
3774 fprintf (file
, " extdefsym: idx: %8lu num: %lu\n",
3775 module
->iextdefsym
, module
->nextdefsym
);
3776 fprintf (file
, " refsym: idx: %8lu num: %lu\n",
3777 module
->irefsym
, module
->nrefsym
);
3778 fprintf (file
, " localsym: idx: %8lu num: %lu\n",
3779 module
->ilocalsym
, module
->nlocalsym
);
3780 fprintf (file
, " extrel: idx: %8lu num: %lu\n",
3781 module
->iextrel
, module
->nextrel
);
3782 fprintf (file
, " init: idx: %8u num: %u\n",
3783 module
->iinit
, module
->ninit
);
3784 fprintf (file
, " term: idx: %8u num: %u\n",
3785 module
->iterm
, module
->nterm
);
3786 fprintf (file
, " objc_module_info: addr: ");
3787 fprintf_vma (file
, module
->objc_module_info_addr
);
3788 fprintf (file
, " size: %lu\n", module
->objc_module_info_size
);
3791 if (dysymtab
->ntoc
> 0)
3793 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3795 fprintf (file
, " table of content: (symbol/module)\n");
3796 for (i
= 0; i
< dysymtab
->ntoc
; i
++)
3798 bfd_mach_o_dylib_table_of_content
*toc
= &dysymtab
->dylib_toc
[i
];
3800 fprintf (file
, " %4u: ", i
);
3801 if (symtab
&& symtab
->symbols
&& toc
->symbol_index
< symtab
->nsyms
)
3803 const char *name
= symtab
->symbols
[toc
->symbol_index
].symbol
.name
;
3804 fprintf (file
, "%s (%lu)", name
? name
: "*invalid*",
3808 fprintf (file
, "%lu", toc
->symbol_index
);
3810 fprintf (file
, " / ");
3811 if (symtab
&& symtab
->strtab
3812 && toc
->module_index
< dysymtab
->nmodtab
)
3814 bfd_mach_o_dylib_module
*mod
;
3815 mod
= &dysymtab
->dylib_module
[toc
->module_index
];
3816 fprintf (file
, "%s (%lu)",
3817 symtab
->strtab
+ mod
->module_name_idx
,
3821 fprintf (file
, "%lu", toc
->module_index
);
3823 fprintf (file
, "\n");
3827 if (dysymtab
->nindirectsyms
!= 0)
3829 fprintf (file
, " indirect symbols:\n");
3831 for (i
= 0; i
< mdata
->nsects
; i
++)
3833 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
3834 unsigned int j
, first
, last
;
3835 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3839 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3841 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3842 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3843 case BFD_MACH_O_S_SYMBOL_STUBS
:
3844 first
= sec
->reserved1
;
3845 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
3847 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
3848 fprintf (file
, " for section %s.%s:\n",
3849 sec
->segname
, sec
->sectname
);
3850 for (j
= first
; j
< last
; j
++)
3852 unsigned int isym
= dysymtab
->indirect_syms
[j
];
3854 fprintf (file
, " ");
3855 fprintf_vma (file
, addr
);
3856 fprintf (file
, " %5u: 0x%08x", j
, isym
);
3857 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_LOCAL
)
3858 fprintf (file
, " LOCAL");
3859 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_ABS
)
3860 fprintf (file
, " ABSOLUTE");
3861 if (symtab
&& symtab
->symbols
3862 && isym
< symtab
->nsyms
3863 && symtab
->symbols
[isym
].symbol
.name
)
3864 fprintf (file
, " %s", symtab
->symbols
[isym
].symbol
.name
);
3865 fprintf (file
, "\n");
3874 if (dysymtab
->nextrefsyms
> 0)
3876 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3878 fprintf (file
, " external reference table: (symbol flags)\n");
3879 for (i
= 0; i
< dysymtab
->nextrefsyms
; i
++)
3881 bfd_mach_o_dylib_reference
*ref
= &dysymtab
->ext_refs
[i
];
3883 fprintf (file
, " %4u: %5lu 0x%02lx", i
, ref
->isym
, ref
->flags
);
3884 if (symtab
&& symtab
->symbols
3885 && ref
->isym
< symtab
->nsyms
3886 && symtab
->symbols
[ref
->isym
].symbol
.name
)
3887 fprintf (file
, " %s", symtab
->symbols
[ref
->isym
].symbol
.name
);
3888 fprintf (file
, "\n");
3895 bfd_mach_o_print_dyld_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3896 bfd_mach_o_load_command
*cmd
, FILE *file
)
3898 bfd_mach_o_dyld_info_command
*info
= &cmd
->command
.dyld_info
;
3900 fprintf (file
, " rebase: off: 0x%08x size: %-8u\n",
3901 info
->rebase_off
, info
->rebase_size
);
3902 fprintf (file
, " bind: off: 0x%08x size: %-8u\n",
3903 info
->bind_off
, info
->bind_size
);
3904 fprintf (file
, " weak bind: off: 0x%08x size: %-8u\n",
3905 info
->weak_bind_off
, info
->weak_bind_size
);
3906 fprintf (file
, " lazy bind: off: 0x%08x size: %-8u\n",
3907 info
->lazy_bind_off
, info
->lazy_bind_size
);
3908 fprintf (file
, " export: off: 0x%08x size: %-8u\n",
3909 info
->export_off
, info
->export_size
);
3913 bfd_mach_o_bfd_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3915 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3916 FILE *file
= (FILE *) ptr
;
3919 bfd_mach_o_print_private_header (abfd
, file
);
3922 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3924 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[i
];
3925 const char *cmd_name
;
3927 cmd_name
= bfd_mach_o_get_name_or_null
3928 (bfd_mach_o_load_command_name
, cmd
->type
);
3929 fprintf (file
, "Load command ");
3930 if (cmd_name
== NULL
)
3931 fprintf (file
, "0x%02x:", cmd
->type
);
3933 fprintf (file
, "%s:", cmd_name
);
3937 case BFD_MACH_O_LC_SEGMENT
:
3938 case BFD_MACH_O_LC_SEGMENT_64
:
3939 bfd_mach_o_print_segment (abfd
, cmd
, file
);
3941 case BFD_MACH_O_LC_UUID
:
3943 bfd_mach_o_uuid_command
*uuid
= &cmd
->command
.uuid
;
3946 for (j
= 0; j
< sizeof (uuid
->uuid
); j
++)
3947 fprintf (file
, " %02x", uuid
->uuid
[j
]);
3951 case BFD_MACH_O_LC_LOAD_DYLIB
:
3952 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3953 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3954 case BFD_MACH_O_LC_ID_DYLIB
:
3956 bfd_mach_o_dylib_command
*dylib
= &cmd
->command
.dylib
;
3957 fprintf (file
, " %s\n", dylib
->name_str
);
3958 fprintf (file
, " time stamp: 0x%08lx\n",
3960 fprintf (file
, " current version: 0x%08lx\n",
3961 dylib
->current_version
);
3962 fprintf (file
, " comptibility version: 0x%08lx\n",
3963 dylib
->compatibility_version
);
3966 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3967 case BFD_MACH_O_LC_ID_DYLINKER
:
3968 fprintf (file
, " %s\n", cmd
->command
.dylinker
.name_str
);
3970 case BFD_MACH_O_LC_SYMTAB
:
3972 bfd_mach_o_symtab_command
*symtab
= &cmd
->command
.symtab
;
3975 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
3976 symtab
->symoff
, symtab
->nsyms
,
3977 symtab
->symoff
+ symtab
->nsyms
3978 * (mach_o_wide_p (&mdata
->header
)
3979 ? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
));
3981 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
3982 symtab
->stroff
, symtab
->strsize
,
3983 symtab
->stroff
+ symtab
->strsize
);
3986 case BFD_MACH_O_LC_DYSYMTAB
:
3987 fprintf (file
, "\n");
3988 bfd_mach_o_print_dysymtab (abfd
, cmd
, file
);
3990 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3991 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3992 case BFD_MACH_O_LC_FUNCTION_STARTS
:
3994 bfd_mach_o_linkedit_command
*linkedit
= &cmd
->command
.linkedit
;
3997 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
3998 linkedit
->dataoff
, linkedit
->datasize
,
3999 linkedit
->dataoff
+ linkedit
->datasize
);
4002 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4003 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4004 case BFD_MACH_O_LC_SUB_LIBRARY
:
4005 case BFD_MACH_O_LC_SUB_CLIENT
:
4006 case BFD_MACH_O_LC_RPATH
:
4008 bfd_mach_o_str_command
*str
= &cmd
->command
.str
;
4009 fprintf (file
, " %s\n", str
->str
);
4012 case BFD_MACH_O_LC_THREAD
:
4013 case BFD_MACH_O_LC_UNIXTHREAD
:
4015 bfd_mach_o_thread_command
*thread
= &cmd
->command
.thread
;
4017 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4019 fprintf (file
, " nflavours: %lu\n", thread
->nflavours
);
4020 for (j
= 0; j
< thread
->nflavours
; j
++)
4022 bfd_mach_o_thread_flavour
*flavour
= &thread
->flavours
[j
];
4024 fprintf (file
, " %2u: flavour: 0x%08lx offset: 0x%08lx"
4026 j
, flavour
->flavour
, flavour
->offset
,
4028 if (bed
->_bfd_mach_o_print_thread
)
4030 char *buf
= bfd_malloc (flavour
->size
);
4033 && bfd_seek (abfd
, flavour
->offset
, SEEK_SET
) == 0
4034 && (bfd_bread (buf
, flavour
->size
, abfd
)
4036 (*bed
->_bfd_mach_o_print_thread
)(abfd
, flavour
,
4043 case BFD_MACH_O_LC_DYLD_INFO
:
4044 fprintf (file
, "\n");
4045 bfd_mach_o_print_dyld_info (abfd
, cmd
, file
);
4047 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4048 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4050 bfd_mach_o_version_min_command
*ver
= &cmd
->command
.version_min
;
4052 fprintf (file
, " %u.%u.%u\n", ver
->rel
, ver
->maj
, ver
->min
);
4056 fprintf (file
, "\n");
4057 fprintf (file
, " offset: 0x%08lx\n", (unsigned long)cmd
->offset
);
4058 fprintf (file
, " size: 0x%08lx\n", (unsigned long)cmd
->len
);
4064 bfd_mach_o_print_section_map (abfd
, file
);
4070 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4071 unsigned char **rbuf
,
4074 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4075 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4078 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4080 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4081 bfd_mach_o_segment_command
*seg
= NULL
;
4083 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4086 seg
= &cur
->command
.segment
;
4088 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4090 unsigned long start
= seg
->fileoff
;
4091 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4092 unsigned char *buf
= bfd_malloc (1024);
4093 unsigned long size
= 1024;
4097 bfd_size_type nread
= 0;
4098 unsigned long offset
;
4099 int found_nonnull
= 0;
4101 if (size
> (end
- start
))
4102 size
= (end
- start
);
4104 buf
= bfd_realloc_or_free (buf
, size
);
4108 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4114 nread
= bfd_bread (buf
, size
, abfd
);
4122 for (offset
= 4; offset
<= size
; offset
+= 4)
4126 val
= *((unsigned long *) (buf
+ size
- offset
));
4127 if (! found_nonnull
)
4132 else if (val
== 0x0)
4134 unsigned long bottom
;
4137 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4138 top
= seg
->fileoff
+ seg
->filesize
- 4;
4139 *rbuf
= bfd_malloc (top
- bottom
);
4140 *rlen
= top
- bottom
;
4142 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4148 if (size
== (end
- start
))
4162 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4164 unsigned char *buf
= NULL
;
4165 unsigned int len
= 0;
4168 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4172 return (char *) buf
;
4176 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4181 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4182 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4184 #define bfd_mach_o_swap_reloc_in NULL
4185 #define bfd_mach_o_swap_reloc_out NULL
4186 #define bfd_mach_o_print_thread NULL
4188 #define TARGET_NAME mach_o_be_vec
4189 #define TARGET_STRING "mach-o-be"
4190 #define TARGET_ARCHITECTURE bfd_arch_unknown
4191 #define TARGET_BIG_ENDIAN 1
4192 #define TARGET_ARCHIVE 0
4193 #include "mach-o-target.c"
4196 #undef TARGET_STRING
4197 #undef TARGET_ARCHITECTURE
4198 #undef TARGET_BIG_ENDIAN
4199 #undef TARGET_ARCHIVE
4201 #define TARGET_NAME mach_o_le_vec
4202 #define TARGET_STRING "mach-o-le"
4203 #define TARGET_ARCHITECTURE bfd_arch_unknown
4204 #define TARGET_BIG_ENDIAN 0
4205 #define TARGET_ARCHIVE 0
4207 #include "mach-o-target.c"
4210 #undef TARGET_STRING
4211 #undef TARGET_ARCHITECTURE
4212 #undef TARGET_BIG_ENDIAN
4213 #undef TARGET_ARCHIVE
4215 /* Not yet handled: creating an archive. */
4216 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4219 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4220 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4221 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4222 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4223 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4224 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4225 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4226 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4227 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4228 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4230 #define TARGET_NAME mach_o_fat_vec
4231 #define TARGET_STRING "mach-o-fat"
4232 #define TARGET_ARCHITECTURE bfd_arch_unknown
4233 #define TARGET_BIG_ENDIAN 1
4234 #define TARGET_ARCHIVE 1
4236 #include "mach-o-target.c"
4239 #undef TARGET_STRING
4240 #undef TARGET_ARCHITECTURE
4241 #undef TARGET_BIG_ENDIAN
4242 #undef TARGET_ARCHIVE