1 /* Mach-O support for BFD.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "libiberty.h"
27 #include "aout/stab_gnu.h"
30 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p
31 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p
32 #define bfd_mach_o_mkobject bfd_false
34 #define FILE_ALIGN(off, algn) \
35 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
37 static int bfd_mach_o_read_symtab_symbols (bfd
*);
40 bfd_mach_o_version (bfd
*abfd
)
42 bfd_mach_o_data_struct
*mdata
= NULL
;
44 BFD_ASSERT (bfd_mach_o_valid (abfd
));
45 mdata
= bfd_mach_o_get_data (abfd
);
47 return mdata
->header
.version
;
51 bfd_mach_o_valid (bfd
*abfd
)
53 if (abfd
== NULL
|| abfd
->xvec
== NULL
)
56 if (abfd
->xvec
->flavour
!= bfd_target_mach_o_flavour
)
59 if (bfd_mach_o_get_data (abfd
) == NULL
)
64 static INLINE bfd_boolean
65 mach_o_wide_p (bfd_mach_o_header
*header
)
67 switch (header
->version
)
79 static INLINE bfd_boolean
80 bfd_mach_o_wide_p (bfd
*abfd
)
82 return mach_o_wide_p (&bfd_mach_o_get_data (abfd
)->header
);
85 /* Tables to translate well known Mach-O segment/section names to bfd
86 names. Use of canonical names (such as .text or .debug_frame) is required
89 struct mach_o_section_name_xlat
92 const char *mach_o_name
;
95 static const struct mach_o_section_name_xlat dwarf_section_names_xlat
[] =
97 { ".debug_frame", "__debug_frame" },
98 { ".debug_info", "__debug_info" },
99 { ".debug_abbrev", "__debug_abbrev" },
100 { ".debug_aranges", "__debug_aranges" },
101 { ".debug_macinfo", "__debug_macinfo" },
102 { ".debug_line", "__debug_line" },
103 { ".debug_loc", "__debug_loc" },
104 { ".debug_pubnames", "__debug_pubnames" },
105 { ".debug_pubtypes", "__debug_pubtypes" },
106 { ".debug_str", "__debug_str" },
107 { ".debug_ranges", "__debug_ranges" },
111 static const struct mach_o_section_name_xlat text_section_names_xlat
[] =
113 { ".text", "__text" },
114 { ".const", "__const" },
115 { ".cstring", "__cstring" },
116 { ".eh_frame", "__eh_frame" },
120 static const struct mach_o_section_name_xlat data_section_names_xlat
[] =
122 { ".data", "__data" },
127 struct mach_o_segment_name_xlat
130 const struct mach_o_section_name_xlat
*sections
;
133 static const struct mach_o_segment_name_xlat segsec_names_xlat
[] =
135 { "__DWARF", dwarf_section_names_xlat
},
136 { "__TEXT", text_section_names_xlat
},
137 { "__DATA", data_section_names_xlat
},
142 /* Mach-O to bfd names. */
145 bfd_mach_o_convert_section_name_to_bfd (bfd
*abfd
, bfd_mach_o_section
*section
)
147 const struct mach_o_segment_name_xlat
*seg
;
150 const char *pfx
= "";
152 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
154 if (strcmp (seg
->segname
, section
->segname
) == 0)
156 const struct mach_o_section_name_xlat
*sec
;
158 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
160 if (strcmp (sec
->mach_o_name
, section
->sectname
) == 0)
162 len
= strlen (sec
->bfd_name
);
163 res
= bfd_alloc (abfd
, len
+ 1);
167 strcpy (res
, sec
->bfd_name
);
174 len
= strlen (section
->segname
) + 1
175 + strlen (section
->sectname
) + 1;
177 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
178 with an underscore. */
179 if (section
->segname
[0] != '_')
181 static const char seg_pfx
[] = "LC_SEGMENT.";
184 len
+= sizeof (seg_pfx
) - 1;
187 res
= bfd_alloc (abfd
, len
);
190 snprintf (res
, len
, "%s%s.%s", pfx
, section
->segname
, section
->sectname
);
194 /* Convert a bfd section name to a Mach-O segment + section name. */
197 bfd_mach_o_convert_section_name_to_mach_o (bfd
*abfd ATTRIBUTE_UNUSED
,
199 bfd_mach_o_section
*section
)
201 const struct mach_o_segment_name_xlat
*seg
;
202 const char *name
= bfd_get_section_name (abfd
, sect
);
208 /* List of well known names. They all start with a dot. */
210 for (seg
= segsec_names_xlat
; seg
->segname
; seg
++)
212 const struct mach_o_section_name_xlat
*sec
;
214 for (sec
= seg
->sections
; sec
->mach_o_name
; sec
++)
216 if (strcmp (sec
->bfd_name
, name
) == 0)
218 strcpy (section
->segname
, seg
->segname
);
219 strcpy (section
->sectname
, sec
->mach_o_name
);
225 /* Strip LC_SEGMENT. prefix. */
226 if (strncmp (name
, "LC_SEGMENT.", 11) == 0)
230 dot
= strchr (name
, '.');
233 /* Try to split name into segment and section names. */
234 if (dot
&& dot
!= name
)
237 seclen
= len
- (dot
+ 1 - name
);
239 if (seglen
< 16 && seclen
< 16)
241 memcpy (section
->segname
, name
, seglen
);
242 section
->segname
[seglen
] = 0;
243 memcpy (section
->sectname
, dot
+ 1, seclen
);
244 section
->sectname
[seclen
] = 0;
251 memcpy (section
->segname
, name
, len
);
252 section
->segname
[len
] = 0;
253 memcpy (section
->sectname
, name
, len
);
254 section
->sectname
[len
] = 0;
257 /* Return the size of an entry for section SEC.
258 Must be called only for symbol pointer section and symbol stubs
262 bfd_mach_o_section_get_entry_size (bfd
*abfd
, bfd_mach_o_section
*sec
)
264 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
266 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
267 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
268 return bfd_mach_o_wide_p (abfd
) ? 8 : 4;
269 case BFD_MACH_O_S_SYMBOL_STUBS
:
270 return sec
->reserved2
;
277 /* Return the number of indirect symbols for a section.
278 Must be called only for symbol pointer section and symbol stubs
282 bfd_mach_o_section_get_nbr_indirect (bfd
*abfd
, bfd_mach_o_section
*sec
)
286 elsz
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
290 return sec
->size
/ elsz
;
294 /* Copy any private info we understand from the input symbol
295 to the output symbol. */
298 bfd_mach_o_bfd_copy_private_symbol_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
299 asymbol
*isymbol ATTRIBUTE_UNUSED
,
300 bfd
*obfd ATTRIBUTE_UNUSED
,
301 asymbol
*osymbol ATTRIBUTE_UNUSED
)
306 /* Copy any private info we understand from the input section
307 to the output section. */
310 bfd_mach_o_bfd_copy_private_section_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
311 asection
*isection ATTRIBUTE_UNUSED
,
312 bfd
*obfd ATTRIBUTE_UNUSED
,
313 asection
*osection ATTRIBUTE_UNUSED
)
318 /* Copy any private info we understand from the input bfd
319 to the output bfd. */
322 bfd_mach_o_bfd_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
324 if (bfd_get_flavour (ibfd
) != bfd_target_mach_o_flavour
325 || bfd_get_flavour (obfd
) != bfd_target_mach_o_flavour
)
328 BFD_ASSERT (bfd_mach_o_valid (ibfd
));
329 BFD_ASSERT (bfd_mach_o_valid (obfd
));
331 /* FIXME: copy commands. */
336 /* Count the total number of symbols. */
339 bfd_mach_o_count_symbols (bfd
*abfd
)
341 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
343 if (mdata
->symtab
== NULL
)
345 return mdata
->symtab
->nsyms
;
349 bfd_mach_o_get_symtab_upper_bound (bfd
*abfd
)
351 long nsyms
= bfd_mach_o_count_symbols (abfd
);
353 return ((nsyms
+ 1) * sizeof (asymbol
*));
357 bfd_mach_o_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
359 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
360 long nsyms
= bfd_mach_o_count_symbols (abfd
);
361 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
367 if (bfd_mach_o_read_symtab_symbols (abfd
) != 0)
370 "bfd_mach_o_canonicalize_symtab: unable to load symbols\n");
374 BFD_ASSERT (sym
->symbols
!= NULL
);
376 for (j
= 0; j
< sym
->nsyms
; j
++)
377 alocation
[j
] = &sym
->symbols
[j
].symbol
;
385 bfd_mach_o_get_synthetic_symtab (bfd
*abfd
,
386 long symcount ATTRIBUTE_UNUSED
,
387 asymbol
**syms ATTRIBUTE_UNUSED
,
388 long dynsymcount ATTRIBUTE_UNUSED
,
389 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
392 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
393 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
394 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
396 unsigned long count
, i
, j
, n
;
403 if (dysymtab
== NULL
|| symtab
== NULL
|| symtab
->symbols
== NULL
)
406 if (dysymtab
->nindirectsyms
== 0)
409 count
= dysymtab
->nindirectsyms
;
410 size
= count
* sizeof (asymbol
) + 1;
412 for (j
= 0; j
< count
; j
++)
414 unsigned int isym
= dysymtab
->indirect_syms
[j
];
416 if (isym
< symtab
->nsyms
&& symtab
->symbols
[isym
].symbol
.name
)
417 size
+= strlen (symtab
->symbols
[isym
].symbol
.name
) + sizeof ("$stub");
420 s
= *ret
= (asymbol
*) bfd_malloc (size
);
423 names
= (char *) (s
+ count
);
428 for (i
= 0; i
< mdata
->nsects
; i
++)
430 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
431 unsigned int first
, last
;
435 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
437 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
438 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
439 case BFD_MACH_O_S_SYMBOL_STUBS
:
440 first
= sec
->reserved1
;
441 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
443 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
444 for (j
= first
; j
< last
; j
++)
446 unsigned int isym
= dysymtab
->indirect_syms
[j
];
448 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
449 s
->section
= sec
->bfdsection
;
450 s
->value
= addr
- sec
->addr
;
453 if (isym
< symtab
->nsyms
454 && symtab
->symbols
[isym
].symbol
.name
)
456 const char *sym
= symtab
->symbols
[isym
].symbol
.name
;
461 memcpy (names
, sym
, len
);
463 memcpy (names
, "$stub", sizeof ("$stub"));
464 names
+= sizeof ("$stub");
483 bfd_mach_o_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
487 bfd_symbol_info (symbol
, ret
);
491 bfd_mach_o_print_symbol (bfd
*abfd
,
494 bfd_print_symbol_type how
)
496 FILE *file
= (FILE *) afile
;
498 bfd_mach_o_asymbol
*asym
= (bfd_mach_o_asymbol
*)symbol
;
502 case bfd_print_symbol_name
:
503 fprintf (file
, "%s", symbol
->name
);
506 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
507 if (asym
->n_type
& BFD_MACH_O_N_STAB
)
508 name
= bfd_get_stab_name (asym
->n_type
);
510 switch (asym
->n_type
& BFD_MACH_O_N_TYPE
)
512 case BFD_MACH_O_N_UNDF
:
515 case BFD_MACH_O_N_ABS
:
518 case BFD_MACH_O_N_INDR
:
521 case BFD_MACH_O_N_PBUD
:
524 case BFD_MACH_O_N_SECT
:
533 fprintf (file
, " %02x %-6s %02x %04x",
534 asym
->n_type
, name
, asym
->n_sect
, asym
->n_desc
);
535 if ((asym
->n_type
& BFD_MACH_O_N_STAB
) == 0
536 && (asym
->n_type
& BFD_MACH_O_N_TYPE
) == BFD_MACH_O_N_SECT
)
537 fprintf (file
, " %-5s", symbol
->section
->name
);
538 fprintf (file
, " %s", symbol
->name
);
543 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype
,
544 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED
,
545 enum bfd_architecture
*type
,
546 unsigned long *subtype
)
548 *subtype
= bfd_arch_unknown
;
552 case BFD_MACH_O_CPU_TYPE_VAX
: *type
= bfd_arch_vax
; break;
553 case BFD_MACH_O_CPU_TYPE_MC680x0
: *type
= bfd_arch_m68k
; break;
554 case BFD_MACH_O_CPU_TYPE_I386
:
555 *type
= bfd_arch_i386
;
556 *subtype
= bfd_mach_i386_i386
;
558 case BFD_MACH_O_CPU_TYPE_X86_64
:
559 *type
= bfd_arch_i386
;
560 *subtype
= bfd_mach_x86_64
;
562 case BFD_MACH_O_CPU_TYPE_MIPS
: *type
= bfd_arch_mips
; break;
563 case BFD_MACH_O_CPU_TYPE_MC98000
: *type
= bfd_arch_m98k
; break;
564 case BFD_MACH_O_CPU_TYPE_HPPA
: *type
= bfd_arch_hppa
; break;
565 case BFD_MACH_O_CPU_TYPE_ARM
: *type
= bfd_arch_arm
; break;
566 case BFD_MACH_O_CPU_TYPE_MC88000
: *type
= bfd_arch_m88k
; break;
567 case BFD_MACH_O_CPU_TYPE_SPARC
:
568 *type
= bfd_arch_sparc
;
569 *subtype
= bfd_mach_sparc
;
571 case BFD_MACH_O_CPU_TYPE_I860
: *type
= bfd_arch_i860
; break;
572 case BFD_MACH_O_CPU_TYPE_ALPHA
: *type
= bfd_arch_alpha
; break;
573 case BFD_MACH_O_CPU_TYPE_POWERPC
:
574 *type
= bfd_arch_powerpc
;
575 *subtype
= bfd_mach_ppc
;
577 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
578 *type
= bfd_arch_powerpc
;
579 *subtype
= bfd_mach_ppc64
;
582 *type
= bfd_arch_unknown
;
588 bfd_mach_o_write_header (bfd
*abfd
, bfd_mach_o_header
*header
)
590 unsigned char buf
[32];
593 size
= mach_o_wide_p (header
) ?
594 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
596 bfd_h_put_32 (abfd
, header
->magic
, buf
+ 0);
597 bfd_h_put_32 (abfd
, header
->cputype
, buf
+ 4);
598 bfd_h_put_32 (abfd
, header
->cpusubtype
, buf
+ 8);
599 bfd_h_put_32 (abfd
, header
->filetype
, buf
+ 12);
600 bfd_h_put_32 (abfd
, header
->ncmds
, buf
+ 16);
601 bfd_h_put_32 (abfd
, header
->sizeofcmds
, buf
+ 20);
602 bfd_h_put_32 (abfd
, header
->flags
, buf
+ 24);
604 if (mach_o_wide_p (header
))
605 bfd_h_put_32 (abfd
, header
->reserved
, buf
+ 28);
607 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
608 || bfd_bwrite ((void *) buf
, size
, abfd
) != size
)
615 bfd_mach_o_write_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
617 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
619 unsigned char buf
[8];
621 unsigned int nflavours
;
623 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
624 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
628 for (i
= 0; i
< cmd
->nflavours
; i
++)
630 BFD_ASSERT ((cmd
->flavours
[i
].size
% 4) == 0);
631 BFD_ASSERT (cmd
->flavours
[i
].offset
== (command
->offset
+ offset
+ 8));
633 bfd_h_put_32 (abfd
, cmd
->flavours
[i
].flavour
, buf
);
634 bfd_h_put_32 (abfd
, (cmd
->flavours
[i
].size
/ 4), buf
+ 4);
636 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
637 || bfd_bwrite ((void *) buf
, 8, abfd
) != 8)
640 offset
+= cmd
->flavours
[i
].size
+ 8;
647 bfd_mach_o_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
650 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
654 bfd_mach_o_canonicalize_one_reloc (bfd
*abfd
, char *buf
,
655 arelent
*res
, asymbol
**syms
)
657 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
658 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
659 bfd_mach_o_reloc_info reloc
;
664 addr
= bfd_get_32 (abfd
, buf
+ 0);
665 symnum
= bfd_get_32 (abfd
, buf
+ 4);
667 if (addr
& BFD_MACH_O_SR_SCATTERED
)
671 /* Scattered relocation.
672 Extract section and offset from r_value. */
673 res
->sym_ptr_ptr
= NULL
;
675 for (j
= 0; j
< mdata
->nsects
; j
++)
677 bfd_mach_o_section
*sect
= mdata
->sections
[j
];
678 if (symnum
>= sect
->addr
&& symnum
< sect
->addr
+ sect
->size
)
680 res
->sym_ptr_ptr
= sect
->bfdsection
->symbol_ptr_ptr
;
681 res
->addend
= symnum
- sect
->addr
;
685 res
->address
= BFD_MACH_O_GET_SR_ADDRESS (addr
);
686 reloc
.r_type
= BFD_MACH_O_GET_SR_TYPE (addr
);
687 reloc
.r_length
= BFD_MACH_O_GET_SR_LENGTH (addr
);
688 reloc
.r_pcrel
= addr
& BFD_MACH_O_SR_PCREL
;
689 reloc
.r_scattered
= 1;
693 unsigned int num
= BFD_MACH_O_GET_R_SYMBOLNUM (symnum
);
696 if (symnum
& BFD_MACH_O_R_EXTERN
)
700 BFD_ASSERT (num
!= 0);
701 BFD_ASSERT (num
<= mdata
->nsects
);
702 sym
= mdata
->sections
[num
- 1]->bfdsection
->symbol_ptr_ptr
;
704 res
->sym_ptr_ptr
= sym
;
705 reloc
.r_type
= BFD_MACH_O_GET_R_TYPE (symnum
);
706 reloc
.r_length
= BFD_MACH_O_GET_R_LENGTH (symnum
);
707 reloc
.r_pcrel
= (symnum
& BFD_MACH_O_R_PCREL
) ? 1 : 0;
708 reloc
.r_scattered
= 0;
711 if (!(*bed
->_bfd_mach_o_swap_reloc_in
)(res
, &reloc
))
717 bfd_mach_o_canonicalize_relocs (bfd
*abfd
, unsigned long filepos
,
719 arelent
*res
, asymbol
**syms
)
723 bfd_size_type native_size
;
725 /* Allocate and read relocs. */
726 native_size
= count
* BFD_MACH_O_RELENT_SIZE
;
727 native_relocs
= bfd_malloc (native_size
);
728 if (native_relocs
== NULL
)
731 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0
732 || bfd_bread (native_relocs
, native_size
, abfd
) != native_size
)
735 for (i
= 0; i
< count
; i
++)
737 char *buf
= native_relocs
+ BFD_MACH_O_RELENT_SIZE
* i
;
739 if (bfd_mach_o_canonicalize_one_reloc (abfd
, buf
, &res
[i
], syms
) < 0)
742 free (native_relocs
);
745 free (native_relocs
);
750 bfd_mach_o_canonicalize_reloc (bfd
*abfd
, asection
*asect
,
751 arelent
**rels
, asymbol
**syms
)
753 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
757 if (asect
->reloc_count
== 0)
760 /* No need to go further if we don't know how to read relocs. */
761 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
764 res
= bfd_malloc (asect
->reloc_count
* sizeof (arelent
));
768 if (bfd_mach_o_canonicalize_relocs (abfd
, asect
->rel_filepos
,
769 asect
->reloc_count
, res
, syms
) < 0)
775 for (i
= 0; i
< asect
->reloc_count
; i
++)
778 asect
->relocation
= res
;
784 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd
*abfd
)
786 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
788 if (mdata
->dysymtab
== NULL
)
790 return (mdata
->dysymtab
->nextrel
+ mdata
->dysymtab
->nlocrel
)
791 * sizeof (arelent
*);
795 bfd_mach_o_canonicalize_dynamic_reloc (bfd
*abfd
, arelent
**rels
,
796 struct bfd_symbol
**syms
)
798 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
799 bfd_mach_o_dysymtab_command
*dysymtab
= mdata
->dysymtab
;
800 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
804 if (dysymtab
== NULL
)
806 if (dysymtab
->nextrel
== 0 && dysymtab
->nlocrel
== 0)
809 /* No need to go further if we don't know how to read relocs. */
810 if (bed
->_bfd_mach_o_swap_reloc_in
== NULL
)
813 res
= bfd_malloc ((dysymtab
->nextrel
+ dysymtab
->nlocrel
) * sizeof (arelent
));
817 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->extreloff
,
818 dysymtab
->nextrel
, res
, syms
) < 0)
824 if (bfd_mach_o_canonicalize_relocs (abfd
, dysymtab
->locreloff
,
826 res
+ dysymtab
->nextrel
, syms
) < 0)
832 for (i
= 0; i
< dysymtab
->nextrel
+ dysymtab
->nlocrel
; i
++)
839 bfd_mach_o_write_relocs (bfd
*abfd
, bfd_mach_o_section
*section
)
841 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
845 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
847 sec
= section
->bfdsection
;
848 if (sec
->reloc_count
== 0)
851 if (bed
->_bfd_mach_o_swap_reloc_out
== NULL
)
854 /* Allocate relocation room. */
855 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, 2);
856 section
->nreloc
= sec
->reloc_count
;
857 sec
->rel_filepos
= mdata
->filelen
;
858 section
->reloff
= sec
->rel_filepos
;
859 mdata
->filelen
+= sec
->reloc_count
* BFD_MACH_O_RELENT_SIZE
;
861 if (bfd_seek (abfd
, section
->reloff
, SEEK_SET
) != 0)
864 /* Convert and write. */
865 entries
= section
->bfdsection
->orelocation
;
866 for (i
= 0; i
< section
->nreloc
; i
++)
868 arelent
*rel
= entries
[i
];
870 bfd_mach_o_reloc_info info
, *pinfo
= &info
;
872 /* Convert relocation to an intermediate representation. */
873 if (!(*bed
->_bfd_mach_o_swap_reloc_out
) (rel
, pinfo
))
876 /* Lower the relocation info. */
877 if (pinfo
->r_scattered
)
881 v
= BFD_MACH_O_SR_SCATTERED
882 | (pinfo
->r_pcrel
? BFD_MACH_O_SR_PCREL
: 0)
883 | BFD_MACH_O_SET_SR_LENGTH(pinfo
->r_length
)
884 | BFD_MACH_O_SET_SR_TYPE(pinfo
->r_type
)
885 | BFD_MACH_O_SET_SR_ADDRESS(pinfo
->r_address
);
886 bfd_put_32 (abfd
, v
, buf
);
887 bfd_put_32 (abfd
, pinfo
->r_value
, buf
+ 4);
893 bfd_put_32 (abfd
, pinfo
->r_address
, buf
);
894 v
= BFD_MACH_O_SET_R_SYMBOLNUM (pinfo
->r_value
)
895 | (pinfo
->r_pcrel
? BFD_MACH_O_R_PCREL
: 0)
896 | BFD_MACH_O_SET_R_LENGTH (pinfo
->r_length
)
897 | (pinfo
->r_extern
? BFD_MACH_O_R_EXTERN
: 0)
898 | BFD_MACH_O_SET_R_TYPE (pinfo
->r_type
);
899 bfd_put_32 (abfd
, v
, buf
+ 4);
902 if (bfd_bwrite ((void *) buf
, BFD_MACH_O_RELENT_SIZE
, abfd
)
903 != BFD_MACH_O_RELENT_SIZE
)
910 bfd_mach_o_write_section_32 (bfd
*abfd
, bfd_mach_o_section
*section
)
912 unsigned char buf
[BFD_MACH_O_SECTION_SIZE
];
914 memcpy (buf
, section
->sectname
, 16);
915 memcpy (buf
+ 16, section
->segname
, 16);
916 bfd_h_put_32 (abfd
, section
->addr
, buf
+ 32);
917 bfd_h_put_32 (abfd
, section
->size
, buf
+ 36);
918 bfd_h_put_32 (abfd
, section
->offset
, buf
+ 40);
919 bfd_h_put_32 (abfd
, section
->align
, buf
+ 44);
920 bfd_h_put_32 (abfd
, section
->reloff
, buf
+ 48);
921 bfd_h_put_32 (abfd
, section
->nreloc
, buf
+ 52);
922 bfd_h_put_32 (abfd
, section
->flags
, buf
+ 56);
923 bfd_h_put_32 (abfd
, section
->reserved1
, buf
+ 60);
924 bfd_h_put_32 (abfd
, section
->reserved2
, buf
+ 64);
926 if (bfd_bwrite ((void *) buf
, BFD_MACH_O_SECTION_SIZE
, abfd
)
927 != BFD_MACH_O_SECTION_SIZE
)
934 bfd_mach_o_write_section_64 (bfd
*abfd
, bfd_mach_o_section
*section
)
936 unsigned char buf
[BFD_MACH_O_SECTION_64_SIZE
];
938 memcpy (buf
, section
->sectname
, 16);
939 memcpy (buf
+ 16, section
->segname
, 16);
940 bfd_h_put_64 (abfd
, section
->addr
, buf
+ 32);
941 bfd_h_put_64 (abfd
, section
->size
, buf
+ 40);
942 bfd_h_put_32 (abfd
, section
->offset
, buf
+ 48);
943 bfd_h_put_32 (abfd
, section
->align
, buf
+ 52);
944 bfd_h_put_32 (abfd
, section
->reloff
, buf
+ 56);
945 bfd_h_put_32 (abfd
, section
->nreloc
, buf
+ 60);
946 bfd_h_put_32 (abfd
, section
->flags
, buf
+ 64);
947 bfd_h_put_32 (abfd
, section
->reserved1
, buf
+ 68);
948 bfd_h_put_32 (abfd
, section
->reserved2
, buf
+ 72);
949 bfd_h_put_32 (abfd
, section
->reserved3
, buf
+ 76);
951 if (bfd_bwrite ((void *) buf
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
952 != BFD_MACH_O_SECTION_64_SIZE
)
959 bfd_mach_o_write_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
961 unsigned char buf
[BFD_MACH_O_LC_SEGMENT_SIZE
];
962 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
965 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
967 for (i
= 0; i
< seg
->nsects
; i
++)
968 if (!bfd_mach_o_write_relocs (abfd
, &seg
->sections
[i
]))
971 memcpy (buf
, seg
->segname
, 16);
972 bfd_h_put_32 (abfd
, seg
->vmaddr
, buf
+ 16);
973 bfd_h_put_32 (abfd
, seg
->vmsize
, buf
+ 20);
974 bfd_h_put_32 (abfd
, seg
->fileoff
, buf
+ 24);
975 bfd_h_put_32 (abfd
, seg
->filesize
, buf
+ 28);
976 bfd_h_put_32 (abfd
, seg
->maxprot
, buf
+ 32);
977 bfd_h_put_32 (abfd
, seg
->initprot
, buf
+ 36);
978 bfd_h_put_32 (abfd
, seg
->nsects
, buf
+ 40);
979 bfd_h_put_32 (abfd
, seg
->flags
, buf
+ 44);
981 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
982 || (bfd_bwrite ((void *) buf
, BFD_MACH_O_LC_SEGMENT_SIZE
- 8, abfd
)
983 != BFD_MACH_O_LC_SEGMENT_SIZE
- 8))
986 for (i
= 0; i
< seg
->nsects
; i
++)
987 if (bfd_mach_o_write_section_32 (abfd
, &seg
->sections
[i
]))
994 bfd_mach_o_write_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
996 unsigned char buf
[BFD_MACH_O_LC_SEGMENT_64_SIZE
];
997 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
1000 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
1002 for (i
= 0; i
< seg
->nsects
; i
++)
1003 if (!bfd_mach_o_write_relocs (abfd
, &seg
->sections
[i
]))
1006 memcpy (buf
, seg
->segname
, 16);
1007 bfd_h_put_64 (abfd
, seg
->vmaddr
, buf
+ 16);
1008 bfd_h_put_64 (abfd
, seg
->vmsize
, buf
+ 24);
1009 bfd_h_put_64 (abfd
, seg
->fileoff
, buf
+ 32);
1010 bfd_h_put_64 (abfd
, seg
->filesize
, buf
+ 40);
1011 bfd_h_put_32 (abfd
, seg
->maxprot
, buf
+ 48);
1012 bfd_h_put_32 (abfd
, seg
->initprot
, buf
+ 52);
1013 bfd_h_put_32 (abfd
, seg
->nsects
, buf
+ 56);
1014 bfd_h_put_32 (abfd
, seg
->flags
, buf
+ 60);
1016 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
1017 || (bfd_bwrite ((void *) buf
, BFD_MACH_O_LC_SEGMENT_64_SIZE
- 8, abfd
)
1018 != BFD_MACH_O_LC_SEGMENT_64_SIZE
- 8))
1021 for (i
= 0; i
< seg
->nsects
; i
++)
1022 if (bfd_mach_o_write_section_64 (abfd
, &seg
->sections
[i
]))
1029 bfd_mach_o_write_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1031 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1032 bfd_mach_o_symtab_command
*sym
= &command
->command
.symtab
;
1033 unsigned char buf
[16];
1035 unsigned int wide
= bfd_mach_o_wide_p (abfd
);
1036 unsigned int symlen
= wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1037 struct bfd_strtab_hash
*strtab
;
1038 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1040 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
1042 /* Write the symbols first. */
1043 mdata
->filelen
= FILE_ALIGN(mdata
->filelen
, wide
? 3 : 2);
1044 sym
->symoff
= mdata
->filelen
;
1045 if (bfd_seek (abfd
, sym
->symoff
, SEEK_SET
) != 0)
1048 sym
->nsyms
= bfd_get_symcount (abfd
);
1049 mdata
->filelen
+= sym
->nsyms
* symlen
;
1051 strtab
= _bfd_stringtab_init ();
1055 for (i
= 0; i
< sym
->nsyms
; i
++)
1057 bfd_size_type str_index
;
1058 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1060 /* Compute name index. */
1061 /* An index of 0 always means the empty string. */
1062 if (s
->symbol
.name
== 0 || s
->symbol
.name
[0] == '\0')
1066 str_index
= _bfd_stringtab_add (strtab
, s
->symbol
.name
, TRUE
, FALSE
);
1067 if (str_index
== (bfd_size_type
) -1)
1070 bfd_h_put_32 (abfd
, str_index
, buf
);
1071 bfd_h_put_8 (abfd
, s
->n_type
, buf
+ 4);
1072 bfd_h_put_8 (abfd
, s
->n_sect
, buf
+ 5);
1073 bfd_h_put_16 (abfd
, s
->n_desc
, buf
+ 6);
1075 bfd_h_put_64 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
, buf
+ 8);
1077 bfd_h_put_32 (abfd
, s
->symbol
.section
->vma
+ s
->symbol
.value
, buf
+ 8);
1079 if (bfd_bwrite ((void *) buf
, symlen
, abfd
) != symlen
)
1082 sym
->strsize
= _bfd_stringtab_size (strtab
);
1083 sym
->stroff
= mdata
->filelen
;
1084 mdata
->filelen
+= sym
->strsize
;
1086 if (_bfd_stringtab_emit (abfd
, strtab
) != TRUE
)
1088 _bfd_stringtab_free (strtab
);
1091 bfd_h_put_32 (abfd
, sym
->symoff
, buf
);
1092 bfd_h_put_32 (abfd
, sym
->nsyms
, buf
+ 4);
1093 bfd_h_put_32 (abfd
, sym
->stroff
, buf
+ 8);
1094 bfd_h_put_32 (abfd
, sym
->strsize
, buf
+ 12);
1096 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
1097 || bfd_bwrite ((void *) buf
, 16, abfd
) != 16)
1103 _bfd_stringtab_free (strtab
);
1107 /* Process the symbols and generate Mach-O specific fields.
1111 bfd_mach_o_mangle_symbols (bfd
*abfd
)
1114 asymbol
**symbols
= bfd_get_outsymbols (abfd
);
1116 for (i
= 0; i
< bfd_get_symcount (abfd
); i
++)
1118 bfd_mach_o_asymbol
*s
= (bfd_mach_o_asymbol
*)symbols
[i
];
1120 if (s
->n_type
== BFD_MACH_O_N_UNDF
&& !(s
->symbol
.flags
& BSF_DEBUGGING
))
1122 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1123 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1124 values haven't been set. */
1125 if (s
->symbol
.section
== bfd_abs_section_ptr
)
1126 s
->n_type
= BFD_MACH_O_N_ABS
;
1127 else if (s
->symbol
.section
== bfd_und_section_ptr
)
1129 s
->n_type
= BFD_MACH_O_N_UNDF
;
1130 if (s
->symbol
.flags
& BSF_WEAK
)
1131 s
->n_desc
|= BFD_MACH_O_N_WEAK_REF
;
1133 else if (s
->symbol
.section
== bfd_com_section_ptr
)
1134 s
->n_type
= BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
;
1136 s
->n_type
= BFD_MACH_O_N_SECT
;
1138 if (s
->symbol
.flags
& BSF_GLOBAL
)
1139 s
->n_type
|= BFD_MACH_O_N_EXT
;
1142 /* Compute section index. */
1143 if (s
->symbol
.section
!= bfd_abs_section_ptr
1144 && s
->symbol
.section
!= bfd_und_section_ptr
1145 && s
->symbol
.section
!= bfd_com_section_ptr
)
1146 s
->n_sect
= s
->symbol
.section
->target_index
;
1148 /* Number symbols. */
1149 s
->symbol
.udata
.i
= i
;
1155 bfd_mach_o_write_contents (bfd
*abfd
)
1158 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1160 if (mdata
->header
.ncmds
== 0)
1161 if (!bfd_mach_o_build_commands (abfd
))
1164 /* Now write header information. */
1165 if (mdata
->header
.filetype
== 0)
1167 if (abfd
->flags
& EXEC_P
)
1168 mdata
->header
.filetype
= BFD_MACH_O_MH_EXECUTE
;
1169 else if (abfd
->flags
& DYNAMIC
)
1170 mdata
->header
.filetype
= BFD_MACH_O_MH_DYLIB
;
1172 mdata
->header
.filetype
= BFD_MACH_O_MH_OBJECT
;
1174 if (!bfd_mach_o_write_header (abfd
, &mdata
->header
))
1177 /* Assign a number to each symbols. */
1178 if (!bfd_mach_o_mangle_symbols (abfd
))
1181 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
1183 unsigned char buf
[8];
1184 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
1185 unsigned long typeflag
;
1187 typeflag
= cur
->type
| (cur
->type_required
? BFD_MACH_O_LC_REQ_DYLD
: 0);
1189 bfd_h_put_32 (abfd
, typeflag
, buf
);
1190 bfd_h_put_32 (abfd
, cur
->len
, buf
+ 4);
1192 if (bfd_seek (abfd
, cur
->offset
, SEEK_SET
) != 0
1193 || bfd_bwrite ((void *) buf
, 8, abfd
) != 8)
1198 case BFD_MACH_O_LC_SEGMENT
:
1199 if (bfd_mach_o_write_segment_32 (abfd
, cur
) != 0)
1202 case BFD_MACH_O_LC_SEGMENT_64
:
1203 if (bfd_mach_o_write_segment_64 (abfd
, cur
) != 0)
1206 case BFD_MACH_O_LC_SYMTAB
:
1207 if (!bfd_mach_o_write_symtab (abfd
, cur
))
1210 case BFD_MACH_O_LC_SYMSEG
:
1212 case BFD_MACH_O_LC_THREAD
:
1213 case BFD_MACH_O_LC_UNIXTHREAD
:
1214 if (bfd_mach_o_write_thread (abfd
, cur
) != 0)
1217 case BFD_MACH_O_LC_LOADFVMLIB
:
1218 case BFD_MACH_O_LC_IDFVMLIB
:
1219 case BFD_MACH_O_LC_IDENT
:
1220 case BFD_MACH_O_LC_FVMFILE
:
1221 case BFD_MACH_O_LC_PREPAGE
:
1222 case BFD_MACH_O_LC_DYSYMTAB
:
1223 case BFD_MACH_O_LC_LOAD_DYLIB
:
1224 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
1225 case BFD_MACH_O_LC_ID_DYLIB
:
1226 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
1227 case BFD_MACH_O_LC_LOAD_DYLINKER
:
1228 case BFD_MACH_O_LC_ID_DYLINKER
:
1229 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
1230 case BFD_MACH_O_LC_ROUTINES
:
1231 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
1235 "unable to write unknown load command 0x%lx\n",
1236 (unsigned long) cur
->type
);
1244 /* Build Mach-O load commands from the sections. */
1247 bfd_mach_o_build_commands (bfd
*abfd
)
1249 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1250 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1251 bfd_mach_o_segment_command
*seg
;
1252 bfd_mach_o_section
*sections
;
1254 bfd_mach_o_load_command
*cmd
;
1255 bfd_mach_o_load_command
*symtab_cmd
;
1258 /* Return now if commands are already built. */
1259 if (mdata
->header
.ncmds
)
1262 /* Very simple version: 1 command (segment) containing all sections. */
1263 mdata
->header
.ncmds
= 2;
1264 mdata
->commands
= bfd_alloc (abfd
, mdata
->header
.ncmds
1265 * sizeof (bfd_mach_o_load_command
));
1266 if (mdata
->commands
== NULL
)
1268 cmd
= &mdata
->commands
[0];
1269 seg
= &cmd
->command
.segment
;
1271 seg
->nsects
= bfd_count_sections (abfd
);
1272 sections
= bfd_alloc (abfd
, seg
->nsects
* sizeof (bfd_mach_o_section
));
1273 if (sections
== NULL
)
1275 seg
->sections
= sections
;
1277 /* Set segment command. */
1280 cmd
->type
= BFD_MACH_O_LC_SEGMENT_64
;
1281 cmd
->offset
= BFD_MACH_O_HEADER_64_SIZE
;
1282 cmd
->len
= BFD_MACH_O_LC_SEGMENT_64_SIZE
1283 + BFD_MACH_O_SECTION_64_SIZE
* seg
->nsects
;
1287 cmd
->type
= BFD_MACH_O_LC_SEGMENT
;
1288 cmd
->offset
= BFD_MACH_O_HEADER_SIZE
;
1289 cmd
->len
= BFD_MACH_O_LC_SEGMENT_SIZE
1290 + BFD_MACH_O_SECTION_SIZE
* seg
->nsects
;
1292 cmd
->type_required
= FALSE
;
1293 mdata
->header
.sizeofcmds
= cmd
->len
;
1294 mdata
->filelen
= cmd
->offset
+ cmd
->len
;
1296 /* Set symtab command. */
1297 symtab_cmd
= &mdata
->commands
[1];
1299 symtab_cmd
->type
= BFD_MACH_O_LC_SYMTAB
;
1300 symtab_cmd
->offset
= cmd
->offset
+ cmd
->len
;
1301 symtab_cmd
->len
= 6 * 4;
1302 symtab_cmd
->type_required
= FALSE
;
1304 mdata
->header
.sizeofcmds
+= symtab_cmd
->len
;
1305 mdata
->filelen
+= symtab_cmd
->len
;
1307 /* Fill segment command. */
1308 memset (seg
->segname
, 0, sizeof (seg
->segname
));
1310 seg
->fileoff
= mdata
->filelen
;
1312 seg
->maxprot
= BFD_MACH_O_PROT_READ
| BFD_MACH_O_PROT_WRITE
1313 | BFD_MACH_O_PROT_EXECUTE
;
1314 seg
->initprot
= seg
->maxprot
;
1317 /* Create Mach-O sections. */
1319 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1321 sections
->bfdsection
= sec
;
1322 bfd_mach_o_convert_section_name_to_mach_o (abfd
, sec
, sections
);
1323 sections
->addr
= bfd_get_section_vma (abfd
, sec
);
1324 sections
->size
= bfd_get_section_size (sec
);
1325 sections
->align
= bfd_get_section_alignment (abfd
, sec
);
1327 if (sections
->size
!= 0)
1329 mdata
->filelen
= FILE_ALIGN (mdata
->filelen
, sections
->align
);
1330 sections
->offset
= mdata
->filelen
;
1333 sections
->offset
= 0;
1334 sections
->reloff
= 0;
1335 sections
->nreloc
= 0;
1336 sections
->reserved1
= 0;
1337 sections
->reserved2
= 0;
1338 sections
->reserved3
= 0;
1340 sec
->filepos
= sections
->offset
;
1341 sec
->target_index
= ++target_index
;
1343 mdata
->filelen
+= sections
->size
;
1346 seg
->filesize
= mdata
->filelen
- seg
->fileoff
;
1347 seg
->vmsize
= seg
->filesize
;
1352 /* Set the contents of a section. */
1355 bfd_mach_o_set_section_contents (bfd
*abfd
,
1357 const void * location
,
1359 bfd_size_type count
)
1363 /* This must be done first, because bfd_set_section_contents is
1364 going to set output_has_begun to TRUE. */
1365 if (! abfd
->output_has_begun
&& ! bfd_mach_o_build_commands (abfd
))
1371 pos
= section
->filepos
+ offset
;
1372 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
1373 || bfd_bwrite (location
, count
, abfd
) != count
)
1380 bfd_mach_o_sizeof_headers (bfd
*a ATTRIBUTE_UNUSED
,
1381 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1386 /* Make an empty symbol. This is required only because
1387 bfd_make_section_anyway wants to create a symbol for the section. */
1390 bfd_mach_o_make_empty_symbol (bfd
*abfd
)
1392 asymbol
*new_symbol
;
1394 new_symbol
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_asymbol
));
1395 if (new_symbol
== NULL
)
1397 new_symbol
->the_bfd
= abfd
;
1398 new_symbol
->udata
.i
= 0;
1403 bfd_mach_o_read_header (bfd
*abfd
, bfd_mach_o_header
*header
)
1405 unsigned char buf
[32];
1407 bfd_vma (*get32
) (const void *) = NULL
;
1409 /* Just read the magic number. */
1410 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1411 || bfd_bread ((void *) buf
, 4, abfd
) != 4)
1414 if (bfd_getb32 (buf
) == BFD_MACH_O_MH_MAGIC
)
1416 header
->byteorder
= BFD_ENDIAN_BIG
;
1417 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1418 header
->version
= 1;
1421 else if (bfd_getl32 (buf
) == BFD_MACH_O_MH_MAGIC
)
1423 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1424 header
->magic
= BFD_MACH_O_MH_MAGIC
;
1425 header
->version
= 1;
1428 else if (bfd_getb32 (buf
) == BFD_MACH_O_MH_MAGIC_64
)
1430 header
->byteorder
= BFD_ENDIAN_BIG
;
1431 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1432 header
->version
= 2;
1435 else if (bfd_getl32 (buf
) == BFD_MACH_O_MH_MAGIC_64
)
1437 header
->byteorder
= BFD_ENDIAN_LITTLE
;
1438 header
->magic
= BFD_MACH_O_MH_MAGIC_64
;
1439 header
->version
= 2;
1444 header
->byteorder
= BFD_ENDIAN_UNKNOWN
;
1448 /* Once the size of the header is known, read the full header. */
1449 size
= mach_o_wide_p (header
) ?
1450 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
1452 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1453 || bfd_bread ((void *) buf
, size
, abfd
) != size
)
1456 header
->cputype
= (*get32
) (buf
+ 4);
1457 header
->cpusubtype
= (*get32
) (buf
+ 8);
1458 header
->filetype
= (*get32
) (buf
+ 12);
1459 header
->ncmds
= (*get32
) (buf
+ 16);
1460 header
->sizeofcmds
= (*get32
) (buf
+ 20);
1461 header
->flags
= (*get32
) (buf
+ 24);
1463 if (mach_o_wide_p (header
))
1464 header
->reserved
= (*get32
) (buf
+ 28);
1470 bfd_mach_o_make_bfd_section (bfd
*abfd
, bfd_mach_o_section
*section
,
1477 sname
= bfd_mach_o_convert_section_name_to_bfd (abfd
, section
);
1481 if ((section
->flags
& BFD_MACH_O_S_ATTR_DEBUG
)
1482 || !strcmp (section
->segname
, "__DWARF"))
1484 /* Force flags for dwarf sections. This looks weird but dsym files
1485 have no flags for them and this is important for gdb. */
1486 flags
= SEC_HAS_CONTENTS
| SEC_DEBUGGING
;
1491 if ((section
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
1492 != BFD_MACH_O_S_ZEROFILL
)
1494 flags
|= SEC_HAS_CONTENTS
| SEC_LOAD
;
1495 if (prot
& BFD_MACH_O_PROT_EXECUTE
)
1497 if (prot
& BFD_MACH_O_PROT_WRITE
)
1499 else if (prot
& BFD_MACH_O_PROT_READ
)
1500 flags
|= SEC_READONLY
;
1503 if (section
->nreloc
!= 0)
1506 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, sname
, flags
);
1510 bfdsec
->vma
= section
->addr
;
1511 bfdsec
->lma
= section
->addr
;
1512 bfdsec
->size
= section
->size
;
1513 bfdsec
->filepos
= section
->offset
;
1514 bfdsec
->alignment_power
= section
->align
;
1515 bfdsec
->segment_mark
= 0;
1516 bfdsec
->reloc_count
= section
->nreloc
;
1517 bfdsec
->rel_filepos
= section
->reloff
;
1523 bfd_mach_o_read_section_32 (bfd
*abfd
,
1524 bfd_mach_o_section
*section
,
1525 unsigned int offset
,
1528 unsigned char buf
[BFD_MACH_O_SECTION_SIZE
];
1530 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1531 || (bfd_bread ((void *) buf
, BFD_MACH_O_SECTION_SIZE
, abfd
)
1532 != BFD_MACH_O_SECTION_SIZE
))
1535 memcpy (section
->sectname
, buf
, 16);
1536 section
->sectname
[16] = '\0';
1537 memcpy (section
->segname
, buf
+ 16, 16);
1538 section
->segname
[16] = '\0';
1539 section
->addr
= bfd_h_get_32 (abfd
, buf
+ 32);
1540 section
->size
= bfd_h_get_32 (abfd
, buf
+ 36);
1541 section
->offset
= bfd_h_get_32 (abfd
, buf
+ 40);
1542 section
->align
= bfd_h_get_32 (abfd
, buf
+ 44);
1543 section
->reloff
= bfd_h_get_32 (abfd
, buf
+ 48);
1544 section
->nreloc
= bfd_h_get_32 (abfd
, buf
+ 52);
1545 section
->flags
= bfd_h_get_32 (abfd
, buf
+ 56);
1546 section
->reserved1
= bfd_h_get_32 (abfd
, buf
+ 60);
1547 section
->reserved2
= bfd_h_get_32 (abfd
, buf
+ 64);
1548 section
->reserved3
= 0;
1549 section
->bfdsection
= bfd_mach_o_make_bfd_section (abfd
, section
, prot
);
1551 if (section
->bfdsection
== NULL
)
1558 bfd_mach_o_read_section_64 (bfd
*abfd
,
1559 bfd_mach_o_section
*section
,
1560 unsigned int offset
,
1563 unsigned char buf
[BFD_MACH_O_SECTION_64_SIZE
];
1565 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0
1566 || (bfd_bread ((void *) buf
, BFD_MACH_O_SECTION_64_SIZE
, abfd
)
1567 != BFD_MACH_O_SECTION_64_SIZE
))
1570 memcpy (section
->sectname
, buf
, 16);
1571 section
->sectname
[16] = '\0';
1572 memcpy (section
->segname
, buf
+ 16, 16);
1573 section
->segname
[16] = '\0';
1574 section
->addr
= bfd_h_get_64 (abfd
, buf
+ 32);
1575 section
->size
= bfd_h_get_64 (abfd
, buf
+ 40);
1576 section
->offset
= bfd_h_get_32 (abfd
, buf
+ 48);
1577 section
->align
= bfd_h_get_32 (abfd
, buf
+ 52);
1578 section
->reloff
= bfd_h_get_32 (abfd
, buf
+ 56);
1579 section
->nreloc
= bfd_h_get_32 (abfd
, buf
+ 60);
1580 section
->flags
= bfd_h_get_32 (abfd
, buf
+ 64);
1581 section
->reserved1
= bfd_h_get_32 (abfd
, buf
+ 68);
1582 section
->reserved2
= bfd_h_get_32 (abfd
, buf
+ 72);
1583 section
->reserved3
= bfd_h_get_32 (abfd
, buf
+ 76);
1584 section
->bfdsection
= bfd_mach_o_make_bfd_section (abfd
, section
, prot
);
1586 if (section
->bfdsection
== NULL
)
1593 bfd_mach_o_read_section (bfd
*abfd
,
1594 bfd_mach_o_section
*section
,
1595 unsigned int offset
,
1600 return bfd_mach_o_read_section_64 (abfd
, section
, offset
, prot
);
1602 return bfd_mach_o_read_section_32 (abfd
, section
, offset
, prot
);
1606 bfd_mach_o_read_symtab_symbol (bfd
*abfd
,
1607 bfd_mach_o_symtab_command
*sym
,
1608 bfd_mach_o_asymbol
*s
,
1611 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1612 unsigned int wide
= mach_o_wide_p (&mdata
->header
);
1613 unsigned int symwidth
=
1614 wide
? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
;
1615 unsigned int symoff
= sym
->symoff
+ (i
* symwidth
);
1616 unsigned char buf
[16];
1617 unsigned char type
= -1;
1618 unsigned char section
= -1;
1620 symvalue value
= -1;
1621 unsigned long stroff
= -1;
1622 unsigned int symtype
= -1;
1624 BFD_ASSERT (sym
->strtab
!= NULL
);
1626 if (bfd_seek (abfd
, symoff
, SEEK_SET
) != 0
1627 || bfd_bread ((void *) buf
, symwidth
, abfd
) != symwidth
)
1629 fprintf (stderr
, "bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu\n",
1630 symwidth
, (unsigned long) symoff
);
1634 stroff
= bfd_h_get_32 (abfd
, buf
);
1635 type
= bfd_h_get_8 (abfd
, buf
+ 4);
1636 symtype
= type
& BFD_MACH_O_N_TYPE
;
1637 section
= bfd_h_get_8 (abfd
, buf
+ 5);
1638 desc
= bfd_h_get_16 (abfd
, buf
+ 6);
1640 value
= bfd_h_get_64 (abfd
, buf
+ 8);
1642 value
= bfd_h_get_32 (abfd
, buf
+ 8);
1644 if (stroff
>= sym
->strsize
)
1646 fprintf (stderr
, "bfd_mach_o_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
1647 (unsigned long) stroff
, (unsigned long) sym
->strsize
);
1651 s
->symbol
.the_bfd
= abfd
;
1652 s
->symbol
.name
= sym
->strtab
+ stroff
;
1653 s
->symbol
.value
= value
;
1654 s
->symbol
.flags
= 0x0;
1655 s
->symbol
.udata
.i
= 0;
1657 s
->n_sect
= section
;
1660 if (type
& BFD_MACH_O_N_STAB
)
1662 s
->symbol
.flags
|= BSF_DEBUGGING
;
1663 s
->symbol
.section
= bfd_und_section_ptr
;
1675 if ((section
> 0) && (section
<= mdata
->nsects
))
1677 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1679 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1686 if (type
& BFD_MACH_O_N_PEXT
)
1687 s
->symbol
.flags
|= BSF_GLOBAL
;
1689 if (type
& BFD_MACH_O_N_EXT
)
1690 s
->symbol
.flags
|= BSF_GLOBAL
;
1692 if (!(type
& (BFD_MACH_O_N_PEXT
| BFD_MACH_O_N_EXT
)))
1693 s
->symbol
.flags
|= BSF_LOCAL
;
1697 case BFD_MACH_O_N_UNDF
:
1698 if (type
== (BFD_MACH_O_N_UNDF
| BFD_MACH_O_N_EXT
)
1699 && s
->symbol
.value
!= 0)
1701 /* A common symbol. */
1702 s
->symbol
.section
= bfd_com_section_ptr
;
1703 s
->symbol
.flags
= BSF_NO_FLAGS
;
1707 s
->symbol
.section
= bfd_und_section_ptr
;
1708 if (s
->n_desc
& BFD_MACH_O_N_WEAK_REF
)
1709 s
->symbol
.flags
|= BSF_WEAK
;
1712 case BFD_MACH_O_N_PBUD
:
1713 s
->symbol
.section
= bfd_und_section_ptr
;
1715 case BFD_MACH_O_N_ABS
:
1716 s
->symbol
.section
= bfd_abs_section_ptr
;
1718 case BFD_MACH_O_N_SECT
:
1719 if ((section
> 0) && (section
<= mdata
->nsects
))
1721 s
->symbol
.section
= mdata
->sections
[section
- 1]->bfdsection
;
1723 s
->symbol
.value
- mdata
->sections
[section
- 1]->addr
;
1727 /* Mach-O uses 0 to mean "no section"; not an error. */
1730 fprintf (stderr
, "bfd_mach_o_read_symtab_symbol: "
1731 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
1732 s
->symbol
.name
, section
, mdata
->nsects
);
1734 s
->symbol
.section
= bfd_und_section_ptr
;
1737 case BFD_MACH_O_N_INDR
:
1738 fprintf (stderr
, "bfd_mach_o_read_symtab_symbol: "
1739 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
1741 s
->symbol
.section
= bfd_und_section_ptr
;
1744 fprintf (stderr
, "bfd_mach_o_read_symtab_symbol: "
1745 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
1746 s
->symbol
.name
, symtype
);
1747 s
->symbol
.section
= bfd_und_section_ptr
;
1756 bfd_mach_o_read_symtab_strtab (bfd
*abfd
)
1758 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1759 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1761 /* Fail if there is no symtab. */
1765 /* Success if already loaded. */
1769 if (abfd
->flags
& BFD_IN_MEMORY
)
1771 struct bfd_in_memory
*b
;
1773 b
= (struct bfd_in_memory
*) abfd
->iostream
;
1775 if ((sym
->stroff
+ sym
->strsize
) > b
->size
)
1777 bfd_set_error (bfd_error_file_truncated
);
1780 sym
->strtab
= (char *) b
->buffer
+ sym
->stroff
;
1784 sym
->strtab
= bfd_alloc (abfd
, sym
->strsize
);
1785 if (sym
->strtab
== NULL
)
1788 if (bfd_seek (abfd
, sym
->stroff
, SEEK_SET
) != 0
1789 || bfd_bread ((void *) sym
->strtab
, sym
->strsize
, abfd
) != sym
->strsize
)
1791 bfd_set_error (bfd_error_file_truncated
);
1800 bfd_mach_o_read_symtab_symbols (bfd
*abfd
)
1802 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1803 bfd_mach_o_symtab_command
*sym
= mdata
->symtab
;
1810 sym
->symbols
= bfd_alloc (abfd
, sym
->nsyms
* sizeof (bfd_mach_o_asymbol
));
1812 if (sym
->symbols
== NULL
)
1814 fprintf (stderr
, "bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols\n");
1818 ret
= bfd_mach_o_read_symtab_strtab (abfd
);
1822 for (i
= 0; i
< sym
->nsyms
; i
++)
1824 ret
= bfd_mach_o_read_symtab_symbol (abfd
, sym
, &sym
->symbols
[i
], i
);
1833 bfd_mach_o_read_dysymtab_symbol (bfd
*abfd
,
1834 bfd_mach_o_dysymtab_command
*dysym
,
1835 bfd_mach_o_symtab_command
*sym
,
1836 bfd_mach_o_asymbol
*s
,
1839 unsigned long isymoff
= dysym
->indirectsymoff
+ (i
* 4);
1840 unsigned long sym_index
;
1841 unsigned char buf
[4];
1843 BFD_ASSERT (i
< dysym
->nindirectsyms
);
1845 if (bfd_seek (abfd
, isymoff
, SEEK_SET
) != 0
1846 || bfd_bread ((void *) buf
, 4, abfd
) != 4)
1848 fprintf (stderr
, "bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
1849 (unsigned long) 4, isymoff
);
1852 sym_index
= bfd_h_get_32 (abfd
, buf
);
1854 return bfd_mach_o_read_symtab_symbol (abfd
, sym
, s
, sym_index
);
1858 bfd_mach_o_i386_flavour_string (unsigned int flavour
)
1860 switch ((int) flavour
)
1862 case BFD_MACH_O_x86_THREAD_STATE32
: return "x86_THREAD_STATE32";
1863 case BFD_MACH_O_x86_FLOAT_STATE32
: return "x86_FLOAT_STATE32";
1864 case BFD_MACH_O_x86_EXCEPTION_STATE32
: return "x86_EXCEPTION_STATE32";
1865 case BFD_MACH_O_x86_THREAD_STATE64
: return "x86_THREAD_STATE64";
1866 case BFD_MACH_O_x86_FLOAT_STATE64
: return "x86_FLOAT_STATE64";
1867 case BFD_MACH_O_x86_EXCEPTION_STATE64
: return "x86_EXCEPTION_STATE64";
1868 case BFD_MACH_O_x86_THREAD_STATE
: return "x86_THREAD_STATE";
1869 case BFD_MACH_O_x86_FLOAT_STATE
: return "x86_FLOAT_STATE";
1870 case BFD_MACH_O_x86_EXCEPTION_STATE
: return "x86_EXCEPTION_STATE";
1871 case BFD_MACH_O_x86_DEBUG_STATE32
: return "x86_DEBUG_STATE32";
1872 case BFD_MACH_O_x86_DEBUG_STATE64
: return "x86_DEBUG_STATE64";
1873 case BFD_MACH_O_x86_DEBUG_STATE
: return "x86_DEBUG_STATE";
1874 case BFD_MACH_O_x86_THREAD_STATE_NONE
: return "x86_THREAD_STATE_NONE";
1875 default: return "UNKNOWN";
1880 bfd_mach_o_ppc_flavour_string (unsigned int flavour
)
1882 switch ((int) flavour
)
1884 case BFD_MACH_O_PPC_THREAD_STATE
: return "PPC_THREAD_STATE";
1885 case BFD_MACH_O_PPC_FLOAT_STATE
: return "PPC_FLOAT_STATE";
1886 case BFD_MACH_O_PPC_EXCEPTION_STATE
: return "PPC_EXCEPTION_STATE";
1887 case BFD_MACH_O_PPC_VECTOR_STATE
: return "PPC_VECTOR_STATE";
1888 case BFD_MACH_O_PPC_THREAD_STATE64
: return "PPC_THREAD_STATE64";
1889 case BFD_MACH_O_PPC_EXCEPTION_STATE64
: return "PPC_EXCEPTION_STATE64";
1890 default: return "UNKNOWN";
1895 bfd_mach_o_read_dylinker (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1897 bfd_mach_o_dylinker_command
*cmd
= &command
->command
.dylinker
;
1898 unsigned char buf
[4];
1899 unsigned int nameoff
;
1901 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_ID_DYLINKER
)
1902 || (command
->type
== BFD_MACH_O_LC_LOAD_DYLINKER
));
1904 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
1905 || bfd_bread ((void *) buf
, 4, abfd
) != 4)
1908 nameoff
= bfd_h_get_32 (abfd
, buf
+ 0);
1910 cmd
->name_offset
= command
->offset
+ nameoff
;
1911 cmd
->name_len
= command
->len
- nameoff
;
1912 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
1913 if (cmd
->name_str
== NULL
)
1915 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
1916 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
1922 bfd_mach_o_read_dylib (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1924 bfd_mach_o_dylib_command
*cmd
= &command
->command
.dylib
;
1925 unsigned char buf
[16];
1926 unsigned int nameoff
;
1928 switch (command
->type
)
1930 case BFD_MACH_O_LC_LOAD_DYLIB
:
1931 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
1932 case BFD_MACH_O_LC_ID_DYLIB
:
1933 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
1940 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
1941 || bfd_bread ((void *) buf
, 16, abfd
) != 16)
1944 nameoff
= bfd_h_get_32 (abfd
, buf
+ 0);
1945 cmd
->timestamp
= bfd_h_get_32 (abfd
, buf
+ 4);
1946 cmd
->current_version
= bfd_h_get_32 (abfd
, buf
+ 8);
1947 cmd
->compatibility_version
= bfd_h_get_32 (abfd
, buf
+ 12);
1949 cmd
->name_offset
= command
->offset
+ nameoff
;
1950 cmd
->name_len
= command
->len
- nameoff
;
1951 cmd
->name_str
= bfd_alloc (abfd
, cmd
->name_len
);
1952 if (cmd
->name_str
== NULL
)
1954 if (bfd_seek (abfd
, cmd
->name_offset
, SEEK_SET
) != 0
1955 || bfd_bread (cmd
->name_str
, cmd
->name_len
, abfd
) != cmd
->name_len
)
1961 bfd_mach_o_read_prebound_dylib (bfd
*abfd ATTRIBUTE_UNUSED
,
1962 bfd_mach_o_load_command
*command ATTRIBUTE_UNUSED
)
1964 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
1966 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_PREBOUND_DYLIB
);
1971 bfd_mach_o_read_thread (bfd
*abfd
, bfd_mach_o_load_command
*command
)
1973 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
1974 bfd_mach_o_thread_command
*cmd
= &command
->command
.thread
;
1975 unsigned char buf
[8];
1976 unsigned int offset
;
1977 unsigned int nflavours
;
1980 BFD_ASSERT ((command
->type
== BFD_MACH_O_LC_THREAD
)
1981 || (command
->type
== BFD_MACH_O_LC_UNIXTHREAD
));
1983 /* Count the number of threads. */
1986 while (offset
!= command
->len
)
1988 if (offset
>= command
->len
)
1991 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
1992 || bfd_bread ((void *) buf
, 8, abfd
) != 8)
1995 offset
+= 8 + bfd_h_get_32 (abfd
, buf
+ 4) * 4;
1999 /* Allocate threads. */
2000 cmd
->flavours
= bfd_alloc
2001 (abfd
, nflavours
* sizeof (bfd_mach_o_thread_flavour
));
2002 if (cmd
->flavours
== NULL
)
2004 cmd
->nflavours
= nflavours
;
2008 while (offset
!= command
->len
)
2010 if (offset
>= command
->len
)
2013 if (nflavours
>= cmd
->nflavours
)
2016 if (bfd_seek (abfd
, command
->offset
+ offset
, SEEK_SET
) != 0
2017 || bfd_bread ((void *) buf
, 8, abfd
) != 8)
2020 cmd
->flavours
[nflavours
].flavour
= bfd_h_get_32 (abfd
, buf
);
2021 cmd
->flavours
[nflavours
].offset
= command
->offset
+ offset
+ 8;
2022 cmd
->flavours
[nflavours
].size
= bfd_h_get_32 (abfd
, buf
+ 4) * 4;
2023 offset
+= cmd
->flavours
[nflavours
].size
+ 8;
2027 for (i
= 0; i
< nflavours
; i
++)
2030 unsigned int snamelen
;
2032 const char *flavourstr
;
2033 const char *prefix
= "LC_THREAD";
2036 switch (mdata
->header
.cputype
)
2038 case BFD_MACH_O_CPU_TYPE_POWERPC
:
2039 case BFD_MACH_O_CPU_TYPE_POWERPC_64
:
2040 flavourstr
= bfd_mach_o_ppc_flavour_string (cmd
->flavours
[i
].flavour
);
2042 case BFD_MACH_O_CPU_TYPE_I386
:
2043 case BFD_MACH_O_CPU_TYPE_X86_64
:
2044 flavourstr
= bfd_mach_o_i386_flavour_string (cmd
->flavours
[i
].flavour
);
2047 flavourstr
= "UNKNOWN_ARCHITECTURE";
2051 snamelen
= strlen (prefix
) + 1 + 20 + 1 + strlen (flavourstr
) + 1;
2052 sname
= bfd_alloc (abfd
, snamelen
);
2058 sprintf (sname
, "%s.%s.%u", prefix
, flavourstr
, j
);
2059 if (bfd_get_section_by_name (abfd
, sname
) == NULL
)
2064 bfdsec
= bfd_make_section_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
2068 bfdsec
->size
= cmd
->flavours
[i
].size
;
2069 bfdsec
->filepos
= cmd
->flavours
[i
].offset
;
2070 bfdsec
->alignment_power
= 0x0;
2072 cmd
->section
= bfdsec
;
2079 bfd_mach_o_read_dysymtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2081 bfd_mach_o_dysymtab_command
*cmd
= &command
->command
.dysymtab
;
2082 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2083 unsigned char buf
[72];
2085 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_DYSYMTAB
);
2087 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2088 || bfd_bread ((void *) buf
, 72, abfd
) != 72)
2091 cmd
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 0);
2092 cmd
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 4);
2093 cmd
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
2094 cmd
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
2095 cmd
->iundefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
2096 cmd
->nundefsym
= bfd_h_get_32 (abfd
, buf
+ 20);
2097 cmd
->tocoff
= bfd_h_get_32 (abfd
, buf
+ 24);
2098 cmd
->ntoc
= bfd_h_get_32 (abfd
, buf
+ 28);
2099 cmd
->modtaboff
= bfd_h_get_32 (abfd
, buf
+ 32);
2100 cmd
->nmodtab
= bfd_h_get_32 (abfd
, buf
+ 36);
2101 cmd
->extrefsymoff
= bfd_h_get_32 (abfd
, buf
+ 40);
2102 cmd
->nextrefsyms
= bfd_h_get_32 (abfd
, buf
+ 44);
2103 cmd
->indirectsymoff
= bfd_h_get_32 (abfd
, buf
+ 48);
2104 cmd
->nindirectsyms
= bfd_h_get_32 (abfd
, buf
+ 52);
2105 cmd
->extreloff
= bfd_h_get_32 (abfd
, buf
+ 56);
2106 cmd
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 60);
2107 cmd
->locreloff
= bfd_h_get_32 (abfd
, buf
+ 64);
2108 cmd
->nlocrel
= bfd_h_get_32 (abfd
, buf
+ 68);
2110 if (cmd
->nmodtab
!= 0)
2113 int wide
= bfd_mach_o_wide_p (abfd
);
2114 unsigned int module_len
= wide
? 56 : 52;
2117 bfd_alloc (abfd
, cmd
->nmodtab
* sizeof (bfd_mach_o_dylib_module
));
2118 if (cmd
->dylib_module
== NULL
)
2121 if (bfd_seek (abfd
, cmd
->modtaboff
, SEEK_SET
) != 0)
2124 for (i
= 0; i
< cmd
->nmodtab
; i
++)
2126 bfd_mach_o_dylib_module
*module
= &cmd
->dylib_module
[i
];
2129 if (bfd_bread ((void *) buf
, module_len
, abfd
) != module_len
)
2132 module
->module_name_idx
= bfd_h_get_32 (abfd
, buf
+ 0);
2133 module
->iextdefsym
= bfd_h_get_32 (abfd
, buf
+ 4);
2134 module
->nextdefsym
= bfd_h_get_32 (abfd
, buf
+ 8);
2135 module
->irefsym
= bfd_h_get_32 (abfd
, buf
+ 12);
2136 module
->nrefsym
= bfd_h_get_32 (abfd
, buf
+ 16);
2137 module
->ilocalsym
= bfd_h_get_32 (abfd
, buf
+ 20);
2138 module
->nlocalsym
= bfd_h_get_32 (abfd
, buf
+ 24);
2139 module
->iextrel
= bfd_h_get_32 (abfd
, buf
+ 28);
2140 module
->nextrel
= bfd_h_get_32 (abfd
, buf
+ 32);
2141 v
= bfd_h_get_32 (abfd
, buf
+36);
2142 module
->iinit
= v
& 0xffff;
2143 module
->iterm
= (v
>> 16) & 0xffff;
2144 v
= bfd_h_get_32 (abfd
, buf
+ 40);
2145 module
->ninit
= v
& 0xffff;
2146 module
->nterm
= (v
>> 16) & 0xffff;
2149 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 44);
2150 module
->objc_module_info_addr
= bfd_h_get_64 (abfd
, buf
+ 48);
2154 module
->objc_module_info_addr
= bfd_h_get_32 (abfd
, buf
+ 44);
2155 module
->objc_module_info_size
= bfd_h_get_32 (abfd
, buf
+ 48);
2164 cmd
->dylib_toc
= bfd_alloc
2165 (abfd
, cmd
->ntoc
* sizeof (bfd_mach_o_dylib_table_of_content
));
2166 if (cmd
->dylib_toc
== NULL
)
2169 if (bfd_seek (abfd
, cmd
->tocoff
, SEEK_SET
) != 0)
2172 for (i
= 0; i
< cmd
->ntoc
; i
++)
2174 bfd_mach_o_dylib_table_of_content
*toc
= &cmd
->dylib_toc
[i
];
2176 if (bfd_bread ((void *) buf
, 8, abfd
) != 8)
2179 toc
->symbol_index
= bfd_h_get_32 (abfd
, buf
+ 0);
2180 toc
->module_index
= bfd_h_get_32 (abfd
, buf
+ 4);
2184 if (cmd
->nindirectsyms
!= 0)
2188 cmd
->indirect_syms
= bfd_alloc
2189 (abfd
, cmd
->nindirectsyms
* sizeof (unsigned int));
2190 if (cmd
->indirect_syms
== NULL
)
2193 if (bfd_seek (abfd
, cmd
->indirectsymoff
, SEEK_SET
) != 0)
2196 for (i
= 0; i
< cmd
->nindirectsyms
; i
++)
2198 unsigned int *is
= &cmd
->indirect_syms
[i
];
2200 if (bfd_bread ((void *) buf
, 4, abfd
) != 4)
2203 *is
= bfd_h_get_32 (abfd
, buf
+ 0);
2207 if (cmd
->nextrefsyms
!= 0)
2212 cmd
->ext_refs
= bfd_alloc
2213 (abfd
, cmd
->nextrefsyms
* sizeof (bfd_mach_o_dylib_reference
));
2214 if (cmd
->ext_refs
== NULL
)
2217 if (bfd_seek (abfd
, cmd
->extrefsymoff
, SEEK_SET
) != 0)
2220 for (i
= 0; i
< cmd
->nextrefsyms
; i
++)
2222 bfd_mach_o_dylib_reference
*ref
= &cmd
->ext_refs
[i
];
2224 if (bfd_bread ((void *) buf
, 4, abfd
) != 4)
2227 /* Fields isym and flags are written as bit-fields, thus we need
2228 a specific processing for endianness. */
2229 v
= bfd_h_get_32 (abfd
, buf
+ 0);
2230 if (bfd_big_endian (abfd
))
2232 ref
->isym
= (v
>> 8) & 0xffffff;
2233 ref
->flags
= v
& 0xff;
2237 ref
->isym
= v
& 0xffffff;
2238 ref
->flags
= (v
>> 24) & 0xff;
2243 if (mdata
->dysymtab
)
2245 mdata
->dysymtab
= cmd
;
2251 bfd_mach_o_read_symtab (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2253 bfd_mach_o_symtab_command
*symtab
= &command
->command
.symtab
;
2254 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2255 unsigned char buf
[16];
2257 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SYMTAB
);
2259 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2260 || bfd_bread ((void *) buf
, 16, abfd
) != 16)
2263 symtab
->symoff
= bfd_h_get_32 (abfd
, buf
);
2264 symtab
->nsyms
= bfd_h_get_32 (abfd
, buf
+ 4);
2265 symtab
->stroff
= bfd_h_get_32 (abfd
, buf
+ 8);
2266 symtab
->strsize
= bfd_h_get_32 (abfd
, buf
+ 12);
2267 symtab
->symbols
= NULL
;
2268 symtab
->strtab
= NULL
;
2270 if (symtab
->nsyms
!= 0)
2271 abfd
->flags
|= HAS_SYMS
;
2275 mdata
->symtab
= symtab
;
2280 bfd_mach_o_read_uuid (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2282 bfd_mach_o_uuid_command
*cmd
= &command
->command
.uuid
;
2285 static const char prefix
[] = "LC_UUID";
2287 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_UUID
);
2289 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2290 || bfd_bread ((void *) cmd
->uuid
, 16, abfd
) != 16)
2293 sname
= bfd_alloc (abfd
, strlen (prefix
) + 1);
2296 strcpy (sname
, prefix
);
2298 bfdsec
= bfd_make_section_anyway_with_flags (abfd
, sname
, SEC_HAS_CONTENTS
);
2304 bfdsec
->size
= command
->len
- 8;
2305 bfdsec
->filepos
= command
->offset
+ 8;
2306 bfdsec
->alignment_power
= 0;
2308 cmd
->section
= bfdsec
;
2314 bfd_mach_o_read_linkedit (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2316 bfd_mach_o_linkedit_command
*cmd
= &command
->command
.linkedit
;
2319 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2320 || bfd_bread ((void *) buf
, 8, abfd
) != 8)
2323 cmd
->dataoff
= bfd_get_32 (abfd
, buf
+ 0);
2324 cmd
->datasize
= bfd_get_32 (abfd
, buf
+ 4);
2329 bfd_mach_o_read_str (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2331 bfd_mach_o_str_command
*cmd
= &command
->command
.str
;
2335 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2336 || bfd_bread ((void *) buf
, 4, abfd
) != 4)
2339 off
= bfd_get_32 (abfd
, buf
+ 0);
2340 cmd
->stroff
= command
->offset
+ off
;
2341 cmd
->str_len
= command
->len
- off
;
2342 cmd
->str
= bfd_alloc (abfd
, cmd
->str_len
);
2343 if (cmd
->str
== NULL
)
2345 if (bfd_seek (abfd
, cmd
->stroff
, SEEK_SET
) != 0
2346 || bfd_bread ((void *) cmd
->str
, cmd
->str_len
, abfd
) != cmd
->str_len
)
2352 bfd_mach_o_read_dyld_info (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2354 bfd_mach_o_dyld_info_command
*cmd
= &command
->command
.dyld_info
;
2357 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2358 || bfd_bread ((void *) buf
, sizeof (buf
), abfd
) != sizeof (buf
))
2361 cmd
->rebase_off
= bfd_get_32 (abfd
, buf
+ 0);
2362 cmd
->rebase_size
= bfd_get_32 (abfd
, buf
+ 4);
2363 cmd
->bind_off
= bfd_get_32 (abfd
, buf
+ 8);
2364 cmd
->bind_size
= bfd_get_32 (abfd
, buf
+ 12);
2365 cmd
->weak_bind_off
= bfd_get_32 (abfd
, buf
+ 16);
2366 cmd
->weak_bind_size
= bfd_get_32 (abfd
, buf
+ 20);
2367 cmd
->lazy_bind_off
= bfd_get_32 (abfd
, buf
+ 24);
2368 cmd
->lazy_bind_size
= bfd_get_32 (abfd
, buf
+ 28);
2369 cmd
->export_off
= bfd_get_32 (abfd
, buf
+ 32);
2370 cmd
->export_size
= bfd_get_32 (abfd
, buf
+ 36);
2375 bfd_mach_o_read_segment (bfd
*abfd
,
2376 bfd_mach_o_load_command
*command
,
2379 unsigned char buf
[64];
2380 bfd_mach_o_segment_command
*seg
= &command
->command
.segment
;
2385 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT_64
);
2387 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2388 || bfd_bread ((void *) buf
, 64, abfd
) != 64)
2391 memcpy (seg
->segname
, buf
, 16);
2392 seg
->segname
[16] = '\0';
2394 seg
->vmaddr
= bfd_h_get_64 (abfd
, buf
+ 16);
2395 seg
->vmsize
= bfd_h_get_64 (abfd
, buf
+ 24);
2396 seg
->fileoff
= bfd_h_get_64 (abfd
, buf
+ 32);
2397 seg
->filesize
= bfd_h_get_64 (abfd
, buf
+ 40);
2398 seg
->maxprot
= bfd_h_get_32 (abfd
, buf
+ 48);
2399 seg
->initprot
= bfd_h_get_32 (abfd
, buf
+ 52);
2400 seg
->nsects
= bfd_h_get_32 (abfd
, buf
+ 56);
2401 seg
->flags
= bfd_h_get_32 (abfd
, buf
+ 60);
2405 BFD_ASSERT (command
->type
== BFD_MACH_O_LC_SEGMENT
);
2407 if (bfd_seek (abfd
, command
->offset
+ 8, SEEK_SET
) != 0
2408 || bfd_bread ((void *) buf
, 48, abfd
) != 48)
2411 memcpy (seg
->segname
, buf
, 16);
2412 seg
->segname
[16] = '\0';
2414 seg
->vmaddr
= bfd_h_get_32 (abfd
, buf
+ 16);
2415 seg
->vmsize
= bfd_h_get_32 (abfd
, buf
+ 20);
2416 seg
->fileoff
= bfd_h_get_32 (abfd
, buf
+ 24);
2417 seg
->filesize
= bfd_h_get_32 (abfd
, buf
+ 28);
2418 seg
->maxprot
= bfd_h_get_32 (abfd
, buf
+ 32);
2419 seg
->initprot
= bfd_h_get_32 (abfd
, buf
+ 36);
2420 seg
->nsects
= bfd_h_get_32 (abfd
, buf
+ 40);
2421 seg
->flags
= bfd_h_get_32 (abfd
, buf
+ 44);
2424 if (seg
->nsects
!= 0)
2426 seg
->sections
= bfd_alloc (abfd
, seg
->nsects
2427 * sizeof (bfd_mach_o_section
));
2428 if (seg
->sections
== NULL
)
2431 for (i
= 0; i
< seg
->nsects
; i
++)
2435 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_64_SIZE
2436 + (i
* BFD_MACH_O_SECTION_64_SIZE
);
2438 segoff
= command
->offset
+ BFD_MACH_O_LC_SEGMENT_SIZE
2439 + (i
* BFD_MACH_O_SECTION_SIZE
);
2441 if (bfd_mach_o_read_section
2442 (abfd
, &seg
->sections
[i
], segoff
, seg
->initprot
, wide
) != 0)
2451 bfd_mach_o_read_segment_32 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2453 return bfd_mach_o_read_segment (abfd
, command
, 0);
2457 bfd_mach_o_read_segment_64 (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2459 return bfd_mach_o_read_segment (abfd
, command
, 1);
2463 bfd_mach_o_read_command (bfd
*abfd
, bfd_mach_o_load_command
*command
)
2465 unsigned char buf
[8];
2467 /* Read command type and length. */
2468 if (bfd_seek (abfd
, command
->offset
, SEEK_SET
) != 0
2469 || bfd_bread ((void *) buf
, 8, abfd
) != 8)
2472 command
->type
= bfd_h_get_32 (abfd
, buf
) & ~BFD_MACH_O_LC_REQ_DYLD
;
2473 command
->type_required
= (bfd_h_get_32 (abfd
, buf
) & BFD_MACH_O_LC_REQ_DYLD
2475 command
->len
= bfd_h_get_32 (abfd
, buf
+ 4);
2477 switch (command
->type
)
2479 case BFD_MACH_O_LC_SEGMENT
:
2480 if (bfd_mach_o_read_segment_32 (abfd
, command
) != 0)
2483 case BFD_MACH_O_LC_SEGMENT_64
:
2484 if (bfd_mach_o_read_segment_64 (abfd
, command
) != 0)
2487 case BFD_MACH_O_LC_SYMTAB
:
2488 if (bfd_mach_o_read_symtab (abfd
, command
) != 0)
2491 case BFD_MACH_O_LC_SYMSEG
:
2493 case BFD_MACH_O_LC_THREAD
:
2494 case BFD_MACH_O_LC_UNIXTHREAD
:
2495 if (bfd_mach_o_read_thread (abfd
, command
) != 0)
2498 case BFD_MACH_O_LC_LOAD_DYLINKER
:
2499 case BFD_MACH_O_LC_ID_DYLINKER
:
2500 if (bfd_mach_o_read_dylinker (abfd
, command
) != 0)
2503 case BFD_MACH_O_LC_LOAD_DYLIB
:
2504 case BFD_MACH_O_LC_ID_DYLIB
:
2505 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
2506 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
2507 if (bfd_mach_o_read_dylib (abfd
, command
) != 0)
2510 case BFD_MACH_O_LC_PREBOUND_DYLIB
:
2511 if (bfd_mach_o_read_prebound_dylib (abfd
, command
) != 0)
2514 case BFD_MACH_O_LC_LOADFVMLIB
:
2515 case BFD_MACH_O_LC_IDFVMLIB
:
2516 case BFD_MACH_O_LC_IDENT
:
2517 case BFD_MACH_O_LC_FVMFILE
:
2518 case BFD_MACH_O_LC_PREPAGE
:
2519 case BFD_MACH_O_LC_ROUTINES
:
2521 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
2522 case BFD_MACH_O_LC_SUB_UMBRELLA
:
2523 case BFD_MACH_O_LC_SUB_LIBRARY
:
2524 case BFD_MACH_O_LC_SUB_CLIENT
:
2525 case BFD_MACH_O_LC_RPATH
:
2526 if (bfd_mach_o_read_str (abfd
, command
) != 0)
2529 case BFD_MACH_O_LC_DYSYMTAB
:
2530 if (bfd_mach_o_read_dysymtab (abfd
, command
) != 0)
2533 case BFD_MACH_O_LC_TWOLEVEL_HINTS
:
2534 case BFD_MACH_O_LC_PREBIND_CKSUM
:
2536 case BFD_MACH_O_LC_UUID
:
2537 if (bfd_mach_o_read_uuid (abfd
, command
) != 0)
2540 case BFD_MACH_O_LC_CODE_SIGNATURE
:
2541 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
2542 if (bfd_mach_o_read_linkedit (abfd
, command
) != 0)
2545 case BFD_MACH_O_LC_DYLD_INFO
:
2546 if (bfd_mach_o_read_dyld_info (abfd
, command
) != 0)
2550 fprintf (stderr
, "unable to read unknown load command 0x%lx\n",
2551 (unsigned long) command
->type
);
2559 bfd_mach_o_flatten_sections (bfd
*abfd
)
2561 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2565 /* Count total number of sections. */
2568 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2570 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2571 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2573 bfd_mach_o_segment_command
*seg
;
2575 seg
= &mdata
->commands
[i
].command
.segment
;
2576 mdata
->nsects
+= seg
->nsects
;
2580 /* Allocate sections array. */
2581 mdata
->sections
= bfd_alloc (abfd
,
2582 mdata
->nsects
* sizeof (bfd_mach_o_section
*));
2584 /* Fill the array. */
2587 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2589 if (mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT
2590 || mdata
->commands
[i
].type
== BFD_MACH_O_LC_SEGMENT_64
)
2592 bfd_mach_o_segment_command
*seg
;
2594 seg
= &mdata
->commands
[i
].command
.segment
;
2595 BFD_ASSERT (csect
+ seg
->nsects
<= mdata
->nsects
);
2597 for (j
= 0; j
< seg
->nsects
; j
++)
2598 mdata
->sections
[csect
++] = &seg
->sections
[j
];
2604 bfd_mach_o_scan_start_address (bfd
*abfd
)
2606 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
2607 bfd_mach_o_thread_command
*cmd
= NULL
;
2610 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
2612 if ((mdata
->commands
[i
].type
== BFD_MACH_O_LC_THREAD
) ||
2613 (mdata
->commands
[i
].type
== BFD_MACH_O_LC_UNIXTHREAD
))
2616 cmd
= &mdata
->commands
[i
].command
.thread
;
2625 for (i
= 0; i
< cmd
->nflavours
; i
++)
2627 if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_I386
)
2628 && (cmd
->flavours
[i
].flavour
2629 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32
))
2631 unsigned char buf
[4];
2633 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 40, SEEK_SET
) != 0
2634 || bfd_bread (buf
, 4, abfd
) != 4)
2637 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2639 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC
)
2640 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE
))
2642 unsigned char buf
[4];
2644 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2645 || bfd_bread (buf
, 4, abfd
) != 4)
2648 abfd
->start_address
= bfd_h_get_32 (abfd
, buf
);
2650 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_POWERPC_64
)
2651 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_PPC_THREAD_STATE64
))
2653 unsigned char buf
[8];
2655 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ 0, SEEK_SET
) != 0
2656 || bfd_bread (buf
, 8, abfd
) != 8)
2659 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2661 else if ((mdata
->header
.cputype
== BFD_MACH_O_CPU_TYPE_X86_64
)
2662 && (cmd
->flavours
[i
].flavour
== BFD_MACH_O_x86_THREAD_STATE64
))
2664 unsigned char buf
[8];
2666 if (bfd_seek (abfd
, cmd
->flavours
[i
].offset
+ (16 * 8), SEEK_SET
) != 0
2667 || bfd_bread (buf
, 8, abfd
) != 8)
2670 abfd
->start_address
= bfd_h_get_64 (abfd
, buf
);
2678 bfd_mach_o_scan (bfd
*abfd
,
2679 bfd_mach_o_header
*header
,
2680 bfd_mach_o_data_struct
*mdata
)
2683 enum bfd_architecture cputype
;
2684 unsigned long cpusubtype
;
2685 unsigned int hdrsize
;
2687 hdrsize
= mach_o_wide_p (header
) ?
2688 BFD_MACH_O_HEADER_64_SIZE
: BFD_MACH_O_HEADER_SIZE
;
2690 mdata
->header
= *header
;
2692 abfd
->flags
= abfd
->flags
& BFD_IN_MEMORY
;
2693 switch (header
->filetype
)
2695 case BFD_MACH_O_MH_OBJECT
:
2696 abfd
->flags
|= HAS_RELOC
;
2698 case BFD_MACH_O_MH_EXECUTE
:
2699 abfd
->flags
|= EXEC_P
;
2701 case BFD_MACH_O_MH_DYLIB
:
2702 case BFD_MACH_O_MH_BUNDLE
:
2703 abfd
->flags
|= DYNAMIC
;
2707 abfd
->tdata
.mach_o_data
= mdata
;
2709 bfd_mach_o_convert_architecture (header
->cputype
, header
->cpusubtype
,
2710 &cputype
, &cpusubtype
);
2711 if (cputype
== bfd_arch_unknown
)
2713 fprintf (stderr
, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
2714 header
->cputype
, header
->cpusubtype
);
2718 bfd_set_arch_mach (abfd
, cputype
, cpusubtype
);
2720 if (header
->ncmds
!= 0)
2722 mdata
->commands
= bfd_alloc
2723 (abfd
, header
->ncmds
* sizeof (bfd_mach_o_load_command
));
2724 if (mdata
->commands
== NULL
)
2727 for (i
= 0; i
< header
->ncmds
; i
++)
2729 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
2732 cur
->offset
= hdrsize
;
2735 bfd_mach_o_load_command
*prev
= &mdata
->commands
[i
- 1];
2736 cur
->offset
= prev
->offset
+ prev
->len
;
2739 if (bfd_mach_o_read_command (abfd
, cur
) < 0)
2744 if (bfd_mach_o_scan_start_address (abfd
) < 0)
2747 bfd_mach_o_flatten_sections (abfd
);
2752 bfd_mach_o_mkobject_init (bfd
*abfd
)
2754 bfd_mach_o_data_struct
*mdata
= NULL
;
2756 mdata
= bfd_alloc (abfd
, sizeof (bfd_mach_o_data_struct
));
2759 abfd
->tdata
.mach_o_data
= mdata
;
2761 mdata
->header
.magic
= 0;
2762 mdata
->header
.cputype
= 0;
2763 mdata
->header
.cpusubtype
= 0;
2764 mdata
->header
.filetype
= 0;
2765 mdata
->header
.ncmds
= 0;
2766 mdata
->header
.sizeofcmds
= 0;
2767 mdata
->header
.flags
= 0;
2768 mdata
->header
.byteorder
= BFD_ENDIAN_UNKNOWN
;
2769 mdata
->commands
= NULL
;
2771 mdata
->sections
= NULL
;
2777 bfd_mach_o_header_p (bfd
*abfd
,
2778 bfd_mach_o_filetype filetype
,
2779 bfd_mach_o_cpu_type cputype
)
2781 struct bfd_preserve preserve
;
2782 bfd_mach_o_header header
;
2784 preserve
.marker
= NULL
;
2785 if (!bfd_mach_o_read_header (abfd
, &header
))
2788 if (! (header
.byteorder
== BFD_ENDIAN_BIG
2789 || header
.byteorder
== BFD_ENDIAN_LITTLE
))
2791 fprintf (stderr
, "unknown header byte-order value 0x%lx\n",
2792 (unsigned long) header
.byteorder
);
2796 if (! ((header
.byteorder
== BFD_ENDIAN_BIG
2797 && abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
2798 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_BIG
)
2799 || (header
.byteorder
== BFD_ENDIAN_LITTLE
2800 && abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
2801 && abfd
->xvec
->header_byteorder
== BFD_ENDIAN_LITTLE
)))
2804 /* Check cputype and filetype.
2805 In case of wildcard, do not accept magics that are handled by existing
2809 if (header
.cputype
!= cputype
)
2814 switch (header
.cputype
)
2816 case BFD_MACH_O_CPU_TYPE_I386
:
2817 /* Handled by mach-o-i386 */
2825 if (header
.filetype
!= filetype
)
2830 switch (header
.filetype
)
2832 case BFD_MACH_O_MH_CORE
:
2833 /* Handled by core_p */
2840 preserve
.marker
= bfd_zalloc (abfd
, sizeof (bfd_mach_o_data_struct
));
2841 if (preserve
.marker
== NULL
2842 || !bfd_preserve_save (abfd
, &preserve
))
2845 if (bfd_mach_o_scan (abfd
, &header
,
2846 (bfd_mach_o_data_struct
*) preserve
.marker
) != 0)
2849 bfd_preserve_finish (abfd
, &preserve
);
2853 bfd_set_error (bfd_error_wrong_format
);
2856 if (preserve
.marker
!= NULL
)
2857 bfd_preserve_restore (abfd
, &preserve
);
2861 static const bfd_target
*
2862 bfd_mach_o_gen_object_p (bfd
*abfd
)
2864 return bfd_mach_o_header_p (abfd
, 0, 0);
2867 static const bfd_target
*
2868 bfd_mach_o_gen_core_p (bfd
*abfd
)
2870 return bfd_mach_o_header_p (abfd
, BFD_MACH_O_MH_CORE
, 0);
2873 typedef struct mach_o_fat_archentry
2875 unsigned long cputype
;
2876 unsigned long cpusubtype
;
2877 unsigned long offset
;
2879 unsigned long align
;
2880 } mach_o_fat_archentry
;
2882 typedef struct mach_o_fat_data_struct
2884 unsigned long magic
;
2885 unsigned long nfat_arch
;
2886 mach_o_fat_archentry
*archentries
;
2887 } mach_o_fat_data_struct
;
2890 bfd_mach_o_archive_p (bfd
*abfd
)
2892 mach_o_fat_data_struct
*adata
= NULL
;
2893 unsigned char buf
[20];
2896 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
2897 || bfd_bread ((void *) buf
, 8, abfd
) != 8)
2900 adata
= bfd_alloc (abfd
, sizeof (mach_o_fat_data_struct
));
2904 adata
->magic
= bfd_getb32 (buf
);
2905 adata
->nfat_arch
= bfd_getb32 (buf
+ 4);
2906 if (adata
->magic
!= 0xcafebabe)
2908 /* Avoid matching Java bytecode files, which have the same magic number.
2909 In the Java bytecode file format this field contains the JVM version,
2910 which starts at 43.0. */
2911 if (adata
->nfat_arch
> 30)
2914 adata
->archentries
=
2915 bfd_alloc (abfd
, adata
->nfat_arch
* sizeof (mach_o_fat_archentry
));
2916 if (adata
->archentries
== NULL
)
2919 for (i
= 0; i
< adata
->nfat_arch
; i
++)
2921 if (bfd_seek (abfd
, 8 + 20 * i
, SEEK_SET
) != 0
2922 || bfd_bread ((void *) buf
, 20, abfd
) != 20)
2924 adata
->archentries
[i
].cputype
= bfd_getb32 (buf
);
2925 adata
->archentries
[i
].cpusubtype
= bfd_getb32 (buf
+ 4);
2926 adata
->archentries
[i
].offset
= bfd_getb32 (buf
+ 8);
2927 adata
->archentries
[i
].size
= bfd_getb32 (buf
+ 12);
2928 adata
->archentries
[i
].align
= bfd_getb32 (buf
+ 16);
2931 abfd
->tdata
.mach_o_fat_data
= adata
;
2936 bfd_release (abfd
, adata
);
2937 bfd_set_error (bfd_error_wrong_format
);
2942 bfd_mach_o_openr_next_archived_file (bfd
*archive
, bfd
*prev
)
2944 mach_o_fat_data_struct
*adata
;
2945 mach_o_fat_archentry
*entry
= NULL
;
2948 enum bfd_architecture arch_type
;
2949 unsigned long arch_subtype
;
2951 adata
= (mach_o_fat_data_struct
*) archive
->tdata
.mach_o_fat_data
;
2952 BFD_ASSERT (adata
!= NULL
);
2954 /* Find index of previous entry. */
2956 i
= 0; /* Start at first one. */
2959 for (i
= 0; i
< adata
->nfat_arch
; i
++)
2961 if (adata
->archentries
[i
].offset
== prev
->origin
)
2965 if (i
== adata
->nfat_arch
)
2968 bfd_set_error (bfd_error_bad_value
);
2971 i
++; /* Get next entry. */
2974 if (i
>= adata
->nfat_arch
)
2976 bfd_set_error (bfd_error_no_more_archived_files
);
2980 entry
= &adata
->archentries
[i
];
2981 nbfd
= _bfd_new_bfd_contained_in (archive
);
2985 nbfd
->origin
= entry
->offset
;
2987 bfd_mach_o_convert_architecture (entry
->cputype
, entry
->cpusubtype
,
2988 &arch_type
, &arch_subtype
);
2989 /* Create the member filename.
2990 Use FILENAME:ARCH_NAME. */
2993 const char *arch_name
;
2994 size_t arch_file_len
= strlen (bfd_get_filename (archive
));
2996 arch_name
= bfd_printable_arch_mach (arch_type
, arch_subtype
);
2997 s
= bfd_malloc (arch_file_len
+ 1 + strlen (arch_name
) + 1);
3000 memcpy (s
, bfd_get_filename (archive
), arch_file_len
);
3001 s
[arch_file_len
] = ':';
3002 strcpy (s
+ arch_file_len
+ 1, arch_name
);
3005 nbfd
->iostream
= NULL
;
3006 bfd_set_arch_mach (nbfd
, arch_type
, arch_subtype
);
3011 /* If ABFD format is FORMAT and architecture is ARCH, return it.
3012 If ABFD is a fat image containing a member that corresponds to FORMAT
3013 and ARCH, returns it.
3014 In other case, returns NULL.
3015 This function allows transparent uses of fat images. */
3017 bfd_mach_o_fat_extract (bfd
*abfd
,
3019 const bfd_arch_info_type
*arch
)
3022 mach_o_fat_data_struct
*adata
;
3025 if (bfd_check_format (abfd
, format
))
3027 if (bfd_get_arch_info (abfd
) == arch
)
3031 if (!bfd_check_format (abfd
, bfd_archive
)
3032 || abfd
->xvec
!= &mach_o_fat_vec
)
3035 /* This is a Mach-O fat image. */
3036 adata
= (mach_o_fat_data_struct
*) abfd
->tdata
.mach_o_fat_data
;
3037 BFD_ASSERT (adata
!= NULL
);
3039 for (i
= 0; i
< adata
->nfat_arch
; i
++)
3041 struct mach_o_fat_archentry
*e
= &adata
->archentries
[i
];
3042 enum bfd_architecture cpu_type
;
3043 unsigned long cpu_subtype
;
3045 bfd_mach_o_convert_architecture (e
->cputype
, e
->cpusubtype
,
3046 &cpu_type
, &cpu_subtype
);
3047 if (cpu_type
!= arch
->arch
|| cpu_subtype
!= arch
->mach
)
3050 /* The architecture is found. */
3051 res
= _bfd_new_bfd_contained_in (abfd
);
3055 res
->origin
= e
->offset
;
3057 res
->filename
= strdup (abfd
->filename
);
3058 res
->iostream
= NULL
;
3060 if (bfd_check_format (res
, format
))
3062 BFD_ASSERT (bfd_get_arch_info (res
) == arch
);
3073 bfd_mach_o_lookup_section (bfd
*abfd
,
3075 bfd_mach_o_load_command
**mcommand
,
3076 bfd_mach_o_section
**msection
)
3078 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
3079 unsigned int i
, j
, num
;
3081 bfd_mach_o_load_command
*ncmd
= NULL
;
3082 bfd_mach_o_section
*nsect
= NULL
;
3084 BFD_ASSERT (mcommand
!= NULL
);
3085 BFD_ASSERT (msection
!= NULL
);
3088 for (i
= 0; i
< md
->header
.ncmds
; i
++)
3090 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
3091 struct bfd_mach_o_segment_command
*seg
= NULL
;
3093 if (cmd
->type
!= BFD_MACH_O_LC_SEGMENT
3094 || cmd
->type
!= BFD_MACH_O_LC_SEGMENT_64
)
3096 seg
= &cmd
->command
.segment
;
3098 for (j
= 0; j
< seg
->nsects
; j
++)
3100 struct bfd_mach_o_section
*sect
= &seg
->sections
[j
];
3102 if (sect
->bfdsection
== section
)
3120 bfd_mach_o_lookup_command (bfd
*abfd
,
3121 bfd_mach_o_load_command_type type
,
3122 bfd_mach_o_load_command
**mcommand
)
3124 struct mach_o_data_struct
*md
= bfd_mach_o_get_data (abfd
);
3125 bfd_mach_o_load_command
*ncmd
= NULL
;
3126 unsigned int i
, num
;
3128 BFD_ASSERT (md
!= NULL
);
3129 BFD_ASSERT (mcommand
!= NULL
);
3132 for (i
= 0; i
< md
->header
.ncmds
; i
++)
3134 struct bfd_mach_o_load_command
*cmd
= &md
->commands
[i
];
3136 if (cmd
->type
!= type
)
3149 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type
)
3153 case BFD_MACH_O_CPU_TYPE_MC680x0
:
3155 case BFD_MACH_O_CPU_TYPE_MC88000
:
3157 case BFD_MACH_O_CPU_TYPE_POWERPC
:
3159 case BFD_MACH_O_CPU_TYPE_I386
:
3161 case BFD_MACH_O_CPU_TYPE_SPARC
:
3163 case BFD_MACH_O_CPU_TYPE_I860
:
3165 case BFD_MACH_O_CPU_TYPE_HPPA
:
3166 return 0xc0000000 - 0x04000000;
3172 typedef struct bfd_mach_o_xlat_name
3177 bfd_mach_o_xlat_name
;
3180 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name
*table
,
3186 for (; table
->name
; table
++)
3188 if (table
->val
& val
)
3191 fprintf (file
, "+");
3192 fprintf (file
, "%s", table
->name
);
3200 fprintf (file
, "+");
3201 fprintf (file
, "0x%lx", val
);
3205 fprintf (file
, "-");
3209 bfd_mach_o_get_name (const bfd_mach_o_xlat_name
*table
, unsigned long val
)
3211 for (; table
->name
; table
++)
3212 if (table
->val
== val
)
3217 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name
[] =
3219 { "vax", BFD_MACH_O_CPU_TYPE_VAX
},
3220 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0
},
3221 { "i386", BFD_MACH_O_CPU_TYPE_I386
},
3222 { "mips", BFD_MACH_O_CPU_TYPE_MIPS
},
3223 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000
},
3224 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA
},
3225 { "arm", BFD_MACH_O_CPU_TYPE_ARM
},
3226 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000
},
3227 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC
},
3228 { "i860", BFD_MACH_O_CPU_TYPE_I860
},
3229 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA
},
3230 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC
},
3231 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64
},
3232 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64
},
3236 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name
[] =
3238 { "object", BFD_MACH_O_MH_OBJECT
},
3239 { "execute", BFD_MACH_O_MH_EXECUTE
},
3240 { "fvmlib", BFD_MACH_O_MH_FVMLIB
},
3241 { "core", BFD_MACH_O_MH_CORE
},
3242 { "preload", BFD_MACH_O_MH_PRELOAD
},
3243 { "dylib", BFD_MACH_O_MH_DYLIB
},
3244 { "dylinker", BFD_MACH_O_MH_DYLINKER
},
3245 { "bundle", BFD_MACH_O_MH_BUNDLE
},
3246 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB
},
3247 { "dym", BFD_MACH_O_MH_DSYM
},
3248 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE
},
3252 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name
[] =
3254 { "noundefs", BFD_MACH_O_MH_NOUNDEFS
},
3255 { "incrlink", BFD_MACH_O_MH_INCRLINK
},
3256 { "dyldlink", BFD_MACH_O_MH_DYLDLINK
},
3257 { "bindatload", BFD_MACH_O_MH_BINDATLOAD
},
3258 { "prebound", BFD_MACH_O_MH_PREBOUND
},
3259 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS
},
3260 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT
},
3261 { "twolevel", BFD_MACH_O_MH_TWOLEVEL
},
3262 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT
},
3263 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS
},
3264 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING
},
3265 { "prebindable", BFD_MACH_O_MH_PREBINDABLE
},
3266 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND
},
3267 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS
},
3268 { "canonical", BFD_MACH_O_MH_CANONICAL
},
3269 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES
},
3270 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK
},
3271 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION
},
3272 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE
},
3273 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE
},
3274 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS
},
3275 { "pie", BFD_MACH_O_MH_PIE
},
3279 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name
[] =
3281 { "regular", BFD_MACH_O_S_REGULAR
},
3282 { "zerofill", BFD_MACH_O_S_ZEROFILL
},
3283 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS
},
3284 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS
},
3285 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS
},
3286 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS
},
3287 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
},
3288 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
},
3289 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS
},
3290 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS
},
3291 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS
},
3292 { "coalesced", BFD_MACH_O_S_COALESCED
},
3293 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL
},
3294 { "interposing", BFD_MACH_O_S_INTERPOSING
},
3295 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS
},
3296 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF
},
3297 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS
},
3301 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name
[] =
3303 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC
},
3304 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC
},
3305 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
},
3306 { "debug", BFD_MACH_O_S_ATTR_DEBUG
},
3307 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE
},
3308 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT
},
3309 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP
},
3310 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
},
3311 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC
},
3312 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
},
3316 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name
[] =
3318 { "segment", BFD_MACH_O_LC_SEGMENT
},
3319 { "symtab", BFD_MACH_O_LC_SYMTAB
},
3320 { "symseg", BFD_MACH_O_LC_SYMSEG
},
3321 { "thread", BFD_MACH_O_LC_THREAD
},
3322 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD
},
3323 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB
},
3324 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB
},
3325 { "ident", BFD_MACH_O_LC_IDENT
},
3326 { "fvmfile", BFD_MACH_O_LC_FVMFILE
},
3327 { "prepage", BFD_MACH_O_LC_PREPAGE
},
3328 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB
},
3329 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB
},
3330 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB
},
3331 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER
},
3332 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER
},
3333 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB
},
3334 { "routines", BFD_MACH_O_LC_ROUTINES
},
3335 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK
},
3336 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA
},
3337 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT
},
3338 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY
},
3339 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS
},
3340 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM
},
3341 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB
},
3342 { "segment_64", BFD_MACH_O_LC_SEGMENT_64
},
3343 { "routines_64", BFD_MACH_O_LC_ROUTINES_64
},
3344 { "uuid", BFD_MACH_O_LC_UUID
},
3345 { "rpath", BFD_MACH_O_LC_RPATH
},
3346 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE
},
3347 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
},
3348 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB
},
3349 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB
},
3350 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO
},
3351 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO
},
3356 bfd_mach_o_print_private_header (bfd
*abfd
, FILE *file
)
3358 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3359 bfd_mach_o_header
*h
= &mdata
->header
;
3361 fputs (_("Mach-O header:\n"), file
);
3362 fprintf (file
, _(" magic : %08lx\n"), h
->magic
);
3363 fprintf (file
, _(" cputype : %08lx (%s)\n"), h
->cputype
,
3364 bfd_mach_o_get_name (bfd_mach_o_cpu_name
, h
->cputype
));
3365 fprintf (file
, _(" cpusubtype: %08lx\n"), h
->cpusubtype
);
3366 fprintf (file
, _(" filetype : %08lx (%s)\n"),
3368 bfd_mach_o_get_name (bfd_mach_o_filetype_name
, h
->filetype
));
3369 fprintf (file
, _(" ncmds : %08lx (%lu)\n"), h
->ncmds
, h
->ncmds
);
3370 fprintf (file
, _(" sizeofcmds: %08lx\n"), h
->sizeofcmds
);
3371 fprintf (file
, _(" flags : %08lx ("), h
->flags
);
3372 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name
, h
->flags
, file
);
3373 fputs (_(")\n"), file
);
3374 fprintf (file
, _(" reserved : %08x\n"), h
->reserved
);
3378 bfd_mach_o_print_section_map (bfd
*abfd
, FILE *file
)
3380 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3382 unsigned int sec_nbr
= 0;
3384 fputs (_("Segments and Sections:\n"), file
);
3385 fputs (_(" #: Segment name Section name Address\n"), file
);
3387 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3389 bfd_mach_o_segment_command
*seg
;
3391 if (mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT
3392 && mdata
->commands
[i
].type
!= BFD_MACH_O_LC_SEGMENT_64
)
3395 seg
= &mdata
->commands
[i
].command
.segment
;
3397 fprintf (file
, "[Segment %-16s ", seg
->segname
);
3398 fprintf_vma (file
, seg
->vmaddr
);
3399 fprintf (file
, "-");
3400 fprintf_vma (file
, seg
->vmaddr
+ seg
->vmsize
- 1);
3402 fputc (seg
->initprot
& BFD_MACH_O_PROT_READ
? 'r' : '-', file
);
3403 fputc (seg
->initprot
& BFD_MACH_O_PROT_WRITE
? 'w' : '-', file
);
3404 fputc (seg
->initprot
& BFD_MACH_O_PROT_EXECUTE
? 'x' : '-', file
);
3405 fprintf (file
, "]\n");
3406 for (j
= 0; j
< seg
->nsects
; j
++)
3408 bfd_mach_o_section
*sec
= &seg
->sections
[j
];
3409 fprintf (file
, "%02u: %-16s %-16s ", ++sec_nbr
,
3410 sec
->segname
, sec
->sectname
);
3411 fprintf_vma (file
, sec
->addr
);
3412 fprintf (file
, " ");
3413 fprintf_vma (file
, sec
->size
);
3414 fprintf (file
, " %08lx\n", sec
->flags
);
3420 bfd_mach_o_print_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3421 bfd_mach_o_section
*sec
, FILE *file
)
3423 fprintf (file
, " Section: %-16s %-16s (bfdname: %s)\n",
3424 sec
->sectname
, sec
->segname
, sec
->bfdsection
->name
);
3425 fprintf (file
, " addr: ");
3426 fprintf_vma (file
, sec
->addr
);
3427 fprintf (file
, " size: ");
3428 fprintf_vma (file
, sec
->size
);
3429 fprintf (file
, " offset: ");
3430 fprintf_vma (file
, sec
->offset
);
3431 fprintf (file
, "\n");
3432 fprintf (file
, " align: %ld", sec
->align
);
3433 fprintf (file
, " nreloc: %lu reloff: ", sec
->nreloc
);
3434 fprintf_vma (file
, sec
->reloff
);
3435 fprintf (file
, "\n");
3436 fprintf (file
, " flags: %08lx (type: %s", sec
->flags
,
3437 bfd_mach_o_get_name (bfd_mach_o_section_type_name
,
3438 sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
));
3439 fprintf (file
, " attr: ");
3440 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name
,
3441 sec
->flags
& BFD_MACH_O_SECTION_ATTRIBUTES_MASK
,
3443 fprintf (file
, ")\n");
3444 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3446 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3447 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3448 case BFD_MACH_O_S_SYMBOL_STUBS
:
3449 fprintf (file
, " first indirect sym: %lu", sec
->reserved1
);
3450 fprintf (file
, " (%u entries)",
3451 bfd_mach_o_section_get_nbr_indirect (abfd
, sec
));
3454 fprintf (file
, " reserved1: 0x%lx", sec
->reserved1
);
3457 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3459 case BFD_MACH_O_S_SYMBOL_STUBS
:
3460 fprintf (file
, " stub size: %lu", sec
->reserved2
);
3463 fprintf (file
, " reserved2: 0x%lx", sec
->reserved2
);
3466 fprintf (file
, " reserved3: 0x%lx\n", sec
->reserved3
);
3470 bfd_mach_o_print_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
3471 bfd_mach_o_load_command
*cmd
, FILE *file
)
3473 bfd_mach_o_segment_command
*seg
= &cmd
->command
.segment
;
3476 fprintf (file
, " name: %s\n", *seg
->segname
? seg
->segname
: "*none*");
3477 fprintf (file
, " vmaddr: ");
3478 fprintf_vma (file
, seg
->vmaddr
);
3479 fprintf (file
, " vmsize: ");
3480 fprintf_vma (file
, seg
->vmsize
);
3481 fprintf (file
, "\n");
3482 fprintf (file
, " fileoff: ");
3483 fprintf_vma (file
, seg
->fileoff
);
3484 fprintf (file
, " filesize: ");
3485 fprintf_vma (file
, (bfd_vma
)seg
->filesize
);
3486 fprintf (file
, " endoff: ");
3487 fprintf_vma (file
, (bfd_vma
)(seg
->fileoff
+ seg
->filesize
));
3488 fprintf (file
, "\n");
3489 fprintf (file
, " nsects: %lu ", seg
->nsects
);
3490 fprintf (file
, " flags: %lx\n", seg
->flags
);
3491 for (i
= 0; i
< seg
->nsects
; i
++)
3492 bfd_mach_o_print_section (abfd
, &seg
->sections
[i
], file
);
3496 bfd_mach_o_print_dysymtab (bfd
*abfd ATTRIBUTE_UNUSED
,
3497 bfd_mach_o_load_command
*cmd
, FILE *file
)
3499 bfd_mach_o_dysymtab_command
*dysymtab
= &cmd
->command
.dysymtab
;
3500 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3503 fprintf (file
, " local symbols: idx: %10lu num: %-8lu",
3504 dysymtab
->ilocalsym
, dysymtab
->nlocalsym
);
3505 fprintf (file
, " (nxtidx: %lu)\n",
3506 dysymtab
->ilocalsym
+ dysymtab
->nlocalsym
);
3507 fprintf (file
, " external symbols: idx: %10lu num: %-8lu",
3508 dysymtab
->iextdefsym
, dysymtab
->nextdefsym
);
3509 fprintf (file
, " (nxtidx: %lu)\n",
3510 dysymtab
->iextdefsym
+ dysymtab
->nextdefsym
);
3511 fprintf (file
, " undefined symbols: idx: %10lu num: %-8lu",
3512 dysymtab
->iundefsym
, dysymtab
->nundefsym
);
3513 fprintf (file
, " (nxtidx: %lu)\n",
3514 dysymtab
->iundefsym
+ dysymtab
->nundefsym
);
3515 fprintf (file
, " table of content: off: 0x%08lx num: %-8lu",
3516 dysymtab
->tocoff
, dysymtab
->ntoc
);
3517 fprintf (file
, " (endoff: 0x%08lx)\n",
3519 + dysymtab
->ntoc
* BFD_MACH_O_TABLE_OF_CONTENT_SIZE
);
3520 fprintf (file
, " module table: off: 0x%08lx num: %-8lu",
3521 dysymtab
->modtaboff
, dysymtab
->nmodtab
);
3522 fprintf (file
, " (endoff: 0x%08lx)\n",
3523 dysymtab
->modtaboff
+ dysymtab
->nmodtab
3524 * (mach_o_wide_p (&mdata
->header
) ?
3525 BFD_MACH_O_DYLIB_MODULE_64_SIZE
: BFD_MACH_O_DYLIB_MODULE_SIZE
));
3526 fprintf (file
, " external reference table: off: 0x%08lx num: %-8lu",
3527 dysymtab
->extrefsymoff
, dysymtab
->nextrefsyms
);
3528 fprintf (file
, " (endoff: 0x%08lx)\n",
3529 dysymtab
->extrefsymoff
3530 + dysymtab
->nextrefsyms
* BFD_MACH_O_REFERENCE_SIZE
);
3531 fprintf (file
, " indirect symbol table: off: 0x%08lx num: %-8lu",
3532 dysymtab
->indirectsymoff
, dysymtab
->nindirectsyms
);
3533 fprintf (file
, " (endoff: 0x%08lx)\n",
3534 dysymtab
->indirectsymoff
3535 + dysymtab
->nindirectsyms
* BFD_MACH_O_INDIRECT_SYMBOL_SIZE
);
3536 fprintf (file
, " external relocation table: off: 0x%08lx num: %-8lu",
3537 dysymtab
->extreloff
, dysymtab
->nextrel
);
3538 fprintf (file
, " (endoff: 0x%08lx)\n",
3539 dysymtab
->extreloff
+ dysymtab
->nextrel
* BFD_MACH_O_RELENT_SIZE
);
3540 fprintf (file
, " local relocation table: off: 0x%08lx num: %-8lu",
3541 dysymtab
->locreloff
, dysymtab
->nlocrel
);
3542 fprintf (file
, " (endoff: 0x%08lx)\n",
3543 dysymtab
->locreloff
+ dysymtab
->nlocrel
* BFD_MACH_O_RELENT_SIZE
);
3545 if (dysymtab
->ntoc
> 0
3546 || dysymtab
->nindirectsyms
> 0
3547 || dysymtab
->nextrefsyms
> 0)
3549 /* Try to read the symbols to display the toc or indirect symbols. */
3550 bfd_mach_o_read_symtab_symbols (abfd
);
3552 else if (dysymtab
->nmodtab
> 0)
3554 /* Try to read the strtab to display modules name. */
3555 bfd_mach_o_read_symtab_strtab (abfd
);
3558 for (i
= 0; i
< dysymtab
->nmodtab
; i
++)
3560 bfd_mach_o_dylib_module
*module
= &dysymtab
->dylib_module
[i
];
3561 fprintf (file
, " module %u:\n", i
);
3562 fprintf (file
, " name: %lu", module
->module_name_idx
);
3563 if (mdata
->symtab
&& mdata
->symtab
->strtab
)
3564 fprintf (file
, ": %s",
3565 mdata
->symtab
->strtab
+ module
->module_name_idx
);
3566 fprintf (file
, "\n");
3567 fprintf (file
, " extdefsym: idx: %8lu num: %lu\n",
3568 module
->iextdefsym
, module
->nextdefsym
);
3569 fprintf (file
, " refsym: idx: %8lu num: %lu\n",
3570 module
->irefsym
, module
->nrefsym
);
3571 fprintf (file
, " localsym: idx: %8lu num: %lu\n",
3572 module
->ilocalsym
, module
->nlocalsym
);
3573 fprintf (file
, " extrel: idx: %8lu num: %lu\n",
3574 module
->iextrel
, module
->nextrel
);
3575 fprintf (file
, " init: idx: %8u num: %u\n",
3576 module
->iinit
, module
->ninit
);
3577 fprintf (file
, " term: idx: %8u num: %u\n",
3578 module
->iterm
, module
->nterm
);
3579 fprintf (file
, " objc_module_info: addr: ");
3580 fprintf_vma (file
, module
->objc_module_info_addr
);
3581 fprintf (file
, " size: %lu\n", module
->objc_module_info_size
);
3584 if (dysymtab
->ntoc
> 0)
3586 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3588 fprintf (file
, " table of content: (symbol/module)\n");
3589 for (i
= 0; i
< dysymtab
->ntoc
; i
++)
3591 bfd_mach_o_dylib_table_of_content
*toc
= &dysymtab
->dylib_toc
[i
];
3593 fprintf (file
, " %4u: ", i
);
3594 if (symtab
&& symtab
->symbols
&& toc
->symbol_index
< symtab
->nsyms
)
3596 const char *name
= symtab
->symbols
[toc
->symbol_index
].symbol
.name
;
3597 fprintf (file
, "%s (%lu)", name
? name
: "*invalid*",
3601 fprintf (file
, "%lu", toc
->symbol_index
);
3603 fprintf (file
, " / ");
3604 if (symtab
&& symtab
->strtab
3605 && toc
->module_index
< dysymtab
->nmodtab
)
3607 bfd_mach_o_dylib_module
*mod
;
3608 mod
= &dysymtab
->dylib_module
[toc
->module_index
];
3609 fprintf (file
, "%s (%lu)",
3610 symtab
->strtab
+ mod
->module_name_idx
,
3614 fprintf (file
, "%lu", toc
->module_index
);
3616 fprintf (file
, "\n");
3620 if (dysymtab
->nindirectsyms
!= 0)
3622 fprintf (file
, " indirect symbols:\n");
3624 for (i
= 0; i
< mdata
->nsects
; i
++)
3626 bfd_mach_o_section
*sec
= mdata
->sections
[i
];
3627 unsigned int j
, first
, last
;
3628 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3632 switch (sec
->flags
& BFD_MACH_O_SECTION_TYPE_MASK
)
3634 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS
:
3635 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS
:
3636 case BFD_MACH_O_S_SYMBOL_STUBS
:
3637 first
= sec
->reserved1
;
3638 last
= first
+ bfd_mach_o_section_get_nbr_indirect (abfd
, sec
);
3640 entry_size
= bfd_mach_o_section_get_entry_size (abfd
, sec
);
3641 fprintf (file
, " for section %s.%s:\n",
3642 sec
->segname
, sec
->sectname
);
3643 for (j
= first
; j
< last
; j
++)
3645 unsigned int isym
= dysymtab
->indirect_syms
[j
];
3647 fprintf (file
, " ");
3648 fprintf_vma (file
, addr
);
3649 fprintf (file
, " %5u: 0x%08x", j
, isym
);
3650 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_LOCAL
)
3651 fprintf (file
, " LOCAL");
3652 if (isym
& BFD_MACH_O_INDIRECT_SYMBOL_ABS
)
3653 fprintf (file
, " ABSOLUTE");
3654 if (symtab
&& symtab
->symbols
3655 && isym
< symtab
->nsyms
3656 && symtab
->symbols
[isym
].symbol
.name
)
3657 fprintf (file
, " %s", symtab
->symbols
[isym
].symbol
.name
);
3658 fprintf (file
, "\n");
3667 if (dysymtab
->nextrefsyms
> 0)
3669 bfd_mach_o_symtab_command
*symtab
= mdata
->symtab
;
3671 fprintf (file
, " external reference table: (symbol flags)\n");
3672 for (i
= 0; i
< dysymtab
->nextrefsyms
; i
++)
3674 bfd_mach_o_dylib_reference
*ref
= &dysymtab
->ext_refs
[i
];
3676 fprintf (file
, " %4u: %5lu 0x%02lx", i
, ref
->isym
, ref
->flags
);
3677 if (symtab
&& symtab
->symbols
3678 && ref
->isym
< symtab
->nsyms
3679 && symtab
->symbols
[ref
->isym
].symbol
.name
)
3680 fprintf (file
, " %s", symtab
->symbols
[ref
->isym
].symbol
.name
);
3681 fprintf (file
, "\n");
3688 bfd_mach_o_print_dyld_info (bfd
*abfd ATTRIBUTE_UNUSED
,
3689 bfd_mach_o_load_command
*cmd
, FILE *file
)
3691 bfd_mach_o_dyld_info_command
*info
= &cmd
->command
.dyld_info
;
3693 fprintf (file
, " rebase: off: 0x%08x size: %-8u\n",
3694 info
->rebase_off
, info
->rebase_size
);
3695 fprintf (file
, " bind: off: 0x%08x size: %-8u\n",
3696 info
->bind_off
, info
->bind_size
);
3697 fprintf (file
, " weak bind: off: 0x%08x size: %-8u\n",
3698 info
->weak_bind_off
, info
->weak_bind_size
);
3699 fprintf (file
, " lazy bind: off: 0x%08x size: %-8u\n",
3700 info
->lazy_bind_off
, info
->lazy_bind_size
);
3701 fprintf (file
, " export: off: 0x%08x size: %-8u\n",
3702 info
->export_off
, info
->export_size
);
3706 bfd_mach_o_bfd_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3708 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3709 FILE *file
= (FILE *) ptr
;
3712 bfd_mach_o_print_private_header (abfd
, file
);
3715 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3717 bfd_mach_o_load_command
*cmd
= &mdata
->commands
[i
];
3719 fprintf (file
, "Load command %s:",
3720 bfd_mach_o_get_name (bfd_mach_o_load_command_name
, cmd
->type
));
3723 case BFD_MACH_O_LC_SEGMENT
:
3724 case BFD_MACH_O_LC_SEGMENT_64
:
3725 bfd_mach_o_print_segment (abfd
, cmd
, file
);
3727 case BFD_MACH_O_LC_UUID
:
3729 bfd_mach_o_uuid_command
*uuid
= &cmd
->command
.uuid
;
3732 for (j
= 0; j
< sizeof (uuid
->uuid
); j
++)
3733 fprintf (file
, " %02x", uuid
->uuid
[j
]);
3737 case BFD_MACH_O_LC_LOAD_DYLIB
:
3738 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB
:
3739 case BFD_MACH_O_LC_REEXPORT_DYLIB
:
3740 case BFD_MACH_O_LC_ID_DYLIB
:
3742 bfd_mach_o_dylib_command
*dylib
= &cmd
->command
.dylib
;
3743 fprintf (file
, " %s\n", dylib
->name_str
);
3744 fprintf (file
, " time stamp: 0x%08lx\n",
3746 fprintf (file
, " current version: 0x%08lx\n",
3747 dylib
->current_version
);
3748 fprintf (file
, " comptibility version: 0x%08lx\n",
3749 dylib
->compatibility_version
);
3752 case BFD_MACH_O_LC_LOAD_DYLINKER
:
3753 case BFD_MACH_O_LC_ID_DYLINKER
:
3754 fprintf (file
, " %s\n", cmd
->command
.dylinker
.name_str
);
3756 case BFD_MACH_O_LC_SYMTAB
:
3758 bfd_mach_o_symtab_command
*symtab
= &cmd
->command
.symtab
;
3761 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n",
3762 symtab
->symoff
, symtab
->nsyms
,
3763 symtab
->symoff
+ symtab
->nsyms
3764 * (mach_o_wide_p (&mdata
->header
)
3765 ? BFD_MACH_O_NLIST_64_SIZE
: BFD_MACH_O_NLIST_SIZE
));
3767 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n",
3768 symtab
->stroff
, symtab
->strsize
,
3769 symtab
->stroff
+ symtab
->strsize
);
3772 case BFD_MACH_O_LC_DYSYMTAB
:
3773 fprintf (file
, "\n");
3774 bfd_mach_o_print_dysymtab (abfd
, cmd
, file
);
3776 case BFD_MACH_O_LC_CODE_SIGNATURE
:
3777 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO
:
3779 bfd_mach_o_linkedit_command
*linkedit
= &cmd
->command
.linkedit
;
3782 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n",
3783 linkedit
->dataoff
, linkedit
->datasize
,
3784 linkedit
->dataoff
+ linkedit
->datasize
);
3787 case BFD_MACH_O_LC_SUB_FRAMEWORK
:
3788 case BFD_MACH_O_LC_SUB_UMBRELLA
:
3789 case BFD_MACH_O_LC_SUB_LIBRARY
:
3790 case BFD_MACH_O_LC_SUB_CLIENT
:
3791 case BFD_MACH_O_LC_RPATH
:
3793 bfd_mach_o_str_command
*str
= &cmd
->command
.str
;
3794 fprintf (file
, " %s\n", str
->str
);
3797 case BFD_MACH_O_LC_THREAD
:
3798 case BFD_MACH_O_LC_UNIXTHREAD
:
3800 bfd_mach_o_thread_command
*thread
= &cmd
->command
.thread
;
3802 bfd_mach_o_backend_data
*bed
= bfd_mach_o_get_backend_data (abfd
);
3804 fprintf (file
, " nflavours: %lu\n", thread
->nflavours
);
3805 for (j
= 0; j
< thread
->nflavours
; j
++)
3807 bfd_mach_o_thread_flavour
*flavour
= &thread
->flavours
[j
];
3809 fprintf (file
, " %2u: flavour: 0x%08lx offset: 0x%08lx"
3811 j
, flavour
->flavour
, flavour
->offset
,
3813 if (bed
->_bfd_mach_o_print_thread
)
3815 char *buf
= bfd_malloc (flavour
->size
);
3818 && bfd_seek (abfd
, flavour
->offset
, SEEK_SET
) == 0
3819 && (bfd_bread (buf
, flavour
->size
, abfd
)
3821 (*bed
->_bfd_mach_o_print_thread
)(abfd
, flavour
,
3828 case BFD_MACH_O_LC_DYLD_INFO
:
3829 fprintf (file
, "\n");
3830 bfd_mach_o_print_dyld_info (abfd
, cmd
, file
);
3833 fprintf (file
, "\n");
3839 bfd_mach_o_print_section_map (abfd
, file
);
3845 bfd_mach_o_core_fetch_environment (bfd
*abfd
,
3846 unsigned char **rbuf
,
3849 bfd_mach_o_data_struct
*mdata
= bfd_mach_o_get_data (abfd
);
3850 unsigned long stackaddr
= bfd_mach_o_stack_addr (mdata
->header
.cputype
);
3853 for (i
= 0; i
< mdata
->header
.ncmds
; i
++)
3855 bfd_mach_o_load_command
*cur
= &mdata
->commands
[i
];
3856 bfd_mach_o_segment_command
*seg
= NULL
;
3858 if (cur
->type
!= BFD_MACH_O_LC_SEGMENT
)
3861 seg
= &cur
->command
.segment
;
3863 if ((seg
->vmaddr
+ seg
->vmsize
) == stackaddr
)
3865 unsigned long start
= seg
->fileoff
;
3866 unsigned long end
= seg
->fileoff
+ seg
->filesize
;
3867 unsigned char *buf
= bfd_malloc (1024);
3868 unsigned long size
= 1024;
3872 bfd_size_type nread
= 0;
3873 unsigned long offset
;
3874 int found_nonnull
= 0;
3876 if (size
> (end
- start
))
3877 size
= (end
- start
);
3879 buf
= bfd_realloc_or_free (buf
, size
);
3883 if (bfd_seek (abfd
, end
- size
, SEEK_SET
) != 0)
3889 nread
= bfd_bread (buf
, size
, abfd
);
3897 for (offset
= 4; offset
<= size
; offset
+= 4)
3901 val
= *((unsigned long *) (buf
+ size
- offset
));
3902 if (! found_nonnull
)
3907 else if (val
== 0x0)
3909 unsigned long bottom
;
3912 bottom
= seg
->fileoff
+ seg
->filesize
- offset
;
3913 top
= seg
->fileoff
+ seg
->filesize
- 4;
3914 *rbuf
= bfd_malloc (top
- bottom
);
3915 *rlen
= top
- bottom
;
3917 memcpy (*rbuf
, buf
+ size
- *rlen
, *rlen
);
3923 if (size
== (end
- start
))
3937 bfd_mach_o_core_file_failing_command (bfd
*abfd
)
3939 unsigned char *buf
= NULL
;
3940 unsigned int len
= 0;
3943 ret
= bfd_mach_o_core_fetch_environment (abfd
, &buf
, &len
);
3947 return (char *) buf
;
3951 bfd_mach_o_core_file_failing_signal (bfd
*abfd ATTRIBUTE_UNUSED
)
3956 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3957 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
3959 #define bfd_mach_o_swap_reloc_in NULL
3960 #define bfd_mach_o_swap_reloc_out NULL
3961 #define bfd_mach_o_print_thread NULL
3963 #define TARGET_NAME mach_o_be_vec
3964 #define TARGET_STRING "mach-o-be"
3965 #define TARGET_BIG_ENDIAN 1
3966 #define TARGET_ARCHIVE 0
3967 #include "mach-o-target.c"
3970 #undef TARGET_STRING
3971 #undef TARGET_BIG_ENDIAN
3972 #undef TARGET_ARCHIVE
3974 #define TARGET_NAME mach_o_le_vec
3975 #define TARGET_STRING "mach-o-le"
3976 #define TARGET_BIG_ENDIAN 0
3977 #define TARGET_ARCHIVE 0
3979 #include "mach-o-target.c"
3982 #undef TARGET_STRING
3983 #undef TARGET_BIG_ENDIAN
3984 #undef TARGET_ARCHIVE
3986 #define TARGET_NAME mach_o_fat_vec
3987 #define TARGET_STRING "mach-o-fat"
3988 #define TARGET_BIG_ENDIAN 1
3989 #define TARGET_ARCHIVE 1
3991 #include "mach-o-target.c"
3994 #undef TARGET_STRING
3995 #undef TARGET_BIG_ENDIAN
3996 #undef TARGET_ARCHIVE