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_UPWARD_DYLIB
:
1298 case BFD_MACH_O_LC_LOAD_DYLINKER
:
1299 case BFD_MACH_O_LC_ID_DYLINKER
:
1300 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
1301 case BFD_MACH_O_LC_ROUTINES
:
1302 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
1305 (*_bfd_error_handler
) (_("unable to write unknown load command 0x%lx"),
1306 (unsigned long) cur
->type
);
1315 bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command
*seg
,
1318 bfd_mach_o_section
*s
= (bfd_mach_o_section
*)sec
->used_by_bfd
;
1319 if (seg
->sect_head
== NULL
)
1322 seg
->sect_tail
->next
= s
;
1326 /* Create section Mach-O flags from BFD flags. */
1329 bfd_mach_o_set_section_flags_from_bfd (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
1332 bfd_mach_o_section
*s
= bfd_mach_o_get_mach_o_section (sec
);
1334 /* Create default flags. */
1335 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1336 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1337 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1338 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1339 | BFD_MACH_O_S_REGULAR
;
1340 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1341 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1342 else if (bfd_flags
& SEC_DEBUGGING
)
1343 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1345 s
->flags
= BFD_MACH_O_S_REGULAR
;
1348 /* Build Mach-O load commands from the sections. */
1351 bfd_mach_o_build_commands (bfd
*abfd
)
1353 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1354 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1355 bfd_mach_o_segment_command
*seg
;
1357 bfd_mach_o_load_command
*cmd
;
1358 bfd_mach_o_load_command
*symtab_cmd
;
1361 /* Return now if commands are already built. */
1362 if (mdata
->header
.ncmds
)
1365 /* Very simple version: a command (segment) to contain all the sections and
1366 a command for the symbol table. */
1367 mdata
->header
.ncmds
= 2;
1368 mdata
->commands
= bfd_alloc (abfd
, mdata
->header
.ncmds
1369 * sizeof (bfd_mach_o_load_command
));
1370 if (mdata
->commands
== NULL
)
1372 cmd
= &mdata
->commands
[0];
1373 seg
= &cmd
->command
.segment
;
1375 seg
->nsects
= bfd_count_sections (abfd
);
1377 /* Set segment command. */
1380 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
1381 cmd
->offset
= BFD_MACH_O_HEADER_64_SIZE
;
1382 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
1383 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
1387 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
1388 cmd
->offset
= BFD_MACH_O_HEADER_SIZE
;
1389 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
1390 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
1392 cmd
->type_required
= FALSE
;
1393 mdata
->header
.sizeofcmds
= cmd
->len
;
1394 mdata
->filelen
= cmd
->offset
+ cmd
->len
;
1396 /* Set symtab command. */
1397 symtab_cmd
= &mdata
->commands
[1];
1399 symtab_cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
1400 symtab_cmd
->offset
= cmd
->offset
+ cmd
->len
;
1401 symtab_cmd
->len
= 6 * 4;
1402 symtab_cmd
->type_required
= FALSE
;
1404 mdata
->header
.sizeofcmds
+= symtab_cmd
->len
;
1405 mdata
->filelen
+= symtab_cmd
->len
;
1407 /* Fill segment command. */
1408 memset (seg
->segname
, 0, sizeof (seg
->segname
));
1410 seg
->fileoff
= mdata
->filelen
;
1412 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
1413 | BFD_MACH_O_PROT_EXECUTE
;
1414 seg
->initprot
= seg
->maxprot
;
1416 seg
->sect_head
= NULL
;
1417 seg
->sect_tail
= NULL
;
1419 /* Create Mach-O sections. */
1421 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1423 bfd_mach_o_section
*msect
= bfd_mach_o_get_mach_o_section (sec
);
1425 bfd_mach_o_append_section_to_segment (seg
, sec
);
1427 if (msect
->flags
== 0)
1429 /* We suppose it hasn't been set. Convert from BFD flags. */
1430 bfd_mach_o_set_section_flags_from_bfd (abfd
, sec
);
1432 msect
->addr
= bfd_get_section_vma (abfd
, sec
);
1433 msect
->size
= bfd_get_section_size (sec
);
1434 msect
->align
= bfd_get_section_alignment (abfd
, sec
);
1436 if (msect
->size
!= 0)
1438 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, msect
->align
);
1439 msect
->offset
= mdata
->filelen
;
1444 sec
->filepos
= msect
->offset
;
1445 sec
->target_index
= ++target_index
;
1447 mdata
->filelen
+= msect
->size
;
1449 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
1450 seg
->vmsize
= seg
->filesize
;
1455 /* Set the contents of a section. */
1458 bfd_mach_o_set_section_contents (bfd
*abfd
,
1460 const void * location
,
1462 bfd_size_type count
)
1466 /* This must be done first, because bfd_set_section_contents is
1467 going to set output_has_begun to TRUE. */
1468 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
1474 pos
= section
->filepos
+ offset
;
1475 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1476 || bfd_bwrite (location
, count
, abfd
) != count
)
1483 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
1484 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1489 /* Make an empty symbol. This is required only because
1490 bfd_make_section_anyway wants to create a symbol for the section. */
1493 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
1495 asymbol
*new_symbol
;
1497 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
1498 if (new_symbol
== NULL
)
1500 new_symbol
->the_bfd
= abfd
;
1501 new_symbol
->udata
.i
= 0;
1506 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1508 struct mach_o_header_external raw
;
1510 bfd_vma (*get32
) (const void *) = NULL
;
1512 /* Just read the magic number. */
1513 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1514 || bfd_bread (raw
.magic
, sizeof (raw
.magic
), abfd
) != 4)
1517 if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
1519 header
->byteorder
= BFD_ENDIAN_BIG
;
1520 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1521 header
->version
= 1;
1524 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC
)
1526 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1527 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1528 header
->version
= 1;
1531 else if (bfd_getb32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
1533 header
->byteorder
= BFD_ENDIAN_BIG
;
1534 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1535 header
->version
= 2;
1538 else if (bfd_getl32 (raw
.magic
) == BFD_MACH_O_MH_MAGIC_64
)
1540 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1541 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1542 header
->version
= 2;
1547 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
1551 /* Once the size of the header is known, read the full header. */
1552 size
= mach_o_wide_p (header
) ?
1553 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1555 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1556 || bfd_bread (&raw
, size
, abfd
) != size
)
1559 header
->cputype
= (*get32
) (raw
.cputype
);
1560 header
->cpusubtype
= (*get32
) (raw
.cpusubtype
);
1561 header
->filetype
= (*get32
) (raw
.filetype
);
1562 header
->ncmds
= (*get32
) (raw
.ncmds
);
1563 header
->sizeofcmds
= (*get32
) (raw
.sizeofcmds
);
1564 header
->flags
= (*get32
) (raw
.flags
);
1566 if (mach_o_wide_p (header
))
1567 header
->reserved
= (*get32
) (raw
.reserved
);
1573 bfd_mach_o_new_section_hook (bfd
*abfd
, asection
*sec
)
1575 bfd_mach_o_section
*s
;
1577 s
= bfd_mach_o_get_mach_o_section (sec
);
1582 s
= (bfd_mach_o_section
*) bfd_zalloc (abfd
, sizeof (*s
));
1585 sec
->used_by_bfd
= s
;
1586 s
->bfdsection
= sec
;
1588 /* Create default name. */
1589 bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, s
);
1591 /* Create default flags. */
1592 bfd_flags
= bfd_get_section_flags (abfd
, sec
);
1593 if ((bfd_flags
& SEC_CODE
) == SEC_CODE
)
1594 s
->flags
= BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
1595 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
1596 | BFD_MACH_O_S_REGULAR
;
1597 else if ((bfd_flags
& (SEC_ALLOC
| SEC_LOAD
)) == SEC_ALLOC
)
1598 s
->flags
= BFD_MACH_O_S_ZEROFILL
;
1599 else if (bfd_flags
& SEC_DEBUGGING
)
1600 s
->flags
= BFD_MACH_O_S_REGULAR
| BFD_MACH_O_S_ATTR_DEBUG
;
1602 s
->flags
= BFD_MACH_O_S_REGULAR
;
1605 return _bfd_generic_new_section_hook (abfd
, sec
);
1609 bfd_mach_o_init_section_from_mach_o (bfd
*abfd
, asection
*sec
,
1613 bfd_mach_o_section
*section
;
1615 flags
= bfd_get_section_flags (abfd
, sec
);
1616 section
= bfd_mach_o_get_mach_o_section (sec
);
1618 if (flags
== SEC_NO_FLAGS
)
1620 /* Try to guess flags. */
1621 if (section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
1622 flags
= SEC_DEBUGGING
;
1626 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1627 != BFD_MACH_O_S_ZEROFILL
)
1630 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
1632 if (prot
& BFD_MACH_O_PROT_WRITE
)
1634 else if (prot
& BFD_MACH_O_PROT_READ
)
1635 flags
|= SEC_READONLY
;
1641 if ((flags
& SEC_DEBUGGING
) == 0)
1645 if (section
->offset
!= 0)
1646 flags
|= SEC_HAS_CONTENTS
;
1647 if (section
->nreloc
!= 0)
1650 bfd_set_section_flags (abfd
, sec
, flags
);
1652 sec
->vma
= section
->addr
;
1653 sec
->lma
= section
->addr
;
1654 sec
->size
= section
->size
;
1655 sec
->filepos
= section
->offset
;
1656 sec
->alignment_power
= section
->align
;
1657 sec
->segment_mark
= 0;
1658 sec
->reloc_count
= section
->nreloc
;
1659 sec
->rel_filepos
= section
->reloff
;
1663 bfd_mach_o_make_bfd_section (bfd
*abfd
,
1664 const unsigned char *segname
,
1665 const unsigned char *sectname
)
1670 bfd_mach_o_convert_section_name_to_bfd
1671 (abfd
, (const char *)segname
, (const char *)sectname
, &sname
, &flags
);
1675 return bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
1679 bfd_mach_o_read_section_32 (bfd
*abfd
,
1680 unsigned int offset
,
1683 struct mach_o_section_32_external raw
;
1685 bfd_mach_o_section
*section
;
1687 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1688 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1689 != BFD_MACH_O_SECTION_SIZE
))
1692 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
1696 section
= bfd_mach_o_get_mach_o_section (sec
);
1697 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
1698 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
1699 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
1700 section
->segname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
1701 section
->addr
= bfd_h_get_32 (abfd
, raw
.addr
);
1702 section
->size
= bfd_h_get_32 (abfd
, raw
.size
);
1703 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
1704 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
1705 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
1706 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
1707 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
1708 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
1709 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
1710 section
->reserved3
= 0;
1712 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
1718 bfd_mach_o_read_section_64 (bfd
*abfd
,
1719 unsigned int offset
,
1722 struct mach_o_section_64_external raw
;
1724 bfd_mach_o_section
*section
;
1726 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1727 || (bfd_bread (&raw
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1728 != BFD_MACH_O_SECTION_64_SIZE
))
1731 sec
= bfd_mach_o_make_bfd_section (abfd
, raw
.segname
, raw
.sectname
);
1735 section
= bfd_mach_o_get_mach_o_section (sec
);
1736 memcpy (section
->segname
, raw
.segname
, sizeof (raw
.segname
));
1737 section
->segname
[BFD_MACH_O_SEGNAME_SIZE
] = 0;
1738 memcpy (section
->sectname
, raw
.sectname
, sizeof (raw
.sectname
));
1739 section
->segname
[BFD_MACH_O_SECTNAME_SIZE
] = 0;
1740 section
->addr
= bfd_h_get_64 (abfd
, raw
.addr
);
1741 section
->size
= bfd_h_get_64 (abfd
, raw
.size
);
1742 section
->offset
= bfd_h_get_32 (abfd
, raw
.offset
);
1743 section
->align
= bfd_h_get_32 (abfd
, raw
.align
);
1744 section
->reloff
= bfd_h_get_32 (abfd
, raw
.reloff
);
1745 section
->nreloc
= bfd_h_get_32 (abfd
, raw
.nreloc
);
1746 section
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
1747 section
->reserved1
= bfd_h_get_32 (abfd
, raw
.reserved1
);
1748 section
->reserved2
= bfd_h_get_32 (abfd
, raw
.reserved2
);
1749 section
->reserved3
= bfd_h_get_32 (abfd
, raw
.reserved3
);
1751 bfd_mach_o_init_section_from_mach_o (abfd
, sec
, prot
);
1757 bfd_mach_o_read_section (bfd
*abfd
,
1758 unsigned int offset
,
1763 return bfd_mach_o_read_section_64 (abfd
, offset
, prot
);
1765 return bfd_mach_o_read_section_32 (abfd
, offset
, prot
);
1769 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
1770 bfd_mach_o_symtab_command
*sym
,
1771 bfd_mach_o_asymbol
*s
,
1774 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1775 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1776 unsigned int symwidth
=
1777 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1778 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
1779 struct mach_o_nlist_64_external raw
;
1780 unsigned char type
= -1;
1781 unsigned char section
= -1;
1783 symvalue value
= -1;
1784 unsigned long stroff
= -1;
1785 unsigned int symtype
= -1;
1787 BFD_ASSERT (sym
->strtab
!= NULL
);
1789 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
1790 || bfd_bread (&raw
, symwidth
, abfd
) != symwidth
)
1792 (*_bfd_error_handler
)
1793 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
1794 symwidth
, (unsigned long) symoff
);
1798 stroff
= bfd_h_get_32 (abfd
, raw
.n_strx
);
1799 type
= bfd_h_get_8 (abfd
, raw
.n_type
);
1800 symtype
= type
& BFD_MACH_O_N_TYPE
;
1801 section
= bfd_h_get_8 (abfd
, raw
.n_sect
);
1802 desc
= bfd_h_get_16 (abfd
, raw
.n_desc
);
1804 value
= bfd_h_get_64 (abfd
, raw
.n_value
);
1806 value
= bfd_h_get_32 (abfd
, raw
.n_value
);
1808 if (stroff
>= sym
->strsize
)
1810 (*_bfd_error_handler
)
1811 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
1812 (unsigned long) stroff
,
1813 (unsigned long) sym
->strsize
);
1817 s
->symbol
.the_bfd
= abfd
;
1818 s
->symbol
.name
= sym
->strtab
+ stroff
;
1819 s
->symbol
.value
= value
;
1820 s
->symbol
.flags
= 0x0;
1821 s
->symbol
.udata
.i
= 0;
1823 s
->n_sect
= section
;
1826 if (type
& BFD_MACH_O_N_STAB
)
1828 s
->symbol
.flags
|= BSF_DEBUGGING
;
1829 s
->symbol
.section
= bfd_und_section_ptr
;
1841 if ((section
> 0) && (section
<= mdata
->nsects
))
1843 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1845 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1852 if (type
& BFD_MACH_O_N_PEXT
)
1853 s
->symbol
.flags
|= BSF_GLOBAL
;
1855 if (type
& BFD_MACH_O_N_EXT
)
1856 s
->symbol
.flags
|= BSF_GLOBAL
;
1858 if (!(type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
)))
1859 s
->symbol
.flags
|= BSF_LOCAL
;
1863 case BFD_MACH_O_N_UNDF
:
1864 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
1865 && s
->symbol
.value
!= 0)
1867 /* A common symbol. */
1868 s
->symbol
.section
= bfd_com_section_ptr
;
1869 s
->symbol
.flags
= BSF_NO_FLAGS
;
1873 s
->symbol
.section
= bfd_und_section_ptr
;
1874 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
1875 s
->symbol
.flags
|= BSF_WEAK
;
1878 case BFD_MACH_O_N_PBUD
:
1879 s
->symbol
.section
= bfd_und_section_ptr
;
1881 case BFD_MACH_O_N_ABS
:
1882 s
->symbol
.section
= bfd_abs_section_ptr
;
1884 case BFD_MACH_O_N_SECT
:
1885 if ((section
> 0) && (section
<= mdata
->nsects
))
1887 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1889 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1893 /* Mach-O uses 0 to mean "no section"; not an error. */
1896 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1897 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
1898 s
->symbol
.name
, section
, mdata
->nsects
);
1900 s
->symbol
.section
= bfd_und_section_ptr
;
1903 case BFD_MACH_O_N_INDR
:
1904 /* FIXME: we don't follow the BFD convention as this indirect symbol
1905 won't be followed by the referenced one. This looks harmless
1906 unless we start using the linker. */
1907 s
->symbol
.flags
|= BSF_INDIRECT
;
1908 s
->symbol
.section
= bfd_ind_section_ptr
;
1909 s
->symbol
.value
= 0;
1912 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbol: "
1913 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
1914 s
->symbol
.name
, symtype
);
1915 s
->symbol
.section
= bfd_und_section_ptr
;
1924 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
1926 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1927 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1929 /* Fail if there is no symtab. */
1933 /* Success if already loaded. */
1937 if (abfd
->flags
& BFD_IN_MEMORY
)
1939 struct bfd_in_memory
*b
;
1941 b
= (struct bfd_in_memory
*) abfd
->iostream
;
1943 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
1945 bfd_set_error (bfd_error_file_truncated
);
1948 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
1952 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
1953 if (sym
->strtab
== NULL
)
1956 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
1957 || bfd_bread ((void *) sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
1959 bfd_set_error (bfd_error_file_truncated
);
1968 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
1970 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1971 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1975 if (sym
== NULL
|| sym
->symbols
)
1977 /* Return now if there are no symbols or if already loaded. */
1981 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
1983 if (sym
->symbols
== NULL
)
1985 (*_bfd_error_handler
) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
1989 ret
= bfd_mach_o_read_symtab_strtab (abfd
);
1993 for (i
= 0; i
< sym
->nsyms
; i
++)
1995 ret
= bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
);
2004 bfd_mach_o_read_dysymtab_symbol (bfd
*abfd
,
2005 bfd_mach_o_dysymtab_command
*dysym
,
2006 bfd_mach_o_symtab_command
*sym
,
2007 bfd_mach_o_asymbol
*s
,
2010 unsigned long isymoff
= dysym
->indirectsymoff
+ (i
* 4);
2011 unsigned long sym_index
;
2012 unsigned char raw
[4];
2014 BFD_ASSERT (i
< dysym
->nindirectsyms
);
2016 if (bfd_seek (abfd
, isymoff
, SEEK_SET
) != 0
2017 || bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2019 (*_bfd_error_handler
)
2020 (_("bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu"),
2021 (unsigned long) sizeof (raw
), isymoff
);
2024 sym_index
= bfd_h_get_32 (abfd
, raw
);
2026 return bfd_mach_o_read_symtab_symbol (abfd
, sym
, s
, sym_index
);
2030 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
2032 switch ((int) flavour
)
2034 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
2035 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
2036 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
2037 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
2038 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
2039 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
2040 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
2041 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
2042 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
2043 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
2044 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
2045 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
2046 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
2047 default: return "UNKNOWN";
2052 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
2054 switch ((int) flavour
)
2056 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
2057 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
2058 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
2059 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
2060 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
2061 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
2062 default: return "UNKNOWN";
2067 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2069 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
2070 struct mach_o_str_command_external raw
;
2071 unsigned int nameoff
;
2073 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
2074 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
2076 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2077 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2080 nameoff
= bfd_h_get_32 (abfd
, raw
.str
);
2082 cmd
->name_offset
= command
->offset
+ nameoff
;
2083 cmd
->name_len
= command
->len
- nameoff
;
2084 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2085 if (cmd
->name_str
== NULL
)
2087 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2088 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2094 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2096 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
2097 struct mach_o_dylib_command_external raw
;
2098 unsigned int nameoff
;
2100 switch (command
->type
)
2102 case BFD_MACH_O_LC_LOAD_DYLIB
:
2103 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2104 case BFD_MACH_O_LC_ID_DYLIB
:
2105 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2106 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
2113 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2114 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2117 nameoff
= bfd_h_get_32 (abfd
, raw
.name
);
2118 cmd
->timestamp
= bfd_h_get_32 (abfd
, raw
.timestamp
);
2119 cmd
->current_version
= bfd_h_get_32 (abfd
, raw
.current_version
);
2120 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, raw
.compatibility_version
);
2122 cmd
->name_offset
= command
->offset
+ nameoff
;
2123 cmd
->name_len
= command
->len
- nameoff
;
2124 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
2125 if (cmd
->name_str
== NULL
)
2127 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
2128 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
2134 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
2135 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
2137 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2139 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
2144 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2146 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2147 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
2148 unsigned int offset
;
2149 unsigned int nflavours
;
2152 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
2153 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
2155 /* Count the number of threads. */
2158 while (offset
!= command
->len
)
2160 struct mach_o_thread_command_external raw
;
2162 if (offset
>= command
->len
)
2165 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2166 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2169 offset
+= sizeof (raw
) + bfd_h_get_32 (abfd
, raw
.count
) * 4;
2173 /* Allocate threads. */
2174 cmd
->flavours
= bfd_alloc
2175 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
2176 if (cmd
->flavours
== NULL
)
2178 cmd
->nflavours
= nflavours
;
2182 while (offset
!= command
->len
)
2184 struct mach_o_thread_command_external raw
;
2186 if (offset
>= command
->len
)
2189 if (nflavours
>= cmd
->nflavours
)
2192 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2193 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2196 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, raw
.flavour
);
2197 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ sizeof (raw
);
2198 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, raw
.count
) * 4;
2199 offset
+= cmd
->flavours
[nflavours
].size
+ sizeof (raw
);
2203 for (i
= 0; i
< nflavours
; i
++)
2206 unsigned int snamelen
;
2208 const char *flavourstr
;
2209 const char *prefix
= "LC_THREAD";
2212 switch (mdata
->header
.cputype
)
2214 case BFD_MACH_O_CPU_TYPE_POWERPC
:
2215 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
2216 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
2218 case BFD_MACH_O_CPU_TYPE_I386
:
2219 case BFD_MACH_O_CPU_TYPE_X86_64
:
2220 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
2223 flavourstr
= "UNKNOWN_ARCHITECTURE";
2227 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
2228 sname
= bfd_alloc (abfd
, snamelen
);
2234 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
2235 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
2240 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
2244 bfdsec
->size
= cmd
->flavours
[i
].size
;
2245 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
2246 bfdsec
->alignment_power
= 0x0;
2248 cmd
->section
= bfdsec
;
2255 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2257 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2258 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2260 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2263 struct mach_o_dysymtab_command_external raw
;
2265 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2266 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2269 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, raw
.ilocalsym
);
2270 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, raw
.nlocalsym
);
2271 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, raw
.iextdefsym
);
2272 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, raw
.nextdefsym
);
2273 cmd
->iundefsym
= bfd_h_get_32 (abfd
, raw
.iundefsym
);
2274 cmd
->nundefsym
= bfd_h_get_32 (abfd
, raw
.nundefsym
);
2275 cmd
->tocoff
= bfd_h_get_32 (abfd
, raw
.tocoff
);
2276 cmd
->ntoc
= bfd_h_get_32 (abfd
, raw
.ntoc
);
2277 cmd
->modtaboff
= bfd_h_get_32 (abfd
, raw
.modtaboff
);
2278 cmd
->nmodtab
= bfd_h_get_32 (abfd
, raw
.nmodtab
);
2279 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, raw
.extrefsymoff
);
2280 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, raw
.nextrefsyms
);
2281 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, raw
.indirectsymoff
);
2282 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, raw
.nindirectsyms
);
2283 cmd
->extreloff
= bfd_h_get_32 (abfd
, raw
.extreloff
);
2284 cmd
->nextrel
= bfd_h_get_32 (abfd
, raw
.nextrel
);
2285 cmd
->locreloff
= bfd_h_get_32 (abfd
, raw
.locreloff
);
2286 cmd
->nlocrel
= bfd_h_get_32 (abfd
, raw
.nlocrel
);
2289 if (cmd
->nmodtab
!= 0)
2292 int wide
= bfd_mach_o_wide_p (abfd
);
2293 unsigned int module_len
= wide
? 56 : 52;
2296 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
2297 if (cmd
->dylib_module
== NULL
)
2300 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2303 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2305 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2307 unsigned char buf
[56];
2309 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
2312 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
2313 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
2314 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
2315 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
2316 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
2317 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
2318 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
2319 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
2320 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
2321 v
= bfd_h_get_32 (abfd
, buf
+36);
2322 module
->iinit
= v
& 0xffff;
2323 module
->iterm
= (v
>> 16) & 0xffff;
2324 v
= bfd_h_get_32 (abfd
, buf
+ 40);
2325 module
->ninit
= v
& 0xffff;
2326 module
->nterm
= (v
>> 16) & 0xffff;
2329 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
2330 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
2334 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
2335 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
2344 cmd
->dylib_toc
= bfd_alloc
2345 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
2346 if (cmd
->dylib_toc
== NULL
)
2349 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2352 for (i
= 0; i
< cmd
->ntoc
; i
++)
2354 struct mach_o_dylib_table_of_contents_external raw
;
2355 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2357 if (bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2360 toc
->symbol_index
= bfd_h_get_32 (abfd
, raw
.symbol_index
);
2361 toc
->module_index
= bfd_h_get_32 (abfd
, raw
.module_index
);
2365 if (cmd
->nindirectsyms
!= 0)
2369 cmd
->indirect_syms
= bfd_alloc
2370 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
2371 if (cmd
->indirect_syms
== NULL
)
2374 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2377 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
2379 unsigned char raw
[4];
2380 unsigned int *is
= &cmd
->indirect_syms
[i
];
2382 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2385 *is
= bfd_h_get_32 (abfd
, raw
);
2389 if (cmd
->nextrefsyms
!= 0)
2394 cmd
->ext_refs
= bfd_alloc
2395 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
2396 if (cmd
->ext_refs
== NULL
)
2399 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2402 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2404 unsigned char raw
[4];
2405 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2407 if (bfd_bread (raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2410 /* Fields isym and flags are written as bit-fields, thus we need
2411 a specific processing for endianness. */
2412 v
= bfd_h_get_32 (abfd
, raw
);
2413 if (bfd_big_endian (abfd
))
2415 ref
->isym
= (v
>> 8) & 0xffffff;
2416 ref
->flags
= v
& 0xff;
2420 ref
->isym
= v
& 0xffffff;
2421 ref
->flags
= (v
>> 24) & 0xff;
2426 if (mdata
->dysymtab
)
2428 mdata
->dysymtab
= cmd
;
2434 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2436 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
2437 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2438 struct mach_o_symtab_command_external raw
;
2440 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2442 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2443 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2446 symtab
->symoff
= bfd_h_get_32 (abfd
, raw
.symoff
);
2447 symtab
->nsyms
= bfd_h_get_32 (abfd
, raw
.nsyms
);
2448 symtab
->stroff
= bfd_h_get_32 (abfd
, raw
.stroff
);
2449 symtab
->strsize
= bfd_h_get_32 (abfd
, raw
.strsize
);
2450 symtab
->symbols
= NULL
;
2451 symtab
->strtab
= NULL
;
2453 if (symtab
->nsyms
!= 0)
2454 abfd
->flags
|= HAS_SYMS
;
2458 mdata
->symtab
= symtab
;
2463 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2465 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
2467 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
2469 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2470 || bfd_bread (cmd
->uuid
, 16, abfd
) != 16)
2477 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2479 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
2480 struct mach_o_linkedit_data_command_external raw
;
2482 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2483 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2486 cmd
->dataoff
= bfd_get_32 (abfd
, raw
.dataoff
);
2487 cmd
->datasize
= bfd_get_32 (abfd
, raw
.datasize
);
2492 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2494 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
2495 struct mach_o_str_command_external raw
;
2498 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2499 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2502 off
= bfd_get_32 (abfd
, raw
.str
);
2503 cmd
->stroff
= command
->offset
+ off
;
2504 cmd
->str_len
= command
->len
- off
;
2505 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
2506 if (cmd
->str
== NULL
)
2508 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
2509 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
2515 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2517 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
2518 struct mach_o_dyld_info_command_external raw
;
2520 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2521 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2524 cmd
->rebase_off
= bfd_get_32 (abfd
, raw
.rebase_off
);
2525 cmd
->rebase_size
= bfd_get_32 (abfd
, raw
.rebase_size
);
2526 cmd
->bind_off
= bfd_get_32 (abfd
, raw
.bind_off
);
2527 cmd
->bind_size
= bfd_get_32 (abfd
, raw
.bind_size
);
2528 cmd
->weak_bind_off
= bfd_get_32 (abfd
, raw
.weak_bind_off
);
2529 cmd
->weak_bind_size
= bfd_get_32 (abfd
, raw
.weak_bind_size
);
2530 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, raw
.lazy_bind_off
);
2531 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, raw
.lazy_bind_size
);
2532 cmd
->export_off
= bfd_get_32 (abfd
, raw
.export_off
);
2533 cmd
->export_size
= bfd_get_32 (abfd
, raw
.export_size
);
2538 bfd_mach_o_read_version_min (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2540 bfd_mach_o_version_min_command
*cmd
= &command
->command
.version_min
;
2541 struct mach_o_version_min_command_external raw
;
2544 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2545 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2548 ver
= bfd_get_32 (abfd
, raw
.version
);
2549 cmd
->rel
= ver
>> 16;
2550 cmd
->maj
= ver
>> 8;
2552 cmd
->reserved
= bfd_get_32 (abfd
, raw
.reserved
);
2557 bfd_mach_o_read_segment (bfd
*abfd
,
2558 bfd_mach_o_load_command
*command
,
2561 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
2566 struct mach_o_segment_command_64_external raw
;
2568 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
2570 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2571 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2574 memcpy (seg
->segname
, raw
.segname
, 16);
2575 seg
->segname
[16] = '\0';
2577 seg
->vmaddr
= bfd_h_get_64 (abfd
, raw
.vmaddr
);
2578 seg
->vmsize
= bfd_h_get_64 (abfd
, raw
.vmsize
);
2579 seg
->fileoff
= bfd_h_get_64 (abfd
, raw
.fileoff
);
2580 seg
->filesize
= bfd_h_get_64 (abfd
, raw
.filesize
);
2581 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
2582 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
2583 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
2584 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2588 struct mach_o_segment_command_32_external raw
;
2590 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
2592 if (bfd_seek (abfd
, command
->offset
+ BFD_MACH_O_LC_SIZE
, SEEK_SET
) != 0
2593 || bfd_bread (&raw
, sizeof (raw
), abfd
) != sizeof (raw
))
2596 memcpy (seg
->segname
, raw
.segname
, 16);
2597 seg
->segname
[16] = '\0';
2599 seg
->vmaddr
= bfd_h_get_32 (abfd
, raw
.vmaddr
);
2600 seg
->vmsize
= bfd_h_get_32 (abfd
, raw
.vmsize
);
2601 seg
->fileoff
= bfd_h_get_32 (abfd
, raw
.fileoff
);
2602 seg
->filesize
= bfd_h_get_32 (abfd
, raw
.filesize
);
2603 seg
->maxprot
= bfd_h_get_32 (abfd
, raw
.maxprot
);
2604 seg
->initprot
= bfd_h_get_32 (abfd
, raw
.initprot
);
2605 seg
->nsects
= bfd_h_get_32 (abfd
, raw
.nsects
);
2606 seg
->flags
= bfd_h_get_32 (abfd
, raw
.flags
);
2608 seg
->sect_head
= NULL
;
2609 seg
->sect_tail
= NULL
;
2611 for (i
= 0; i
< seg
->nsects
; i
++)
2617 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
2618 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
2620 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
2621 + (i
* BFD_MACH_O_SECTION_SIZE
);
2623 sec
= bfd_mach_o_read_section (abfd
, segoff
, seg
->initprot
, wide
);
2627 bfd_mach_o_append_section_to_segment (seg
, sec
);
2634 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2636 return bfd_mach_o_read_segment (abfd
, command
, 0);
2640 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2642 return bfd_mach_o_read_segment (abfd
, command
, 1);
2646 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2648 struct mach_o_load_command_external raw
;
2651 /* Read command type and length. */
2652 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
2653 || bfd_bread (&raw
, BFD_MACH_O_LC_SIZE
, abfd
) != BFD_MACH_O_LC_SIZE
)
2656 cmd
= bfd_h_get_32 (abfd
, raw
.cmd
);
2657 command
->type
= cmd
& ~BFD_MACH_O_LC_REQ_DYLD
;
2658 command
->type_required
= cmd
& BFD_MACH_O_LC_REQ_DYLD
? TRUE
: FALSE
;
2659 command
->len
= bfd_h_get_32 (abfd
, raw
.cmdsize
);
2661 switch (command
->type
)
2663 case BFD_MACH_O_LC_SEGMENT
:
2664 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
2667 case BFD_MACH_O_LC_SEGMENT_64
:
2668 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
2671 case BFD_MACH_O_LC_SYMTAB
:
2672 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
2675 case BFD_MACH_O_LC_SYMSEG
:
2677 case BFD_MACH_O_LC_THREAD
:
2678 case BFD_MACH_O_LC_UNIXTHREAD
:
2679 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
2682 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2683 case BFD_MACH_O_LC_ID_DYLINKER
:
2684 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
2687 case BFD_MACH_O_LC_LOAD_DYLIB
:
2688 case BFD_MACH_O_LC_ID_DYLIB
:
2689 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2690 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2691 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
2692 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
2695 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
2696 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
2699 case BFD_MACH_O_LC_LOADFVMLIB
:
2700 case BFD_MACH_O_LC_IDFVMLIB
:
2701 case BFD_MACH_O_LC_IDENT
:
2702 case BFD_MACH_O_LC_FVMFILE
:
2703 case BFD_MACH_O_LC_PREPAGE
:
2704 case BFD_MACH_O_LC_ROUTINES
:
2705 case BFD_MACH_O_LC_ROUTINES_64
:
2707 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
2708 case BFD_MACH_O_LC_SUB_UMBRELLA
:
2709 case BFD_MACH_O_LC_SUB_LIBRARY
:
2710 case BFD_MACH_O_LC_SUB_CLIENT
:
2711 case BFD_MACH_O_LC_RPATH
:
2712 if (bfd_mach_o_read_str (abfd
, command
) != 0)
2715 case BFD_MACH_O_LC_DYSYMTAB
:
2716 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
2719 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
2720 case BFD_MACH_O_LC_PREBIND_CKSUM
:
2722 case BFD_MACH_O_LC_UUID
:
2723 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
2726 case BFD_MACH_O_LC_CODE_SIGNATURE
:
2727 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
2728 case BFD_MACH_O_LC_FUNCTION_STARTS
:
2729 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
2732 case BFD_MACH_O_LC_DYLD_INFO
:
2733 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
2736 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
2737 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
2738 if (!bfd_mach_o_read_version_min (abfd
, command
))
2742 (*_bfd_error_handler
)(_("%B: unable to read unknown load command 0x%lx"),
2743 abfd
, (unsigned long) command
->type
);
2751 bfd_mach_o_flatten_sections (bfd
*abfd
)
2753 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2757 /* Count total number of sections. */
2760 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2762 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2763 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2765 bfd_mach_o_segment_command
*seg
;
2767 seg
= &mdata
->commands
[i
].command
.segment
;
2768 mdata
->nsects
+= seg
->nsects
;
2772 /* Allocate sections array. */
2773 mdata
->sections
= bfd_alloc (abfd
,
2774 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2776 /* Fill the array. */
2779 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2781 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2782 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2784 bfd_mach_o_segment_command
*seg
;
2785 bfd_mach_o_section
*sec
;
2787 seg
= &mdata
->commands
[i
].command
.segment
;
2788 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
2790 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
2791 mdata
->sections
[csect
++] = sec
;
2797 bfd_mach_o_scan_start_address (bfd
*abfd
)
2799 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2800 bfd_mach_o_thread_command
*cmd
= NULL
;
2803 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2805 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
2806 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
2809 cmd
= &mdata
->commands
[i
].command
.thread
;
2818 for (i
= 0; i
< cmd
->nflavours
; i
++)
2820 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
2821 && (cmd
->flavours
[i
].flavour
2822 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
2824 unsigned char buf
[4];
2826 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
2827 || bfd_bread (buf
, 4, abfd
) != 4)
2830 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2832 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
2833 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
2835 unsigned char buf
[4];
2837 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2838 || bfd_bread (buf
, 4, abfd
) != 4)
2841 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2843 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
2844 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
2846 unsigned char buf
[8];
2848 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2849 || bfd_bread (buf
, 8, abfd
) != 8)
2852 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2854 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
2855 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
2857 unsigned char buf
[8];
2859 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
2860 || bfd_bread (buf
, 8, abfd
) != 8)
2863 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2871 bfd_mach_o_set_arch_mach (bfd
*abfd
,
2872 enum bfd_architecture arch
,
2873 unsigned long machine
)
2875 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
2877 /* If this isn't the right architecture for this backend, and this
2878 isn't the generic backend, fail. */
2879 if (arch
!= bed
->arch
2880 && arch
!= bfd_arch_unknown
2881 && bed
->arch
!= bfd_arch_unknown
)
2884 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
2888 bfd_mach_o_scan (bfd
*abfd
,
2889 bfd_mach_o_header
*header
,
2890 bfd_mach_o_data_struct
*mdata
)
2893 enum bfd_architecture cputype
;
2894 unsigned long cpusubtype
;
2895 unsigned int hdrsize
;
2897 hdrsize
= mach_o_wide_p (header
) ?
2898 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2900 mdata
->header
= *header
;
2902 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
2903 switch (header
->filetype
)
2905 case BFD_MACH_O_MH_OBJECT
:
2906 abfd
->flags
|= HAS_RELOC
;
2908 case BFD_MACH_O_MH_EXECUTE
:
2909 abfd
->flags
|= EXEC_P
;
2911 case BFD_MACH_O_MH_DYLIB
:
2912 case BFD_MACH_O_MH_BUNDLE
:
2913 abfd
->flags
|= DYNAMIC
;
2917 abfd
->tdata
.mach_o_data
= mdata
;
2919 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
2920 &cputype
, &cpusubtype
);
2921 if (cputype
== bfd_arch_unknown
)
2923 (*_bfd_error_handler
) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
2924 header
->cputype
, header
->cpusubtype
);
2928 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
2930 if (header
->ncmds
!= 0)
2932 mdata
->commands
= bfd_alloc
2933 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
2934 if (mdata
->commands
== NULL
)
2937 for (i
= 0; i
< header
->ncmds
; i
++)
2939 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
2942 cur
->offset
= hdrsize
;
2945 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
2946 cur
->offset
= prev
->offset
+ prev
->len
;
2949 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
2954 if (bfd_mach_o_scan_start_address (abfd
) < 0)
2957 bfd_mach_o_flatten_sections (abfd
);
2962 bfd_mach_o_mkobject_init (bfd
*abfd
)
2964 bfd_mach_o_data_struct
*mdata
= NULL
;
2966 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
2969 abfd
->tdata
.mach_o_data
= mdata
;
2971 mdata
->header
.magic
= 0;
2972 mdata
->header
.cputype
= 0;
2973 mdata
->header
.cpusubtype
= 0;
2974 mdata
->header
.filetype
= 0;
2975 mdata
->header
.ncmds
= 0;
2976 mdata
->header
.sizeofcmds
= 0;
2977 mdata
->header
.flags
= 0;
2978 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
2979 mdata
->commands
= NULL
;
2981 mdata
->sections
= NULL
;
2987 bfd_mach_o_gen_mkobject (bfd
*abfd
)
2989 bfd_mach_o_data_struct
*mdata
;
2991 if (!bfd_mach_o_mkobject_init (abfd
))
2994 mdata
= bfd_mach_o_get_data (abfd
);
2995 mdata
->header
.magic
= BFD_MACH_O_MH_MAGIC
;
2996 mdata
->header
.cputype
= 0;
2997 mdata
->header
.cpusubtype
= 0;
2998 mdata
->header
.byteorder
= abfd
->xvec
->byteorder
;
2999 mdata
->header
.version
= 1;
3005 bfd_mach_o_header_p (bfd
*abfd
,
3006 bfd_mach_o_filetype filetype
,
3007 bfd_mach_o_cpu_type cputype
)
3009 struct bfd_preserve preserve
;
3010 bfd_mach_o_header header
;
3012 preserve
.marker
= NULL
;
3013 if (!bfd_mach_o_read_header (abfd
, &header
))
3016 if (! (header
.byteorder
== BFD_ENDIAN_BIG
3017 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
3019 (*_bfd_error_handler
) (_("unknown header byte-order value 0x%lx"),
3020 (unsigned long) header
.byteorder
);
3024 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
3025 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
3026 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
3027 || (header
.byteorder
== BFD_ENDIAN_LITTLE
3028 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
3029 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
3032 /* Check cputype and filetype.
3033 In case of wildcard, do not accept magics that are handled by existing
3037 if (header
.cputype
!= cputype
)
3042 switch (header
.cputype
)
3044 case BFD_MACH_O_CPU_TYPE_I386
:
3045 /* Handled by mach-o-i386 */
3053 if (header
.filetype
!= filetype
)
3058 switch (header
.filetype
)
3060 case BFD_MACH_O_MH_CORE
:
3061 /* Handled by core_p */
3068 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
3069 if (preserve
.marker
== NULL
3070 || !bfd_preserve_save (abfd
, &preserve
))
3073 if (bfd_mach_o_scan (abfd
, &header
,
3074 (bfd_mach_o_data_struct
*) preserve
.marker
) != 0)
3077 bfd_preserve_finish (abfd
, &preserve
);
3081 bfd_set_error (bfd_error_wrong_format
);
3084 if (preserve
.marker
!= NULL
)
3085 bfd_preserve_restore (abfd
, &preserve
);
3089 static const bfd_target
*
3090 bfd_mach_o_gen_object_p (bfd
*abfd
)
3092 return bfd_mach_o_header_p (abfd
, 0, 0);
3095 static const bfd_target
*
3096 bfd_mach_o_gen_core_p (bfd
*abfd
)
3098 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
3101 typedef struct mach_o_fat_archentry
3103 unsigned long cputype
;
3104 unsigned long cpusubtype
;
3105 unsigned long offset
;
3107 unsigned long align
;
3108 } mach_o_fat_archentry
;
3110 typedef struct mach_o_fat_data_struct
3112 unsigned long magic
;
3113 unsigned long nfat_arch
;
3114 mach_o_fat_archentry
*archentries
;
3115 } mach_o_fat_data_struct
;
3118 bfd_mach_o_archive_p (bfd
*abfd
)
3120 mach_o_fat_data_struct
*adata
= NULL
;
3121 struct mach_o_fat_header_external hdr
;
3124 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
3125 || bfd_bread (&hdr
, sizeof (hdr
), abfd
) != sizeof (hdr
))
3128 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
3132 adata
->magic
= bfd_getb32 (hdr
.magic
);
3133 adata
->nfat_arch
= bfd_getb32 (hdr
.nfat_arch
);
3134 if (adata
->magic
!= 0xcafebabe)
3136 /* Avoid matching Java bytecode files, which have the same magic number.
3137 In the Java bytecode file format this field contains the JVM version,
3138 which starts at 43.0. */
3139 if (adata
->nfat_arch
> 30)
3142 adata
->archentries
=
3143 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
3144 if (adata
->archentries
== NULL
)
3147 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3149 struct mach_o_fat_arch_external arch
;
3150 if (bfd_bread (&arch
, sizeof (arch
), abfd
) != sizeof (arch
))
3152 adata
->archentries
[i
].cputype
= bfd_getb32 (arch
.cputype
);
3153 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (arch
.cpusubtype
);
3154 adata
->archentries
[i
].offset
= bfd_getb32 (arch
.offset
);
3155 adata
->archentries
[i
].size
= bfd_getb32 (arch
.size
);
3156 adata
->archentries
[i
].align
= bfd_getb32 (arch
.align
);
3159 abfd
->tdata
.mach_o_fat_data
= adata
;
3164 bfd_release (abfd
, adata
);
3165 bfd_set_error (bfd_error_wrong_format
);
3170 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
3172 mach_o_fat_data_struct
*adata
;
3173 mach_o_fat_archentry
*entry
= NULL
;
3176 enum bfd_architecture arch_type
;
3177 unsigned long arch_subtype
;
3179 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
3180 BFD_ASSERT (adata
!= NULL
);
3182 /* Find index of previous entry. */
3184 i
= 0; /* Start at first one. */
3187 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3189 if (adata
->archentries
[i
].offset
== prev
->origin
)
3193 if (i
== adata
->nfat_arch
)
3196 bfd_set_error (bfd_error_bad_value
);
3199 i
++; /* Get next entry. */
3202 if (i
>= adata
->nfat_arch
)
3204 bfd_set_error (bfd_error_no_more_archived_files
);
3208 entry
= &adata
->archentries
[i
];
3209 nbfd
= _bfd_new_bfd_contained_in (archive
);
3213 nbfd
->origin
= entry
->offset
;
3215 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
3216 &arch_type
, &arch_subtype
);
3218 /* Create the member filename. Use ARCH_NAME. */
3219 nbfd
->filename
= bfd_printable_arch_mach (arch_type
, arch_subtype
);
3220 nbfd
->iostream
= NULL
;
3221 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
3226 /* If ABFD format is FORMAT and architecture is ARCH, return it.
3227 If ABFD is a fat image containing a member that corresponds to FORMAT
3228 and ARCH, returns it.
3229 In other case, returns NULL.
3230 This function allows transparent uses of fat images. */
3232 bfd_mach_o_fat_extract (bfd
*abfd
,
3234 const bfd_arch_info_type
*arch
)
3237 mach_o_fat_data_struct
*adata
;
3240 if (bfd_check_format (abfd
, format
))
3242 if (bfd_get_arch_info (abfd
) == arch
)
3246 if (!bfd_check_format (abfd
, bfd_archive
)
3247 || abfd
->xvec
!= &mach_o_fat_vec
)
3250 /* This is a Mach-O fat image. */
3251 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
3252 BFD_ASSERT (adata
!= NULL
);
3254 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3256 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
3257 enum bfd_architecture cpu_type
;
3258 unsigned long cpu_subtype
;
3260 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
3261 &cpu_type
, &cpu_subtype
);
3262 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
3265 /* The architecture is found. */
3266 res
= _bfd_new_bfd_contained_in (abfd
);
3270 res
->origin
= e
->offset
;
3272 res
->filename
= bfd_printable_arch_mach (cpu_type
, cpu_subtype
);
3273 res
->iostream
= NULL
;
3275 if (bfd_check_format (res
, format
))
3277 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
3288 bfd_mach_o_lookup_command (bfd
*abfd
,
3289 bfd_mach_o_load_command_type type
,
3290 bfd_mach_o_load_command
**mcommand
)
3292 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
3293 bfd_mach_o_load_command
*ncmd
= NULL
;
3294 unsigned int i
, num
;
3296 BFD_ASSERT (md
!= NULL
);
3297 BFD_ASSERT (mcommand
!= NULL
);
3300 for (i
= 0; i
< md
->header
.ncmds
; i
++)
3302 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
3304 if (cmd
->type
!= type
)
3317 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
3321 case BFD_MACH_O_CPU_TYPE_MC680x0
:
3323 case BFD_MACH_O_CPU_TYPE_MC88000
:
3325 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3327 case BFD_MACH_O_CPU_TYPE_I386
:
3329 case BFD_MACH_O_CPU_TYPE_SPARC
:
3331 case BFD_MACH_O_CPU_TYPE_I860
:
3333 case BFD_MACH_O_CPU_TYPE_HPPA
:
3334 return 0xc0000000 - 0x04000000;
3340 typedef struct bfd_mach_o_xlat_name
3345 bfd_mach_o_xlat_name
;
3348 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name
*table
,
3354 for (; table
->name
; table
++)
3356 if (table
->val
& val
)
3359 fprintf (file
, "+");
3360 fprintf (file
, "%s", table
->name
);
3368 fprintf (file
, "+");
3369 fprintf (file
, "0x%lx", val
);
3373 fprintf (file
, "-");
3377 bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name
*table
,
3380 for (; table
->name
; table
++)
3381 if (table
->val
== val
)
3387 bfd_mach_o_get_name (const bfd_mach_o_xlat_name
*table
, unsigned long val
)
3389 const char *res
= bfd_mach_o_get_name_or_null (table
, val
);
3397 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name
[] =
3399 { "vax", BFD_MACH_O_CPU_TYPE_VAX
},
3400 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0
},
3401 { "i386", BFD_MACH_O_CPU_TYPE_I386
},
3402 { "mips", BFD_MACH_O_CPU_TYPE_MIPS
},
3403 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000
},
3404 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA
},
3405 { "arm", BFD_MACH_O_CPU_TYPE_ARM
},
3406 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000
},
3407 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC
},
3408 { "i860", BFD_MACH_O_CPU_TYPE_I860
},
3409 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA
},
3410 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC
},
3411 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64
},
3412 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64
},
3416 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name
[] =
3418 { "object", BFD_MACH_O_MH_OBJECT
},
3419 { "execute", BFD_MACH_O_MH_EXECUTE
},
3420 { "fvmlib", BFD_MACH_O_MH_FVMLIB
},
3421 { "core", BFD_MACH_O_MH_CORE
},
3422 { "preload", BFD_MACH_O_MH_PRELOAD
},
3423 { "dylib", BFD_MACH_O_MH_DYLIB
},
3424 { "dylinker", BFD_MACH_O_MH_DYLINKER
},
3425 { "bundle", BFD_MACH_O_MH_BUNDLE
},
3426 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB
},
3427 { "dym", BFD_MACH_O_MH_DSYM
},
3428 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE
},
3432 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name
[] =
3434 { "noundefs", BFD_MACH_O_MH_NOUNDEFS
},
3435 { "incrlink", BFD_MACH_O_MH_INCRLINK
},
3436 { "dyldlink", BFD_MACH_O_MH_DYLDLINK
},
3437 { "bindatload", BFD_MACH_O_MH_BINDATLOAD
},
3438 { "prebound", BFD_MACH_O_MH_PREBOUND
},
3439 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS
},
3440 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT
},
3441 { "twolevel", BFD_MACH_O_MH_TWOLEVEL
},
3442 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT
},
3443 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS
},
3444 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING
},
3445 { "prebindable", BFD_MACH_O_MH_PREBINDABLE
},
3446 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND
},
3447 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS
},
3448 { "canonical", BFD_MACH_O_MH_CANONICAL
},
3449 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES
},
3450 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK
},
3451 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION
},
3452 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE
},
3453 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE
},
3454 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS
},
3455 { "pie", BFD_MACH_O_MH_PIE
},
3459 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
3461 { "regular", BFD_MACH_O_S_REGULAR
},
3462 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
3463 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
3464 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
3465 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
3466 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
3467 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
3468 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
3469 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
3470 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
3471 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
3472 { "coalesced", BFD_MACH_O_S_COALESCED
},
3473 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
3474 { "interposing", BFD_MACH_O_S_INTERPOSING
},
3475 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
3476 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
3477 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
3481 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
3483 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
3484 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
3485 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
3486 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
3487 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
3488 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
3489 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
3490 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
3491 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
3492 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
3496 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name
[] =
3498 { "segment", BFD_MACH_O_LC_SEGMENT
},
3499 { "symtab", BFD_MACH_O_LC_SYMTAB
},
3500 { "symseg", BFD_MACH_O_LC_SYMSEG
},
3501 { "thread", BFD_MACH_O_LC_THREAD
},
3502 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD
},
3503 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB
},
3504 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB
},
3505 { "ident", BFD_MACH_O_LC_IDENT
},
3506 { "fvmfile", BFD_MACH_O_LC_FVMFILE
},
3507 { "prepage", BFD_MACH_O_LC_PREPAGE
},
3508 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB
},
3509 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB
},
3510 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB
},
3511 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER
},
3512 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER
},
3513 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB
},
3514 { "routines", BFD_MACH_O_LC_ROUTINES
},
3515 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK
},
3516 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA
},
3517 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT
},
3518 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY
},
3519 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS
},
3520 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM
},
3521 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB
},
3522 { "segment_64", BFD_MACH_O_LC_SEGMENT_64
},
3523 { "routines_64", BFD_MACH_O_LC_ROUTINES_64
},
3524 { "uuid", BFD_MACH_O_LC_UUID
},
3525 { "rpath", BFD_MACH_O_LC_RPATH
},
3526 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE
},
3527 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
},
3528 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB
},
3529 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB
},
3530 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO
},
3531 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO
},
3532 { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
},
3533 { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX
},
3534 { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
},
3535 { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS
},
3536 { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT
},
3540 /* Get the section type from NAME. Return -1 if NAME is unknown. */
3543 bfd_mach_o_get_section_type_from_name (const char *name
)
3545 bfd_mach_o_xlat_name
*x
;
3547 for (x
= bfd_mach_o_section_type_name
; x
->name
; x
++)
3548 if (strcmp (x
->name
, name
) == 0)
3550 return (unsigned int)-1;
3553 /* Get the section attribute from NAME. Return -1 if NAME is unknown. */
3556 bfd_mach_o_get_section_attribute_from_name (const char *name
)
3558 bfd_mach_o_xlat_name
*x
;
3560 for (x
= bfd_mach_o_section_attribute_name
; x
->name
; x
++)
3561 if (strcmp (x
->name
, name
) == 0)
3563 return (unsigned int)-1;
3567 bfd_mach_o_print_private_header (bfd
*abfd
, FILE *file
)
3569 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3570 bfd_mach_o_header
*h
= &mdata
->header
;
3572 fputs (_("Mach-O header:\n"), file
);
3573 fprintf (file
, _(" magic : %08lx\n"), h
->magic
);
3574 fprintf (file
, _(" cputype : %08lx (%s)\n"), h
->cputype
,
3575 bfd_mach_o_get_name (bfd_mach_o_cpu_name
, h
->cputype
));
3576 fprintf (file
, _(" cpusubtype: %08lx\n"), h
->cpusubtype
);
3577 fprintf (file
, _(" filetype : %08lx (%s)\n"),
3579 bfd_mach_o_get_name (bfd_mach_o_filetype_name
, h
->filetype
));
3580 fprintf (file
, _(" ncmds : %08lx (%lu)\n"), h
->ncmds
, h
->ncmds
);
3581 fprintf (file
, _(" sizeofcmds: %08lx\n"), h
->sizeofcmds
);
3582 fprintf (file
, _(" flags : %08lx ("), h
->flags
);
3583 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name
, h
->flags
, file
);
3584 fputs (_(")\n"), file
);
3585 fprintf (file
, _(" reserved : %08x\n"), h
->reserved
);
3589 bfd_mach_o_print_section_map (bfd
*abfd
, FILE *file
)
3591 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3593 unsigned int sec_nbr
= 0;
3595 fputs (_("Segments and Sections:\n"), file
);
3596 fputs (_(" #: Segment name Section name Address\n"), file
);
3598 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3600 bfd_mach_o_segment_command
*seg
;
3601 bfd_mach_o_section
*sec
;
3603 if (mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT
3604 && mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT_64
)
3607 seg
= &mdata
->commands
[i
].command
.segment
;
3609 fprintf (file
, "[Segment %-16s ", seg
->segname
);
3610 fprintf_vma (file
, seg
->vmaddr
);
3611 fprintf (file
, "-");
3612 fprintf_vma (file
, seg
->vmaddr
+ seg
->vmsize
- 1);
3614 fputc (seg
->initprot
& BFD_MACH_O_PROT_READ
? 'r' : '-', file
);
3615 fputc (seg
->initprot
& BFD_MACH_O_PROT_WRITE
? 'w' : '-', file
);
3616 fputc (seg
->initprot
& BFD_MACH_O_PROT_EXECUTE
? 'x' : '-', file
);
3617 fprintf (file
, "]\n");
3619 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3621 fprintf (file
, "%02u: %-16s %-16s ", ++sec_nbr
,
3622 sec
->segname
, sec
->sectname
);
3623 fprintf_vma (file
, sec
->addr
);
3624 fprintf (file
, " ");
3625 fprintf_vma (file
, sec
->size
);
3626 fprintf (file
, " %08lx\n", sec
->flags
);
3632 bfd_mach_o_print_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3633 bfd_mach_o_section
*sec
, FILE *file
)
3635 fprintf (file
, " Section: %-16s %-16s (bfdname: %s)\n",
3636 sec
->sectname
, sec
->segname
, sec
->bfdsection
->name
);
3637 fprintf (file
, " addr: ");
3638 fprintf_vma (file
, sec
->addr
);
3639 fprintf (file
, " size: ");
3640 fprintf_vma (file
, sec
->size
);
3641 fprintf (file
, " offset: ");
3642 fprintf_vma (file
, sec
->offset
);
3643 fprintf (file
, "\n");
3644 fprintf (file
, " align: %ld", sec
->align
);
3645 fprintf (file
, " nreloc: %lu reloff: ", sec
->nreloc
);
3646 fprintf_vma (file
, sec
->reloff
);
3647 fprintf (file
, "\n");
3648 fprintf (file
, " flags: %08lx (type: %s", sec
->flags
,
3649 bfd_mach_o_get_name (bfd_mach_o_section_type_name
,
3650 sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
));
3651 fprintf (file
, " attr: ");
3652 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name
,
3653 sec
->flags
& BFD_MACH_O_SECTION_ATTRIBUTES_MASK
,
3655 fprintf (file
, ")\n");
3656 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3658 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3659 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3660 case BFD_MACH_O_S_SYMBOL_STUBS
:
3661 fprintf (file
, " first indirect sym: %lu", sec
->reserved1
);
3662 fprintf (file
, " (%u entries)",
3663 bfd_mach_o_section_get_nbr_indirect (abfd
, sec
));
3666 fprintf (file
, " reserved1: 0x%lx", sec
->reserved1
);
3669 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3671 case BFD_MACH_O_S_SYMBOL_STUBS
:
3672 fprintf (file
, " stub size: %lu", sec
->reserved2
);
3675 fprintf (file
, " reserved2: 0x%lx", sec
->reserved2
);
3678 fprintf (file
, " reserved3: 0x%lx\n", sec
->reserved3
);
3682 bfd_mach_o_print_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
3683 bfd_mach_o_load_command
*cmd
, FILE *file
)
3685 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3686 bfd_mach_o_section
*sec
;
3688 fprintf (file
, " name: %s\n", *seg
->segname
? seg
->segname
: "*none*");
3689 fprintf (file
, " vmaddr: ");
3690 fprintf_vma (file
, seg
->vmaddr
);
3691 fprintf (file
, " vmsize: ");
3692 fprintf_vma (file
, seg
->vmsize
);
3693 fprintf (file
, "\n");
3694 fprintf (file
, " fileoff: ");
3695 fprintf_vma (file
, seg
->fileoff
);
3696 fprintf (file
, " filesize: ");
3697 fprintf_vma (file
, (bfd_vma
)seg
->filesize
);
3698 fprintf (file
, " endoff: ");
3699 fprintf_vma (file
, (bfd_vma
)(seg
->fileoff
+ seg
->filesize
));
3700 fprintf (file
, "\n");
3701 fprintf (file
, " nsects: %lu ", seg
->nsects
);
3702 fprintf (file
, " flags: %lx\n", seg
->flags
);
3703 for (sec
= seg
->sect_head
; sec
!= NULL
; sec
= sec
->next
)
3704 bfd_mach_o_print_section (abfd
, sec
, file
);
3708 bfd_mach_o_print_dysymtab (bfd
*abfd ATTRIBUTE_UNUSED
,
3709 bfd_mach_o_load_command
*cmd
, FILE *file
)
3711 bfd_mach_o_dysymtab_command
*dysymtab
= &cmd
->command
.dysymtab
;
3712 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3715 fprintf (file
, " local symbols: idx: %10lu num: %-8lu",
3716 dysymtab
->ilocalsym
, dysymtab
->nlocalsym
);
3717 fprintf (file
, " (nxtidx: %lu)\n",
3718 dysymtab
->ilocalsym
+ dysymtab
->nlocalsym
);
3719 fprintf (file
, " external symbols: idx: %10lu num: %-8lu",
3720 dysymtab
->iextdefsym
, dysymtab
->nextdefsym
);
3721 fprintf (file
, " (nxtidx: %lu)\n",
3722 dysymtab
->iextdefsym
+ dysymtab
->nextdefsym
);
3723 fprintf (file
, " undefined symbols: idx: %10lu num: %-8lu",
3724 dysymtab
->iundefsym
, dysymtab
->nundefsym
);
3725 fprintf (file
, " (nxtidx: %lu)\n",
3726 dysymtab
->iundefsym
+ dysymtab
->nundefsym
);
3727 fprintf (file
, " table of content: off: 0x%08lx num: %-8lu",
3728 dysymtab
->tocoff
, dysymtab
->ntoc
);
3729 fprintf (file
, " (endoff: 0x%08lx)\n",
3731 + dysymtab
->ntoc
* BFD_MACH_O_TABLE_OF_CONTENT_SIZE
);
3732 fprintf (file
, " module table: off: 0x%08lx num: %-8lu",
3733 dysymtab
->modtaboff
, dysymtab
->nmodtab
);
3734 fprintf (file
, " (endoff: 0x%08lx)\n",
3735 dysymtab
->modtaboff
+ dysymtab
->nmodtab
3736 * (mach_o_wide_p (&mdata
->header
) ?
3737 BFD_MACH_O_DYLIB_MODULE_64_SIZE
: BFD_MACH_O_DYLIB_MODULE_SIZE
));
3738 fprintf (file
, " external reference table: off: 0x%08lx num: %-8lu",
3739 dysymtab
->extrefsymoff
, dysymtab
->nextrefsyms
);
3740 fprintf (file
, " (endoff: 0x%08lx)\n",
3741 dysymtab
->extrefsymoff
3742 + dysymtab
->nextrefsyms
* BFD_MACH_O_REFERENCE_SIZE
);
3743 fprintf (file
, " indirect symbol table: off: 0x%08lx num: %-8lu",
3744 dysymtab
->indirectsymoff
, dysymtab
->nindirectsyms
);
3745 fprintf (file
, " (endoff: 0x%08lx)\n",
3746 dysymtab
->indirectsymoff
3747 + dysymtab
->nindirectsyms
* BFD_MACH_O_INDIRECT_SYMBOL_SIZE
);
3748 fprintf (file
, " external relocation table: off: 0x%08lx num: %-8lu",
3749 dysymtab
->extreloff
, dysymtab
->nextrel
);
3750 fprintf (file
, " (endoff: 0x%08lx)\n",
3751 dysymtab
->extreloff
+ dysymtab
->nextrel
* BFD_MACH_O_RELENT_SIZE
);
3752 fprintf (file
, " local relocation table: off: 0x%08lx num: %-8lu",
3753 dysymtab
->locreloff
, dysymtab
->nlocrel
);
3754 fprintf (file
, " (endoff: 0x%08lx)\n",
3755 dysymtab
->locreloff
+ dysymtab
->nlocrel
* BFD_MACH_O_RELENT_SIZE
);
3757 if (dysymtab
->ntoc
> 0
3758 || dysymtab
->nindirectsyms
> 0
3759 || dysymtab
->nextrefsyms
> 0)
3761 /* Try to read the symbols to display the toc or indirect symbols. */
3762 bfd_mach_o_read_symtab_symbols (abfd
);
3764 else if (dysymtab
->nmodtab
> 0)
3766 /* Try to read the strtab to display modules name. */
3767 bfd_mach_o_read_symtab_strtab (abfd
);
3770 for (i
= 0; i
< dysymtab
->nmodtab
; i
++)
3772 bfd_mach_o_dylib_module
*module
= &dysymtab
->dylib_module
[i
];
3773 fprintf (file
, " module %u:\n", i
);
3774 fprintf (file
, " name: %lu", module
->module_name_idx
);
3775 if (mdata
->symtab
&& mdata
->symtab
->strtab
)
3776 fprintf (file
, ": %s",
3777 mdata
->symtab
->strtab
+ module
->module_name_idx
);
3778 fprintf (file
, "\n");
3779 fprintf (file
, " extdefsym: idx: %8lu num: %lu\n",
3780 module
->iextdefsym
, module
->nextdefsym
);
3781 fprintf (file
, " refsym: idx: %8lu num: %lu\n",
3782 module
->irefsym
, module
->nrefsym
);
3783 fprintf (file
, " localsym: idx: %8lu num: %lu\n",
3784 module
->ilocalsym
, module
->nlocalsym
);
3785 fprintf (file
, " extrel: idx: %8lu num: %lu\n",
3786 module
->iextrel
, module
->nextrel
);
3787 fprintf (file
, " init: idx: %8u num: %u\n",
3788 module
->iinit
, module
->ninit
);
3789 fprintf (file
, " term: idx: %8u num: %u\n",
3790 module
->iterm
, module
->nterm
);
3791 fprintf (file
, " objc_module_info: addr: ");
3792 fprintf_vma (file
, module
->objc_module_info_addr
);
3793 fprintf (file
, " size: %lu\n", module
->objc_module_info_size
);
3796 if (dysymtab
->ntoc
> 0)
3798 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3800 fprintf (file
, " table of content: (symbol/module)\n");
3801 for (i
= 0; i
< dysymtab
->ntoc
; i
++)
3803 bfd_mach_o_dylib_table_of_content
*toc
= &dysymtab
->dylib_toc
[i
];
3805 fprintf (file
, " %4u: ", i
);
3806 if (symtab
&& symtab
->symbols
&& toc
->symbol_index
< symtab
->nsyms
)
3808 const char *name
= symtab
->symbols
[toc
->symbol_index
].symbol
.name
;
3809 fprintf (file
, "%s (%lu)", name
? name
: "*invalid*",
3813 fprintf (file
, "%lu", toc
->symbol_index
);
3815 fprintf (file
, " / ");
3816 if (symtab
&& symtab
->strtab
3817 && toc
->module_index
< dysymtab
->nmodtab
)
3819 bfd_mach_o_dylib_module
*mod
;
3820 mod
= &dysymtab
->dylib_module
[toc
->module_index
];
3821 fprintf (file
, "%s (%lu)",
3822 symtab
->strtab
+ mod
->module_name_idx
,
3826 fprintf (file
, "%lu", toc
->module_index
);
3828 fprintf (file
, "\n");
3832 if (dysymtab
->nindirectsyms
!= 0)
3834 fprintf (file
, " indirect symbols:\n");
3836 for (i
= 0; i
< mdata
->nsects
; i
++)
3838 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
3839 unsigned int j
, first
, last
;
3840 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3844 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3846 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3847 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3848 case BFD_MACH_O_S_SYMBOL_STUBS
:
3849 first
= sec
->reserved1
;
3850 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
3852 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
3853 fprintf (file
, " for section %s.%s:\n",
3854 sec
->segname
, sec
->sectname
);
3855 for (j
= first
; j
< last
; j
++)
3857 unsigned int isym
= dysymtab
->indirect_syms
[j
];
3859 fprintf (file
, " ");
3860 fprintf_vma (file
, addr
);
3861 fprintf (file
, " %5u: 0x%08x", j
, isym
);
3862 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_LOCAL
)
3863 fprintf (file
, " LOCAL");
3864 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_ABS
)
3865 fprintf (file
, " ABSOLUTE");
3866 if (symtab
&& symtab
->symbols
3867 && isym
< symtab
->nsyms
3868 && symtab
->symbols
[isym
].symbol
.name
)
3869 fprintf (file
, " %s", symtab
->symbols
[isym
].symbol
.name
);
3870 fprintf (file
, "\n");
3879 if (dysymtab
->nextrefsyms
> 0)
3881 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3883 fprintf (file
, " external reference table: (symbol flags)\n");
3884 for (i
= 0; i
< dysymtab
->nextrefsyms
; i
++)
3886 bfd_mach_o_dylib_reference
*ref
= &dysymtab
->ext_refs
[i
];
3888 fprintf (file
, " %4u: %5lu 0x%02lx", i
, ref
->isym
, ref
->flags
);
3889 if (symtab
&& symtab
->symbols
3890 && ref
->isym
< symtab
->nsyms
3891 && symtab
->symbols
[ref
->isym
].symbol
.name
)
3892 fprintf (file
, " %s", symtab
->symbols
[ref
->isym
].symbol
.name
);
3893 fprintf (file
, "\n");
3900 bfd_mach_o_print_dyld_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3901 bfd_mach_o_load_command
*cmd
, FILE *file
)
3903 bfd_mach_o_dyld_info_command
*info
= &cmd
->command
.dyld_info
;
3905 fprintf (file
, " rebase: off: 0x%08x size: %-8u\n",
3906 info
->rebase_off
, info
->rebase_size
);
3907 fprintf (file
, " bind: off: 0x%08x size: %-8u\n",
3908 info
->bind_off
, info
->bind_size
);
3909 fprintf (file
, " weak bind: off: 0x%08x size: %-8u\n",
3910 info
->weak_bind_off
, info
->weak_bind_size
);
3911 fprintf (file
, " lazy bind: off: 0x%08x size: %-8u\n",
3912 info
->lazy_bind_off
, info
->lazy_bind_size
);
3913 fprintf (file
, " export: off: 0x%08x size: %-8u\n",
3914 info
->export_off
, info
->export_size
);
3918 bfd_mach_o_bfd_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3920 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3921 FILE *file
= (FILE *) ptr
;
3924 bfd_mach_o_print_private_header (abfd
, file
);
3927 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3929 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[i
];
3930 const char *cmd_name
;
3932 cmd_name
= bfd_mach_o_get_name_or_null
3933 (bfd_mach_o_load_command_name
, cmd
->type
);
3934 fprintf (file
, "Load command ");
3935 if (cmd_name
== NULL
)
3936 fprintf (file
, "0x%02x:", cmd
->type
);
3938 fprintf (file
, "%s:", cmd_name
);
3942 case BFD_MACH_O_LC_SEGMENT
:
3943 case BFD_MACH_O_LC_SEGMENT_64
:
3944 bfd_mach_o_print_segment (abfd
, cmd
, file
);
3946 case BFD_MACH_O_LC_UUID
:
3948 bfd_mach_o_uuid_command
*uuid
= &cmd
->command
.uuid
;
3951 for (j
= 0; j
< sizeof (uuid
->uuid
); j
++)
3952 fprintf (file
, " %02x", uuid
->uuid
[j
]);
3956 case BFD_MACH_O_LC_LOAD_DYLIB
:
3957 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3958 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3959 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB
:
3960 case BFD_MACH_O_LC_ID_DYLIB
:
3962 bfd_mach_o_dylib_command
*dylib
= &cmd
->command
.dylib
;
3963 fprintf (file
, " %s\n", dylib
->name_str
);
3964 fprintf (file
, " time stamp: 0x%08lx\n",
3966 fprintf (file
, " current version: 0x%08lx\n",
3967 dylib
->current_version
);
3968 fprintf (file
, " comptibility version: 0x%08lx\n",
3969 dylib
->compatibility_version
);
3972 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3973 case BFD_MACH_O_LC_ID_DYLINKER
:
3974 fprintf (file
, " %s\n", cmd
->command
.dylinker
.name_str
);
3976 case BFD_MACH_O_LC_SYMTAB
:
3978 bfd_mach_o_symtab_command
*symtab
= &cmd
->command
.symtab
;
3981 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
3982 symtab
->symoff
, symtab
->nsyms
,
3983 symtab
->symoff
+ symtab
->nsyms
3984 * (mach_o_wide_p (&mdata
->header
)
3985 ? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
));
3987 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
3988 symtab
->stroff
, symtab
->strsize
,
3989 symtab
->stroff
+ symtab
->strsize
);
3992 case BFD_MACH_O_LC_DYSYMTAB
:
3993 fprintf (file
, "\n");
3994 bfd_mach_o_print_dysymtab (abfd
, cmd
, file
);
3996 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3997 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3998 case BFD_MACH_O_LC_FUNCTION_STARTS
:
4000 bfd_mach_o_linkedit_command
*linkedit
= &cmd
->command
.linkedit
;
4003 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
4004 linkedit
->dataoff
, linkedit
->datasize
,
4005 linkedit
->dataoff
+ linkedit
->datasize
);
4008 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
4009 case BFD_MACH_O_LC_SUB_UMBRELLA
:
4010 case BFD_MACH_O_LC_SUB_LIBRARY
:
4011 case BFD_MACH_O_LC_SUB_CLIENT
:
4012 case BFD_MACH_O_LC_RPATH
:
4014 bfd_mach_o_str_command
*str
= &cmd
->command
.str
;
4015 fprintf (file
, " %s\n", str
->str
);
4018 case BFD_MACH_O_LC_THREAD
:
4019 case BFD_MACH_O_LC_UNIXTHREAD
:
4021 bfd_mach_o_thread_command
*thread
= &cmd
->command
.thread
;
4023 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
4025 fprintf (file
, " nflavours: %lu\n", thread
->nflavours
);
4026 for (j
= 0; j
< thread
->nflavours
; j
++)
4028 bfd_mach_o_thread_flavour
*flavour
= &thread
->flavours
[j
];
4030 fprintf (file
, " %2u: flavour: 0x%08lx offset: 0x%08lx"
4032 j
, flavour
->flavour
, flavour
->offset
,
4034 if (bed
->_bfd_mach_o_print_thread
)
4036 char *buf
= bfd_malloc (flavour
->size
);
4039 && bfd_seek (abfd
, flavour
->offset
, SEEK_SET
) == 0
4040 && (bfd_bread (buf
, flavour
->size
, abfd
)
4042 (*bed
->_bfd_mach_o_print_thread
)(abfd
, flavour
,
4049 case BFD_MACH_O_LC_DYLD_INFO
:
4050 fprintf (file
, "\n");
4051 bfd_mach_o_print_dyld_info (abfd
, cmd
, file
);
4053 case BFD_MACH_O_LC_VERSION_MIN_MACOSX
:
4054 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS
:
4056 bfd_mach_o_version_min_command
*ver
= &cmd
->command
.version_min
;
4058 fprintf (file
, " %u.%u.%u\n", ver
->rel
, ver
->maj
, ver
->min
);
4062 fprintf (file
, "\n");
4063 fprintf (file
, " offset: 0x%08lx\n", (unsigned long)cmd
->offset
);
4064 fprintf (file
, " size: 0x%08lx\n", (unsigned long)cmd
->len
);
4070 bfd_mach_o_print_section_map (abfd
, file
);
4076 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
4077 unsigned char **rbuf
,
4080 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
4081 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
4084 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
4086 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
4087 bfd_mach_o_segment_command
*seg
= NULL
;
4089 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
4092 seg
= &cur
->command
.segment
;
4094 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
4096 unsigned long start
= seg
->fileoff
;
4097 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
4098 unsigned char *buf
= bfd_malloc (1024);
4099 unsigned long size
= 1024;
4103 bfd_size_type nread
= 0;
4104 unsigned long offset
;
4105 int found_nonnull
= 0;
4107 if (size
> (end
- start
))
4108 size
= (end
- start
);
4110 buf
= bfd_realloc_or_free (buf
, size
);
4114 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
4120 nread
= bfd_bread (buf
, size
, abfd
);
4128 for (offset
= 4; offset
<= size
; offset
+= 4)
4132 val
= *((unsigned long *) (buf
+ size
- offset
));
4133 if (! found_nonnull
)
4138 else if (val
== 0x0)
4140 unsigned long bottom
;
4143 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
4144 top
= seg
->fileoff
+ seg
->filesize
- 4;
4145 *rbuf
= bfd_malloc (top
- bottom
);
4146 *rlen
= top
- bottom
;
4148 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
4154 if (size
== (end
- start
))
4168 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
4170 unsigned char *buf
= NULL
;
4171 unsigned int len
= 0;
4174 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
4178 return (char *) buf
;
4182 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
4187 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4188 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4190 #define bfd_mach_o_swap_reloc_in NULL
4191 #define bfd_mach_o_swap_reloc_out NULL
4192 #define bfd_mach_o_print_thread NULL
4194 #define TARGET_NAME mach_o_be_vec
4195 #define TARGET_STRING "mach-o-be"
4196 #define TARGET_ARCHITECTURE bfd_arch_unknown
4197 #define TARGET_BIG_ENDIAN 1
4198 #define TARGET_ARCHIVE 0
4199 #include "mach-o-target.c"
4202 #undef TARGET_STRING
4203 #undef TARGET_ARCHITECTURE
4204 #undef TARGET_BIG_ENDIAN
4205 #undef TARGET_ARCHIVE
4207 #define TARGET_NAME mach_o_le_vec
4208 #define TARGET_STRING "mach-o-le"
4209 #define TARGET_ARCHITECTURE bfd_arch_unknown
4210 #define TARGET_BIG_ENDIAN 0
4211 #define TARGET_ARCHIVE 0
4213 #include "mach-o-target.c"
4216 #undef TARGET_STRING
4217 #undef TARGET_ARCHITECTURE
4218 #undef TARGET_BIG_ENDIAN
4219 #undef TARGET_ARCHIVE
4221 /* Not yet handled: creating an archive. */
4222 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4225 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4226 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4227 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4228 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4229 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4230 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4231 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4232 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4233 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4234 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4236 #define TARGET_NAME mach_o_fat_vec
4237 #define TARGET_STRING "mach-o-fat"
4238 #define TARGET_ARCHITECTURE bfd_arch_unknown
4239 #define TARGET_BIG_ENDIAN 1
4240 #define TARGET_ARCHIVE 1
4242 #include "mach-o-target.c"
4245 #undef TARGET_STRING
4246 #undef TARGET_ARCHITECTURE
4247 #undef TARGET_BIG_ENDIAN
4248 #undef TARGET_ARCHIVE