diff options
| -rw-r--r-- | bfd/ChangeLog | 30 | ||||
| -rw-r--r-- | bfd/Makefile.am | 20 | ||||
| -rw-r--r-- | bfd/Makefile.in | 22 | ||||
| -rw-r--r-- | bfd/archures.c | 25 | ||||
| -rw-r--r-- | bfd/bfd-in2.h | 12 | ||||
| -rw-r--r-- | bfd/bfd.c | 29 | ||||
| -rw-r--r-- | bfd/doc/Makefile.in | 2 | ||||
| -rw-r--r-- | bfd/mach-o-target.c | 117 | ||||
| -rw-r--r-- | bfd/mach-o.c | 2163 | ||||
| -rw-r--r-- | bfd/mach-o.h | 490 | ||||
| -rw-r--r-- | bfd/pef-traceback.h | 215 | ||||
| -rw-r--r-- | bfd/pef.c | 1207 | ||||
| -rw-r--r-- | bfd/pef.h | 186 | ||||
| -rw-r--r-- | bfd/targets.c | 42 | ||||
| -rw-r--r-- | bfd/xsym.c | 2449 | ||||
| -rw-r--r-- | bfd/xsym.h | 699 |
16 files changed, 7660 insertions, 48 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 09714d1..d78a72d 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,33 @@ +2002-11-06 Klee Dienes <kdienes@apple.com> + + * Makefile.am (BFD32_BACKENDS): Add mach-o.lo, pef.lo, and + xsym.lo. + (BFD32_BACKENDS_CFILES): Add mach-o.c, pef.c, and xsym.c. + (SOURCE_HFILES): Add mach-o.h, pef.h, pef-traceback.h, xsym.h + * archures.c (enum bfd_architecture): Add bfd_arch_m98k. + * bfd.c (struct bfd): Add private data for mach-o, pef, and sym. + * targets.c (enum bfd_flavour): Add flavours for mach-o, pef, and + sym. + (_bfd_target_vector): Add target vectors for mach-o, pef, and sym. + * Makefile.in: Regenerate. + * doc/Makefile.in: Regenerate. + * bfd-in2.h: Regenerate. + * xsym.c: New file. Contains support for the Apple/Metrowerks + xSYM debugging format. + * xsym.h: New file. + * pef.c: New file. Contains support for the Apple Code Fragment + Manager Preferred Executable Format + * pef.h: New file. + * pef-traceback.h: New file. Contains support for parsing PowerPC + traceback tables as used by PEF executables (and perhaps other + systems as well). + * mach-o.c: New file. Contains support for the Mach-O object file + format. + * mach-o.h: New file. + * mach-o-target.c: New file. Declares the mach-o targets + themselves. Included three times by mach-o.c; each time with a + different set of macros set. + 2002-11-06 Graeme Peterson <gp@qnx.com> * Makefile.am: Remove entries for elf32-qnx.[ch]. diff --git a/bfd/Makefile.am b/bfd/Makefile.am index 59c2668..0c1a798 100644 --- a/bfd/Makefile.am +++ b/bfd/Makefile.am @@ -266,6 +266,7 @@ BFD32_BACKENDS = \ m68klynx.lo \ m68knetbsd.lo \ m88kmach3.lo \ + mach-o.lo \ mipsbsd.lo \ newsos3.lo \ nlm.lo \ @@ -277,6 +278,7 @@ BFD32_BACKENDS = \ oasys.lo \ pc532-mach.lo \ pdp11.lo \ + pef.lo \ pe-arm.lo \ pei-arm.lo \ pe-i386.lo \ @@ -306,7 +308,8 @@ BFD32_BACKENDS = \ vms-hdr.lo \ vms-misc.lo \ vms-tir.lo \ - xcofflink.lo + xcofflink.lo \ + xsym.lo BFD32_BACKENDS_CFILES = \ aout-adobe.c \ @@ -420,6 +423,7 @@ BFD32_BACKENDS_CFILES = \ m68klynx.c \ m68knetbsd.c \ m88kmach3.c \ + mach-o.c \ mipsbsd.c \ newsos3.c \ nlm.c \ @@ -431,6 +435,7 @@ BFD32_BACKENDS_CFILES = \ oasys.c \ pc532-mach.c \ pdp11.c \ + pef.c \ pe-arm.c \ pei-arm.c \ pe-i386.c \ @@ -459,7 +464,8 @@ BFD32_BACKENDS_CFILES = \ vms-hdr.c \ vms-misc.c \ vms-tir.c \ - xcofflink.c + xcofflink.c \ + xsym.c # The .o files needed by all of the 64 bit vectors that are configured into # target_vector in targets.c if configured with --enable-targets=all @@ -563,9 +569,10 @@ SOURCE_HFILES = \ elf64-hppa.h elfcode.h elfcore.h elflink.h \ freebsd.h genlink.h go32stub.h \ libaout.h libbfd.h libcoff.h libecoff.h libhppa.h libieee.h \ - libnlm.h liboasys.h libpei.h libxcoff.h \ + libnlm.h liboasys.h libpei.h libxcoff.h mach-o.h \ netbsd.h nlm-target.h nlmcode.h nlmswap.h ns32k.h \ - peicode.h som.h version.h vms.h xcoff-target.h + pef.h pef-traceback.h peicode.h som.h version.h \ + vms.h xcoff-target.h xsym.h ## ... and all .h files which are in the build tree. BUILD_HFILES = \ @@ -1327,6 +1334,8 @@ m68knetbsd.lo: m68knetbsd.c netbsd.h $(INCDIR)/filenames.h \ m88kmach3.lo: m88kmach3.c $(INCDIR)/filenames.h libaout.h \ $(INCDIR)/bfdlink.h aout-target.h $(INCDIR)/aout/aout64.h \ $(INCDIR)/aout/stab_gnu.h $(INCDIR)/aout/stab.def $(INCDIR)/aout/ar.h +mach-o.lo: mach-o.c mach-o.h $(INCDIR)/filenames.h \ + $(INCDIR)/libiberty.h mach-o-target.c mipsbsd.lo: mipsbsd.c $(INCDIR)/filenames.h libaout.h \ $(INCDIR)/bfdlink.h aout-target.h $(INCDIR)/aout/aout64.h \ $(INCDIR)/aout/stab_gnu.h $(INCDIR)/aout/stab.def $(INCDIR)/aout/ar.h @@ -1358,6 +1367,8 @@ pc532-mach.lo: pc532-mach.c $(INCDIR)/filenames.h libaout.h \ pdp11.lo: pdp11.c $(INCDIR)/filenames.h libaout.h $(INCDIR)/bfdlink.h \ aout-target.h $(INCDIR)/aout/aout64.h $(INCDIR)/aout/stab_gnu.h \ $(INCDIR)/aout/stab.def $(INCDIR)/aout/ar.h $(INCDIR)/safe-ctype.h +pef.lo: pef.c pef.h pef-traceback.h $(INCDIR)/filenames.h \ + $(INCDIR)/libiberty.h pe-arm.lo: pe-arm.c $(INCDIR)/filenames.h coff-arm.c \ $(INCDIR)/coff/arm.h $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \ $(INCDIR)/coff/pe.h libcoff.h $(INCDIR)/bfdlink.h coffcode.h \ @@ -1450,6 +1461,7 @@ vms-tir.lo: vms-tir.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \ xcofflink.lo: xcofflink.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \ $(INCDIR)/coff/internal.h $(INCDIR)/coff/xcoff.h libcoff.h \ libxcoff.h +xsym.lo: xsym.c xsym.h $(INCDIR)/filenames.h aix5ppc-core.lo: aix5ppc-core.c aout64.lo: aout64.c aoutx.h $(INCDIR)/filenames.h $(INCDIR)/safe-ctype.h \ $(INCDIR)/bfdlink.h libaout.h $(INCDIR)/aout/aout64.h \ diff --git a/bfd/Makefile.in b/bfd/Makefile.in index bce5486..0104743 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -393,6 +393,7 @@ BFD32_BACKENDS = \ m68klynx.lo \ m68knetbsd.lo \ m88kmach3.lo \ + mach-o.lo \ mipsbsd.lo \ newsos3.lo \ nlm.lo \ @@ -404,6 +405,7 @@ BFD32_BACKENDS = \ oasys.lo \ pc532-mach.lo \ pdp11.lo \ + pef.lo \ pe-arm.lo \ pei-arm.lo \ pe-i386.lo \ @@ -433,7 +435,8 @@ BFD32_BACKENDS = \ vms-hdr.lo \ vms-misc.lo \ vms-tir.lo \ - xcofflink.lo + xcofflink.lo \ + xsym.lo BFD32_BACKENDS_CFILES = \ @@ -548,6 +551,7 @@ BFD32_BACKENDS_CFILES = \ m68klynx.c \ m68knetbsd.c \ m88kmach3.c \ + mach-o.c \ mipsbsd.c \ newsos3.c \ nlm.c \ @@ -559,6 +563,7 @@ BFD32_BACKENDS_CFILES = \ oasys.c \ pc532-mach.c \ pdp11.c \ + pef.c \ pe-arm.c \ pei-arm.c \ pe-i386.c \ @@ -587,7 +592,8 @@ BFD32_BACKENDS_CFILES = \ vms-hdr.c \ vms-misc.c \ vms-tir.c \ - xcofflink.c + xcofflink.c \ + xsym.c # The .o files needed by all of the 64 bit vectors that are configured into @@ -697,9 +703,10 @@ SOURCE_HFILES = \ elf64-hppa.h elfcode.h elfcore.h elflink.h \ freebsd.h genlink.h go32stub.h \ libaout.h libbfd.h libcoff.h libecoff.h libhppa.h libieee.h \ - libnlm.h liboasys.h libpei.h libxcoff.h \ + libnlm.h liboasys.h libpei.h libxcoff.h mach-o.h \ netbsd.h nlm-target.h nlmcode.h nlmswap.h ns32k.h \ - peicode.h som.h version.h vms.h xcoff-target.h + pef.h pef-traceback.h peicode.h som.h version.h \ + vms.h xcoff-target.h xsym.h BUILD_HFILES = \ @@ -778,7 +785,7 @@ configure.in version.h DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) -TAR = tar +TAR = gtar GZIP_ENV = --best SOURCES = $(libbfd_a_SOURCES) $(libbfd_la_SOURCES) OBJECTS = $(libbfd_a_OBJECTS) $(libbfd_la_OBJECTS) @@ -1858,6 +1865,8 @@ m68knetbsd.lo: m68knetbsd.c netbsd.h $(INCDIR)/filenames.h \ m88kmach3.lo: m88kmach3.c $(INCDIR)/filenames.h libaout.h \ $(INCDIR)/bfdlink.h aout-target.h $(INCDIR)/aout/aout64.h \ $(INCDIR)/aout/stab_gnu.h $(INCDIR)/aout/stab.def $(INCDIR)/aout/ar.h +mach-o.lo: mach-o.c mach-o.h $(INCDIR)/filenames.h \ + $(INCDIR)/libiberty.h mach-o-target.c mipsbsd.lo: mipsbsd.c $(INCDIR)/filenames.h libaout.h \ $(INCDIR)/bfdlink.h aout-target.h $(INCDIR)/aout/aout64.h \ $(INCDIR)/aout/stab_gnu.h $(INCDIR)/aout/stab.def $(INCDIR)/aout/ar.h @@ -1889,6 +1898,8 @@ pc532-mach.lo: pc532-mach.c $(INCDIR)/filenames.h libaout.h \ pdp11.lo: pdp11.c $(INCDIR)/filenames.h libaout.h $(INCDIR)/bfdlink.h \ aout-target.h $(INCDIR)/aout/aout64.h $(INCDIR)/aout/stab_gnu.h \ $(INCDIR)/aout/stab.def $(INCDIR)/aout/ar.h $(INCDIR)/safe-ctype.h +pef.lo: pef.c pef.h pef-traceback.h $(INCDIR)/filenames.h \ + $(INCDIR)/libiberty.h pe-arm.lo: pe-arm.c $(INCDIR)/filenames.h coff-arm.c \ $(INCDIR)/coff/arm.h $(INCDIR)/coff/external.h $(INCDIR)/coff/internal.h \ $(INCDIR)/coff/pe.h libcoff.h $(INCDIR)/bfdlink.h coffcode.h \ @@ -1981,6 +1992,7 @@ vms-tir.lo: vms-tir.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \ xcofflink.lo: xcofflink.c $(INCDIR)/filenames.h $(INCDIR)/bfdlink.h \ $(INCDIR)/coff/internal.h $(INCDIR)/coff/xcoff.h libcoff.h \ libxcoff.h +xsym.lo: xsym.c xsym.h $(INCDIR)/filenames.h aix5ppc-core.lo: aix5ppc-core.c aout64.lo: aout64.c aoutx.h $(INCDIR)/filenames.h $(INCDIR)/safe-ctype.h \ $(INCDIR)/bfdlink.h libaout.h $(INCDIR)/aout/aout64.h \ diff --git a/bfd/archures.c b/bfd/archures.c index 1ab0cfa..485fef2 100644 --- a/bfd/archures.c +++ b/bfd/archures.c @@ -4,21 +4,21 @@ Free Software Foundation, Inc. Hacked by John Gilmore and Steve Chamberlain of Cygnus Support. -This file is part of BFD, the Binary File Descriptor library. + This file is part of BFD, the Binary File Descriptor library. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "bfd.h" #include "sysdep.h" @@ -160,6 +160,7 @@ DESCRIPTION . bfd_arch_alliant, {* Alliant *} . bfd_arch_convex, {* Convex *} . bfd_arch_m88k, {* Motorola 88xxx *} +. bfd_arch_m98k, {* Motorola 98xxx *} . bfd_arch_pyramid, {* Pyramid Technology *} . bfd_arch_h8300, {* Hitachi H8/300 *} .#define bfd_mach_h8300 1 diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h index 018a0fd..b58e7f5 100644 --- a/bfd/bfd-in2.h +++ b/bfd/bfd-in2.h @@ -1551,6 +1551,7 @@ enum bfd_architecture bfd_arch_alliant, /* Alliant */ bfd_arch_convex, /* Convex */ bfd_arch_m88k, /* Motorola 88xxx */ + bfd_arch_m98k, /* Motorola 98xxx */ bfd_arch_pyramid, /* Pyramid Technology */ bfd_arch_h8300, /* Hitachi H8/300 */ #define bfd_mach_h8300 1 @@ -3533,6 +3534,11 @@ struct _bfd struct cisco_core_struct *cisco_core_data; struct versados_data_struct *versados_data; struct netbsd_core_struct *netbsd_core_data; + struct mach_o_data_struct *mach_o_data; + struct mach_o_fat_data_struct *mach_o_fat_data; + struct bfd_pef_data_struct *pef_data; + struct bfd_pef_xlib_data_struct *pef_xlib_data; + struct bfd_sym_data_struct *sym_data; PTR any; } tdata; @@ -3795,7 +3801,11 @@ enum bfd_flavour bfd_target_msdos_flavour, bfd_target_ovax_flavour, bfd_target_evax_flavour, - bfd_target_mmo_flavour + bfd_target_mmo_flavour, + bfd_target_mach_o_flavour, + bfd_target_pef_flavour, + bfd_target_pef_xlib_flavour, + bfd_target_sym_flavour }; enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; @@ -4,21 +4,21 @@ Free Software Foundation, Inc. Written by Cygnus Support. -This file is part of BFD, the Binary File Descriptor library. + This file is part of BFD, the Binary File Descriptor library. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* SECTION @@ -180,6 +180,11 @@ CODE_FRAGMENT . struct cisco_core_struct *cisco_core_data; . struct versados_data_struct *versados_data; . struct netbsd_core_struct *netbsd_core_data; +. struct mach_o_data_struct *mach_o_data; +. struct mach_o_fat_data_struct *mach_o_fat_data; +. struct bfd_pef_data_struct *pef_data; +. struct bfd_pef_xlib_data_struct *pef_xlib_data; +. struct bfd_sym_data_struct *sym_data; . PTR any; . } . tdata; diff --git a/bfd/doc/Makefile.in b/bfd/doc/Makefile.in index d25bbf2..ec09ffb 100644 --- a/bfd/doc/Makefile.in +++ b/bfd/doc/Makefile.in @@ -245,7 +245,7 @@ DIST_COMMON = ChangeLog Makefile.am Makefile.in DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) -TAR = tar +TAR = gtar GZIP_ENV = --best all: all-redirect .SUFFIXES: diff --git a/bfd/mach-o-target.c b/bfd/mach-o-target.c new file mode 100644 index 0000000..b271bfc --- /dev/null +++ b/bfd/mach-o-target.c @@ -0,0 +1,117 @@ +/* Mach-O support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifndef TARGET_NAME +#error TARGET_NAME must be defined +#endif /* TARGET_NAME */ + +#ifndef TARGET_STRING +#error TARGET_STRING must be defined +#endif /* TARGET_STRING */ + +#ifndef TARGET_BIG_ENDIAN +#error TARGET_BIG_ENDIAN must be defined +#endif /* TARGET_BIG_ENDIAN */ + +#ifndef TARGET_ARCHIVE +#error TARGET_ARCHIVE must be defined +#endif /* TARGET_ARCHIVE */ + +#if ((TARGET_ARCHIVE) && (! TARGET_BIG_ENDIAN)) +#error Mach-O fat files must always be big-endian. +#endif /* ((TARGET_ARCHIVE) && (! TARGET_BIG_ENDIAN)) */ + +const bfd_target TARGET_NAME = +{ + TARGET_STRING, /* Name. */ + bfd_target_mach_o_flavour, +#if TARGET_BIG_ENDIAN + BFD_ENDIAN_BIG, /* Target byte order. */ + BFD_ENDIAN_BIG, /* Target headers byte order. */ +#else + BFD_ENDIAN_LITTLE, /* Target byte order. */ + BFD_ENDIAN_LITTLE, /* Target headers byte order. */ +#endif + (HAS_RELOC | EXEC_P | /* Object flags. */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS + | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */ + '_', /* symbol_leading_char. */ + ' ', /* ar_pad_char. */ + 16, /* ar_max_namelen. */ + +#if TARGET_BIG_ENDIAN + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Data. */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Hdrs. */ +#else + bfd_getl64, bfd_getl_signed_64, bfd_putl64, + bfd_getl32, bfd_getl_signed_32, bfd_putl32, + bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ + bfd_getl64, bfd_getl_signed_64, bfd_putl64, + bfd_getl32, bfd_getl_signed_32, bfd_putl32, + bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ +#endif /* TARGET_BIG_ENDIAN */ + + { /* bfd_check_format. */ +#if TARGET_ARCHIVE + _bfd_dummy_target, + _bfd_dummy_target, + bfd_mach_o_archive_p, + _bfd_dummy_target, +#else + _bfd_dummy_target, + bfd_mach_o_object_p, + _bfd_dummy_target, + bfd_mach_o_core_p +#endif + }, + { /* bfd_set_format. */ + bfd_false, + bfd_mach_o_mkobject, + bfd_false, + bfd_mach_o_mkobject, + }, + { /* bfd_write_contents. */ + bfd_false, + bfd_mach_o_write_contents, + bfd_false, + bfd_mach_o_write_contents, + }, + + BFD_JUMP_TABLE_GENERIC (bfd_mach_o), + BFD_JUMP_TABLE_COPY (bfd_mach_o), + BFD_JUMP_TABLE_CORE (bfd_mach_o), + BFD_JUMP_TABLE_ARCHIVE (bfd_mach_o), + BFD_JUMP_TABLE_SYMBOLS (bfd_mach_o), + BFD_JUMP_TABLE_RELOCS (bfd_mach_o), + BFD_JUMP_TABLE_WRITE (bfd_mach_o), + BFD_JUMP_TABLE_LINK (bfd_mach_o), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + + NULL, + + NULL +}; + diff --git a/bfd/mach-o.c b/bfd/mach-o.c new file mode 100644 index 0000000..6243220 --- /dev/null +++ b/bfd/mach-o.c @@ -0,0 +1,2163 @@ +/* Mach-O support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "mach-o.h" +#include "bfd.h" +#include "sysdep.h" +#include "libbfd.h" +#include "libiberty.h" +#include <ctype.h> + +#ifndef BFD_IO_FUNCS +#define BFD_IO_FUNCS 0 +#endif + +#define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive +#define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr +#define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap +#define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table +#define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table +#define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname +#define bfd_mach_o_write_armap _bfd_noarchive_write_armap +#define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index +#define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt +#define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp +#define bfd_mach_o_close_and_cleanup _bfd_generic_close_and_cleanup +#define bfd_mach_o_bfd_free_cached_info _bfd_generic_bfd_free_cached_info +#define bfd_mach_o_new_section_hook _bfd_generic_new_section_hook +#define bfd_mach_o_get_section_contents_in_window _bfd_generic_get_section_contents_in_window +#define bfd_mach_o_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name +#define bfd_mach_o_get_lineno _bfd_nosymbols_get_lineno +#define bfd_mach_o_find_nearest_line _bfd_nosymbols_find_nearest_line +#define bfd_mach_o_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol +#define bfd_mach_o_read_minisymbols _bfd_generic_read_minisymbols +#define bfd_mach_o_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol +#define bfd_mach_o_get_reloc_upper_bound _bfd_norelocs_get_reloc_upper_bound +#define bfd_mach_o_canonicalize_reloc _bfd_norelocs_canonicalize_reloc +#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup +#define bfd_mach_o_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents +#define bfd_mach_o_bfd_relax_section bfd_generic_relax_section +#define bfd_mach_o_bfd_link_hash_table_create _bfd_generic_link_hash_table_create +#define bfd_mach_o_bfd_link_hash_table_free _bfd_generic_link_hash_table_free +#define bfd_mach_o_bfd_link_add_symbols _bfd_generic_link_add_symbols +#define bfd_mach_o_bfd_link_just_syms _bfd_generic_link_just_syms +#define bfd_mach_o_bfd_final_link _bfd_generic_final_link +#define bfd_mach_o_bfd_link_split_section _bfd_generic_link_split_section +#define bfd_mach_o_set_arch_mach bfd_default_set_arch_mach +#define bfd_mach_o_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data +#define bfd_mach_o_bfd_set_private_flags _bfd_generic_bfd_set_private_flags +#define bfd_mach_o_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data +#define bfd_mach_o_get_section_contents _bfd_generic_get_section_contents +#define bfd_mach_o_set_section_contents _bfd_generic_set_section_contents +#define bfd_mach_o_bfd_gc_sections bfd_generic_gc_sections +#define bfd_mach_o_bfd_merge_sections bfd_generic_merge_sections +#define bfd_mach_o_bfd_discard_group bfd_generic_discard_group + +static boolean bfd_mach_o_bfd_copy_private_symbol_data PARAMS ((bfd *, asymbol *, bfd *, asymbol *)); +static boolean bfd_mach_o_bfd_copy_private_section_data PARAMS ((bfd *, asection *, bfd *, asection *)); +static boolean bfd_mach_o_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *)); +static long bfd_mach_o_count_symbols PARAMS ((bfd *)); +static long bfd_mach_o_get_symtab_upper_bound PARAMS ((bfd *)); +static long bfd_mach_o_get_symtab PARAMS ((bfd *, asymbol **)); +static void bfd_mach_o_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *)); +static void bfd_mach_o_print_symbol PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type)); +static void bfd_mach_o_convert_architecture PARAMS ((bfd_mach_o_cpu_type, bfd_mach_o_cpu_subtype, enum bfd_architecture *, unsigned long *)); +static boolean bfd_mach_o_write_contents PARAMS ((bfd *)); +static int bfd_mach_o_sizeof_headers PARAMS ((bfd *, boolean)); +static asymbol * bfd_mach_o_make_empty_symbol PARAMS ((bfd *)); +static int bfd_mach_o_write_header PARAMS ((bfd *, bfd_mach_o_header *)); +static int bfd_mach_o_read_header PARAMS ((bfd *, bfd_mach_o_header *)); +static asection * bfd_mach_o_make_bfd_section PARAMS ((bfd *, bfd_mach_o_section *)); +static int bfd_mach_o_scan_read_section PARAMS ((bfd *, bfd_mach_o_section *, bfd_vma)); +static int bfd_mach_o_scan_write_section PARAMS ((bfd *, bfd_mach_o_section *, bfd_vma)); +static int bfd_mach_o_scan_write_symtab_symbols PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_write_thread PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_dylinker PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_dylib PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_prebound_dylib PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_thread PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_write_symtab PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_dysymtab PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_symtab PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_segment PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_write_segment PARAMS ((bfd *, bfd_mach_o_load_command *)); +static int bfd_mach_o_scan_read_command PARAMS ((bfd *, bfd_mach_o_load_command *)); +static void bfd_mach_o_flatten_sections PARAMS ((bfd *)); +static const char * bfd_mach_o_i386_flavour_string PARAMS ((unsigned int)); +static const char * bfd_mach_o_ppc_flavour_string PARAMS ((unsigned int)); + +/* The flags field of a section structure is separated into two parts a section + type and section attributes. The section types are mutually exclusive (it + can only have one type) but the section attributes are not (it may have more + than one attribute). */ + +#define SECTION_TYPE 0x000000ff /* 256 section types. */ +#define SECTION_ATTRIBUTES 0xffffff00 /* 24 section attributes. */ + +/* Constants for the section attributes part of the flags field of a section + structure. */ + +#define SECTION_ATTRIBUTES_USR 0xff000000 /* User-settable attributes. */ +#define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* Section contains only true machine instructions. */ +#define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* System setable attributes. */ +#define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* Section contains some machine instructions. */ +#define S_ATTR_EXT_RELOC 0x00000200 /* Section has external relocation entries. */ +#define S_ATTR_LOC_RELOC 0x00000100 /* Section has local relocation entries. */ + +#define N_STAB 0xe0 +#define N_TYPE 0x1e +#define N_EXT 0x01 +#define N_UNDF 0x0 +#define N_ABS 0x2 +#define N_SECT 0xe +#define N_INDR 0xa + +boolean +bfd_mach_o_valid (abfd) + bfd *abfd; +{ + if (abfd == NULL || abfd->xvec == NULL) + return 0; + + if (! ((abfd->xvec == &mach_o_be_vec) + || (abfd->xvec == &mach_o_le_vec) + || (abfd->xvec == &mach_o_fat_vec))) + return 0; + + if (abfd->tdata.mach_o_data == NULL) + return 0; + return 1; +} + +/* Copy any private info we understand from the input symbol + to the output symbol. */ + +static boolean +bfd_mach_o_bfd_copy_private_symbol_data (ibfd, isymbol, obfd, osymbol) + bfd *ibfd ATTRIBUTE_UNUSED; + asymbol *isymbol ATTRIBUTE_UNUSED; + bfd *obfd ATTRIBUTE_UNUSED; + asymbol *osymbol ATTRIBUTE_UNUSED; +{ + return true; +} + +/* Copy any private info we understand from the input section + to the output section. */ + +static boolean +bfd_mach_o_bfd_copy_private_section_data (ibfd, isection, obfd, osection) + bfd *ibfd ATTRIBUTE_UNUSED; + asection *isection ATTRIBUTE_UNUSED; + bfd *obfd ATTRIBUTE_UNUSED; + asection *osection ATTRIBUTE_UNUSED; +{ + return true; +} + +/* Copy any private info we understand from the input bfd + to the output bfd. */ + +static boolean +bfd_mach_o_bfd_copy_private_bfd_data (ibfd, obfd) + bfd *ibfd; + bfd *obfd; +{ + BFD_ASSERT (bfd_mach_o_valid (ibfd)); + BFD_ASSERT (bfd_mach_o_valid (obfd)); + + obfd->tdata.mach_o_data = ibfd->tdata.mach_o_data; + obfd->tdata.mach_o_data->ibfd = ibfd; + return true; +} + +static long +bfd_mach_o_count_symbols (abfd) + bfd *abfd; +{ + bfd_mach_o_data_struct *mdata = NULL; + long nsyms = 0; + unsigned long i; + + BFD_ASSERT (bfd_mach_o_valid (abfd)); + mdata = abfd->tdata.mach_o_data; + + for (i = 0; i < mdata->header.ncmds; i++) + if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB) + { + bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab; + nsyms += sym->nsyms; + } + + return nsyms; +} + +static long +bfd_mach_o_get_symtab_upper_bound (abfd) + bfd *abfd; +{ + long nsyms = bfd_mach_o_count_symbols (abfd); + + if (nsyms < 0) + return nsyms; + + return ((nsyms + 1) * sizeof (asymbol *)); +} + +static long +bfd_mach_o_get_symtab (abfd, alocation) + bfd *abfd; + asymbol **alocation; +{ + bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; + long nsyms = bfd_mach_o_count_symbols (abfd); + asymbol **csym = alocation; + unsigned long i, j; + + if (nsyms < 0) + return nsyms; + + for (i = 0; i < mdata->header.ncmds; i++) + { + if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB) + { + bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab; + + if (bfd_mach_o_scan_read_symtab_symbols (abfd, &mdata->commands[i].command.symtab) != 0) + { + fprintf (stderr, "bfd_mach_o_get_symtab: unable to load symbols for section %lu\n", i); + return 0; + } + + BFD_ASSERT (sym->symbols != NULL); + + for (j = 0; j < sym->nsyms; j++) + { + BFD_ASSERT (csym < (alocation + nsyms)); + *csym++ = &sym->symbols[j]; + } + } + } + + *csym++ = NULL; + + return nsyms; +} + +static void +bfd_mach_o_get_symbol_info (abfd, symbol, ret) + bfd *abfd ATTRIBUTE_UNUSED; + asymbol *symbol; + symbol_info *ret; +{ + bfd_symbol_info (symbol, ret); +} + +static void +bfd_mach_o_print_symbol (abfd, afile, symbol, how) + bfd *abfd; + PTR afile; + asymbol *symbol; + bfd_print_symbol_type how; +{ + FILE *file = (FILE *) afile; + + switch (how) + { + case bfd_print_symbol_name: + fprintf (file, "%s", symbol->name); + break; + default: + bfd_print_symbol_vandf (abfd, (PTR) file, symbol); + fprintf (file, " %-5s %s", symbol->section->name, symbol->name); + } +} + +static void +bfd_mach_o_convert_architecture (mtype, msubtype, type, subtype) + bfd_mach_o_cpu_type mtype; + bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED; + enum bfd_architecture *type; + unsigned long *subtype; +{ + *subtype = bfd_arch_unknown; + + switch (mtype) + { + case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break; + case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break; + case BFD_MACH_O_CPU_TYPE_I386: *type = bfd_arch_i386; break; + case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break; + case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break; + case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break; + case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break; + case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break; + case BFD_MACH_O_CPU_TYPE_SPARC: *type = bfd_arch_sparc; break; + case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break; + case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break; + case BFD_MACH_O_CPU_TYPE_POWERPC: *type = bfd_arch_powerpc; break; + default: *type = bfd_arch_unknown; break; + } + + switch (*type) + { + case bfd_arch_i386: *subtype = bfd_mach_i386_i386; break; + case bfd_arch_sparc: *subtype = bfd_mach_sparc; break; + default: + *subtype = bfd_arch_unknown; + } +} + +static boolean +bfd_mach_o_write_contents (abfd) + bfd *abfd; +{ + unsigned int i; + asection *s; + + bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; + + /* Write data sections first in case they overlap header data to be + written later. */ + + for (s = abfd->sections; s != (asection *) NULL; s = s->next) + ; + +#if 0 + for (i = 0; i < mdata->header.ncmds; i++) + { + bfd_mach_o_load_command *cur = &mdata->commands[i]; + if (cur->type != BFD_MACH_O_LC_SEGMENT) + break; + + { + bfd_mach_o_segment_command *seg = &cur->command.segment; + char buf[1024]; + bfd_vma nbytes = seg->filesize; + bfd_vma curoff = seg->fileoff; + + while (nbytes > 0) + { + bfd_vma thisread = nbytes; + + if (thisread > 1024) + thisread = 1024; + + bfd_seek (abfd, curoff, SEEK_SET); + if (bfd_bread ((PTR) buf, thisread, abfd) != thisread) + return false; + + bfd_seek (abfd, curoff, SEEK_SET); + if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread) + return false; + + nbytes -= thisread; + curoff += thisread; + } + } + } +#endif + + /* Now write header information. */ + if (bfd_mach_o_write_header (abfd, &mdata->header) != 0) + return false; + + for (i = 0; i < mdata->header.ncmds; i++) + { + unsigned char buf[8]; + bfd_mach_o_load_command *cur = &mdata->commands[i]; + unsigned long typeflag; + + typeflag = cur->type_required ? cur->type & BFD_MACH_O_LC_REQ_DYLD : cur->type; + + bfd_h_put_32 (abfd, typeflag, buf); + bfd_h_put_32 (abfd, cur->len, buf + 4); + + bfd_seek (abfd, cur->offset, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 8, abfd) != 8) + return false; + + switch (cur->type) + { + case BFD_MACH_O_LC_SEGMENT: + if (bfd_mach_o_scan_write_segment (abfd, cur) != 0) + return false; + break; + case BFD_MACH_O_LC_SYMTAB: + if (bfd_mach_o_scan_write_symtab (abfd, cur) != 0) + return false; + break; + case BFD_MACH_O_LC_SYMSEG: + break; + case BFD_MACH_O_LC_THREAD: + case BFD_MACH_O_LC_UNIXTHREAD: + if (bfd_mach_o_scan_write_thread (abfd, cur) != 0) + return false; + break; + case BFD_MACH_O_LC_LOADFVMLIB: + case BFD_MACH_O_LC_IDFVMLIB: + case BFD_MACH_O_LC_IDENT: + case BFD_MACH_O_LC_FVMFILE: + case BFD_MACH_O_LC_PREPAGE: + case BFD_MACH_O_LC_DYSYMTAB: + case BFD_MACH_O_LC_LOAD_DYLIB: + case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: + case BFD_MACH_O_LC_ID_DYLIB: + case BFD_MACH_O_LC_LOAD_DYLINKER: + case BFD_MACH_O_LC_ID_DYLINKER: + case BFD_MACH_O_LC_PREBOUND_DYLIB: + case BFD_MACH_O_LC_ROUTINES: + case BFD_MACH_O_LC_SUB_FRAMEWORK: + break; + default: + fprintf (stderr, + "unable to write unknown load command 0x%lx\n", + (long) cur->type); + return false; + } + } + + return true; +} + +static int +bfd_mach_o_sizeof_headers (a, b) + bfd *a ATTRIBUTE_UNUSED; + boolean b ATTRIBUTE_UNUSED; +{ + return 0; +} + +/* Make an empty symbol. This is required only because + bfd_make_section_anyway wants to create a symbol for the section. */ + +static asymbol * +bfd_mach_o_make_empty_symbol (abfd) + bfd *abfd; +{ + asymbol *new; + + new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol)); + if (new == NULL) + return new; + new->the_bfd = abfd; + return new; +} + +static int +bfd_mach_o_write_header (abfd, header) + bfd *abfd; + bfd_mach_o_header *header; +{ + unsigned char buf[28]; + + bfd_h_put_32 (abfd, header->magic, buf + 0); + bfd_h_put_32 (abfd, header->cputype, buf + 4); + bfd_h_put_32 (abfd, header->cpusubtype, buf + 8); + bfd_h_put_32 (abfd, header->filetype, buf + 12); + bfd_h_put_32 (abfd, header->ncmds, buf + 16); + bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20); + bfd_h_put_32 (abfd, header->flags, buf + 24); + + bfd_seek (abfd, 0, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 28, abfd) != 28) + return -1; + + return 0; +} + +static int +bfd_mach_o_read_header (abfd, header) + bfd *abfd; + bfd_mach_o_header *header; +{ + unsigned char buf[28]; + bfd_vma (*get32) PARAMS ((const bfd_byte *)) = NULL; + + bfd_seek (abfd, 0, SEEK_SET); + + if (bfd_bread ((PTR) buf, 28, abfd) != 28) + return -1; + + if (bfd_getb32 (buf) == 0xfeedface) + { + header->byteorder = BFD_ENDIAN_BIG; + header->magic = 0xfeedface; + get32 = bfd_getb32; + } + else if (bfd_getl32 (buf) == 0xfeedface) + { + header->byteorder = BFD_ENDIAN_LITTLE; + header->magic = 0xfeedface; + get32 = bfd_getl32; + } + else + { + header->byteorder = BFD_ENDIAN_UNKNOWN; + return -1; + } + + header->cputype = (*get32) (buf + 4); + header->cpusubtype = (*get32) (buf + 8); + header->filetype = (*get32) (buf + 12); + header->ncmds = (*get32) (buf + 16); + header->sizeofcmds = (*get32) (buf + 20); + header->flags = (*get32) (buf + 24); + + return 0; +} + +static asection * +bfd_mach_o_make_bfd_section (abfd, section) + bfd *abfd; + bfd_mach_o_section *section; +{ + asection *bfdsec; + char *sname; + const char *prefix = "LC_SEGMENT"; + unsigned int snamelen; + + snamelen = strlen (prefix) + 1 + + strlen (section->segname) + 1 + + strlen (section->sectname) + 1; + + sname = (char *) bfd_alloc (abfd, snamelen); + if (sname == NULL) + return NULL; + sprintf (sname, "%s.%s.%s", prefix, section->segname, section->sectname); + + bfdsec = bfd_make_section_anyway (abfd, sname); + if (bfdsec == NULL) + return NULL; + + bfdsec->vma = section->addr; + bfdsec->lma = section->addr; + bfdsec->_raw_size = section->size; + bfdsec->filepos = section->offset; + bfdsec->alignment_power = section->align; + + if (section->flags & BFD_MACH_O_S_ZEROFILL) + bfdsec->flags = SEC_ALLOC; + else + bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE; + + return bfdsec; +} + +static int +bfd_mach_o_scan_read_section (abfd, section, offset) + bfd *abfd; + bfd_mach_o_section *section; + bfd_vma offset; +{ + unsigned char buf[68]; + + bfd_seek (abfd, offset, SEEK_SET); + if (bfd_bread ((PTR) buf, 68, abfd) != 68) + return -1; + + memcpy (section->sectname, buf, 16); + section->sectname[16] = '\0'; + memcpy (section->segname, buf + 16, 16); + section->segname[16] = '\0'; + section->addr = bfd_h_get_32 (abfd, buf + 32); + section->size = bfd_h_get_32 (abfd, buf + 36); + section->offset = bfd_h_get_32 (abfd, buf + 40); + section->align = bfd_h_get_32 (abfd, buf + 44); + section->reloff = bfd_h_get_32 (abfd, buf + 48); + section->nreloc = bfd_h_get_32 (abfd, buf + 52); + section->flags = bfd_h_get_32 (abfd, buf + 56); + section->reserved1 = bfd_h_get_32 (abfd, buf + 60); + section->reserved2 = bfd_h_get_32 (abfd, buf + 64); + section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section); + + if (section->bfdsection == NULL) + return -1; + + return 0; +} + +static int +bfd_mach_o_scan_write_section (abfd, section, offset) + bfd *abfd; + bfd_mach_o_section *section; + bfd_vma offset; +{ + unsigned char buf[68]; + + memcpy (buf, section->sectname, 16); + memcpy (buf + 16, section->segname, 16); + bfd_h_put_32 (abfd, section->addr, buf + 32); + bfd_h_put_32 (abfd, section->size, buf + 36); + bfd_h_put_32 (abfd, section->offset, buf + 40); + bfd_h_put_32 (abfd, section->align, buf + 44); + bfd_h_put_32 (abfd, section->reloff, buf + 48); + bfd_h_put_32 (abfd, section->nreloc, buf + 52); + bfd_h_put_32 (abfd, section->flags, buf + 56); + /* bfd_h_put_32 (abfd, section->reserved1, buf + 60); */ + /* bfd_h_put_32 (abfd, section->reserved2, buf + 64); */ + + bfd_seek (abfd, offset, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 68, abfd) != 68) + return -1; + + return 0; +} + +static int +bfd_mach_o_scan_write_symtab_symbols (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_symtab_command *sym = &command->command.symtab; + asymbol *s = NULL; + unsigned long i; + + for (i = 0; i < sym->nsyms; i++) + { + unsigned char buf[12]; + bfd_vma symoff = sym->symoff + (i * 12); + unsigned char ntype = 0; + unsigned char nsect = 0; + short ndesc = 0; + + s = &sym->symbols[i]; + + /* Don't set this from the symbol information; use stored values. */ +#if 0 + if (s->flags & BSF_GLOBAL) + ntype |= N_EXT; + if (s->flags & BSF_DEBUGGING) + ntype |= N_STAB; + + if (s->section == bfd_und_section_ptr) + ntype |= N_UNDF; + else if (s->section == bfd_abs_section_ptr) + ntype |= N_ABS; + else + ntype |= N_SECT; +#endif + + /* Instead just set from the stored values. */ + ntype = (s->udata.i >> 24) & 0xff; + nsect = (s->udata.i >> 16) & 0xff; + ndesc = s->udata.i & 0xffff; + + bfd_h_put_32 (abfd, s->name - sym->strtab, buf); + bfd_h_put_8 (abfd, ntype, buf + 4); + bfd_h_put_8 (abfd, nsect, buf + 5); + bfd_h_put_16 (abfd, ndesc, buf + 6); + bfd_h_put_32 (abfd, s->section->vma + s->value, buf + 8); + + bfd_seek (abfd, symoff, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 12, abfd) != 12) + { + fprintf (stderr, "bfd_mach_o_scan_write_symtab_symbols: unable to write %d bytes at %lu\n", + 12, (unsigned long) symoff); + return -1; + } + } + + return 0; +} + +int +bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, i) + bfd *abfd; + bfd_mach_o_symtab_command *sym; + asymbol *s; + unsigned long i; +{ + bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; + bfd_vma symoff = sym->symoff + (i * 12); + unsigned char buf[12]; + unsigned char type = -1; + unsigned char section = -1; + short desc = -1; + long value = -1; + unsigned long stroff = -1; + unsigned int symtype = -1; + + BFD_ASSERT (sym->strtab != NULL); + + bfd_seek (abfd, symoff, SEEK_SET); + if (bfd_bread ((PTR) buf, 12, abfd) != 12) + { + fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n", + 12, (unsigned long) symoff); + return -1; + } + + stroff = bfd_h_get_32 (abfd, buf); + type = bfd_h_get_8 (abfd, buf + 4); + symtype = (type & 0x0e); + section = bfd_h_get_8 (abfd, buf + 5) - 1; + desc = bfd_h_get_16 (abfd, buf + 6); + value = bfd_h_get_32 (abfd, buf + 8); + + if (stroff >= sym->strsize) + { + fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n", + (unsigned long) stroff, (unsigned long) sym->strsize); + return -1; + } + + s->the_bfd = abfd; + s->name = sym->strtab + stroff; + s->value = value; + s->udata.i = (type << 24) | (section << 16) | desc; + s->flags = 0x0; + + if (type & BFD_MACH_O_N_STAB) + { + s->flags |= BSF_DEBUGGING; + s->section = bfd_und_section_ptr; + } + else + { + if (type & BFD_MACH_O_N_PEXT) + { + type &= ~BFD_MACH_O_N_PEXT; + s->flags |= BSF_GLOBAL; + } + + if (type & BFD_MACH_O_N_EXT) + { + type &= ~BFD_MACH_O_N_EXT; + s->flags |= BSF_GLOBAL; + } + + switch (symtype) + { + case BFD_MACH_O_N_UNDF: + s->section = bfd_und_section_ptr; + break; + case BFD_MACH_O_N_PBUD: + s->section = bfd_und_section_ptr; + break; + case BFD_MACH_O_N_ABS: + s->section = bfd_abs_section_ptr; + break; + case BFD_MACH_O_N_SECT: + if ((section > 0) && (section <= mdata->nsects)) + { + s->section = mdata->sections[section - 1]->bfdsection; + s->value = s->value - mdata->sections[section - 1]->addr; + } + else + { + /* Mach-O uses 0 to mean "no section"; not an error. */ + if (section != 0) + { + fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: " + "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n", + s->name, section, mdata->nsects); + } + s->section = bfd_und_section_ptr; + } + break; + case BFD_MACH_O_N_INDR: + fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: " + "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n", + s->name); + s->section = bfd_und_section_ptr; + break; + default: + fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: " + "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n", + s->name, symtype); + s->section = bfd_und_section_ptr; + break; + } + } + + return 0; +} + +int +bfd_mach_o_scan_read_symtab_strtab (abfd, sym) + bfd *abfd; + bfd_mach_o_symtab_command *sym; +{ + BFD_ASSERT (sym->strtab == NULL); + + if (abfd->flags & BFD_IN_MEMORY) + { + struct bfd_in_memory *b; + + b = (struct bfd_in_memory *) abfd->iostream; + + if ((sym->stroff + sym->strsize) > b->size) + { + bfd_set_error (bfd_error_file_truncated); + return -1; + } + sym->strtab = b->buffer + sym->stroff; + return 0; + } + + sym->strtab = bfd_alloc (abfd, sym->strsize); + if (sym->strtab == NULL) + return -1; + + bfd_seek (abfd, sym->stroff, SEEK_SET); + if (bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize) + { + fprintf (stderr, "bfd_mach_o_scan_read_symtab_strtab: unable to read %lu bytes at %lu\n", + sym->strsize, sym->stroff); + return -1; + } + + return 0; +} + +int +bfd_mach_o_scan_read_symtab_symbols (abfd, sym) + bfd *abfd; + bfd_mach_o_symtab_command *sym; +{ + unsigned long i; + int ret; + + BFD_ASSERT (sym->symbols == NULL); + sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (asymbol)); + + if (sym->symbols == NULL) + { + fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n"); + return -1; + } + + ret = bfd_mach_o_scan_read_symtab_strtab (abfd, sym); + if (ret != 0) + return ret; + + for (i = 0; i < sym->nsyms; i++) + { + ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i); + if (ret != 0) + return ret; + } + + return 0; +} + +int +bfd_mach_o_scan_read_dysymtab_symbol (abfd, dysym, sym, s, i) + bfd *abfd; + bfd_mach_o_dysymtab_command *dysym; + bfd_mach_o_symtab_command *sym; + asymbol *s; + unsigned long i; +{ + unsigned long isymoff = dysym->indirectsymoff + (i * 4); + unsigned long symindex; + unsigned char buf[4]; + + BFD_ASSERT (i < dysym->nindirectsyms); + + bfd_seek (abfd, isymoff, SEEK_SET); + if (bfd_bread ((PTR) buf, 4, abfd) != 4) + { + fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n", + (unsigned long) 4, isymoff); + return -1; + } + symindex = bfd_h_get_32 (abfd, buf); + + return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex); +} + +static const char * +bfd_mach_o_i386_flavour_string (flavour) + unsigned int flavour; +{ + switch ((int) flavour) + { + case BFD_MACH_O_i386_NEW_THREAD_STATE: return "i386_NEW_THREAD_STATE"; + case BFD_MACH_O_i386_FLOAT_STATE: return "i386_FLOAT_STATE"; + case BFD_MACH_O_i386_ISA_PORT_MAP_STATE: return "i386_ISA_PORT_MAP_STATE"; + case BFD_MACH_O_i386_V86_ASSIST_STATE: return "i386_V86_ASSIST_STATE"; + case BFD_MACH_O_i386_REGS_SEGS_STATE: return "i386_REGS_SEGS_STATE"; + case BFD_MACH_O_i386_THREAD_SYSCALL_STATE: return "i386_THREAD_SYSCALL_STATE"; + case BFD_MACH_O_i386_THREAD_STATE_NONE: return "i386_THREAD_STATE_NONE"; + case BFD_MACH_O_i386_SAVED_STATE: return "i386_SAVED_STATE"; + case BFD_MACH_O_i386_THREAD_STATE: return "i386_THREAD_STATE"; + case BFD_MACH_O_i386_THREAD_FPSTATE: return "i386_THREAD_FPSTATE"; + case BFD_MACH_O_i386_THREAD_EXCEPTSTATE: return "i386_THREAD_EXCEPTSTATE"; + case BFD_MACH_O_i386_THREAD_CTHREADSTATE: return "i386_THREAD_CTHREADSTATE"; + default: return "UNKNOWN"; + } +} + +static const char * +bfd_mach_o_ppc_flavour_string (flavour) + unsigned int flavour; +{ + switch ((int) flavour) + { + case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE"; + case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE"; + case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE"; + case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE"; + default: return "UNKNOWN"; + } +} + +static int +bfd_mach_o_scan_write_thread (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_thread_command *cmd = &command->command.thread; + unsigned int i; + unsigned char buf[8]; + bfd_vma offset; + unsigned int nflavours; + + BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD) + || (command->type == BFD_MACH_O_LC_UNIXTHREAD)); + + offset = 8; + nflavours = 0; + for (i = 0; i < cmd->nflavours; i++) + { + BFD_ASSERT ((cmd->flavours[i].size % 4) == 0); + BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8)); + + bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf); + bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4); + + bfd_seek (abfd, command->offset + offset, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 8, abfd) != 8) + return -1; + + offset += cmd->flavours[i].size + 8; + } + + return 0; +} + +static int +bfd_mach_o_scan_read_dylinker (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_dylinker_command *cmd = &command->command.dylinker; + unsigned char buf[4]; + unsigned int nameoff; + asection *bfdsec; + char *sname; + const char *prefix; + + BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER) + || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bread ((PTR) buf, 4, abfd) != 4) + return -1; + + nameoff = bfd_h_get_32 (abfd, buf + 0); + + cmd->name_offset = command->offset + nameoff; + cmd->name_len = command->len - nameoff; + + if (command->type == BFD_MACH_O_LC_LOAD_DYLINKER) + prefix = "LC_LOAD_DYLINKER"; + else if (command->type == BFD_MACH_O_LC_ID_DYLINKER) + prefix = "LC_ID_DYLINKER"; + else + abort (); + + sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); + if (sname == NULL) + return -1; + strcpy (sname, prefix); + + bfdsec = bfd_make_section_anyway (abfd, sname); + if (bfdsec == NULL) + return -1; + + bfdsec->vma = 0; + bfdsec->lma = 0; + bfdsec->_raw_size = command->len - 8; + bfdsec->filepos = command->offset + 8; + bfdsec->alignment_power = 0; + bfdsec->flags = SEC_HAS_CONTENTS; + + cmd->section = bfdsec; + + return 0; +} + +static int +bfd_mach_o_scan_read_dylib (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_dylib_command *cmd = &command->command.dylib; + unsigned char buf[16]; + unsigned int nameoff; + asection *bfdsec; + char *sname; + const char *prefix; + + BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLIB) + || (command->type == BFD_MACH_O_LC_LOAD_DYLIB) + || (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB)); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bread ((PTR) buf, 16, abfd) != 16) + return -1; + + nameoff = bfd_h_get_32 (abfd, buf + 0); + cmd->timestamp = bfd_h_get_32 (abfd, buf + 4); + cmd->current_version = bfd_h_get_32 (abfd, buf + 8); + cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12); + + cmd->name_offset = command->offset + nameoff; + cmd->name_len = command->len - nameoff; + + if (command->type == BFD_MACH_O_LC_LOAD_DYLIB) + prefix = "LC_LOAD_DYLIB"; + else if (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB) + prefix = "LC_LOAD_WEAK_DYLIB"; + else if (command->type == BFD_MACH_O_LC_ID_DYLIB) + prefix = "LC_ID_DYLIB"; + else + abort (); + + sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); + if (sname == NULL) + return -1; + strcpy (sname, prefix); + + bfdsec = bfd_make_section_anyway (abfd, sname); + if (bfdsec == NULL) + return -1; + + bfdsec->vma = 0; + bfdsec->lma = 0; + bfdsec->_raw_size = command->len - 8; + bfdsec->filepos = command->offset + 8; + bfdsec->alignment_power = 0; + bfdsec->flags = SEC_HAS_CONTENTS; + + cmd->section = bfdsec; + + return 0; +} + +static int +bfd_mach_o_scan_read_prebound_dylib (abfd, command) + bfd *abfd ATTRIBUTE_UNUSED; + bfd_mach_o_load_command *command ATTRIBUTE_UNUSED; +{ + /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */ + + BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB); + return 0; +} + +static int +bfd_mach_o_scan_read_thread (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_data_struct *mdata = NULL; + bfd_mach_o_thread_command *cmd = &command->command.thread; + unsigned char buf[8]; + bfd_vma offset; + unsigned int nflavours; + unsigned int i; + + BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD) + || (command->type == BFD_MACH_O_LC_UNIXTHREAD)); + + BFD_ASSERT (bfd_mach_o_valid (abfd)); + mdata = abfd->tdata.mach_o_data; + + offset = 8; + nflavours = 0; + while (offset != command->len) + { + if (offset >= command->len) + return -1; + + bfd_seek (abfd, command->offset + offset, SEEK_SET); + + if (bfd_bread ((PTR) buf, 8, abfd) != 8) + return -1; + + offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4; + nflavours++; + } + + cmd->flavours = + ((bfd_mach_o_thread_flavour *) + bfd_alloc (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour))); + if (cmd->flavours == NULL) + return -1; + cmd->nflavours = nflavours; + + offset = 8; + nflavours = 0; + while (offset != command->len) + { + if (offset >= command->len) + return -1; + + if (nflavours >= cmd->nflavours) + return -1; + + bfd_seek (abfd, command->offset + offset, SEEK_SET); + + if (bfd_bread ((PTR) buf, 8, abfd) != 8) + return -1; + + cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf); + cmd->flavours[nflavours].offset = command->offset + offset + 8; + cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4; + offset += cmd->flavours[nflavours].size + 8; + nflavours++; + } + + for (i = 0; i < nflavours; i++) + { + asection *bfdsec; + unsigned int snamelen; + char *sname; + const char *flavourstr; + const char *prefix = "LC_THREAD"; + unsigned int i = 0; + + switch (mdata->header.cputype) + { + case BFD_MACH_O_CPU_TYPE_POWERPC: + flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour); + break; + case BFD_MACH_O_CPU_TYPE_I386: + flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour); + break; + default: + flavourstr = "UNKNOWN_ARCHITECTURE"; + break; + } + + snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1; + sname = (char *) bfd_alloc (abfd, snamelen); + if (sname == NULL) + return -1; + + for (;;) + { + sprintf (sname, "%s.%s.%u", prefix, flavourstr, i); + if (bfd_get_section_by_name (abfd, sname) == NULL) { + break; + } + i++; + } + + bfdsec = bfd_make_section (abfd, sname); + + bfdsec->vma = 0; + bfdsec->lma = 0; + bfdsec->_raw_size = cmd->flavours[i].size; + bfdsec->filepos = cmd->flavours[i].offset; + bfdsec->alignment_power = 0x0; + bfdsec->flags = SEC_HAS_CONTENTS; + + cmd->section = bfdsec; + } + + return 0; +} + +static int +bfd_mach_o_scan_write_symtab (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_symtab_command *seg = &command->command.symtab; + unsigned char buf[16]; + + BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB); + + bfd_h_put_32 (abfd, seg->symoff, buf); + bfd_h_put_32 (abfd, seg->nsyms, buf + 4); + bfd_h_put_32 (abfd, seg->stroff, buf + 8); + bfd_h_put_32 (abfd, seg->strsize, buf + 12); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 16, abfd) != 16) + return -1; + + if (bfd_mach_o_scan_write_symtab_symbols (abfd, command) != 0) + return -1; + + return 0; +} + +static int +bfd_mach_o_scan_read_dysymtab (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_dysymtab_command *seg = &command->command.dysymtab; + unsigned char buf[72]; + + BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bread ((PTR) buf, 72, abfd) != 72) + return -1; + + seg->ilocalsym = bfd_h_get_32 (abfd, buf + 0); + seg->nlocalsym = bfd_h_get_32 (abfd, buf + 4); + seg->iextdefsym = bfd_h_get_32 (abfd, buf + 8); + seg->nextdefsym = bfd_h_get_32 (abfd, buf + 12); + seg->iundefsym = bfd_h_get_32 (abfd, buf + 16); + seg->nundefsym = bfd_h_get_32 (abfd, buf + 20); + seg->tocoff = bfd_h_get_32 (abfd, buf + 24); + seg->ntoc = bfd_h_get_32 (abfd, buf + 28); + seg->modtaboff = bfd_h_get_32 (abfd, buf + 32); + seg->nmodtab = bfd_h_get_32 (abfd, buf + 36); + seg->extrefsymoff = bfd_h_get_32 (abfd, buf + 40); + seg->nextrefsyms = bfd_h_get_32 (abfd, buf + 44); + seg->indirectsymoff = bfd_h_get_32 (abfd, buf + 48); + seg->nindirectsyms = bfd_h_get_32 (abfd, buf + 52); + seg->extreloff = bfd_h_get_32 (abfd, buf + 56); + seg->nextrel = bfd_h_get_32 (abfd, buf + 60); + seg->locreloff = bfd_h_get_32 (abfd, buf + 64); + seg->nlocrel = bfd_h_get_32 (abfd, buf + 68); + + return 0; +} + +static int +bfd_mach_o_scan_read_symtab (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + bfd_mach_o_symtab_command *seg = &command->command.symtab; + unsigned char buf[16]; + asection *bfdsec; + char *sname; + const char *prefix = "LC_SYMTAB.stabs"; + + BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bread ((PTR) buf, 16, abfd) != 16) + return -1; + + seg->symoff = bfd_h_get_32 (abfd, buf); + seg->nsyms = bfd_h_get_32 (abfd, buf + 4); + seg->stroff = bfd_h_get_32 (abfd, buf + 8); + seg->strsize = bfd_h_get_32 (abfd, buf + 12); + seg->symbols = NULL; + seg->strtab = NULL; + + sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); + if (sname == NULL) + return -1; + strcpy (sname, prefix); + + bfdsec = bfd_make_section_anyway (abfd, sname); + if (bfdsec == NULL) + return -1; + + bfdsec->vma = 0; + bfdsec->lma = 0; + bfdsec->_raw_size = seg->nsyms * 12; + bfdsec->filepos = seg->symoff; + bfdsec->alignment_power = 0; + bfdsec->flags = SEC_HAS_CONTENTS; + + seg->stabs_segment = bfdsec; + + prefix = "LC_SYMTAB.stabstr"; + sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); + if (sname == NULL) + return -1; + strcpy (sname, prefix); + + bfdsec = bfd_make_section_anyway (abfd, sname); + if (bfdsec == NULL) + return -1; + + bfdsec->vma = 0; + bfdsec->lma = 0; + bfdsec->_raw_size = seg->strsize; + bfdsec->filepos = seg->stroff; + bfdsec->alignment_power = 0; + bfdsec->flags = SEC_HAS_CONTENTS; + + seg->stabstr_segment = bfdsec; + + return 0; +} + +static int +bfd_mach_o_scan_read_segment (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + unsigned char buf[48]; + bfd_mach_o_segment_command *seg = &command->command.segment; + unsigned long i; + asection *bfdsec; + char *sname; + const char *prefix = "LC_SEGMENT"; + unsigned int snamelen; + + BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bread ((PTR) buf, 48, abfd) != 48) + return -1; + + memcpy (seg->segname, buf, 16); + seg->vmaddr = bfd_h_get_32 (abfd, buf + 16); + seg->vmsize = bfd_h_get_32 (abfd, buf + 20); + seg->fileoff = bfd_h_get_32 (abfd, buf + 24); + seg->filesize = bfd_h_get_32 (abfd, buf + 28); + /* seg->maxprot = bfd_h_get_32 (abfd, buf + 32); */ + /* seg->initprot = bfd_h_get_32 (abfd, buf + 36); */ + seg->nsects = bfd_h_get_32 (abfd, buf + 40); + seg->flags = bfd_h_get_32 (abfd, buf + 44); + + snamelen = strlen (prefix) + 1 + strlen (seg->segname) + 1; + sname = (char *) bfd_alloc (abfd, snamelen); + if (sname == NULL) + return -1; + sprintf (sname, "%s.%s", prefix, seg->segname); + + bfdsec = bfd_make_section_anyway (abfd, sname); + if (bfdsec == NULL) + return -1; + + bfdsec->vma = seg->vmaddr; + bfdsec->lma = seg->vmaddr; + bfdsec->_raw_size = seg->filesize; + bfdsec->filepos = seg->fileoff; + bfdsec->alignment_power = 0x0; + bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE; + + seg->segment = bfdsec; + + if (seg->nsects != 0) + { + seg->sections = + ((bfd_mach_o_section *) + bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section))); + if (seg->sections == NULL) + return -1; + + for (i = 0; i < seg->nsects; i++) + { + bfd_vma segoff = command->offset + 48 + 8 + (i * 68); + + if (bfd_mach_o_scan_read_section (abfd, &seg->sections[i], segoff) != 0) + return -1; + } + } + + return 0; +} + +static int +bfd_mach_o_scan_write_segment (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + unsigned char buf[48]; + bfd_mach_o_segment_command *seg = &command->command.segment; + unsigned long i; + + BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT); + + memcpy (buf, seg->segname, 16); + bfd_h_put_32 (abfd, seg->vmaddr, buf + 16); + bfd_h_put_32 (abfd, seg->vmsize, buf + 20); + bfd_h_put_32 (abfd, seg->fileoff, buf + 24); + bfd_h_put_32 (abfd, seg->filesize, buf + 28); + bfd_h_put_32 (abfd, 0 /* seg->maxprot */, buf + 32); + bfd_h_put_32 (abfd, 0 /* seg->initprot */, buf + 36); + bfd_h_put_32 (abfd, seg->nsects, buf + 40); + bfd_h_put_32 (abfd, seg->flags, buf + 44); + + bfd_seek (abfd, command->offset + 8, SEEK_SET); + if (bfd_bwrite ((PTR) buf, 48, abfd) != 48) + return -1; + + { + char buf[1024]; + bfd_vma nbytes = seg->filesize; + bfd_vma curoff = seg->fileoff; + + while (nbytes > 0) + { + bfd_vma thisread = nbytes; + + if (thisread > 1024) + thisread = 1024; + + bfd_seek (abfd, curoff, SEEK_SET); + if (bfd_bread ((PTR) buf, thisread, abfd) != thisread) + return -1; + + bfd_seek (abfd, curoff, SEEK_SET); + if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread) + return -1; + + nbytes -= thisread; + curoff += thisread; + } + } + + for (i = 0; i < seg->nsects; i++) + { + bfd_vma segoff = command->offset + 48 + 8 + (i * 68); + + if (bfd_mach_o_scan_write_section (abfd, &seg->sections[i], segoff) != 0) + return -1; + } + + return 0; +} + +static int +bfd_mach_o_scan_read_command (abfd, command) + bfd *abfd; + bfd_mach_o_load_command *command; +{ + unsigned char buf[8]; + + bfd_seek (abfd, command->offset, SEEK_SET); + if (bfd_bread ((PTR) buf, 8, abfd) != 8) + return -1; + + command->type = (bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD); + command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD) ? 1 : 0; + command->len = bfd_h_get_32 (abfd, buf + 4); + + switch (command->type) + { + case BFD_MACH_O_LC_SEGMENT: + if (bfd_mach_o_scan_read_segment (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_SYMTAB: + if (bfd_mach_o_scan_read_symtab (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_SYMSEG: + break; + case BFD_MACH_O_LC_THREAD: + case BFD_MACH_O_LC_UNIXTHREAD: + if (bfd_mach_o_scan_read_thread (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_LOAD_DYLINKER: + case BFD_MACH_O_LC_ID_DYLINKER: + if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_LOAD_DYLIB: + case BFD_MACH_O_LC_ID_DYLIB: + case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: + if (bfd_mach_o_scan_read_dylib (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_PREBOUND_DYLIB: + if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_LOADFVMLIB: + case BFD_MACH_O_LC_IDFVMLIB: + case BFD_MACH_O_LC_IDENT: + case BFD_MACH_O_LC_FVMFILE: + case BFD_MACH_O_LC_PREPAGE: + case BFD_MACH_O_LC_ROUTINES: + case BFD_MACH_O_LC_SUB_FRAMEWORK: + break; + case BFD_MACH_O_LC_DYSYMTAB: + if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0) + return -1; + break; + case BFD_MACH_O_LC_SUB_UMBRELLA: + case BFD_MACH_O_LC_SUB_CLIENT: + case BFD_MACH_O_LC_SUB_LIBRARY: + case BFD_MACH_O_LC_TWOLEVEL_HINTS: + case BFD_MACH_O_LC_PREBIND_CKSUM: + break; + default: + fprintf (stderr, "unable to read unknown load command 0x%lx\n", + (unsigned long) command->type); + break; + } + + return 0; +} + +static void +bfd_mach_o_flatten_sections (abfd) + bfd *abfd; +{ + bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; + long csect = 0; + unsigned long i, j; + + mdata->nsects = 0; + + for (i = 0; i < mdata->header.ncmds; i++) + { + if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT) + { + bfd_mach_o_segment_command *seg = &mdata->commands[i].command.segment; + mdata->nsects += seg->nsects; + } + } + + mdata->sections = bfd_alloc (abfd, mdata->nsects * sizeof (bfd_mach_o_section *)); + csect = 0; + + for (i = 0; i < mdata->header.ncmds; i++) + { + if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT) + { + bfd_mach_o_segment_command *seg = &mdata->commands[i].command.segment; + + BFD_ASSERT (csect + seg->nsects <= mdata->nsects); + + for (j = 0; j < seg->nsects; j++) + mdata->sections[csect++] = &seg->sections[j]; + } + } +} + +int +bfd_mach_o_scan_start_address (abfd) + bfd *abfd; +{ + bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; + bfd_mach_o_thread_command *cmd = NULL; + unsigned long i; + + for (i = 0; i < mdata->header.ncmds; i++) + { + if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) || + (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD)) + { + if (cmd == NULL) + cmd = &mdata->commands[i].command.thread; + else + return 0; + } + } + + if (cmd == NULL) + return 0; + + for (i = 0; i < cmd->nflavours; i++) + { + if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386) + && (cmd->flavours[i].flavour == (unsigned long) BFD_MACH_O_i386_THREAD_STATE)) + { + unsigned char buf[4]; + + bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET); + + if (bfd_bread (buf, 4, abfd) != 4) + return -1; + + abfd->start_address = bfd_h_get_32 (abfd, buf); + } + else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC) + && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE)) + { + unsigned char buf[4]; + + bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET); + + if (bfd_bread (buf, 4, abfd) != 4) + return -1; + + abfd->start_address = bfd_h_get_32 (abfd, buf); + } + } + + return 0; +} + +int +bfd_mach_o_scan (abfd, header) + bfd *abfd; + bfd_mach_o_header *header; +{ + unsigned int i; + bfd_mach_o_data_struct *mdata = NULL; + enum bfd_architecture cputype; + unsigned long cpusubtype; + + mdata = ((bfd_mach_o_data_struct *) + bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct))); + if (mdata == NULL) + return -1; + + mdata->header = *header; + mdata->symbols = NULL; + + abfd->flags = abfd->xvec->object_flags | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)); + abfd->tdata.mach_o_data = mdata; + + bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype, &cputype, &cpusubtype); + if (cputype == bfd_arch_unknown) + { + fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n", + header->cputype, header->cpusubtype); + return -1; + } + + bfd_set_arch_mach (abfd, cputype, cpusubtype); + + if (header->ncmds != 0) + { + mdata->commands = + ((bfd_mach_o_load_command *) + bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command))); + if (mdata->commands == NULL) + return -1; + + for (i = 0; i < header->ncmds; i++) + { + bfd_mach_o_load_command *cur = &mdata->commands[i]; + + if (i == 0) + cur->offset = 28; + else + { + bfd_mach_o_load_command *prev = &mdata->commands[i - 1]; + cur->offset = prev->offset + prev->len; + } + + if (bfd_mach_o_scan_read_command (abfd, cur) < 0) + return -1; + } + } + + if (bfd_mach_o_scan_start_address (abfd) < 0) + { +#if 0 + fprintf (stderr, "bfd_mach_o_scan: unable to scan start address: %s\n", + bfd_errmsg (bfd_get_error ())); + abfd->tdata.mach_o_data = NULL; + return -1; +#endif + } + + bfd_mach_o_flatten_sections (abfd); + + return 0; +} + +boolean +bfd_mach_o_mkobject (abfd) + bfd *abfd; +{ + bfd_mach_o_data_struct *mdata = NULL; + + mdata = ((bfd_mach_o_data_struct *) + bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct))); + if (mdata == NULL) + return false; + abfd->tdata.mach_o_data = mdata; + + mdata->header.magic = 0; + mdata->header.cputype = 0; + mdata->header.cpusubtype = 0; + mdata->header.filetype = 0; + mdata->header.ncmds = 0; + mdata->header.sizeofcmds = 0; + mdata->header.flags = 0; + mdata->header.byteorder = BFD_ENDIAN_UNKNOWN; + mdata->commands = NULL; + mdata->nsymbols = 0; + mdata->symbols = NULL; + mdata->nsects = 0; + mdata->sections = NULL; + mdata->ibfd = NULL; + + return true; +} + +const bfd_target * +bfd_mach_o_object_p (abfd) + bfd *abfd; +{ + bfd_mach_o_header header; + + if (bfd_mach_o_read_header (abfd, &header) != 0) + { + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + if (! ((header.byteorder == BFD_ENDIAN_BIG) + || (header.byteorder == BFD_ENDIAN_LITTLE))) + { + fprintf (stderr, "unknown header byte-order value 0x%lx\n", (long) header.byteorder); + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + if (! (((header.byteorder == BFD_ENDIAN_BIG) + && (abfd->xvec->byteorder == BFD_ENDIAN_BIG) + && (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)) + || + ((header.byteorder == BFD_ENDIAN_LITTLE) + && (abfd->xvec->byteorder == BFD_ENDIAN_LITTLE) + && (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))) + { + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + abfd->tdata.mach_o_data = NULL; + + if (bfd_mach_o_scan (abfd, &header) != 0) + { + abfd->tdata.mach_o_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + return abfd->xvec; +} + +const bfd_target * +bfd_mach_o_core_p (abfd) + bfd *abfd; +{ + bfd_mach_o_header header; + + bfd_set_error (bfd_error_wrong_format); + + if (bfd_mach_o_read_header (abfd, &header) != 0) + return NULL; + + if (! ((header.byteorder == BFD_ENDIAN_BIG) + || (header.byteorder == BFD_ENDIAN_LITTLE))) + { + fprintf (stderr, "unknown header byte-order value 0x%lx\n", (long) header.byteorder); + abort (); + } + + if (! (((header.byteorder == BFD_ENDIAN_BIG) + && (abfd->xvec->byteorder == BFD_ENDIAN_BIG) + && (abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)) + || + ((header.byteorder == BFD_ENDIAN_LITTLE) + && (abfd->xvec->byteorder == BFD_ENDIAN_LITTLE) + && (abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))) + return NULL; + + if (header.filetype != BFD_MACH_O_MH_CORE) + return NULL; + + abfd->tdata.mach_o_data = NULL; + if (bfd_mach_o_scan (abfd, &header) != 0) + { + abfd->tdata.mach_o_data = NULL; + return NULL; + } + + return abfd->xvec; +} + +typedef struct mach_o_fat_archentry +{ + unsigned long cputype; + unsigned long cpusubtype; + unsigned long offset; + unsigned long size; + unsigned long align; + bfd *abfd; +} mach_o_fat_archentry; + +typedef struct mach_o_fat_data_struct +{ + unsigned long magic; + unsigned long nfat_arch; + mach_o_fat_archentry *archentries; +} mach_o_fat_data_struct; + +const bfd_target * +bfd_mach_o_archive_p (abfd) + bfd *abfd; +{ + mach_o_fat_data_struct *adata; + unsigned char buf[20]; + unsigned long i; + + bfd_seek (abfd, 0, SEEK_SET); + if (bfd_bread ((PTR) buf, 8, abfd) != 8) + return NULL; + + adata = (mach_o_fat_data_struct *) + bfd_alloc (abfd, sizeof (mach_o_fat_data_struct)); + if (adata == NULL) + return NULL; + + adata->magic = bfd_getb32 (buf); + adata->nfat_arch = bfd_getb32 (buf + 4); + if (adata->magic != 0xcafebabe) + return NULL; + + adata->archentries = (mach_o_fat_archentry *) + bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry)); + if (adata->archentries == NULL) + return NULL; + + for (i = 0; i < adata->nfat_arch; i++) + { + bfd_seek (abfd, 8 + 20 * i, SEEK_SET); + + if (bfd_bread ((PTR) buf, 20, abfd) != 20) + return NULL; + adata->archentries[i].cputype = bfd_getb32 (buf); + adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4); + adata->archentries[i].offset = bfd_getb32 (buf + 8); + adata->archentries[i].size = bfd_getb32 (buf + 12); + adata->archentries[i].align = bfd_getb32 (buf + 16); + adata->archentries[i].abfd = NULL; + } + + abfd->tdata.mach_o_fat_data = adata; + return abfd->xvec; +} + +bfd * +bfd_mach_o_openr_next_archived_file (archive, prev) + bfd *archive; + bfd *prev; +{ + mach_o_fat_data_struct *adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data; + mach_o_fat_archentry *entry = NULL; + unsigned long i; + + BFD_ASSERT (adata != NULL); + + /* Find index of previous entry. */ + if (prev == NULL) + i = 0; /* Start at first one. */ + else + { + for (i = 0; i < adata->nfat_arch; i++) + { + if (adata->archentries[i].abfd == prev) + break; + } + + if (i == adata->nfat_arch) + { + /* Not found. */ + bfd_set_error (bfd_error_bad_value); + return NULL; + } + i++; /* Get next entry. */ + } + + if (i >= adata->nfat_arch) + { + bfd_set_error (bfd_error_no_more_archived_files); + return NULL; + } + + entry = &adata->archentries[i]; + if (entry->abfd == NULL) + { + bfd *nbfd = _bfd_new_bfd_contained_in (archive); + char *s = NULL; + + if (nbfd == NULL) + return NULL; + + nbfd->origin = entry->offset; + s = bfd_malloc (strlen (archive->filename) + 1); + if (s == NULL) + return NULL; + strcpy (s, archive->filename); + nbfd->filename = s; + nbfd->iostream = NULL; + entry->abfd = nbfd; + } + + return entry->abfd; +} + +int bfd_mach_o_lookup_section + (bfd *abfd, asection *section, + bfd_mach_o_load_command **mcommand, bfd_mach_o_section **msection) +{ + struct mach_o_data_struct *md = abfd->tdata.mach_o_data; + unsigned int i, j, num; + + bfd_mach_o_load_command *ncmd = NULL; + bfd_mach_o_section *nsect = NULL; + + BFD_ASSERT (mcommand != NULL); + BFD_ASSERT (msection != NULL); + + num = 0; + for (i = 0; i < md->header.ncmds; i++) + { + struct bfd_mach_o_load_command *cmd = &md->commands[i]; + struct bfd_mach_o_segment_command *seg = NULL; + + if (cmd->type != BFD_MACH_O_LC_SEGMENT) + continue; + seg = &cmd->command.segment; + + if (seg->segment == section) + { + if (num == 0) + ncmd = cmd; + num++; + } + + for (j = 0; j < seg->nsects; j++) + { + struct bfd_mach_o_section *sect = &seg->sections[j]; + + if (sect->bfdsection == section) + { + if (num == 0) + nsect = sect; + num++; + } + } + } + + *mcommand = ncmd; + *msection = nsect; + return num; +} + +int +bfd_mach_o_lookup_command + (bfd *abfd, bfd_mach_o_load_command_type type, + bfd_mach_o_load_command **mcommand) +{ + struct mach_o_data_struct *md = NULL; + bfd_mach_o_load_command *ncmd = NULL; + unsigned int i, num; + + md = abfd->tdata.mach_o_data; + + BFD_ASSERT (md != NULL); + BFD_ASSERT (mcommand != NULL); + + num = 0; + for (i = 0; i < md->header.ncmds; i++) + { + struct bfd_mach_o_load_command *cmd = &md->commands[i]; + + if (cmd->type != type) + continue; + + if (num == 0) + ncmd = cmd; + num++; + } + + *mcommand = ncmd; + return num; +} + +unsigned long +bfd_mach_o_stack_addr (type) + enum bfd_mach_o_cpu_type type; +{ + switch (type) + { + case BFD_MACH_O_CPU_TYPE_MC680x0: + return 0x04000000; + case BFD_MACH_O_CPU_TYPE_MC88000: + return 0xffffe000; + case BFD_MACH_O_CPU_TYPE_POWERPC: + return 0xc0000000; + case BFD_MACH_O_CPU_TYPE_I386: + return 0xc0000000; + case BFD_MACH_O_CPU_TYPE_SPARC: + return 0xf0000000; + case BFD_MACH_O_CPU_TYPE_I860: + return 0; + case BFD_MACH_O_CPU_TYPE_HPPA: + return (0xc0000000-0x04000000); + default: + return 0; + } +} + +int +bfd_mach_o_core_fetch_environment (abfd, rbuf, rlen) + bfd *abfd; + unsigned char **rbuf; + unsigned int *rlen; +{ + bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; + unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype); + unsigned int i = 0; + + for (i = 0; i < mdata->header.ncmds; i++) + { + bfd_mach_o_load_command *cur = &mdata->commands[i]; + bfd_mach_o_segment_command *seg = NULL; + + if (cur->type != BFD_MACH_O_LC_SEGMENT) + continue; + + seg = &cur->command.segment; + + if ((seg->vmaddr + seg->vmsize) == stackaddr) + { + unsigned long start = seg->fileoff; + unsigned long end = seg->fileoff + seg->filesize; + unsigned char *buf = bfd_malloc (1024); + unsigned long size = 1024; + + for (;;) + { + bfd_size_type nread = 0; + unsigned long offset; + int found_nonnull = 0; + + if (size > (end - start)) + size = (end - start); + + buf = bfd_realloc (buf, size); + + bfd_seek (abfd, end - size, SEEK_SET); + nread = bfd_bread (buf, size, abfd); + + if (nread != size) + return -1; + + for (offset = 4; offset <= size; offset += 4) + { + unsigned long val = *((unsigned long *) (buf + size - offset)); + + if (! found_nonnull) + { + if (val != 0) + found_nonnull = 1; + } + else if (val == 0x0) + { + unsigned long bottom = seg->fileoff + seg->filesize - offset; + unsigned long top = seg->fileoff + seg->filesize - 4; + + *rbuf = bfd_malloc (top - bottom); + *rlen = top - bottom; + + memcpy (*rbuf, buf + size - *rlen, *rlen); + return 0; + } + } + + if (size == (end - start)) + break; + + size *= 2; + } + } + } + + return -1; +} + +char * +bfd_mach_o_core_file_failing_command (abfd) + bfd *abfd; +{ + unsigned char *buf = NULL; + unsigned int len = 0; + int ret = -1; + + ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len); + if (ret < 0) + return NULL; + + return buf; +} + +int +bfd_mach_o_core_file_failing_signal (abfd) + bfd *abfd ATTRIBUTE_UNUSED; +{ + return 0; +} + +boolean +bfd_mach_o_core_file_matches_executable_p (core_bfd, exec_bfd) + bfd *core_bfd ATTRIBUTE_UNUSED; + bfd *exec_bfd ATTRIBUTE_UNUSED; +{ + return true; +} + +#define TARGET_NAME mach_o_be_vec +#define TARGET_STRING "mach-o-be" +#define TARGET_BIG_ENDIAN 1 +#define TARGET_ARCHIVE 0 + +#include "mach-o-target.c" + +#undef TARGET_NAME +#undef TARGET_STRING +#undef TARGET_BIG_ENDIAN +#undef TARGET_ARCHIVE + +#define TARGET_NAME mach_o_le_vec +#define TARGET_STRING "mach-o-le" +#define TARGET_BIG_ENDIAN 0 +#define TARGET_ARCHIVE 0 + +#include "mach-o-target.c" + +#undef TARGET_NAME +#undef TARGET_STRING +#undef TARGET_BIG_ENDIAN +#undef TARGET_ARCHIVE + +#define TARGET_NAME mach_o_fat_vec +#define TARGET_STRING "mach-o-fat" +#define TARGET_BIG_ENDIAN 1 +#define TARGET_ARCHIVE 1 + +#include "mach-o-target.c" + +#undef TARGET_NAME +#undef TARGET_STRING +#undef TARGET_BIG_ENDIAN +#undef TARGET_ARCHIVE + diff --git a/bfd/mach-o.h b/bfd/mach-o.h new file mode 100644 index 0000000..c368c1e --- /dev/null +++ b/bfd/mach-o.h @@ -0,0 +1,490 @@ +/* Mach-O support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifndef _BFD_MACH_O_H_ +#define _BFD_MACH_O_H_ + +#include "bfd.h" + +#define BFD_MACH_O_N_STAB 0xe0 /* If any of these bits set, a symbolic debugging entry. */ +#define BFD_MACH_O_N_PEXT 0x10 /* Private external symbol bit. */ +#define BFD_MACH_O_N_TYPE 0x0e /* Mask for the type bits. */ +#define BFD_MACH_O_N_EXT 0x01 /* External symbol bit, set for external symbols. */ +#define BFD_MACH_O_N_UNDF 0x00 /* Undefined, n_sect == NO_SECT. */ +#define BFD_MACH_O_N_ABS 0x02 /* Absolute, n_sect == NO_SECT. */ +#define BFD_MACH_O_N_SECT 0x0e /* Defined in section number n_sect. */ +#define BFD_MACH_O_N_PBUD 0x0c /* Prebound undefined (defined in a dylib). */ +#define BFD_MACH_O_N_INDR 0x0a /* Indirect. */ + +typedef enum bfd_mach_o_ppc_thread_flavour + { + BFD_MACH_O_PPC_THREAD_STATE = 1, + BFD_MACH_O_PPC_FLOAT_STATE = 2, + BFD_MACH_O_PPC_EXCEPTION_STATE = 3, + BFD_MACH_O_PPC_VECTOR_STATE = 4 + } +bfd_mach_o_ppc_thread_flavour; + +typedef enum bfd_mach_o_i386_thread_flavour + { + BFD_MACH_O_i386_NEW_THREAD_STATE = 1, + BFD_MACH_O_i386_FLOAT_STATE = 2, + BFD_MACH_O_i386_ISA_PORT_MAP_STATE = 3, + BFD_MACH_O_i386_V86_ASSIST_STATE = 4, + BFD_MACH_O_i386_REGS_SEGS_STATE = 5, + BFD_MACH_O_i386_THREAD_SYSCALL_STATE = 6, + BFD_MACH_O_i386_THREAD_STATE_NONE = 7, + BFD_MACH_O_i386_SAVED_STATE = 8, + BFD_MACH_O_i386_THREAD_STATE = -1, + BFD_MACH_O_i386_THREAD_FPSTATE = -2, + BFD_MACH_O_i386_THREAD_EXCEPTSTATE = -3, + BFD_MACH_O_i386_THREAD_CTHREADSTATE = -4, + } +bfd_mach_o_i386_thread_flavour; + +#define BFD_MACH_O_LC_REQ_DYLD 0x80000000 + +typedef enum bfd_mach_o_load_command_type + { + BFD_MACH_O_LC_SEGMENT = 0x1, /* File segment to be mapped. */ + BFD_MACH_O_LC_SYMTAB = 0x2, /* Link-edit stab symbol table info (obsolete). */ + BFD_MACH_O_LC_SYMSEG = 0x3, /* Link-edit gdb symbol table info. */ + BFD_MACH_O_LC_THREAD = 0x4, /* Thread. */ + BFD_MACH_O_LC_UNIXTHREAD = 0x5, /* UNIX thread (includes a stack). */ + BFD_MACH_O_LC_LOADFVMLIB = 0x6, /* Load a fixed VM shared library. */ + BFD_MACH_O_LC_IDFVMLIB = 0x7, /* Fixed VM shared library id. */ + BFD_MACH_O_LC_IDENT = 0x8, /* Object identification information (obsolete). */ + BFD_MACH_O_LC_FVMFILE = 0x9, /* Fixed VM file inclusion. */ + BFD_MACH_O_LC_PREPAGE = 0xa, /* Prepage command (internal use). */ + BFD_MACH_O_LC_DYSYMTAB = 0xb, /* Dynamic link-edit symbol table info. */ + BFD_MACH_O_LC_LOAD_DYLIB = 0xc, /* Load a dynamicly linked shared library. */ + BFD_MACH_O_LC_ID_DYLIB = 0xd, /* Dynamicly linked shared lib identification. */ + BFD_MACH_O_LC_LOAD_DYLINKER = 0xe, /* Load a dynamic linker. */ + BFD_MACH_O_LC_ID_DYLINKER = 0xf, /* Dynamic linker identification. */ + BFD_MACH_O_LC_PREBOUND_DYLIB = 0x10,/* Modules prebound for a dynamicly. */ + BFD_MACH_O_LC_ROUTINES = 0x11, /* Image routines. */ + BFD_MACH_O_LC_SUB_FRAMEWORK = 0x12, /* Sub framework. */ + BFD_MACH_O_LC_SUB_UMBRELLA = 0x13, /* Sub umbrella. */ + BFD_MACH_O_LC_SUB_CLIENT = 0x14, /* Sub client. */ + BFD_MACH_O_LC_SUB_LIBRARY = 0x15, /* Sub library. */ + BFD_MACH_O_LC_TWOLEVEL_HINTS = 0x16,/* Two-level namespace lookup hints. */ + BFD_MACH_O_LC_PREBIND_CKSUM = 0x17, /* Prebind checksum. */ + /* Load a dynamicly linked shared library that is allowed to be + missing (weak). */ + BFD_MACH_O_LC_LOAD_WEAK_DYLIB = 0x18 + } +bfd_mach_o_load_command_type; + +typedef enum bfd_mach_o_cpu_type + { + BFD_MACH_O_CPU_TYPE_VAX = 1, + BFD_MACH_O_CPU_TYPE_MC680x0 = 6, + BFD_MACH_O_CPU_TYPE_I386 = 7, + BFD_MACH_O_CPU_TYPE_MIPS = 8, + BFD_MACH_O_CPU_TYPE_MC98000 = 10, + BFD_MACH_O_CPU_TYPE_HPPA = 11, + BFD_MACH_O_CPU_TYPE_ARM = 12, + BFD_MACH_O_CPU_TYPE_MC88000 = 13, + BFD_MACH_O_CPU_TYPE_SPARC = 14, + BFD_MACH_O_CPU_TYPE_I860 = 15, + BFD_MACH_O_CPU_TYPE_ALPHA = 16, + BFD_MACH_O_CPU_TYPE_POWERPC = 18 + } +bfd_mach_o_cpu_type; + +typedef enum bfd_mach_o_filetype + { + BFD_MACH_O_MH_OBJECT = 1, + BFD_MACH_O_MH_EXECUTE = 2, + BFD_MACH_O_MH_FVMLIB = 3, + BFD_MACH_O_MH_CORE = 4, + BFD_MACH_O_MH_PRELOAD = 5, + BFD_MACH_O_MH_DYLIB = 6, + BFD_MACH_O_MH_DYLINKER = 7, + BFD_MACH_O_MH_BUNDLE = 8 + } +bfd_mach_o_filetype; + +/* Constants for the type of a section. */ + +typedef enum bfd_mach_o_section_type + { + /* Regular section. */ + BFD_MACH_O_S_REGULAR = 0x0, + + /* Zero fill on demand section. */ + BFD_MACH_O_S_ZEROFILL = 0x1, + + /* Section with only literal C strings. */ + BFD_MACH_O_S_CSTRING_LITERALS = 0x2, + + /* Section with only 4 byte literals. */ + BFD_MACH_O_S_4BYTE_LITERALS = 0x3, + + /* Section with only 8 byte literals. */ + BFD_MACH_O_S_8BYTE_LITERALS = 0x4, + + /* Section with only pointers to literals. */ + BFD_MACH_O_S_LITERAL_POINTERS = 0x5, + + /* For the two types of symbol pointers sections and the symbol stubs + section they have indirect symbol table entries. For each of the + entries in the section the indirect symbol table entries, in + corresponding order in the indirect symbol table, start at the index + stored in the reserved1 field of the section structure. Since the + indirect symbol table entries correspond to the entries in the + section the number of indirect symbol table entries is inferred from + the size of the section divided by the size of the entries in the + section. For symbol pointers sections the size of the entries in + the section is 4 bytes and for symbol stubs sections the byte size + of the stubs is stored in the reserved2 field of the section + structure. */ + + /* Section with only non-lazy symbol pointers. */ + BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS = 0x6, + + /* Section with only lazy symbol pointers. */ + BFD_MACH_O_S_LAZY_SYMBOL_POINTERS = 0x7, + + /* Section with only symbol stubs, byte size of stub in the reserved2 field. */ + BFD_MACH_O_S_SYMBOL_STUBS = 0x8, + + /* Section with only function pointers for initialization. */ + BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS = 0x9 + } +bfd_mach_o_section_type; + +typedef unsigned long bfd_mach_o_cpu_subtype; + +typedef struct bfd_mach_o_header +{ + unsigned long magic; + unsigned long cputype; + unsigned long cpusubtype; + unsigned long filetype; + unsigned long ncmds; + unsigned long sizeofcmds; + unsigned long flags; + enum bfd_endian byteorder; +} +bfd_mach_o_header; + +typedef struct bfd_mach_o_section +{ + asection *bfdsection; + char sectname[16 + 1]; + char segname[16 + 1]; + bfd_vma addr; + bfd_vma size; + bfd_vma offset; + unsigned long align; + bfd_vma reloff; + unsigned long nreloc; + unsigned long flags; + unsigned long reserved1; + unsigned long reserved2; +} +bfd_mach_o_section; + +typedef struct bfd_mach_o_segment_command +{ + char segname[16]; + bfd_vma vmaddr; + bfd_vma vmsize; + bfd_vma fileoff; + unsigned long filesize; + unsigned long nsects; + unsigned long flags; + bfd_mach_o_section *sections; + asection *segment; +} +bfd_mach_o_segment_command; + +typedef struct bfd_mach_o_symtab_command +{ + unsigned long symoff; + unsigned long nsyms; + unsigned long stroff; + unsigned long strsize; + asymbol *symbols; + char *strtab; + asection *stabs_segment; + asection *stabstr_segment; +} +bfd_mach_o_symtab_command; + +/* This is the second set of the symbolic information which is used to support + the data structures for the dynamicly link editor. + + The original set of symbolic information in the symtab_command which contains + the symbol and string tables must also be present when this load command is + present. When this load command is present the symbol table is organized + into three groups of symbols: + local symbols (static and debugging symbols) - grouped by module + defined external symbols - grouped by module (sorted by name if not lib) + undefined external symbols (sorted by name) + In this load command there are offsets and counts to each of the three groups + of symbols. + + This load command contains a the offsets and sizes of the following new + symbolic information tables: + table of contents + module table + reference symbol table + indirect symbol table + The first three tables above (the table of contents, module table and + reference symbol table) are only present if the file is a dynamicly linked + shared library. For executable and object modules, which are files + containing only one module, the information that would be in these three + tables is determined as follows: + table of contents - the defined external symbols are sorted by name + module table - the file contains only one module so everything in the + file is part of the module. + reference symbol table - is the defined and undefined external symbols + + For dynamicly linked shared library files this load command also contains + offsets and sizes to the pool of relocation entries for all sections + separated into two groups: + external relocation entries + local relocation entries + For executable and object modules the relocation entries continue to hang + off the section structures. */ + +typedef struct bfd_mach_o_dysymtab_command +{ + /* The symbols indicated by symoff and nsyms of the LC_SYMTAB load command + are grouped into the following three groups: + local symbols (further grouped by the module they are from) + defined external symbols (further grouped by the module they are from) + undefined symbols + + The local symbols are used only for debugging. The dynamic binding + process may have to use them to indicate to the debugger the local + symbols for a module that is being bound. + + The last two groups are used by the dynamic binding process to do the + binding (indirectly through the module table and the reference symbol + table when this is a dynamicly linked shared library file). */ + + unsigned long ilocalsym; /* Index to local symbols. */ + unsigned long nlocalsym; /* Number of local symbols. */ + unsigned long iextdefsym; /* Index to externally defined symbols. */ + unsigned long nextdefsym; /* Number of externally defined symbols. */ + unsigned long iundefsym; /* Index to undefined symbols. */ + unsigned long nundefsym; /* Number of undefined symbols. */ + + /* For the for the dynamic binding process to find which module a symbol + is defined in the table of contents is used (analogous to the ranlib + structure in an archive) which maps defined external symbols to modules + they are defined in. This exists only in a dynamicly linked shared + library file. For executable and object modules the defined external + symbols are sorted by name and is use as the table of contents. */ + + unsigned long tocoff; /* File offset to table of contents. */ + unsigned long ntoc; /* Number of entries in table of contents. */ + + /* To support dynamic binding of "modules" (whole object files) the symbol + table must reflect the modules that the file was created from. This is + done by having a module table that has indexes and counts into the merged + tables for each module. The module structure that these two entries + refer to is described below. This exists only in a dynamicly linked + shared library file. For executable and object modules the file only + contains one module so everything in the file belongs to the module. */ + + unsigned long modtaboff; /* File offset to module table. */ + unsigned long nmodtab; /* Number of module table entries. */ + + /* To support dynamic module binding the module structure for each module + indicates the external references (defined and undefined) each module + makes. For each module there is an offset and a count into the + reference symbol table for the symbols that the module references. + This exists only in a dynamicly linked shared library file. For + executable and object modules the defined external symbols and the + undefined external symbols indicates the external references. */ + + unsigned long extrefsymoff; /* Offset to referenced symbol table. */ + unsigned long nextrefsyms; /* Number of referenced symbol table entries. */ + + /* The sections that contain "symbol pointers" and "routine stubs" have + indexes and (implied counts based on the size of the section and fixed + size of the entry) into the "indirect symbol" table for each pointer + and stub. For every section of these two types the index into the + indirect symbol table is stored in the section header in the field + reserved1. An indirect symbol table entry is simply a 32bit index into + the symbol table to the symbol that the pointer or stub is referring to. + The indirect symbol table is ordered to match the entries in the section. */ + + unsigned long indirectsymoff; /* File offset to the indirect symbol table. */ + unsigned long nindirectsyms; /* Number of indirect symbol table entries. */ + + /* To support relocating an individual module in a library file quickly the + external relocation entries for each module in the library need to be + accessed efficiently. Since the relocation entries can't be accessed + through the section headers for a library file they are separated into + groups of local and external entries further grouped by module. In this + case the presents of this load command who's extreloff, nextrel, + locreloff and nlocrel fields are non-zero indicates that the relocation + entries of non-merged sections are not referenced through the section + structures (and the reloff and nreloc fields in the section headers are + set to zero). + + Since the relocation entries are not accessed through the section headers + this requires the r_address field to be something other than a section + offset to identify the item to be relocated. In this case r_address is + set to the offset from the vmaddr of the first LC_SEGMENT command. + + The relocation entries are grouped by module and the module table + entries have indexes and counts into them for the group of external + relocation entries for that the module. + + For sections that are merged across modules there must not be any + remaining external relocation entries for them (for merged sections + remaining relocation entries must be local). */ + + unsigned long extreloff; /* Offset to external relocation entries. */ + unsigned long nextrel; /* Number of external relocation entries. */ + + /* All the local relocation entries are grouped together (they are not + grouped by their module since they are only used if the object is moved + from it staticly link edited address). */ + + unsigned long locreloff; /* Offset to local relocation entries. */ + unsigned long nlocrel; /* Number of local relocation entries. */ +} +bfd_mach_o_dysymtab_command; + +/* An indirect symbol table entry is simply a 32bit index into the symbol table + to the symbol that the pointer or stub is refering to. Unless it is for a + non-lazy symbol pointer section for a defined symbol which strip(1) as + removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the + symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that. */ + +#define INDIRECT_SYMBOL_LOCAL 0x80000000 +#define INDIRECT_SYMBOL_ABS 0x40000000 + +typedef struct bfd_mach_o_thread_flavour +{ + unsigned long flavour; + bfd_vma offset; + unsigned long size; +} +bfd_mach_o_thread_flavour; + +typedef struct bfd_mach_o_thread_command +{ + unsigned long nflavours; + bfd_mach_o_thread_flavour *flavours; + asection *section; +} +bfd_mach_o_thread_command; + +typedef struct bfd_mach_o_dylinker_command +{ + unsigned long cmd; /* LC_ID_DYLIB or LC_LOAD_DYLIB. */ + unsigned long cmdsize; /* Includes pathname string. */ + unsigned long name_offset; /* Offset to library's path name. */ + unsigned long name_len; /* Offset to library's path name. */ + asection *section; +} +bfd_mach_o_dylinker_command; + +typedef struct bfd_mach_o_dylib_command +{ + unsigned long cmd; /* LC_ID_DYLIB or LC_LOAD_DYLIB. */ + unsigned long cmdsize; /* Includes pathname string. */ + unsigned long name_offset; /* Offset to library's path name. */ + unsigned long name_len; /* Offset to library's path name. */ + unsigned long timestamp; /* Library's build time stamp. */ + unsigned long current_version; /* Library's current version number. */ + unsigned long compatibility_version; /* Library's compatibility vers number. */ + asection *section; +} +bfd_mach_o_dylib_command; + +typedef struct bfd_mach_o_prebound_dylib_command +{ + unsigned long cmd; /* LC_PREBOUND_DYLIB. */ + unsigned long cmdsize; /* Includes strings. */ + unsigned long name; /* Library's path name. */ + unsigned long nmodules; /* Number of modules in library. */ + unsigned long linked_modules; /* Bit vector of linked modules. */ + asection *section; +} +bfd_mach_o_prebound_dylib_command; + +typedef struct bfd_mach_o_load_command +{ + bfd_mach_o_load_command_type type; + unsigned int type_required; + bfd_vma offset; + bfd_vma len; + union + { + bfd_mach_o_segment_command segment; + bfd_mach_o_symtab_command symtab; + bfd_mach_o_dysymtab_command dysymtab; + bfd_mach_o_thread_command thread; + bfd_mach_o_dylib_command dylib; + bfd_mach_o_dylinker_command dylinker; + bfd_mach_o_prebound_dylib_command prebound_dylib; + } + command; +} +bfd_mach_o_load_command; + +typedef struct mach_o_data_struct +{ + bfd_mach_o_header header; + bfd_mach_o_load_command *commands; + unsigned long nsymbols; + asymbol *symbols; + unsigned long nsects; + bfd_mach_o_section **sections; + bfd *ibfd; +} +mach_o_data_struct; + +typedef struct mach_o_data_struct bfd_mach_o_data_struct; + +boolean bfd_mach_o_valid PARAMS ((bfd *)); +int bfd_mach_o_scan_read_symtab_symbol PARAMS ((bfd *, bfd_mach_o_symtab_command *, asymbol *, unsigned long)); +int bfd_mach_o_scan_read_symtab_strtab PARAMS ((bfd *, bfd_mach_o_symtab_command *)); +int bfd_mach_o_scan_read_symtab_symbols PARAMS ((bfd *, bfd_mach_o_symtab_command *)); +int bfd_mach_o_scan_read_dysymtab_symbol PARAMS ((bfd *, bfd_mach_o_dysymtab_command *, bfd_mach_o_symtab_command *, asymbol *, unsigned long)); +int bfd_mach_o_scan_start_address PARAMS ((bfd *)); +int bfd_mach_o_scan PARAMS ((bfd *, bfd_mach_o_header *)); +boolean bfd_mach_o_mkobject PARAMS ((bfd *)); +const bfd_target * bfd_mach_o_object_p PARAMS ((bfd *)); +const bfd_target * bfd_mach_o_core_p PARAMS ((bfd *)); +const bfd_target * bfd_mach_o_archive_p PARAMS ((bfd *)); +bfd * bfd_mach_o_openr_next_archived_file PARAMS ((bfd *, bfd *)); +int bfd_mach_o_lookup_section PARAMS ((bfd *, asection *, bfd_mach_o_load_command **, bfd_mach_o_section **)); +int bfd_mach_o_lookup_command PARAMS ((bfd *, bfd_mach_o_load_command_type, bfd_mach_o_load_command **)); +unsigned long bfd_mach_o_stack_addr PARAMS ((enum bfd_mach_o_cpu_type)); +int bfd_mach_o_core_fetch_environment PARAMS ((bfd *, unsigned char **, unsigned int *)); +char * bfd_mach_o_core_file_failing_command PARAMS ((bfd *)); +int bfd_mach_o_core_file_failing_signal PARAMS ((bfd *)); +boolean bfd_mach_o_core_file_matches_executable_p PARAMS ((bfd *, bfd *)); + +extern const bfd_target mach_o_be_vec; +extern const bfd_target mach_o_le_vec; +extern const bfd_target mach_o_fat_vec; + +#endif /* _BFD_MACH_O_H_ */ diff --git a/bfd/pef-traceback.h b/bfd/pef-traceback.h new file mode 100644 index 0000000..15f43b6 --- /dev/null +++ b/bfd/pef-traceback.h @@ -0,0 +1,215 @@ +/* PowerPC traceback table support for BFD. + Copyright 1993, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Originally written by Ira Ruben, 06/28/93 */ + +/* This is a compiler independent representation of the AIX Version 3 traceback table (in + sys/debug.h), which occurs, usually, one per procedure (routine). The table is marked by + a multiple of 4 32-bit word of zeroes in the instruction space. The traceback table is + also referred to as "procedure-end table". + + The AIX traceback table representation on which this header is based is defined as a + series of bit field struct specifications. Bit fields are compiler dependent! Thus, + the definitions presented here follow the original header and the existing documentation + (such as it is), but define the fields as BIT MASKS and other macros. The mask names, + however, where chosen as the original field names to give some compatibility with the + original header and to agree with the documentation. */ + +#ifndef __TRACEBACK__ +#define __TRACEBACK__ + +#define TB_C 0U /* C */ +#define TB_FORTRAN 1U /* FORTRAN */ +#define TB_PASCAL 2U /* Pascal */ +#define TB_ADA 3U /* ADA */ +#define TB_PL1 4U /* PL1 */ +#define TB_BASIC 5U /* Basic */ +#define TB_LISP 6U /* Lisp */ +#define TB_COBOL 7U /* eCobol */ +#define TB_MODULA2 8U /* Modula2 */ +#define TB_CPLUSPLUS 9U /* C++ */ +#define TB_RPG 10U /* RPG */ +#define TB_PL8 11U /* PL8 */ +#define TB_ASM 12U /* Asm */ + +/* flags 1 */ + +#define TB_GLOBALLINK 0x80U /* Routine is Global Linkage. */ +#define TB_is_eprol 0x40U /* Out-of-line prolog or epilog routine. */ +#define TB_HAS_TBOFF 0x20U /* tb_offset set (extension field). */ +#define TB_INT_PROC 0x10U /* Internal leaf routine. */ +#define TB_HAS_CTL 0x08U /* Has controlled automatic storage. */ +#define TB_TOCLESS 0X04U /* Routine has no TOC. */ +#define TB_FP_PRESENT 0x02U /* Routine has floating point ops. */ +#define TB_LOG_ABORT 0x01U /* fp_present && log/abort compiler opt. */ + +/* flags 2 */ + +#define TB_INT_HNDL 0x80U /* Routine is an interrupt handler. */ +#define TB_NAME_PRESENT 0x40U /* Name_len/name set (extension field). */ +#define TB_USES_ALLOCA 0x20U /* Uses alloca() to allocate storage. */ +#define TB_CL_DIS_inv 0x1CU /* On-condition directives (see below). */ +#define TB_SAVES_CR 0x02U /* Routine saves the CR. */ +#define TB_SAVES_LR 0x01U /* Routine saves the LR. */ + +/* cl_dis_inv "on condition" settings: */ + +#define TB_CL_DIS_INV(x) (((x) & cl_dis_inv) >> 2U) + +#define TB_WALK_ONCOND 0U /* Walk stack without restoring state. */ +#define TB_DISCARD_ONCOND 1U /* Walk stack and discard. */ +#define TB_INVOKE_ONCOND 2U /* Invoke a specific system routine. */ + +/* flags 3 */ + +#define TB_STORES_BC 0x80U /* Routine saves frame ptr of caller. */ +#define TB_SPARE2 0X40U /* Spare bit. */ +#define TB_FPR_SAVED 0x3fU /* Number of FPRs saved (max of 32). */ + /* (Last reg saved is ALWAYS fpr31). */ + +#define TB_NUM_FPR_SAVED(x) ((x) & fpr_saved) + +/* flags 4 */ + +#define TB_HAS_VEC_INFO 0x80U /* Routine uses vectors. */ +#define TB_SPARE3 0X40U /* Spare bit. */ +#define TB_GPR_SAVED 0x3fU /* Number of GPRs saved (max of 32). */ + /* (Last reg saved is ALWAYS gpr31). */ + +#define TB_NUM_GPR_SAVED(x) ((x) & gpr_saved) + +/* flags 5 */ + +#define TB_FLOATPARAMS 0xfeU /* Number of floating point parameters. */ +#define TB_PARAMSONSTK 0X01U /* All parameters are on the stack. */ + +#define TB_NUM_FLOATPARAMS(X) (((x) & floatparams) >> 1U) + +/* traceback_table (fixed portion). */ + +struct traceback_table +{ + /* Traceback table layout (fixed portion): */ + + unsigned char version; /* Traceback format version. */ + unsigned char lang; /* Language indicators: */ + unsigned char flags1; /* Flag bits #1: */ + unsigned char flags2; /* Flag bits #2: */ + unsigned char flags3; /* Flag bits #3: */ + unsigned char flags4; /* Flag bits #4: */ + unsigned char fixedparams; /* Number of fixed point parameters. */ + unsigned char flags5; /* Flag bits #5: */ +}; + +/* traceback_table (optional) extensions. */ + +/* Optional portions exist independently in the order presented below, + not as a structure or a union. Whether or not portions exist is + determinable from bit-fields within the fixed portion above. */ + +/* The following is present only if fixedparams or floatparams are non + zero and it immediately follows the fixed portion of the traceback + table... */ + +/* Order and type encoding of parameters: */ +struct traceback_table_fixedparams +{ + unsigned long paraminfo; +}; + +/* Left-justified bit-encoding as follows: */ +#define FIXED_PARAM 0 /* '0' ==> fixed param (1 gpr or word). */ +#define SPFP_PARAM 2 /* '10' ==> single-precision float param. */ +#define DPFP_PARAM 3 /* '11' ==> double-precision float param. */ + +#define PARAM_ENCODING(x, bit) /* Yields xxx_PARAM as a function of "bit". */ \ + ((((x)&(1UL<<(31UL-(bit++))))==0UL) /* Values 0:31 (left-to-right). "bit" is */ \ + ? FIXED_PARAM /* an L-value that's left incremented to */ \ + : ((((x)&(1UL<<(31UL-(bit++))))==0)/* the next bit position for the next */ \ + ? SPFP_PARAM /* parameter. This will be 1 or 2 bit */ \ + : DPFP_PARAM)) /* positions later. */ + +/* The following is present only if has_tboff (in flags1) in fixed part is present... */ + +/* Offset from start of code to TracebackTbl. */ +struct traceback_table_tboff +{ + unsigned long tb_offset; +}; + +/* The following is present only if int_hndl (in flags2) in fixed part is present ... */ + +/* What interrupts are handled by the routine. */ +struct traceback_table_interrupts +{ + long hand_mask; +}; + +/* The following are present only if has_ctl (in flags1) in fixed part is present... */ + +/* Controlled automatic storage info: */ +struct traceback_table_anchors +{ + unsigned long ctl_info; /* Number of controlled automatic anchors. */ + long ctl_info_disp[1]; /* Array of stack displacements where each. */ +}; /* Anchor is located (array STARTS here). */ + +/* The following are present only if name_present (in flags2) in fixed + part is present... */ + +/* Routine name: */ +struct traceback_table_routine +{ + unsigned short name_len; /* Length of name that follows. */ + char name[1]; /* Name starts here (NOT null terminated). */ +}; + +/* The following are present only if uses_alloca (in flags2) in fixed + part is present... */ + +/* Register auto storage when alloca() is used. */ +struct traceback_table_alloca +{ + char alloca_reg; +}; + +/* The following are present only if has_vec_info (in flags4) in fixed + part is present... */ + +/* Vector info: */ +struct traceback_table_vector +{ + unsigned char vec_flags1; /* Vec info bits #1: */ + +#define TB_VR_SAVED 0xFCU /* Number of saved vector registers. */ +#define TB_SAVES_VRSAVE 0x02U /* Saves VRsave. */ +#define TB_HAS_VARARGS 0x01U /* Routine has a variable argument list. */ + +#define TB_NUM_VR_SAVED(x) (((x) & TB_VR_SAVED) >> 2U) + + unsigned char vec_flags2; /* Vec info bits #2: */ + +#define TB_VECTORPARAMS 0xfeU /* Number of vector parameters. */ +#define TB_VEC_PRESENT 0x01U /* Routine uses at least one vec instr. */ + +#define VECPARAMS(x) (((x) & TB_VECTORPARAMS) >> 1U) +}; + +#endif diff --git a/bfd/pef.c b/bfd/pef.c new file mode 100644 index 0000000..bb0d6c5 --- /dev/null +++ b/bfd/pef.c @@ -0,0 +1,1207 @@ +/* PEF support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include <ctype.h> + +#include "pef.h" +#include "pef-traceback.h" + +#include "bfd.h" +#include "sysdep.h" +#include "libbfd.h" + +#include "libiberty.h" + +#ifndef BFD_IO_FUNCS +#define BFD_IO_FUNCS 0 +#endif + +#define bfd_pef_close_and_cleanup _bfd_generic_close_and_cleanup +#define bfd_pef_bfd_free_cached_info _bfd_generic_bfd_free_cached_info +#define bfd_pef_new_section_hook _bfd_generic_new_section_hook +#define bfd_pef_bfd_is_local_label_name bfd_generic_is_local_label_name +#define bfd_pef_get_lineno _bfd_nosymbols_get_lineno +#define bfd_pef_find_nearest_line _bfd_nosymbols_find_nearest_line +#define bfd_pef_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol +#define bfd_pef_read_minisymbols _bfd_generic_read_minisymbols +#define bfd_pef_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol + +#define bfd_pef_get_reloc_upper_bound _bfd_norelocs_get_reloc_upper_bound +#define bfd_pef_canonicalize_reloc _bfd_norelocs_canonicalize_reloc +#define bfd_pef_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup + +#define bfd_pef_set_arch_mach _bfd_generic_set_arch_mach + +#define bfd_pef_get_section_contents _bfd_generic_get_section_contents +#define bfd_pef_set_section_contents _bfd_generic_set_section_contents + +#define bfd_pef_bfd_get_relocated_section_contents \ + bfd_generic_get_relocated_section_contents +#define bfd_pef_bfd_relax_section bfd_generic_relax_section +#define bfd_pef_bfd_gc_sections bfd_generic_gc_sections +#define bfd_pef_bfd_merge_sections bfd_generic_merge_sections +#define bfd_pef_bfd_discard_group bfd_generic_discard_group +#define bfd_pef_bfd_link_hash_table_create _bfd_generic_link_hash_table_create +#define bfd_pef_bfd_link_hash_table_free _bfd_generic_link_hash_table_free +#define bfd_pef_bfd_link_add_symbols _bfd_generic_link_add_symbols +#define bfd_pef_bfd_link_just_syms _bfd_generic_link_just_syms +#define bfd_pef_bfd_final_link _bfd_generic_final_link +#define bfd_pef_bfd_link_split_section _bfd_generic_link_split_section +#define bfd_pef_get_section_contents_in_window \ + _bfd_generic_get_section_contents_in_window + +static void bfd_pef_print_symbol +PARAMS ((bfd *abfd, PTR afile, asymbol *symbol, bfd_print_symbol_type how)); +static void bfd_pef_convert_architecture +PARAMS ((unsigned long architecture, + enum bfd_architecture *type, unsigned long *subtype)); +static boolean bfd_pef_mkobject PARAMS ((bfd *abfd)); +static int bfd_pef_parse_traceback_table +PARAMS ((bfd *abfd, asection *section, unsigned char *buf, + size_t len, size_t pos, asymbol *sym, FILE *file)); +static const char *bfd_pef_section_name PARAMS ((bfd_pef_section *section)); +static unsigned long bfd_pef_section_flags PARAMS ((bfd_pef_section *section)); +static asection *bfd_pef_make_bfd_section PARAMS ((bfd *abfd, bfd_pef_section *section)); +static int bfd_pef_read_header PARAMS ((bfd *abfd, bfd_pef_header *header)); +static const bfd_target *bfd_pef_object_p PARAMS ((bfd *)); +static int bfd_pef_parse_traceback_tables +PARAMS ((bfd *abfd, asection *sec, unsigned char *buf, + size_t len, long *nsym, asymbol **csym)); +static int bfd_pef_parse_function_stub +PARAMS ((bfd *abfd, unsigned char *buf, size_t len, unsigned long *offset)); +static int bfd_pef_parse_function_stubs +PARAMS ((bfd *abfd, asection *codesec, unsigned char *codebuf, size_t codelen, + unsigned char *loaderbuf, size_t loaderlen, unsigned long *nsym, asymbol **csym)); +static long bfd_pef_parse_symbols PARAMS ((bfd *abfd, asymbol **csym)); +static long bfd_pef_count_symbols PARAMS ((bfd *abfd)); +static long bfd_pef_get_symtab_upper_bound PARAMS ((bfd *)); +static long bfd_pef_get_symtab PARAMS ((bfd *, asymbol **)); +static asymbol *bfd_pef_make_empty_symbol PARAMS ((bfd *)); +static void bfd_pef_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *)); +static int bfd_pef_sizeof_headers PARAMS ((bfd *, boolean)); + +static int bfd_pef_xlib_read_header PARAMS ((bfd *abfd, bfd_pef_xlib_header *header)); +static int bfd_pef_xlib_scan PARAMS ((bfd *abfd, bfd_pef_xlib_header *header)); +static const bfd_target *bfd_pef_xlib_object_p PARAMS ((bfd *abfd)); + +static void +bfd_pef_print_symbol (abfd, afile, symbol, how) + bfd *abfd; + PTR afile; + asymbol *symbol; + bfd_print_symbol_type how; +{ + FILE *file = (FILE *) afile; + switch (how) { + case bfd_print_symbol_name: + fprintf (file, "%s", symbol->name); + break; + default: + bfd_print_symbol_vandf (abfd, (PTR) file, symbol); + fprintf (file, " %-5s %s", symbol->section->name, symbol->name); + if (strncmp (symbol->name, "__traceback_", strlen ("__traceback_")) == 0) { + char *buf = alloca (symbol->udata.i); + size_t offset = symbol->value + 4; + size_t len = symbol->udata.i; + int ret; + + bfd_get_section_contents (abfd, symbol->section, buf, offset, len); + ret = bfd_pef_parse_traceback_table (abfd, symbol->section, buf, len, 0, NULL, file); + if (ret < 0) { + fprintf (file, " [ERROR]"); + } + } + } +} + +static void bfd_pef_convert_architecture (architecture, type, subtype) + unsigned long architecture; + enum bfd_architecture *type; + unsigned long *subtype; +{ + *subtype = bfd_arch_unknown; + *type = bfd_arch_unknown; + + const unsigned long ARCH_POWERPC = 0x70777063; /* 'pwpc' */ + const unsigned long ARCH_M68K = 0x6d36386b; /* 'm68k' */ + + if (architecture == ARCH_POWERPC) + *type = bfd_arch_powerpc; + else if (architecture == ARCH_M68K) + *type = bfd_arch_m68k; +} + +static boolean +bfd_pef_mkobject (abfd) + bfd *abfd ATTRIBUTE_UNUSED; +{ + return true; +} + +static int +bfd_pef_parse_traceback_table (abfd, section, buf, len, pos, sym, file) + bfd *abfd; + asection *section; + unsigned char *buf; + size_t len; + size_t pos; + asymbol *sym; + FILE *file; +{ + struct traceback_table table; + size_t offset; + const char *s; + asymbol tmpsymbol; + + if (sym == NULL) { sym = &tmpsymbol; } + + sym->name = NULL; + sym->value = 0; + sym->the_bfd = abfd; + sym->section = section; + sym->flags = 0; + sym->udata.i = 0; + + /* memcpy is fine since all fields are unsigned char */ + + if ((pos + 8) > len) { return -1; } + memcpy (&table, buf + pos, 8); + + /* calling code relies on returned symbols having a name and correct offset */ + + if ((table.lang != TB_C) && (table.lang != TB_CPLUSPLUS)) { + return -1; + } + if (! (table.flags2 & TB_NAME_PRESENT)) { + return -1; + } + if (! table.flags1 & TB_HAS_TBOFF) { + return -1; + } + + offset = 8; + + if ((table.flags5 & TB_FLOATPARAMS) || (table.fixedparams)) { + offset += 4; + } + + if (table.flags1 & TB_HAS_TBOFF) { + + struct traceback_table_tboff off; + + if ((pos + offset + 4) > len) { return -1; } + off.tb_offset = bfd_getb32 (buf + pos + offset); + offset += 4; + + /* need to subtract 4 because the offset includes the 0x0L + preceding the table */ + + if (file != NULL) { + fprintf (file, " [offset = 0x%lx]", off.tb_offset); + } + + if ((file == NULL) && ((off.tb_offset + 4) > (pos + offset))) { + return -1; + } + sym->value = pos - off.tb_offset - 4; + } + + if (table.flags2 & TB_INT_HNDL) { + offset += 4; + } + + if (table.flags1 & TB_HAS_CTL) { + + struct traceback_table_anchors anchors; + + if ((pos + offset + 4) > len) { return -1; } + anchors.ctl_info = bfd_getb32 (buf + pos + offset); + offset += 4; + + if (anchors.ctl_info > 1024) { + return -1; + } + + offset += anchors.ctl_info * 4; + } + + if (table.flags2 & TB_NAME_PRESENT) { + + struct traceback_table_routine name; + char *namebuf; + + if ((pos + offset + 2) > len) { return -1; } + name.name_len = bfd_getb16 (buf + pos + offset); + offset += 2; + + if (name.name_len > 4096) { return -1; } + + if ((pos + offset + name.name_len) > len) { return -1; } + + namebuf = (char *) bfd_alloc (abfd, name.name_len + 1); + if (namebuf == NULL) { return -1; } + + memcpy (namebuf, buf + pos + offset, name.name_len); + namebuf[name.name_len] = '\0'; + + /* strip leading period inserted by compiler */ + if (namebuf[0] == '.') { + memmove (namebuf, namebuf + 1, name.name_len + 1); + } + + sym->name = namebuf; + + for (s = sym->name; (*s != '\0'); s++) { + if (! isprint (*s)) { + return -1; + } + } + + offset += name.name_len; + } + + if (table.flags2 & TB_USES_ALLOCA) { + offset += 4; + } + + if (table.flags4 & TB_HAS_VEC_INFO) { + offset += 4; + } + + if (file != NULL) { + fprintf (file, " [length = 0x%lx]", (long) offset); + } + return offset; +} + +static const char *bfd_pef_section_name (section) + bfd_pef_section *section; +{ + switch (section->section_kind) { + case BFD_PEF_SECTION_CODE: return "code"; + case BFD_PEF_SECTION_UNPACKED_DATA: return "unpacked-data"; + case BFD_PEF_SECTION_PACKED_DATA: return "packed-data"; + case BFD_PEF_SECTION_CONSTANT: return "constant"; + case BFD_PEF_SECTION_LOADER: return "loader"; + case BFD_PEF_SECTION_DEBUG: return "debug"; + case BFD_PEF_SECTION_EXEC_DATA: return "exec-data"; + case BFD_PEF_SECTION_EXCEPTION: return "exception"; + case BFD_PEF_SECTION_TRACEBACK: return "traceback"; + default: return "unknown"; + } +} + +static unsigned long bfd_pef_section_flags (section) + bfd_pef_section *section; +{ + switch (section->section_kind) { + case BFD_PEF_SECTION_CODE: + return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE; + case BFD_PEF_SECTION_UNPACKED_DATA: + case BFD_PEF_SECTION_PACKED_DATA: + case BFD_PEF_SECTION_CONSTANT: + case BFD_PEF_SECTION_LOADER: + case BFD_PEF_SECTION_DEBUG: + case BFD_PEF_SECTION_EXEC_DATA: + case BFD_PEF_SECTION_EXCEPTION: + case BFD_PEF_SECTION_TRACEBACK: + default: + return SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC; + } +} + +static asection * +bfd_pef_make_bfd_section (abfd, section) + bfd *abfd; + bfd_pef_section *section; +{ + asection *bfdsec; + const char *name = bfd_pef_section_name (section); + + bfdsec = bfd_make_section_anyway (abfd, name); + if (bfdsec == NULL) { return NULL; } + + bfdsec->vma = section->default_address + section->container_offset; + bfdsec->lma = section->default_address + section->container_offset; + bfdsec->_raw_size = section->container_length; + bfdsec->filepos = section->container_offset; + bfdsec->alignment_power = section->alignment; + + bfdsec->flags = bfd_pef_section_flags (section); + + return bfdsec; +} + +int bfd_pef_parse_loader_header (abfd, buf, len, header) + bfd *abfd ATTRIBUTE_UNUSED; + unsigned char *buf; + size_t len; + bfd_pef_loader_header *header; +{ + BFD_ASSERT (len == 56); + + header->main_section = bfd_getb32 (buf); + header->main_offset = bfd_getb32 (buf + 4); + header->init_section = bfd_getb32 (buf + 8); + header->init_offset = bfd_getb32 (buf + 12); + header->term_section = bfd_getb32 (buf + 16); + header->term_offset = bfd_getb32 (buf + 20); + header->imported_library_count = bfd_getb32 (buf + 24); + header->total_imported_symbol_count = bfd_getb32 (buf + 28); + header->reloc_section_count = bfd_getb32 (buf + 32); + header->reloc_instr_offset = bfd_getb32 (buf + 36); + header->loader_strings_offset = bfd_getb32 (buf + 40); + header->export_hash_offset = bfd_getb32 (buf + 44); + header->export_hash_table_power = bfd_getb32 (buf + 48); + header->exported_symbol_count = bfd_getb32 (buf + 52); + + return 0; +} + +int bfd_pef_parse_imported_library (abfd, buf, len, header) + bfd *abfd ATTRIBUTE_UNUSED; + unsigned char *buf; + size_t len; + bfd_pef_imported_library *header; +{ + BFD_ASSERT (len == 24); + + header->name_offset = bfd_getb32 (buf); + header->old_implementation_version = bfd_getb32 (buf + 4); + header->current_version = bfd_getb32 (buf + 8); + header->imported_symbol_count = bfd_getb32 (buf + 12); + header->first_imported_symbol = bfd_getb32 (buf + 16); + header->options = buf[20]; + header->reserved_a = buf[21]; + header->reserved_b = bfd_getb16 (buf + 22); + + return 0; +} + +int bfd_pef_parse_imported_symbol (abfd, buf, len, symbol) + bfd *abfd ATTRIBUTE_UNUSED; + unsigned char *buf; + size_t len; + bfd_pef_imported_symbol *symbol; +{ + unsigned long value; + + BFD_ASSERT (len == 4); + + value = bfd_getb32 (buf); + symbol->class = value >> 24; + symbol->name = value & 0x00ffffff; + + return 0; +} + +int bfd_pef_scan_section (abfd, section) + bfd *abfd; + bfd_pef_section *section; +{ + unsigned char buf[28]; + + bfd_seek (abfd, section->header_offset, SEEK_SET); + if (bfd_bread ((PTR) buf, 28, abfd) != 28) { return -1; } + + section->name_offset = bfd_h_get_32 (abfd, buf); + section->default_address = bfd_h_get_32 (abfd, buf + 4); + section->total_length = bfd_h_get_32 (abfd, buf + 8); + section->unpacked_length = bfd_h_get_32 (abfd, buf + 12); + section->container_length = bfd_h_get_32 (abfd, buf + 16); + section->container_offset = bfd_h_get_32 (abfd, buf + 20); + section->section_kind = buf[24]; + section->share_kind = buf[25]; + section->alignment = buf[26]; + section->reserved = buf[27]; + + section->bfd_section = bfd_pef_make_bfd_section (abfd, section); + if (section->bfd_section == NULL) { return -1; } + + return 0; +} + +void +bfd_pef_print_loader_header (abfd, header, file) + bfd *abfd ATTRIBUTE_UNUSED; + bfd_pef_loader_header *header; + FILE *file; +{ + fprintf (file, "main_section: %ld\n", header->main_section); + fprintf (file, "main_offset: %lu\n", header->main_offset); + fprintf (file, "init_section: %ld\n", header->init_section); + fprintf (file, "init_offset: %lu\n", header->init_offset); + fprintf (file, "term_section: %ld\n", header->term_section); + fprintf (file, "term_offset: %lu\n", header->term_offset); + fprintf (file, "imported_library_count: %lu\n", header->imported_library_count); + fprintf (file, "total_imported_symbol_count: %lu\n", header->total_imported_symbol_count); + fprintf (file, "reloc_section_count: %lu\n", header->reloc_section_count); + fprintf (file, "reloc_instr_offset: %lu\n", header->reloc_instr_offset); + fprintf (file, "loader_strings_offset: %lu\n", header->loader_strings_offset); + fprintf (file, "export_hash_offset: %lu\n", header->export_hash_offset); + fprintf (file, "export_hash_table_power: %lu\n", header->export_hash_table_power); + fprintf (file, "exported_symbol_count: %lu\n", header->exported_symbol_count); +} + +int +bfd_pef_print_loader_section (abfd, file) + bfd *abfd; + FILE *file; +{ + bfd_pef_loader_header header; + asection *loadersec = NULL; + unsigned char *loaderbuf = NULL; + size_t loaderlen = 0; + int ret; + + loadersec = bfd_get_section_by_name (abfd, "loader"); + if (loadersec == NULL) { return -1; } + + loaderlen = bfd_section_size (abfd, loadersec); + loaderbuf = (unsigned char *) bfd_malloc (loaderlen); + if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0) + { free (loaderbuf); return -1; } + if (bfd_bread ((PTR) loaderbuf, loaderlen, abfd) != loaderlen) + { free (loaderbuf); return -1; } + + if (loaderlen < 56) { free (loaderbuf); return -1; } + ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header); + if (ret < 0) { free (loaderbuf); return -1; } + + bfd_pef_print_loader_header (abfd, &header, file); + return 0; +} + +int +bfd_pef_scan_start_address (abfd) + bfd *abfd; +{ + bfd_pef_loader_header header; + asection *section; + + asection *loadersec = NULL; + unsigned char *loaderbuf = NULL; + size_t loaderlen = 0; + int ret; + + loadersec = bfd_get_section_by_name (abfd, "loader"); + if (loadersec == NULL) { goto end; } + + loaderlen = bfd_section_size (abfd, loadersec); + loaderbuf = (unsigned char *) bfd_malloc (loaderlen); + if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0) { goto error; } + if (bfd_bread ((PTR) loaderbuf, loaderlen, abfd) != loaderlen) { goto error; } + + if (loaderlen < 56) { goto error; } + ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header); + if (ret < 0) { goto error; } + + if (header.main_section < 0) { goto end; } + + for (section = abfd->sections; section != NULL; section = section->next) { + if ((section->index + 1) == header.main_section) { break; } + } + + if (section == NULL) { goto error; } + + abfd->start_address = section->vma + header.main_offset; + + end: + if (loaderbuf != NULL) { free (loaderbuf); } + return 0; + + error: + if (loaderbuf != NULL) { free (loaderbuf); } + return -1; +} + +int +bfd_pef_scan (abfd, header) + bfd *abfd; + bfd_pef_header *header; +{ + unsigned int i; + bfd_pef_data_struct *mdata = NULL; + enum bfd_architecture cputype; + unsigned long cpusubtype; + + if ((header->tag1 != BFD_PEF_TAG1) || (header->tag2 != BFD_PEF_TAG2)) { + return -1; + } + + mdata = ((bfd_pef_data_struct *) + bfd_alloc (abfd, sizeof (bfd_pef_data_struct))); + if (mdata == NULL) { return -1; } + + bfd_pef_convert_architecture (header->architecture, &cputype, &cpusubtype); + if (cputype == bfd_arch_unknown) { + fprintf (stderr, "bfd_pef_scan: unknown architecture 0x%lx\n", header->architecture); + return -1; + } + bfd_set_arch_mach (abfd, cputype, cpusubtype); + + mdata->header = *header; + + abfd->flags = abfd->xvec->object_flags | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)); + + if (header->section_count != 0) { + + mdata->sections = + ((bfd_pef_section *) + bfd_alloc (abfd, header->section_count * sizeof (bfd_pef_section))); + if (mdata->sections == NULL) { return -1; } + + for (i = 0; i < header->section_count; i++) { + bfd_pef_section *cur = &mdata->sections[i]; + cur->header_offset = 40 + (i * 28); + if (bfd_pef_scan_section (abfd, cur) < 0) { + return -1; + } + } + } + + if (bfd_pef_scan_start_address (abfd) < 0) { +#if 0 + fprintf (stderr, "bfd_pef_scan: unable to scan start address: %s\n", + bfd_errmsg (bfd_get_error ())); + abfd->tdata.pef_data = NULL; + return -1; +#endif + } + + abfd->tdata.pef_data = mdata; + + return 0; +} + +static int +bfd_pef_read_header (abfd, header) + bfd *abfd; + bfd_pef_header *header; +{ + unsigned char buf[40]; + + bfd_seek (abfd, 0, SEEK_SET); + + if (bfd_bread ((PTR) buf, 40, abfd) != 40) { return -1; } + + header->tag1 = bfd_getb32 (buf); + header->tag2 = bfd_getb32 (buf + 4); + header->architecture = bfd_getb32 (buf + 8); + header->format_version = bfd_getb32 (buf + 12); + header->timestamp = bfd_getb32 (buf + 16); + header->old_definition_version = bfd_getb32 (buf + 20); + header->old_implementation_version = bfd_getb32 (buf + 24); + header->current_version = bfd_getb32 (buf + 28); + header->section_count = bfd_getb32 (buf + 32) + 1; + header->instantiated_section_count = bfd_getb32 (buf + 34); + header->reserved = bfd_getb32 (buf + 36); + + return 0; +} + +static const bfd_target * +bfd_pef_object_p (abfd) + bfd *abfd; +{ + bfd_pef_header header; + + abfd->tdata.pef_data = NULL; + + if (bfd_pef_read_header (abfd, &header) != 0) { + abfd->tdata.pef_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + if (bfd_pef_scan (abfd, &header) != 0) { + abfd->tdata.pef_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + return abfd->xvec; +} + +static int bfd_pef_parse_traceback_tables (abfd, sec, buf, len, nsym, csym) + bfd *abfd; + asection *sec; + unsigned char *buf; + size_t len; + long *nsym; + asymbol **csym; +{ + char *name; + + asymbol function; + asymbol traceback; + + const char *const tbprefix = "__traceback_"; + size_t tbnamelen; + + size_t pos = 0; + unsigned long count = 0; + int ret; + + for (;;) { + + /* we're reading symbols two at a time */ + + if (csym && ((csym[count] == NULL) || (csym[count + 1] == NULL))) { + break; + } + + pos += 3; + pos -= (pos % 4); + + while ((pos + 4) <= len) { + if (bfd_getb32 (buf + pos) == 0) { + break; + } + pos += 4; + } + + if ((pos + 4) > len) { + break; + } + + ret = bfd_pef_parse_traceback_table (abfd, sec, buf, len, pos + 4, &function, 0); + if (ret < 0) { + /* skip over 0x0L to advance to next possible traceback table */ + pos += 4; + continue; + } + + BFD_ASSERT (function.name != NULL); + + /* Don't bother to compute the name if we are just + counting symbols */ + + if (csym) + { + tbnamelen = strlen (tbprefix) + strlen (function.name); + name = bfd_alloc (abfd, tbnamelen + 1); + if (name == NULL) { + bfd_release (abfd, (PTR) function.name); + function.name = NULL; + break; + } + snprintf (name, tbnamelen + 1, "%s%s", tbprefix, function.name); + traceback.name = name; + traceback.value = pos; + traceback.the_bfd = abfd; + traceback.section = sec; + traceback.flags = 0; + traceback.udata.i = ret; + + *(csym[count]) = function; + *(csym[count + 1]) = traceback; + } + + pos += ret; + count += 2; + } + + *nsym = count; + return 0; +} + +static int bfd_pef_parse_function_stub (abfd, buf, len, offset) + bfd *abfd ATTRIBUTE_UNUSED; + unsigned char *buf; + size_t len; + unsigned long *offset; +{ + BFD_ASSERT (len == 24); + + if ((bfd_getb32 (buf) & 0xffff0000) != 0x81820000) { return -1; } + if (bfd_getb32 (buf + 4) != 0x90410014) { return -1; } + if (bfd_getb32 (buf + 8) != 0x800c0000) { return -1; } + if (bfd_getb32 (buf + 12) != 0x804c0004) { return -1; } + if (bfd_getb32 (buf + 16) != 0x7c0903a6) { return -1; } + if (bfd_getb32 (buf + 20) != 0x4e800420) { return -1; } + + if (offset != NULL) { + *offset = (bfd_getb32 (buf) & 0x0000ffff) / 4; + } + + return 0; +} + +static int bfd_pef_parse_function_stubs (abfd, codesec, codebuf, codelen, loaderbuf, loaderlen, nsym, csym) + bfd *abfd; + asection *codesec; + unsigned char *codebuf; + size_t codelen; + unsigned char *loaderbuf; + size_t loaderlen; + unsigned long *nsym; + asymbol **csym; +{ + const char *const sprefix = "__stub_"; + + size_t codepos = 0; + unsigned long count = 0; + + bfd_pef_loader_header header; + bfd_pef_imported_library *libraries = NULL; + bfd_pef_imported_symbol *imports = NULL; + + unsigned long i; + int ret; + + if (loaderlen < 56) { goto error; } + + ret = bfd_pef_parse_loader_header (abfd, loaderbuf, 56, &header); + if (ret < 0) { goto error; } + + libraries = (bfd_pef_imported_library *) bfd_malloc + (header.imported_library_count * sizeof (bfd_pef_imported_library)); + imports = (bfd_pef_imported_symbol *) bfd_malloc + (header.total_imported_symbol_count * sizeof (bfd_pef_imported_symbol)); + + if (loaderlen < (56 + (header.imported_library_count * 24))) { goto error; } + for (i = 0; i < header.imported_library_count; i++) { + ret = bfd_pef_parse_imported_library + (abfd, loaderbuf + 56 + (i * 24), 24, &libraries[i]); + if (ret < 0) { goto error; } + } + + if (loaderlen < (56 + (header.imported_library_count * 24) + (header.total_imported_symbol_count * 4))) + { goto error; } + for (i = 0; i < header.total_imported_symbol_count; i++) { + ret = bfd_pef_parse_imported_symbol + (abfd, loaderbuf + 56 + (header.imported_library_count * 24) + (i * 4), 4, &imports[i]); + if (ret < 0) { goto error; } + } + + codepos = 0; + + for (;;) { + + asymbol sym; + const char *symname; + char *name; + unsigned long index; + int ret; + + if (csym && (csym[count] == NULL)) { break; } + + codepos += 3; + codepos -= (codepos % 4); + + while ((codepos + 4) <= codelen) { + if ((bfd_getb32 (codebuf + codepos) & 0xffff0000) == 0x81820000) { + break; + } + codepos += 4; + } + + if ((codepos + 4) > codelen) { + break; + } + + ret = bfd_pef_parse_function_stub (abfd, codebuf + codepos, 24, &index); + if (ret < 0) { codepos += 24; continue; } + + if (index >= header.total_imported_symbol_count) { codepos += 24; continue; } + + { + size_t max, namelen; + const char *s; + + if (loaderlen < (header.loader_strings_offset + imports[index].name)) { goto error; } + + max = loaderlen - (header.loader_strings_offset + imports[index].name); + symname = loaderbuf + header.loader_strings_offset + imports[index].name; + namelen = 0; + for (s = symname; s < (symname + max); s++) { + if (*s == '\0') { break; } + if (! isprint (*s)) { goto error; } + namelen++; + } + if (*s != '\0') { goto error; } + + name = bfd_alloc (abfd, strlen (sprefix) + namelen + 1); + if (name == NULL) { break; } + + snprintf (name, strlen (sprefix) + namelen + 1, "%s%s", sprefix, symname); + sym.name = name; + } + + sym.value = codepos; + sym.the_bfd = abfd; + sym.section = codesec; + sym.flags = 0; + sym.udata.i = 0; + + codepos += 24; + + if (csym != NULL) { + *(csym[count]) = sym; + } + count++; + } + + goto end; + + end: + if (libraries != NULL) { free (libraries); } + if (imports != NULL) { free (imports); } + *nsym = count; + return 0; + + error: + if (libraries != NULL) { free (libraries); } + if (imports != NULL) { free (imports); } + *nsym = count; + return -1; +} + +static long bfd_pef_parse_symbols (abfd, csym) + bfd *abfd; + asymbol **csym; +{ + unsigned long count = 0; + + asection *codesec = NULL; + unsigned char *codebuf = NULL; + size_t codelen = 0; + + asection *loadersec = NULL; + unsigned char *loaderbuf = NULL; + size_t loaderlen = 0; + + codesec = bfd_get_section_by_name (abfd, "code"); + if (codesec != NULL) + { + codelen = bfd_section_size (abfd, codesec); + codebuf = (unsigned char *) bfd_malloc (codelen); + if (bfd_seek (abfd, codesec->filepos, SEEK_SET) < 0) { goto end; } + if (bfd_bread ((PTR) codebuf, codelen, abfd) != codelen) { goto end; } + } + + loadersec = bfd_get_section_by_name (abfd, "loader"); + if (loadersec != NULL) + { + loaderlen = bfd_section_size (abfd, loadersec); + loaderbuf = (unsigned char *) bfd_malloc (loaderlen); + if (bfd_seek (abfd, loadersec->filepos, SEEK_SET) < 0) { goto end; } + if (bfd_bread ((PTR) loaderbuf, loaderlen, abfd) != loaderlen) { goto end; } + } + + count = 0; + if (codesec != NULL) + { + unsigned long ncount = 0; + bfd_pef_parse_traceback_tables (abfd, codesec, codebuf, codelen, &ncount, csym); + count += ncount; + } + + if ((codesec != NULL) && (loadersec != NULL)) + { + unsigned long ncount = 0; + bfd_pef_parse_function_stubs + (abfd, codesec, codebuf, codelen, loaderbuf, loaderlen, &ncount, + (csym != NULL) ? (csym + count) : NULL); + count += ncount; + } + + if (csym != NULL) { + csym[count] = NULL; + } + + end: + if (codebuf != NULL) + free (codebuf); + + if (loaderbuf != NULL) + free (loaderbuf); + + return count; +} + +static long +bfd_pef_count_symbols (abfd) + bfd *abfd; +{ + return bfd_pef_parse_symbols (abfd, NULL); +} + +static long +bfd_pef_get_symtab_upper_bound (abfd) + bfd *abfd; +{ + long nsyms = bfd_pef_count_symbols (abfd); + if (nsyms < 0) { return nsyms; } + return ((nsyms + 1) * sizeof (asymbol *)); +} + +static long +bfd_pef_get_symtab (abfd, alocation) + bfd *abfd; + asymbol **alocation; +{ + long i; + asymbol *syms; + long ret; + + long nsyms = bfd_pef_count_symbols (abfd); + if (nsyms < 0) { return nsyms; } + + syms = bfd_alloc (abfd, nsyms * sizeof (asymbol)); + if (syms == NULL) { return -1; } + + for (i = 0; i < nsyms; i++) { + alocation[i] = &syms[i]; + } + alocation[nsyms] = NULL; + + ret = bfd_pef_parse_symbols (abfd, alocation); + if (ret != nsyms) { + return 0; + } + + return ret; +} + +static asymbol * +bfd_pef_make_empty_symbol (abfd) + bfd *abfd; +{ + return (asymbol *) bfd_alloc (abfd, sizeof (asymbol)); +} + +static void +bfd_pef_get_symbol_info (abfd, symbol, ret) + bfd *abfd ATTRIBUTE_UNUSED; + asymbol *symbol; + symbol_info *ret; +{ + bfd_symbol_info (symbol, ret); +} + +static int +bfd_pef_sizeof_headers (abfd, exec) + bfd *abfd ATTRIBUTE_UNUSED; + boolean exec ATTRIBUTE_UNUSED; +{ + return 0; +} + +const bfd_target pef_vec = +{ + "pef", /* name */ + bfd_target_pef_flavour, /* flavour */ + BFD_ENDIAN_BIG, /* byteorder */ + BFD_ENDIAN_BIG, /* header_byteorder */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA + | SEC_ROM | SEC_HAS_CONTENTS), /* section_flags */ + 0, /* symbol_leading_char */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ + { /* bfd_check_format */ + _bfd_dummy_target, + bfd_pef_object_p, /* bfd_check_format */ + _bfd_dummy_target, + _bfd_dummy_target, + }, + { /* bfd_set_format */ + bfd_false, + bfd_pef_mkobject, + bfd_false, + bfd_false, + }, + { /* bfd_write_contents */ + bfd_false, + bfd_true, + bfd_false, + bfd_false, + }, + + BFD_JUMP_TABLE_GENERIC (bfd_pef), + BFD_JUMP_TABLE_COPY (_bfd_generic), + BFD_JUMP_TABLE_CORE (_bfd_nocore), + BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), + BFD_JUMP_TABLE_SYMBOLS (bfd_pef), + BFD_JUMP_TABLE_RELOCS (bfd_pef), + BFD_JUMP_TABLE_WRITE (bfd_pef), + BFD_JUMP_TABLE_LINK (bfd_pef), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + + NULL, + + NULL +}; + +#define bfd_pef_xlib_close_and_cleanup _bfd_generic_close_and_cleanup +#define bfd_pef_xlib_bfd_free_cached_info _bfd_generic_bfd_free_cached_info +#define bfd_pef_xlib_new_section_hook _bfd_generic_new_section_hook +#define bfd_pef_xlib_get_section_contents _bfd_generic_get_section_contents +#define bfd_pef_xlib_set_section_contents _bfd_generic_set_section_contents +#define bfd_pef_xlib_get_section_contents_in_window _bfd_generic_get_section_contents_in_window +#define bfd_pef_xlib_set_section_contents_in_window _bfd_generic_set_section_contents_in_window + +static int +bfd_pef_xlib_read_header (abfd, header) + bfd *abfd; + bfd_pef_xlib_header *header; +{ + unsigned char buf[76]; + + bfd_seek (abfd, 0, SEEK_SET); + + if (bfd_bread ((PTR) buf, 76, abfd) != 76) { return -1; } + + header->tag1 = bfd_getb32 (buf); + header->tag2 = bfd_getb32 (buf + 4); + header->current_format = bfd_getb32 (buf + 8); + header->container_strings_offset = bfd_getb32 (buf + 12); + header->export_hash_offset = bfd_getb32 (buf + 16); + header->export_key_offset = bfd_getb32 (buf + 20); + header->export_symbol_offset = bfd_getb32 (buf + 24); + header->export_names_offset = bfd_getb32 (buf + 28); + header->export_hash_table_power = bfd_getb32 (buf + 32); + header->exported_symbol_count = bfd_getb32 (buf + 36); + header->frag_name_offset = bfd_getb32 (buf + 40); + header->frag_name_length = bfd_getb32 (buf + 44); + header->dylib_path_offset = bfd_getb32 (buf + 48); + header->dylib_path_length = bfd_getb32 (buf + 52); + header->cpu_family = bfd_getb32 (buf + 56); + header->cpu_model = bfd_getb32 (buf + 60); + header->date_time_stamp = bfd_getb32 (buf + 64); + header->current_version = bfd_getb32 (buf + 68); + header->old_definition_version = bfd_getb32 (buf + 72); + header->old_implementation_version = bfd_getb32 (buf + 76); + + return 0; +} + +int +bfd_pef_xlib_scan (abfd, header) + bfd *abfd; + bfd_pef_xlib_header *header; +{ + bfd_pef_xlib_data_struct *mdata = NULL; + + if ((header->tag1 != BFD_PEF_XLIB_TAG1) + || ((header->tag2 != BFD_PEF_VLIB_TAG2) && (header->tag2 != BFD_PEF_BLIB_TAG2))) { + return -1; + } + + mdata = ((bfd_pef_xlib_data_struct *) + bfd_alloc (abfd, sizeof (bfd_pef_xlib_data_struct))); + if (mdata == NULL) { return -1; } + + mdata->header = *header; + + abfd->flags = abfd->xvec->object_flags | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)); + + abfd->tdata.pef_xlib_data = mdata; + + return 0; +} + +static const bfd_target * +bfd_pef_xlib_object_p (abfd) + bfd *abfd; +{ + bfd_pef_xlib_header header; + + abfd->tdata.pef_xlib_data = NULL; + + if (bfd_pef_xlib_read_header (abfd, &header) != 0) { + abfd->tdata.pef_xlib_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + if (bfd_pef_xlib_scan (abfd, &header) != 0) { + abfd->tdata.pef_xlib_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + return abfd->xvec; +} + +const bfd_target pef_xlib_vec = +{ + "pef-xlib", /* name */ + bfd_target_pef_xlib_flavour, /* flavour */ + BFD_ENDIAN_BIG, /* byteorder */ + BFD_ENDIAN_BIG, /* header_byteorder */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA + | SEC_ROM | SEC_HAS_CONTENTS), /* section_flags */ + 0, /* symbol_leading_char */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ + { /* bfd_check_format */ + _bfd_dummy_target, + bfd_pef_xlib_object_p, /* bfd_check_format */ + _bfd_dummy_target, + _bfd_dummy_target, + }, + { /* bfd_set_format */ + bfd_false, + bfd_pef_mkobject, + bfd_false, + bfd_false, + }, + { /* bfd_write_contents */ + bfd_false, + bfd_true, + bfd_false, + bfd_false, + }, + + BFD_JUMP_TABLE_GENERIC (bfd_pef_xlib), + BFD_JUMP_TABLE_COPY (_bfd_generic), + BFD_JUMP_TABLE_CORE (_bfd_nocore), + BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), + BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols), + BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), + BFD_JUMP_TABLE_WRITE (_bfd_nowrite), + BFD_JUMP_TABLE_LINK (_bfd_nolink), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + + NULL, + + NULL +}; + diff --git a/bfd/pef.h b/bfd/pef.h new file mode 100644 index 0000000..e909be4 --- /dev/null +++ b/bfd/pef.h @@ -0,0 +1,186 @@ +/* PEF support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "bfd.h" + +#include <stdio.h> + +struct bfd_pef_header +{ + unsigned long tag1; + unsigned long tag2; + unsigned long architecture; + unsigned long format_version; + unsigned long timestamp; + unsigned long old_definition_version; + unsigned long old_implementation_version; + unsigned long current_version; + unsigned short section_count; + unsigned short instantiated_section_count; + unsigned long reserved; +}; +typedef struct bfd_pef_header bfd_pef_header; + +struct bfd_pef_loader_header +{ + long main_section; + unsigned long main_offset; + long init_section; + unsigned long init_offset; + long term_section; + unsigned long term_offset; + unsigned long imported_library_count; + unsigned long total_imported_symbol_count; + unsigned long reloc_section_count; + unsigned long reloc_instr_offset; + unsigned long loader_strings_offset; + unsigned long export_hash_offset; + unsigned long export_hash_table_power; + unsigned long exported_symbol_count; +}; +typedef struct bfd_pef_loader_header bfd_pef_loader_header; + +struct bfd_pef_imported_library +{ + unsigned long name_offset; + unsigned long old_implementation_version; + unsigned long current_version; + unsigned long imported_symbol_count; + unsigned long first_imported_symbol; + unsigned char options; + unsigned char reserved_a; + unsigned short reserved_b; +}; +typedef struct bfd_pef_imported_library bfd_pef_imported_library; + +enum bfd_pef_imported_library_options + { + BFD_PEF_WEAK_IMPORT_LIB = 0x40, + BFD_PEF_INIT_LIB_BEFORE = 0x80 + }; + +struct bfd_pef_imported_symbol +{ + unsigned char class; + unsigned long name; +}; +typedef struct bfd_pef_imported_symbol bfd_pef_imported_symbol; + +enum bfd_pef_imported_symbol_class + { + BFD_PEF_CODE_SYMBOL = 0x00, + BFD_PEF_DATA_SYMBOL = 0x01, + BFD_PEF_TVECTOR_SYMBOL = 0x02, + BFD_PEF_TOC_SYMBOL = 0x03, + BFD_PEF_GLUE_SYMBOL = 0x04, + BFD_PEF_UNDEFINED_SYMBOL = 0x0F, + BFD_PEF_WEAK_IMPORT_SYMBOL_MASK = 0x80 + }; + +#define BFD_PEF_TAG1 0x4A6F7921 /* 'Joy!' */ +#define BFD_PEF_TAG2 0x70656666 /* 'peff' */ + +#define BFD_PEF_VERSION 0x00000001 + +struct bfd_pef_section +{ + long name_offset; + unsigned long header_offset; + unsigned long default_address; + unsigned long total_length; + unsigned long unpacked_length; + unsigned long container_length; + unsigned long container_offset; + unsigned char section_kind; + unsigned char share_kind; + unsigned char alignment; + unsigned char reserved; + asection *bfd_section; +}; +typedef struct bfd_pef_section bfd_pef_section; + +#define BFD_PEF_SECTION_CODE 0 +#define BFD_PEF_SECTION_UNPACKED_DATA 1 +#define BFD_PEF_SECTION_PACKED_DATA 2 +#define BFD_PEF_SECTION_CONSTANT 3 +#define BFD_PEF_SECTION_LOADER 4 +#define BFD_PEF_SECTION_DEBUG 5 +#define BFD_PEF_SECTION_EXEC_DATA 6 +#define BFD_PEF_SECTION_EXCEPTION 7 +#define BFD_PEF_SECTION_TRACEBACK 8 + +#define BFD_PEF_SHARE_PROCESS 1 +#define BFD_PEF_SHARE_GLOBAL 4 +#define BFD_PEF_SHARE_PROTECTED 5 + +struct bfd_pef_data_struct +{ + bfd_pef_header header; + bfd_pef_section *sections; + bfd *ibfd; +}; +typedef struct bfd_pef_data_struct bfd_pef_data_struct; + +#define BFD_PEF_XLIB_TAG1 0xF04D6163 /* '?Mac' */ +#define BFD_PEF_VLIB_TAG2 0x564C6962 /* 'VLib' */ +#define BFD_PEF_BLIB_TAG2 0x424C6962 /* 'BLib' */ + +#define BFD_PEF_XLIB_VERSION 0x00000001 + +struct bfd_pef_xlib_header +{ + unsigned long tag1; + unsigned long tag2; + unsigned long current_format; + unsigned long container_strings_offset; + unsigned long export_hash_offset; + unsigned long export_key_offset; + unsigned long export_symbol_offset; + unsigned long export_names_offset; + unsigned long export_hash_table_power; + unsigned long exported_symbol_count; + + unsigned long frag_name_offset; + unsigned long frag_name_length; + unsigned long dylib_path_offset; + unsigned long dylib_path_length; + unsigned long cpu_family; + unsigned long cpu_model; + unsigned long date_time_stamp; + unsigned long current_version; + unsigned long old_definition_version; + unsigned long old_implementation_version; +}; +typedef struct bfd_pef_xlib_header bfd_pef_xlib_header; + +struct bfd_pef_xlib_data_struct +{ + bfd_pef_xlib_header header; +}; +typedef struct bfd_pef_xlib_data_struct bfd_pef_xlib_data_struct; + +int bfd_pef_parse_loader_header PARAMS ((bfd *, unsigned char *, size_t, bfd_pef_loader_header *)); +int bfd_pef_print_loader_section PARAMS ((bfd *, FILE *)); +void bfd_pef_print_loader_header PARAMS ((bfd *, bfd_pef_loader_header *, FILE *)); +int bfd_pef_parse_imported_library PARAMS ((bfd *, unsigned char *, size_t, bfd_pef_imported_library *)); +int bfd_pef_parse_imported_symbol PARAMS ((bfd *, unsigned char *, size_t, bfd_pef_imported_symbol *)); +int bfd_pef_scan_section PARAMS ((bfd *, bfd_pef_section *)); +int bfd_pef_scan_start_address PARAMS ((bfd *)); +int bfd_pef_scan PARAMS ((bfd *, bfd_pef_header *)); diff --git a/bfd/targets.c b/bfd/targets.c index b9c86a1..6a68eaa 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -4,21 +4,21 @@ Free Software Foundation, Inc. Written by Cygnus Support. -This file is part of BFD, the Binary File Descriptor library. + This file is part of BFD, the Binary File Descriptor library. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "bfd.h" #include "sysdep.h" @@ -155,7 +155,11 @@ DESCRIPTION . bfd_target_msdos_flavour, . bfd_target_ovax_flavour, . bfd_target_evax_flavour, -. bfd_target_mmo_flavour +. bfd_target_mmo_flavour, +. bfd_target_mach_o_flavour, +. bfd_target_pef_flavour, +. bfd_target_pef_xlib_flavour, +. bfd_target_sym_flavour .}; . .enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; @@ -645,6 +649,9 @@ extern const bfd_target m68knetbsd_vec; extern const bfd_target m68ksysvcoff_vec; extern const bfd_target m88kbcs_vec; extern const bfd_target m88kmach3_vec; +extern const bfd_target mach_o_be_vec; +extern const bfd_target mach_o_le_vec; +extern const bfd_target mach_o_fat_vec; extern const bfd_target mcore_pe_big_vec; extern const bfd_target mcore_pe_little_vec; extern const bfd_target mcore_pei_big_vec; @@ -661,6 +668,8 @@ extern const bfd_target or32coff_big_vec; extern const bfd_target pc532machaout_vec; extern const bfd_target pc532netbsd_vec; extern const bfd_target pdp11_aout_vec; +extern const bfd_target pef_vec; +extern const bfd_target pef_xlib_vec; extern const bfd_target pmac_xcoff_vec; extern const bfd_target ppcboot_vec; extern const bfd_target riscix_vec; @@ -680,6 +689,7 @@ extern const bfd_target sparclynx_aout_vec; extern const bfd_target sparclynx_coff_vec; extern const bfd_target sparcnetbsd_vec; extern const bfd_target sunos_big_vec; +extern const bfd_target sym_vec; extern const bfd_target tic30_aout_vec; extern const bfd_target tic30_coff_vec; extern const bfd_target tic4x_coff0_beh_vec; @@ -957,6 +967,9 @@ static const bfd_target * const _bfd_target_vector[] = { &m68ksysvcoff_vec, &m88kbcs_vec, &m88kmach3_vec, + &mach_o_be_vec, + &mach_o_le_vec, + &mach_o_fat_vec, &mcore_pe_big_vec, &mcore_pe_little_vec, &mcore_pei_big_vec, @@ -984,6 +997,8 @@ static const bfd_target * const _bfd_target_vector[] = { &pc532machaout_vec, &pc532netbsd_vec, &pdp11_aout_vec, + &pef_vec, + &pef_xlib_vec, #if 0 /* This has the same magic number as RS/6000. */ &pmac_xcoff_vec, @@ -1013,6 +1028,7 @@ static const bfd_target * const _bfd_target_vector[] = { &sparclynx_coff_vec, &sparcnetbsd_vec, &sunos_big_vec, + &sym_vec, &tic30_aout_vec, &tic30_coff_vec, &tic54x_coff0_beh_vec, diff --git a/bfd/xsym.c b/bfd/xsym.c new file mode 100644 index 0000000..99b4eb7 --- /dev/null +++ b/bfd/xsym.c @@ -0,0 +1,2449 @@ +/* xSYM symbol-file support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "xsym.h" +#include "bfd.h" +#include "sysdep.h" +#include "libbfd.h" + +#define bfd_sym_close_and_cleanup _bfd_generic_close_and_cleanup +#define bfd_sym_bfd_free_cached_info _bfd_generic_bfd_free_cached_info +#define bfd_sym_new_section_hook _bfd_generic_new_section_hook +#define bfd_sym_bfd_is_local_label_name bfd_generic_is_local_label_name +#define bfd_sym_get_lineno _bfd_nosymbols_get_lineno +#define bfd_sym_find_nearest_line _bfd_nosymbols_find_nearest_line +#define bfd_sym_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol +#define bfd_sym_read_minisymbols _bfd_generic_read_minisymbols +#define bfd_sym_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol +#define bfd_sym_get_reloc_upper_bound _bfd_norelocs_get_reloc_upper_bound +#define bfd_sym_canonicalize_reloc _bfd_norelocs_canonicalize_reloc +#define bfd_sym_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup +#define bfd_sym_set_arch_mach _bfd_generic_set_arch_mach +#define bfd_sym_get_section_contents _bfd_generic_get_section_contents +#define bfd_sym_set_section_contents _bfd_generic_set_section_contents +#define bfd_sym_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents +#define bfd_sym_bfd_relax_section bfd_generic_relax_section +#define bfd_sym_bfd_gc_sections bfd_generic_gc_sections +#define bfd_sym_bfd_merge_sections bfd_generic_merge_sections +#define bfd_sym_bfd_discard_group bfd_generic_discard_group +#define bfd_sym_bfd_link_hash_table_create _bfd_generic_link_hash_table_create +#define bfd_sym_bfd_link_hash_table_free _bfd_generic_link_hash_table_free +#define bfd_sym_bfd_link_add_symbols _bfd_generic_link_add_symbols +#define bfd_sym_bfd_link_just_syms _bfd_generic_link_just_syms +#define bfd_sym_bfd_final_link _bfd_generic_final_link +#define bfd_sym_bfd_link_split_section _bfd_generic_link_split_section +#define bfd_sym_get_section_contents_in_window _bfd_generic_get_section_contents_in_window + +static int pstrcmp PARAMS ((unsigned char *, unsigned char *)); +static unsigned long compute_offset + PARAMS ((unsigned long, unsigned long, unsigned long, unsigned long)); + +extern const bfd_target sym_vec; + +static int +pstrcmp (a, b) + unsigned char *a; + unsigned char *b; +{ + unsigned char clen; + int ret; + + clen = (a[0] > b[0]) ? a[0] : b[0]; + ret = memcmp (a + 1, b + 1, clen); + if (ret != 0) + return ret; + + if (a[0] == b[0]) + return 0; + else if (a[0] < b[0]) + return -1; + else + return 0; +} + +static unsigned long +compute_offset (first_page, page_size, entry_size, index) + unsigned long first_page; + unsigned long page_size; + unsigned long entry_size; + unsigned long index; +{ + unsigned long entries_per_page = page_size / entry_size; + unsigned long page_number = first_page + (index / entries_per_page); + unsigned long page_offset = (index % entries_per_page) * entry_size; + + return (page_number * page_size) + page_offset; +} + +boolean +bfd_sym_mkobject (abfd) + bfd *abfd ATTRIBUTE_UNUSED; +{ + return (boolean) true; +} + +void +bfd_sym_print_symbol (abfd, afile, symbol, how) + bfd *abfd ATTRIBUTE_UNUSED; + PTR afile ATTRIBUTE_UNUSED; + asymbol *symbol ATTRIBUTE_UNUSED; + bfd_print_symbol_type how ATTRIBUTE_UNUSED; +{ + return; +} + +boolean +bfd_sym_valid (abfd) + bfd *abfd; +{ + if (abfd == NULL || abfd->xvec == NULL) + return 0; + + return (abfd->xvec == &sym_vec); +} + +unsigned char * +bfd_sym_read_name_table (abfd, dshb) + bfd *abfd; + bfd_sym_header_block *dshb; +{ + unsigned char *rstr; + long ret; + size_t table_size = dshb->dshb_nte.dti_page_count * dshb->dshb_page_size; + size_t table_offset = dshb->dshb_nte.dti_first_page * dshb->dshb_page_size; + + rstr = (unsigned char *) bfd_alloc (abfd, table_size); + if (rstr == NULL) + return rstr; + + bfd_seek (abfd, table_offset, SEEK_SET); + ret = bfd_bread (rstr, table_size, abfd); + if ((ret < 0) || ((unsigned long) ret != table_size)) + { + bfd_release (abfd, rstr); + return NULL; + } + + return rstr; +} + +void +bfd_sym_parse_file_reference_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_file_reference *entry; +{ + BFD_ASSERT (len == 6); + + entry->fref_frte_index = bfd_getb16 (buf); + entry->fref_offset = bfd_getb32 (buf + 2); +} + +void +bfd_sym_parse_disk_table_v32 (buf, len, table) + unsigned char *buf; + size_t len; + bfd_sym_table_info *table; +{ + BFD_ASSERT (len == 8); + + table->dti_first_page = bfd_getb16 (buf); + table->dti_page_count = bfd_getb16 (buf + 2); + table->dti_object_count = bfd_getb32 (buf + 4); +} + +void +bfd_sym_parse_header_v32 (buf, len, header) + unsigned char *buf; + size_t len; + bfd_sym_header_block *header; +{ + BFD_ASSERT (len == 154); + + memcpy (header->dshb_id, buf, 32); + header->dshb_page_size = bfd_getb16 (buf + 32); + header->dshb_hash_page = bfd_getb16 (buf + 34); + header->dshb_root_mte = bfd_getb16 (buf + 36); + header->dshb_mod_date = bfd_getb32 (buf + 38); + + bfd_sym_parse_disk_table_v32 (buf + 42, 8, &header->dshb_frte); + bfd_sym_parse_disk_table_v32 (buf + 50, 8, &header->dshb_rte); + bfd_sym_parse_disk_table_v32 (buf + 58, 8, &header->dshb_mte); + bfd_sym_parse_disk_table_v32 (buf + 66, 8, &header->dshb_cmte); + bfd_sym_parse_disk_table_v32 (buf + 74, 8, &header->dshb_cvte); + bfd_sym_parse_disk_table_v32 (buf + 82, 8, &header->dshb_csnte); + bfd_sym_parse_disk_table_v32 (buf + 90, 8, &header->dshb_clte); + bfd_sym_parse_disk_table_v32 (buf + 98, 8, &header->dshb_ctte); + bfd_sym_parse_disk_table_v32 (buf + 106, 8, &header->dshb_tte); + bfd_sym_parse_disk_table_v32 (buf + 114, 8, &header->dshb_nte); + bfd_sym_parse_disk_table_v32 (buf + 122, 8, &header->dshb_tinfo); + bfd_sym_parse_disk_table_v32 (buf + 130, 8, &header->dshb_fite); + bfd_sym_parse_disk_table_v32 (buf + 138, 8, &header->dshb_const); + + memcpy (&header->dshb_file_creator, buf + 146, 4); + memcpy (&header->dshb_file_type, buf + 150, 4); +} + +int +bfd_sym_read_header_v32 (abfd, header) + bfd *abfd; + bfd_sym_header_block *header; +{ + unsigned char buf[154]; + long ret; + + ret = bfd_bread (buf, 154, abfd); + if (ret != 154) + return -1; + + bfd_sym_parse_header_v32 (buf, 154, header); + + return 0; +} + +int +bfd_sym_read_header_v34 (abfd, header) + bfd *abfd ATTRIBUTE_UNUSED; + bfd_sym_header_block *header ATTRIBUTE_UNUSED; +{ + abort (); +} + +int +bfd_sym_read_header (abfd, header, version) + bfd *abfd; + bfd_sym_header_block *header; + bfd_sym_version version; +{ + switch (version) + { + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + return bfd_sym_read_header_v34 (abfd, header); + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + return bfd_sym_read_header_v32 (abfd, header); + case BFD_SYM_VERSION_3_1: + default: + return false; + } +} + +int +bfd_sym_read_version (abfd, version) + bfd *abfd; + bfd_sym_version *version; +{ + unsigned char version_string[32]; + long ret; + + ret = bfd_bread (version_string, sizeof (version_string), abfd); + if (ret != sizeof (version_string)) + return -1; + + if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_1) == 0) + *version = BFD_SYM_VERSION_3_1; + else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_2) == 0) + *version = BFD_SYM_VERSION_3_2; + else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_3) == 0) + *version = BFD_SYM_VERSION_3_3; + else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_4) == 0) + *version = BFD_SYM_VERSION_3_4; + else if (pstrcmp (version_string, BFD_SYM_VERSION_STR_3_5) == 0) + *version = BFD_SYM_VERSION_3_5; + else + return -1; + + return 0; +} + +void +bfd_sym_display_table_summary (f, dti, name) + FILE *f; + bfd_sym_table_info *dti; + const char *name; +{ + fprintf (f, "%-6s %13ld %13ld %13ld\n", + name, + dti->dti_first_page, + dti->dti_page_count, + dti->dti_object_count); +} + +void +bfd_sym_display_header (f, dshb) + FILE *f; + bfd_sym_header_block *dshb; +{ + fprintf (f, " Version: %.*s\n", dshb->dshb_id[0], dshb->dshb_id + 1); + fprintf (f, " Page Size: 0x%x\n", dshb->dshb_page_size); + fprintf (f, " Hash Page: %lu\n", dshb->dshb_hash_page); + fprintf (f, " Root MTE: %lu\n", dshb->dshb_root_mte); + fprintf (f, " Modification Date: "); + fprintf (f, "[unimplemented]"); + fprintf (f, " (0x%lx)\n", dshb->dshb_mod_date); + + fprintf (f, " File Creator: %.4s Type: %.4s\n\n", + dshb->dshb_file_creator, dshb->dshb_file_type); + + fprintf (f, "Table Name First Page Page Count Object Count\n"); + fprintf (f, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); + + bfd_sym_display_table_summary (f, &dshb->dshb_nte, "NTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_rte, "RTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_mte, "MTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_frte, "FRTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_cmte, "CMTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_cvte, "CVTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_csnte, "CSNTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_clte, "CLTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_ctte, "CTTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_tte, "TTE"); + bfd_sym_display_table_summary (f, &dshb->dshb_tinfo, "TINFO"); + bfd_sym_display_table_summary (f, &dshb->dshb_fite, "FITE"); + bfd_sym_display_table_summary (f, &dshb->dshb_const, "CONST"); + + fprintf (f, "\n"); +} + +void +bfd_sym_parse_resources_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_resources_table_entry *entry; +{ + BFD_ASSERT (len == 18); + + memcpy (&entry->rte_res_type, buf, 4); + entry->rte_res_number = bfd_getb16 (buf + 4); + entry->rte_nte_index = bfd_getb32 (buf + 6); + entry->rte_mte_first = bfd_getb16 (buf + 10); + entry->rte_mte_last = bfd_getb16 (buf + 12); + entry->rte_res_size = bfd_getb32 (buf + 14); +} + +void +bfd_sym_parse_modules_table_entry_v33 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_modules_table_entry *entry; +{ + BFD_ASSERT (len == 46); + + entry->mte_rte_index = bfd_getb16 (buf); + entry->mte_res_offset = bfd_getb32 (buf + 2); + entry->mte_size = bfd_getb32 (buf + 6); + entry->mte_kind = buf[10]; + entry->mte_scope = buf[11]; + entry->mte_parent = bfd_getb16 (buf + 12); + bfd_sym_parse_file_reference_v32 (buf + 14, 6, &entry->mte_imp_fref); + entry->mte_imp_end = bfd_getb32 (buf + 20); + entry->mte_nte_index = bfd_getb32 (buf + 24); + entry->mte_cmte_index = bfd_getb16 (buf + 28); + entry->mte_cvte_index = bfd_getb32 (buf + 30); + entry->mte_clte_index = bfd_getb16 (buf + 34); + entry->mte_ctte_index = bfd_getb16 (buf + 36); + entry->mte_csnte_idx_1 = bfd_getb32 (buf + 38); + entry->mte_csnte_idx_2 = bfd_getb32 (buf + 42); +} + +void +bfd_sym_parse_file_references_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_file_references_table_entry *entry; +{ + unsigned int type; + + BFD_ASSERT (len == 10); + + memset (entry, 0, sizeof (bfd_sym_file_references_table_entry)); + type = bfd_getb16 (buf); + + switch (type) + { + case BFD_SYM_END_OF_LIST_3_2: + entry->generic.type = BFD_SYM_END_OF_LIST; + break; + + case BFD_SYM_FILE_NAME_INDEX_3_2: + entry->filename.type = BFD_SYM_FILE_NAME_INDEX; + entry->filename.nte_index = bfd_getb32 (buf + 2); + entry->filename.mod_date = bfd_getb32 (buf + 6); + break; + + default: + entry->entry.mte_index = type; + entry->entry.file_offset = bfd_getb32 (buf + 2); + } +} + +void +bfd_sym_parse_contained_modules_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_contained_modules_table_entry *entry; +{ + unsigned int type; + + BFD_ASSERT (len == 6); + + memset (entry, 0, sizeof (bfd_sym_contained_modules_table_entry)); + type = bfd_getb16 (buf); + + switch (type) + { + case BFD_SYM_END_OF_LIST_3_2: + entry->generic.type = BFD_SYM_END_OF_LIST; + break; + + default: + entry->entry.mte_index = type; + entry->entry.nte_index = bfd_getb32 (buf + 2); + break; + } +} + +void +bfd_sym_parse_contained_variables_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_contained_variables_table_entry *entry; +{ + unsigned int type; + + BFD_ASSERT (len == 26); + + memset (entry, 0, sizeof (bfd_sym_contained_variables_table_entry)); + type = bfd_getb16 (buf); + + switch (type) + { + case BFD_SYM_END_OF_LIST_3_2: + entry->generic.type = BFD_SYM_END_OF_LIST; + break; + + case BFD_SYM_SOURCE_FILE_CHANGE_3_2: + entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE; + bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref); + break; + + default: + entry->entry.tte_index = type; + entry->entry.nte_index = bfd_getb32 (buf + 2); + entry->entry.file_delta = bfd_getb16 (buf + 6); + entry->entry.scope = buf[8]; + entry->entry.la_size = buf[9]; + + if (entry->entry.la_size == BFD_SYM_CVTE_SCA) + { + entry->entry.address.scstruct.sca_kind = buf[10]; + entry->entry.address.scstruct.sca_class = buf[11]; + entry->entry.address.scstruct.sca_offset = bfd_getb32 (buf + 12); + } + else if (entry->entry.la_size <= BFD_SYM_CVTE_SCA) + { + memcpy (&entry->entry.address.lastruct.la, buf + 10, BFD_SYM_CVTE_SCA); + entry->entry.address.lastruct.la_kind = buf[23]; + } + else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA) + { + entry->entry.address.biglastruct.big_la = bfd_getb32 (buf + 10); + entry->entry.address.biglastruct.big_la_kind = buf[12]; + } + } +} + +void +bfd_sym_parse_contained_statements_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_contained_statements_table_entry *entry; +{ + unsigned int type; + + BFD_ASSERT (len == 8); + + memset (entry, 0, sizeof (bfd_sym_contained_statements_table_entry)); + type = bfd_getb16 (buf); + + switch (type) + { + case BFD_SYM_END_OF_LIST_3_2: + entry->generic.type = BFD_SYM_END_OF_LIST; + break; + + case BFD_SYM_SOURCE_FILE_CHANGE_3_2: + entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE; + bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref); + break; + + default: + entry->entry.mte_index = type; + entry->entry.mte_offset = bfd_getb16 (buf + 2); + entry->entry.file_delta = bfd_getb32 (buf + 4); + break; + } +} + +void +bfd_sym_parse_contained_labels_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_contained_labels_table_entry *entry; +{ + unsigned int type; + + BFD_ASSERT (len == 12); + + memset (entry, 0, sizeof (bfd_sym_contained_labels_table_entry)); + type = bfd_getb16 (buf); + + switch (type) + { + case BFD_SYM_END_OF_LIST_3_2: + entry->generic.type = BFD_SYM_END_OF_LIST; + break; + + case BFD_SYM_SOURCE_FILE_CHANGE_3_2: + entry->file.type = BFD_SYM_SOURCE_FILE_CHANGE; + bfd_sym_parse_file_reference_v32 (buf + 2, 6, &entry->file.fref); + break; + + default: + entry->entry.mte_index = type; + entry->entry.mte_offset = bfd_getb16 (buf + 2); + entry->entry.nte_index = bfd_getb32 (buf + 4); + entry->entry.file_delta = bfd_getb16 (buf + 8); + entry->entry.scope = bfd_getb16 (buf + 10); + break; + } +} + +void +bfd_sym_parse_type_table_entry_v32 (buf, len, entry) + unsigned char *buf; + size_t len; + bfd_sym_type_table_entry *entry; +{ + BFD_ASSERT (len == 4); + + *entry = bfd_getb32 (buf); +} + +int +bfd_sym_fetch_resources_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_resources_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_resources_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size; + unsigned char buf[18]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + return -1; + + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 18; + parser = bfd_sym_parse_resources_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_1: + default: + return -1; + } + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_rte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_modules_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_modules_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_modules_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size; + unsigned char buf[46]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + return -1; + + case BFD_SYM_VERSION_3_3: + entry_size = 46; + parser = bfd_sym_parse_modules_table_entry_v33; + break; + + case BFD_SYM_VERSION_3_2: + case BFD_SYM_VERSION_3_1: + default: + return -1; + } + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_mte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_file_references_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_file_references_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_file_references_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[8]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 10; + parser = bfd_sym_parse_file_references_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_frte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_contained_modules_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_contained_modules_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_contained_modules_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[6]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 6; + parser = bfd_sym_parse_contained_modules_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_cmte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_contained_variables_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_contained_variables_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_contained_variables_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[26]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 26; + parser = bfd_sym_parse_contained_variables_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_cvte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_contained_statements_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_contained_statements_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_contained_statements_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[8]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 8; + parser = bfd_sym_parse_contained_statements_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_csnte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_contained_labels_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_contained_labels_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_contained_labels_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[12]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 12; + parser = bfd_sym_parse_contained_labels_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_clte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_contained_types_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_contained_types_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_contained_types_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[0]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 0; + parser = NULL; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_ctte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_file_references_index_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_file_references_index_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_file_references_index_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[0]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 0; + parser = NULL; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_fite.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_constant_pool_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_constant_pool_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_constant_pool_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[0]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 0; + parser = NULL; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_fite.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_type_table_entry (abfd, entry, index) + bfd *abfd; + bfd_sym_type_table_entry *entry; + unsigned long index; +{ + void (*parser) (unsigned char *, size_t, bfd_sym_type_table_entry *) = NULL; + unsigned long offset; + unsigned long entry_size = 0; + unsigned char buf[4]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + switch (sdata->version) + { + case BFD_SYM_VERSION_3_3: + case BFD_SYM_VERSION_3_2: + entry_size = 4; + parser = bfd_sym_parse_type_table_entry_v32; + break; + + case BFD_SYM_VERSION_3_5: + case BFD_SYM_VERSION_3_4: + case BFD_SYM_VERSION_3_1: + default: + break; + } + + if (parser == NULL) + return -1; + + offset = compute_offset (sdata->header.dshb_tte.dti_first_page, + sdata->header.dshb_page_size, + entry_size, index); + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + if (bfd_bread (buf, entry_size, abfd) != entry_size) + return -1; + + (*parser) (buf, entry_size, entry); + + return 0; +} + +int +bfd_sym_fetch_type_information_table_entry (abfd, entry, offset) + bfd *abfd; + bfd_sym_type_information_table_entry *entry; + unsigned long offset; +{ + unsigned char buf[4]; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return -1; + + if (bfd_seek (abfd, offset, SEEK_SET) < 0) + return -1; + + if (bfd_bread (buf, 4, abfd) != 4) + return -1; + entry->nte_index = bfd_getb32 (buf); + + if (bfd_bread (buf, 2, abfd) != 2) + return -1; + entry->physical_size = bfd_getb16 (buf); + + if (entry->physical_size & 0x8000) + { + if (bfd_bread (buf, 4, abfd) != 4) + return -1; + entry->physical_size &= 0x7fff; + entry->logical_size = bfd_getb32 (buf); + entry->offset = offset + 10; + } + else + { + if (bfd_bread (buf, 2, abfd) != 2) + return -1; + entry->physical_size &= 0x7fff; + entry->logical_size = bfd_getb16 (buf); + entry->offset = offset + 8; + } + + return 0; +} + +int +bfd_sym_fetch_type_table_information (abfd, entry, index) + bfd *abfd; + bfd_sym_type_information_table_entry *entry; + unsigned long index; +{ + bfd_sym_type_table_entry tindex; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (sdata->header.dshb_tte.dti_object_count <= 99) + return -1; + if (index < 100) + return -1; + + if (bfd_sym_fetch_type_table_entry (abfd, &tindex, index - 100) < 0) + return -1; + if (bfd_sym_fetch_type_information_table_entry (abfd, entry, tindex) < 0) + return -1; + + return 0; +} + +const unsigned char * +bfd_sym_symbol_name (abfd, index) + bfd *abfd; + unsigned long index; +{ + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (index == 0) + return ""; + + index *= 2; + if ((index / sdata->header.dshb_page_size) > sdata->header.dshb_nte.dti_page_count) + return "\009[INVALID]"; + + return ((const unsigned char *) sdata->name_table + index); +} + +const unsigned char * +bfd_sym_module_name (abfd, index) + bfd *abfd; + unsigned long index; +{ + bfd_sym_modules_table_entry entry; + + if (bfd_sym_fetch_modules_table_entry (abfd, &entry, index) < 0) + return "\011[INVALID]"; + + return bfd_sym_symbol_name (abfd, entry.mte_nte_index); +} + +const char * +bfd_sym_unparse_storage_kind (kind) + enum bfd_sym_storage_kind kind; +{ + switch (kind) + { + case BFD_SYM_STORAGE_KIND_LOCAL: return "LOCAL"; + case BFD_SYM_STORAGE_KIND_VALUE: return "VALUE"; + case BFD_SYM_STORAGE_KIND_REFERENCE: return "REFERENCE"; + case BFD_SYM_STORAGE_KIND_WITH: return "WITH"; + default: return "[UNKNOWN]"; + } +} + +const char * +bfd_sym_unparse_storage_class (kind) + enum bfd_sym_storage_class kind; +{ + switch (kind) + { + case BFD_SYM_STORAGE_CLASS_REGISTER: return "REGISTER"; + case BFD_SYM_STORAGE_CLASS_GLOBAL: return "GLOBAL"; + case BFD_SYM_STORAGE_CLASS_FRAME_RELATIVE: return "FRAME_RELATIVE"; + case BFD_SYM_STORAGE_CLASS_STACK_RELATIVE: return "STACK_RELATIVE"; + case BFD_SYM_STORAGE_CLASS_ABSOLUTE: return "ABSOLUTE"; + case BFD_SYM_STORAGE_CLASS_CONSTANT: return "CONSTANT"; + case BFD_SYM_STORAGE_CLASS_RESOURCE: return "RESOURCE"; + case BFD_SYM_STORAGE_CLASS_BIGCONSTANT: return "BIGCONSTANT"; + default: return "[UNKNOWN]"; + } +} + +const char * +bfd_sym_unparse_module_kind (kind) + enum bfd_sym_module_kind kind; +{ + switch (kind) + { + case BFD_SYM_MODULE_KIND_NONE: return "NONE"; + case BFD_SYM_MODULE_KIND_PROGRAM: return "PROGRAM"; + case BFD_SYM_MODULE_KIND_UNIT: return "UNIT"; + case BFD_SYM_MODULE_KIND_PROCEDURE: return "PROCEDURE"; + case BFD_SYM_MODULE_KIND_FUNCTION: return "FUNCTION"; + case BFD_SYM_MODULE_KIND_DATA: return "DATA"; + case BFD_SYM_MODULE_KIND_BLOCK: return "BLOCK"; + default: return "[UNKNOWN]"; + } +} + +const char * +bfd_sym_unparse_symbol_scope (scope) + enum bfd_sym_symbol_scope scope; +{ + switch (scope) + { + case BFD_SYM_SYMBOL_SCOPE_LOCAL: return "LOCAL"; + case BFD_SYM_SYMBOL_SCOPE_GLOBAL: return "GLOBAL"; + default: + return "[UNKNOWN]"; + } +} + +void +bfd_sym_print_file_reference (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_file_reference *entry; +{ + bfd_sym_file_references_table_entry frtentry; + int ret; + + ret = bfd_sym_fetch_file_references_table_entry (abfd, &frtentry, entry->fref_frte_index); + fprintf (f, "FILE "); + + if ((ret < 0) || (frtentry.generic.type != BFD_SYM_FILE_NAME_INDEX)) + fprintf (f, "[INVALID]"); + else + fprintf (f, "\"%.*s\"", + bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[0], + &bfd_sym_symbol_name (abfd, frtentry.filename.nte_index)[1]); + + fprintf (f, " (FRTE %lu)", entry->fref_frte_index); +} + +void +bfd_sym_print_resources_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_resources_table_entry *entry; +{ + fprintf (f, " \"%.*s\" (NTE %lu), type \"%.4s\", num %u, size %lu, MTE %lu -- %lu", + bfd_sym_symbol_name (abfd, entry->rte_nte_index)[0], + &bfd_sym_symbol_name (abfd, entry->rte_nte_index)[1], + entry->rte_nte_index, entry->rte_res_type, entry->rte_res_number, + entry->rte_res_size, entry->rte_mte_first, entry->rte_mte_last); +} + +void +bfd_sym_print_modules_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_modules_table_entry *entry; +{ + fprintf (f, "\"%.*s\" (NTE %lu)", + bfd_sym_symbol_name (abfd, entry->mte_nte_index)[0], + &bfd_sym_symbol_name (abfd, entry->mte_nte_index)[1], + entry->mte_nte_index); + + fprintf (f, "\n "); + + bfd_sym_print_file_reference (abfd, f, &entry->mte_imp_fref); + fprintf (f, " range %lu -- %lu", entry->mte_imp_fref.fref_offset, entry->mte_imp_end); + + fprintf (f, "\n "); + + fprintf (f, "kind %s", bfd_sym_unparse_module_kind (entry->mte_kind)); + fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->mte_scope)); + + fprintf (f, ", RTE %lu, offset %lu, size %lu", + entry->mte_rte_index, entry->mte_res_offset, entry->mte_size); + + fprintf (f, "\n "); + + fprintf (f, "CMTE %lu, CVTE %lu, CLTE %lu, CTTE %lu, CSNTE1 %lu, CSNTE2 %lu", + entry->mte_cmte_index, entry->mte_cvte_index, + entry->mte_clte_index, entry->mte_ctte_index, + entry->mte_csnte_idx_1, entry->mte_csnte_idx_2); + + if (entry->mte_parent != 0) + fprintf (f, ", parent %lu", entry->mte_parent); + else + fprintf (f, ", no parent"); + + if (entry->mte_cmte_index != 0) + fprintf (f, ", child %lu", entry->mte_cmte_index); + else + fprintf (f, ", no child"); + +#if 0 + { + MTE bfd_sym_modules_table_entry pentry; + + ret = bfd_sym_fetch_modules_table_entry (abfd, &pentry, entry->mte_parent); + if (ret < 0) + fprintf (f, " parent MTE %lu [INVALID]\n", entry->mte_parent); + else + fprintf (f, " parent MTE %lu \"%.*s\"\n", + entry->mte_parent, + bfd_sym_symbol_name (abfd, pentry.mte_nte_index)[0], + &bfd_sym_symbol_name (abfd, pentry.mte_nte_index)[1]); + } +#endif +} + +void +bfd_sym_print_file_references_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_file_references_table_entry *entry; +{ + switch (entry->generic.type) + { + case BFD_SYM_FILE_NAME_INDEX: + fprintf (f, "FILE \"%.*s\" (NTE %lu), modtime ", + bfd_sym_symbol_name (abfd, entry->filename.nte_index)[0], + &bfd_sym_symbol_name (abfd, entry->filename.nte_index)[1], + entry->filename.nte_index); + + fprintf (f, "[UNIMPLEMENTED]"); + /* printModDate (entry->filename.mod_date); */ + fprintf (f, " (0x%lx)", entry->filename.mod_date); + break; + + case BFD_SYM_END_OF_LIST: + fprintf (f, "END"); + break; + + default: + fprintf (f, "\"%.*s\" (MTE %lu), offset %lu", + bfd_sym_module_name (abfd, entry->entry.mte_index)[0], + &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], + entry->entry.mte_index, + entry->entry.file_offset); + break; + } +} + +void +bfd_sym_print_contained_modules_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_contained_modules_table_entry *entry; +{ + switch (entry->generic.type) + { + case BFD_SYM_END_OF_LIST: + fprintf (f, "END"); + break; + + default: + fprintf (f, "\"%.*s\" (MTE %lu, NTE %lu)", + bfd_sym_module_name (abfd, entry->entry.mte_index)[0], + &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], + entry->entry.mte_index, + entry->entry.nte_index); + break; + } +} + +void +bfd_sym_print_contained_variables_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_contained_variables_table_entry *entry; +{ + if (entry->generic.type == BFD_SYM_END_OF_LIST) + { + fprintf (f, "END"); + return; + } + + if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE) + { + bfd_sym_print_file_reference (abfd, f, &entry->file.fref); + fprintf (f, " offset %lu", entry->file.fref.fref_offset); + return; + } + + fprintf (f, "\"%.*s\" (NTE %lu)", + bfd_sym_symbol_name (abfd, entry->entry.nte_index)[0], + &bfd_sym_symbol_name (abfd, entry->entry.nte_index)[1], + entry->entry.nte_index); + + fprintf (f, ", TTE %lu", entry->entry.tte_index); + fprintf (f, ", offset %lu", entry->entry.file_delta); + fprintf (f, ", scope %s", bfd_sym_unparse_symbol_scope (entry->entry.scope)); + + if (entry->entry.la_size == BFD_SYM_CVTE_SCA) + fprintf (f, ", latype %s, laclass %s, laoffset %lu", + bfd_sym_unparse_storage_kind (entry->entry.address.scstruct.sca_kind), + bfd_sym_unparse_storage_class (entry->entry.address.scstruct.sca_class), + entry->entry.address.scstruct.sca_offset); + else if (entry->entry.la_size <= BFD_SYM_CVTE_LA_MAX_SIZE) + { + unsigned long i; + + fprintf (f, ", la ["); + for (i = 0; i < entry->entry.la_size; i++) + fprintf (f, "0x%02x ", entry->entry.address.lastruct.la[i]); + fprintf (f, "]"); + } + else if (entry->entry.la_size == BFD_SYM_CVTE_BIG_LA) + fprintf (f, ", bigla %lu, biglakind %u", + entry->entry.address.biglastruct.big_la, + entry->entry.address.biglastruct.big_la_kind); + + else + fprintf (f, ", la [INVALID]"); +} + +void +bfd_sym_print_contained_statements_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_contained_statements_table_entry *entry; +{ + if (entry->generic.type == BFD_SYM_END_OF_LIST) + { + fprintf (f, "END"); + return; + } + + if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE) + { + bfd_sym_print_file_reference (abfd, f, &entry->file.fref); + fprintf (f, " offset %lu", entry->file.fref.fref_offset); + return; + } + + fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu", + bfd_sym_module_name (abfd, entry->entry.mte_index)[0], + &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], + entry->entry.mte_index, + entry->entry.mte_offset, + entry->entry.file_delta); +} + +void +bfd_sym_print_contained_labels_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_contained_labels_table_entry *entry; +{ + if (entry->generic.type == BFD_SYM_END_OF_LIST) + { + fprintf (f, "END"); + return; + } + + if (entry->generic.type == BFD_SYM_SOURCE_FILE_CHANGE) + { + bfd_sym_print_file_reference (abfd, f, &entry->file.fref); + fprintf (f, " offset %lu", entry->file.fref.fref_offset); + return; + } + + fprintf (f, "\"%.*s\" (MTE %lu), offset %lu, delta %lu, scope %s", + bfd_sym_module_name (abfd, entry->entry.mte_index)[0], + &bfd_sym_module_name (abfd, entry->entry.mte_index)[1], + entry->entry.mte_index, + entry->entry.mte_offset, + entry->entry.file_delta, + bfd_sym_unparse_symbol_scope (entry->entry.scope)); +} + +void +bfd_sym_print_contained_types_table_entry (abfd, f, entry) + bfd *abfd ATTRIBUTE_UNUSED; + FILE *f; + bfd_sym_contained_types_table_entry *entry ATTRIBUTE_UNUSED; +{ + fprintf (f, "[UNIMPLEMENTED]"); +} + +const char * +bfd_sym_type_operator_name (num) + unsigned char num; +{ + switch (num) + { + case 1: return "TTE"; + case 2: return "PointerTo"; + case 3: return "ScalarOf"; + case 4: return "ConstantOf"; + case 5: return "EnumerationOf"; + case 6: return "VectorOf"; + case 7: return "RecordOf"; + case 8: return "UnionOf"; + case 9: return "SubRangeOf"; + case 10: return "SetOf"; + case 11: return "NamedTypeOf"; + case 12: return "ProcOf"; + case 13: return "ValueOf"; + case 14: return "ArrayOf"; + default: return "[UNKNOWN OPERATOR]"; + } +} + +const char * +bfd_sym_type_basic_name (num) + unsigned char num; +{ + switch (num) + { + case 0: return "void"; + case 1: return "pascal string"; + case 2: return "unsigned long"; + case 3: return "signed long"; + case 4: return "extended (10 bytes)"; + case 5: return "pascal boolean (1 byte)"; + case 6: return "unsigned byte"; + case 7: return "signed byte"; + case 8: return "character (1 byte)"; + case 9: return "wide character (2 bytes)"; + case 10: return "unsigned short"; + case 11: return "signed short"; + case 12: return "singled"; + case 13: return "double"; + case 14: return "extended (12 bytes)"; + case 15: return "computational (8 bytes)"; + case 16: return "c string"; + case 17: return "as-is string"; + default: return "[UNKNOWN BASIC TYPE]"; + } +} + +int +bfd_sym_fetch_long (buf, len, offset, offsetptr, value) + unsigned char *buf; + unsigned long len; + unsigned long offset; + unsigned long *offsetptr; + long *value; +{ + int ret; + + if (offset >= len) + { + *value = 0; + offset += 0; + ret = -1; + } + else if (! (buf[offset] & 0x80)) + { + *value = buf[offset]; + offset += 1; + ret = 0; + } + else if (buf[offset] == 0xc0) + { + if ((offset + 5) > len) + { + *value = 0; + offset = len; + ret = -1; + } + else + { + *value = bfd_getb32 (buf + offset + 1); + offset += 5; + ret = 0; + } + } + else if ((buf[offset] & 0xc0) == 0xc0) + { + *value = -(buf[offset] & 0x3f); + offset += 1; + ret = 0; + } + else if ((buf[offset] & 0xc0) == 0x80) + { + if ((offset + 2) > len) + { + *value = 0; + offset = len; + ret = -1; + } + else + { + *value = bfd_getb16 (buf + offset) & 0x3fff; + offset += 2; + ret = 0; + } + } + else + abort (); + + if (offsetptr != NULL) + *offsetptr = offset; + + return ret; +} + +void +bfd_sym_print_type_information (abfd, f, buf, len, offset, offsetptr) + bfd *abfd; + FILE *f; + unsigned char *buf; + unsigned long len; + unsigned long offset; + unsigned long *offsetptr; +{ + unsigned int type; + + if (offset >= len) + { + fprintf (f, "[NULL]"); + + if (offsetptr != NULL) + *offsetptr = offset; + return; + } + + type = buf[offset]; + offset++; + + if (! (type & 0x80)) + { + fprintf (f, "[%s] (0x%x)", bfd_sym_type_basic_name (type & 0x7f), type); + + if (offsetptr != NULL) + *offsetptr = offset; + return; + } + + if (type & 0x40) + fprintf (f, "[packed "); + else + fprintf (f, "["); + + switch (type & 0x3f) + { + case 1: + { + long value; + bfd_sym_type_information_table_entry tinfo; + + bfd_sym_fetch_long (buf, len, offset, &offset, &value); + if (value <= 0) + fprintf (f, "[INVALID]"); + else + { + if (bfd_sym_fetch_type_table_information (abfd, &tinfo, value) < 0) + fprintf (f, "[INVALID]"); + else + fprintf (f, "\"%.*s\"", + bfd_sym_symbol_name (abfd, tinfo.nte_index)[0], + &bfd_sym_symbol_name (abfd, tinfo.nte_index)[1]); + } + fprintf (f, " (TTE %lu)", value); + break; + } + + case 2: + fprintf (f, "pointer (0x%x) to ", type); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + break; + + case 3: + { + unsigned long value; + + fprintf (f, "scalar (0x%x) of ", type); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + bfd_sym_fetch_long (buf, len, offset, &offset, &value); + fprintf (f, " (%lu)", value); + break; + } + + case 5: + { + unsigned long lower, upper, nelem; + unsigned long i; + + fprintf (f, "enumeration (0x%x) of ", type); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + bfd_sym_fetch_long (buf, len, offset, &offset, &lower); + bfd_sym_fetch_long (buf, len, offset, &offset, &upper); + bfd_sym_fetch_long (buf, len, offset, &offset, &nelem); + fprintf (f, " from %lu to %lu with %lu elements: ", lower, upper, nelem); + + for (i = 0; i < nelem; i++) + { + fprintf (f, "\n "); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + } + break; + } + + case 6: + fprintf (f, "vector (0x%x)", type); + fprintf (f, "\n index "); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + fprintf (f, "\n target "); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + break; + + case 7: + case 8: + { + long nrec, eloff, i; + + if ((type & 0x3f) == 7) + fprintf (f, "record (0x%x) of ", type); + else + fprintf (f, "union (0x%x) of ", type); + + bfd_sym_fetch_long (buf, len, offset, &offset, &nrec); + fprintf (f, "%lu elements: ", nrec); + + for (i = 0; i < nrec; i++) + { + bfd_sym_fetch_long (buf, len, offset, &offset, &eloff); + fprintf (f, "\n "); + fprintf (f, "offset %lu: ", eloff); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + } + break; + } + + case 9: + fprintf (f, "subrange (0x%x) of ", type); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + fprintf (f, " lower "); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + fprintf (f, " upper "); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + break; + + case 11: + { + long value; + + fprintf (f, "named type (0x%x) ", type); + bfd_sym_fetch_long (buf, len, offset, &offset, &value); + if (value <= 0) + fprintf (f, "[INVALID]"); + else + fprintf (f, "\"%.*s\"", + bfd_sym_symbol_name (abfd, value)[0], + &bfd_sym_symbol_name (abfd, value)[1]); + + fprintf (f, " (NTE %lu) with type ", value); + bfd_sym_print_type_information (abfd, f, buf, len, offset, &offset); + break; + } + + default: + fprintf (f, "%s (0x%x)", bfd_sym_type_operator_name (type), type); + break; + } + + if (type == (0x40 | 0x6)) + { + /* Vector. */ + long n, width, m; + long l; + long i; + + bfd_sym_fetch_long (buf, len, offset, &offset, &n); + bfd_sym_fetch_long (buf, len, offset, &offset, &width); + bfd_sym_fetch_long (buf, len, offset, &offset, &m); + /* fprintf (f, "\n "); */ + fprintf (f, " N %ld, width %ld, M %ld, ", n, width, m); + for (i = 0; i < m; i++) + { + bfd_sym_fetch_long (buf, len, offset, &offset, &l); + if (i != 0) + fprintf (f, " "); + fprintf (f, "%ld", l); + } + } + else if (type & 0x40) + { + /* Other packed type. */ + long msb, lsb; + + bfd_sym_fetch_long (buf, len, offset, &offset, &msb); + bfd_sym_fetch_long (buf, len, offset, &offset, &lsb); + /* fprintf (f, "\n "); */ + fprintf (f, " msb %ld, lsb %ld", msb, lsb); + } + + fprintf (f, "]"); + + if (offsetptr != NULL) + *offsetptr = offset; +} + +void +bfd_sym_print_type_information_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + bfd_sym_type_information_table_entry *entry; +{ + unsigned char *buf; + unsigned long offset; + unsigned int i; + + fprintf (f, "\"%.*s\" (NTE %lu), %lu bytes at %lu, logical size %lu", + bfd_sym_symbol_name (abfd, entry->nte_index)[0], + &bfd_sym_symbol_name (abfd, entry->nte_index)[1], + entry->nte_index, + entry->physical_size, entry->offset, entry->logical_size); + + fprintf (f, "\n "); + + buf = alloca (entry->physical_size); + if (buf == NULL) + { + fprintf (f, "[ERROR]\n"); + return; + } + if (bfd_seek (abfd, entry->offset, SEEK_SET) < 0) + { + fprintf (f, "[ERROR]\n"); + return; + } + if (bfd_bread (buf, entry->physical_size, abfd) != entry->physical_size) + { + fprintf (f, "[ERROR]\n"); + return; + } + + fprintf (f, "["); + for (i = 0; i < entry->physical_size; i++) + { + if (i == 0) + fprintf (f, "0x%02x", buf[i]); + else + fprintf (f, " 0x%02x", buf[i]); + } + + fprintf (f, "]"); + fprintf (f, "\n "); + + bfd_sym_print_type_information (abfd, f, buf, entry->physical_size, 0, &offset); + + if (offset != entry->physical_size) + fprintf (f, "\n [parser used %lu bytes instead of %lu]", offset, entry->physical_size); } + +void +bfd_sym_print_file_references_index_table_entry (abfd, f, entry) + bfd *abfd ATTRIBUTE_UNUSED; + FILE *f; + bfd_sym_file_references_index_table_entry *entry ATTRIBUTE_UNUSED; +{ + fprintf (f, "[UNIMPLEMENTED]"); +} + +void +bfd_sym_print_constant_pool_entry (abfd, f, entry) + bfd *abfd ATTRIBUTE_UNUSED; + FILE *f; + bfd_sym_constant_pool_entry *entry ATTRIBUTE_UNUSED; +{ + fprintf (f, "[UNIMPLEMENTED]"); +} + +unsigned char * +bfd_sym_display_name_table_entry (abfd, f, entry) + bfd *abfd; + FILE *f; + unsigned char *entry; +{ + unsigned long index; + unsigned long offset; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + index = (entry - sdata->name_table) / 2; + + if ((sdata->version >= BFD_SYM_VERSION_3_4) && (entry[0] == 255) && (entry[1] == 0)) + { + unsigned short length = bfd_getb16 (entry + 2); + fprintf (f, "[%8lu] \"%.*s\"\n", index, length, entry + 4); + offset = 2 + length + 1; + } + else + { + if (! ((entry[0] == 0) || ((entry[0] == 1) && (entry[1] == '\0')))) + fprintf (f, "[%8lu] \"%.*s\"\n", index, entry[0], entry + 1); + + if (sdata->version >= BFD_SYM_VERSION_3_4) + offset = entry[0] + 2; + else + offset = entry[0] + 1; + } + + return (entry + offset + (offset % 2)); +} + +void +bfd_sym_display_name_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long name_table_len; + unsigned char *name_table, *name_table_end, *cur; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + name_table_len = sdata->header.dshb_nte.dti_page_count * sdata->header.dshb_page_size; + name_table = sdata->name_table; + name_table_end = name_table + name_table_len; + + fprintf (f, "name table (NTE) contains %lu bytes:\n\n", name_table_len); + + cur = name_table; + for (;;) + { + cur = bfd_sym_display_name_table_entry (abfd, f, cur); + if (cur >= name_table_end) + break; + } +} + +void +bfd_sym_display_resources_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_resources_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "resource table (RTE) contains %lu objects:\n\n", + sdata->header.dshb_rte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_rte.dti_object_count; i++) + { + if (bfd_sym_fetch_resources_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_resources_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_modules_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_modules_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "module table (MTE) contains %lu objects:\n\n", + sdata->header.dshb_mte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_mte.dti_object_count; i++) + { + if (bfd_sym_fetch_modules_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_modules_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_file_references_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_file_references_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "file reference table (FRTE) contains %lu objects:\n\n", + sdata->header.dshb_frte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_frte.dti_object_count; i++) + { + if (bfd_sym_fetch_file_references_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_file_references_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_contained_modules_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_contained_modules_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "contained modules table (CMTE) contains %lu objects:\n\n", + sdata->header.dshb_cmte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_cmte.dti_object_count; i++) + { + if (bfd_sym_fetch_contained_modules_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_contained_modules_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_contained_variables_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_contained_variables_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "contained variables table (CVTE) contains %lu objects:\n\n", + sdata->header.dshb_cvte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_cvte.dti_object_count; i++) + { + if (bfd_sym_fetch_contained_variables_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_contained_variables_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } + + fprintf (f, "\n"); +} + +void +bfd_sym_display_contained_statements_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_contained_statements_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "contained statements table (CSNTE) contains %lu objects:\n\n", + sdata->header.dshb_csnte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_csnte.dti_object_count; i++) + { + if (bfd_sym_fetch_contained_statements_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_contained_statements_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_contained_labels_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_contained_labels_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "contained labels table (CLTE) contains %lu objects:\n\n", + sdata->header.dshb_clte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_clte.dti_object_count; i++) + { + if (bfd_sym_fetch_contained_labels_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_contained_labels_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_contained_types_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_contained_types_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "contained types table (CTTE) contains %lu objects:\n\n", + sdata->header.dshb_ctte.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_ctte.dti_object_count; i++) + { + if (bfd_sym_fetch_contained_types_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_contained_types_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_file_references_index_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_file_references_index_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "file references index table (FITE) contains %lu objects:\n\n", + sdata->header.dshb_fite.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_fite.dti_object_count; i++) + { + if (bfd_sym_fetch_file_references_index_table_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_file_references_index_table_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_constant_pool (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_constant_pool_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + fprintf (f, "constant pool (CONST) contains %lu objects:\n\n", + sdata->header.dshb_const.dti_object_count); + + for (i = 1; i <= sdata->header.dshb_const.dti_object_count; i++) + { + if (bfd_sym_fetch_constant_pool_entry (abfd, &entry, i) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] ", i); + bfd_sym_print_constant_pool_entry (abfd, f, &entry); + fprintf (f, "\n"); + } + } +} + +void +bfd_sym_display_type_information_table (abfd, f) + bfd *abfd; + FILE *f; +{ + unsigned long i; + bfd_sym_type_table_entry index; + bfd_sym_type_information_table_entry entry; + bfd_sym_data_struct *sdata = NULL; + + BFD_ASSERT (bfd_sym_valid (abfd)); + sdata = abfd->tdata.sym_data; + + if (sdata->header.dshb_tte.dti_object_count > 99) + fprintf (f, "type table (TINFO) contains %lu objects:\n\n", + sdata->header.dshb_tte.dti_object_count - 99); + else + { + fprintf (f, "type table (TINFO) contains [INVALID] objects:\n\n"); + return; + } + + for (i = 100; i <= sdata->header.dshb_tte.dti_object_count; i++) + { + if (bfd_sym_fetch_type_table_entry (abfd, &index, i - 100) < 0) + fprintf (f, " [%8lu] [INVALID]\n", i); + else + { + fprintf (f, " [%8lu] (TINFO %lu) ", i, index); + + if (bfd_sym_fetch_type_information_table_entry (abfd, &entry, index) < 0) + fprintf (f, "[INVALID]"); + else + bfd_sym_print_type_information_table_entry (abfd, f, &entry); + + fprintf (f, "\n"); + } + } +} + +const bfd_target * +bfd_sym_object_p (abfd) + bfd *abfd; +{ + bfd_sym_data_struct *mdata = NULL; + asection *bfdsec; + const char *name = "symbols"; + + mdata = ((bfd_sym_data_struct *) + bfd_alloc (abfd, sizeof (bfd_sym_data_struct))); + if (mdata == NULL) + return NULL; + + abfd->tdata.sym_data = mdata; + + mdata->name_table = 0; + mdata->sbfd = abfd; + + bfd_seek (abfd, 0, SEEK_SET); + if (bfd_sym_read_version (abfd, &mdata->version) != 0) + { + abfd->tdata.sym_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + bfd_seek (abfd, 0, SEEK_SET); + if (bfd_sym_read_header (abfd, &mdata->header, mdata->version) != 0) + { + abfd->tdata.sym_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + mdata->name_table = bfd_sym_read_name_table (abfd, &mdata->header); + if (mdata->name_table == NULL) + { + abfd->tdata.sym_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + bfdsec = bfd_make_section_anyway (abfd, name); + if (bfdsec == NULL) + { + abfd->tdata.sym_data = NULL; + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + bfdsec->vma = 0; + bfdsec->lma = 0; + bfdsec->_raw_size = 0; + bfdsec->filepos = 0; + bfdsec->alignment_power = 0; + + bfdsec->flags = SEC_HAS_CONTENTS; + + return abfd->xvec; +} + +asymbol * +bfd_sym_make_empty_symbol (abfd) + bfd *abfd; +{ + return (asymbol *) bfd_alloc (abfd, sizeof (asymbol)); +} + +void +bfd_sym_get_symbol_info (abfd, symbol, ret) + bfd *abfd ATTRIBUTE_UNUSED; + asymbol *symbol; + symbol_info *ret; +{ + bfd_symbol_info (symbol, ret); +} + +long +bfd_sym_get_symtab_upper_bound (abfd) + bfd *abfd ATTRIBUTE_UNUSED; +{ + return 0; +} + +long +bfd_sym_get_symtab (abfd, sym) + bfd *abfd ATTRIBUTE_UNUSED; + asymbol **sym ATTRIBUTE_UNUSED; +{ + return 0; +} + +int +bfd_sym_sizeof_headers (abfd, exec) + bfd *abfd ATTRIBUTE_UNUSED; + boolean exec ATTRIBUTE_UNUSED; +{ + return 0; +} + +const bfd_target sym_vec = +{ + "sym", /* name */ + bfd_target_sym_flavour, /* flavour */ + BFD_ENDIAN_BIG, /* byteorder */ + BFD_ENDIAN_BIG, /* header_byteorder */ + (HAS_RELOC | EXEC_P | /* object flags */ + HAS_LINENO | HAS_DEBUG | + HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED), + (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE | SEC_DATA + | SEC_ROM | SEC_HAS_CONTENTS), /* section_flags */ + 0, /* symbol_leading_char */ + ' ', /* ar_pad_char */ + 16, /* ar_max_namelen */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ + bfd_getb64, bfd_getb_signed_64, bfd_putb64, + bfd_getb32, bfd_getb_signed_32, bfd_putb32, + bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ + { /* bfd_check_format */ + _bfd_dummy_target, + bfd_sym_object_p, /* bfd_check_format */ + _bfd_dummy_target, + _bfd_dummy_target, + }, + { /* bfd_set_format */ + bfd_false, + bfd_sym_mkobject, + bfd_false, + bfd_false, + }, + { /* bfd_write_contents */ + bfd_false, + bfd_true, + bfd_false, + bfd_false, + }, + + BFD_JUMP_TABLE_GENERIC (bfd_sym), + BFD_JUMP_TABLE_COPY (_bfd_generic), + BFD_JUMP_TABLE_CORE (_bfd_nocore), + BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), + BFD_JUMP_TABLE_SYMBOLS (bfd_sym), + BFD_JUMP_TABLE_RELOCS (bfd_sym), + BFD_JUMP_TABLE_WRITE (bfd_sym), + BFD_JUMP_TABLE_LINK (bfd_sym), + BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), + + NULL, + + NULL +}; + diff --git a/bfd/xsym.h b/bfd/xsym.h new file mode 100644 index 0000000..388da85 --- /dev/null +++ b/bfd/xsym.h @@ -0,0 +1,699 @@ +/* xSYM symbol-file support for BFD. + Copyright 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#include "bfd.h" +#include <stdio.h> + +#ifndef __xSYM_H__ +#define __xSYM_H__ + +#define BFD_SYM_VERSION_STR_3_1 "\013Version 3.1" +#define BFD_SYM_VERSION_STR_3_2 "\013Version 3.2" +#define BFD_SYM_VERSION_STR_3_3 "\013Version 3.3" +#define BFD_SYM_VERSION_STR_3_4 "\013Version 3.4" +#define BFD_SYM_VERSION_STR_3_5 "\013Version 3.5" +#define BFD_SYM_END_OF_LIST_3_2 0xffff +#define BFD_SYM_END_OF_LIST_3_4 0xffffffff +#define BFD_SYM_END_OF_LIST BFD_SYM_END_OF_LIST_3_4 +#define BFD_SYM_FILE_NAME_INDEX_3_2 0xfffe +#define BFD_SYM_FILE_NAME_INDEX_3_4 0xfffffffe +#define BFD_SYM_FILE_NAME_INDEX BFD_SYM_FILE_NAME_INDEX_3_4 +#define BFD_SYM_SOURCE_FILE_CHANGE_3_2 0xfffe +#define BFD_SYM_SOURCE_FILE_CHANGE_3_4 0xfffffffe +#define BFD_SYM_SOURCE_FILE_CHANGE BFD_SYM_SOURCE_FILE_CHANGE_3_4 +#define BFD_SYM_MAXIMUM_LEGAL_INDEX_3_2 0xfffd +#define BFD_SYM_MAXIMUM_LEGAL_INDEX_3_4 0xfffffffd +#define BFD_SYM_MAXIMUM_LEGAL_INDEX BFD_SYM_MAXIMUM_LEGAL_INDEX_3_4 + +enum bfd_sym_storage_class +{ + BFD_SYM_STORAGE_CLASS_REGISTER = 0, + BFD_SYM_STORAGE_CLASS_GLOBAL = 1, + BFD_SYM_STORAGE_CLASS_FRAME_RELATIVE = 2, + BFD_SYM_STORAGE_CLASS_STACK_RELATIVE = 3, + BFD_SYM_STORAGE_CLASS_ABSOLUTE = 4, + BFD_SYM_STORAGE_CLASS_CONSTANT = 5, + BFD_SYM_STORAGE_CLASS_BIGCONSTANT = 6, + BFD_SYM_STORAGE_CLASS_RESOURCE = 99 +}; +typedef enum bfd_sym_storage_class bfd_sym_storage_class; + +enum bfd_sym_storage_kind +{ + BFD_SYM_STORAGE_KIND_LOCAL = 0, + BFD_SYM_STORAGE_KIND_VALUE = 1, + BFD_SYM_STORAGE_KIND_REFERENCE = 2, + BFD_SYM_STORAGE_KIND_WITH = 3 +}; +typedef enum bfd_sym_storage_kind bfd_sym_storage_kind; + +enum bfd_sym_version +{ + BFD_SYM_VERSION_3_1, + BFD_SYM_VERSION_3_2, + BFD_SYM_VERSION_3_3, + BFD_SYM_VERSION_3_4, + BFD_SYM_VERSION_3_5 +}; +typedef enum bfd_sym_version bfd_sym_version; + +enum bfd_sym_module_kind +{ + BFD_SYM_MODULE_KIND_NONE = 0, + BFD_SYM_MODULE_KIND_PROGRAM = 1, + BFD_SYM_MODULE_KIND_UNIT = 2, + BFD_SYM_MODULE_KIND_PROCEDURE = 3, + BFD_SYM_MODULE_KIND_FUNCTION = 4, + BFD_SYM_MODULE_KIND_DATA = 5, + BFD_SYM_MODULE_KIND_BLOCK = 6 +}; +typedef enum bfd_sym_module_kind bfd_sym_module_kind; + +enum bfd_sym_symbol_scope +{ + BFD_SYM_SYMBOL_SCOPE_LOCAL = 0, /* Object is seen only inside current scope. */ + BFD_SYM_SYMBOL_SCOPE_GLOBAL = 1 /* Object has global scope. */ +}; +typedef enum bfd_sym_symbol_scope bfd_sym_symbol_scope; + +struct bfd_sym_file_reference +{ + unsigned long fref_frte_index; /* File reference table index. */ + unsigned long fref_offset; /* Absolute offset into source file. */ +}; +typedef struct bfd_sym_file_reference bfd_sym_file_reference; + +/* NAME TABLE (NTE). */ + +/* RESOURCES TABLE (RTE) + + All code and data is *defined* to reside in a resource. Even A5 + relative data is defined to reside in a dummy resource of ResType + 'gbld'. Code always resides in a resource. Because a code/data + is built of many modules, when walking through a resource we must + point back to the modules in the order they were defined. This is + done by requiring the entries in the Modules Entry table to be + ordered by resource/resource-number and by the location in that + resource. Hence, the resource table entry points to the first + module making up that resource. All modules table entries following + that first one with the same restype/resnum are contiguous and offset + from that first entry. */ + +struct bfd_sym_resources_table_entry +{ + unsigned char rte_res_type[4]; /* Resource Type. */ + unsigned short rte_res_number; /* Resource Number. */ + unsigned long rte_nte_index; /* Name of the resource. */ + unsigned long rte_mte_first; /* Index of first module in the resource. */ + unsigned long rte_mte_last; /* Index of the last module in the resource. */ + unsigned long rte_res_size; /* Size of the resource. */ +}; +typedef struct bfd_sym_resources_table_entry bfd_sym_resources_table_entry; + +/* MODULES TABLE (MTE) + + Modules table entries are ordered by their appearance in a resource. + (Note that having a single module copied into two resources is not + possible). Modules map back to their resource via an index into the + resource table and an offset into the resource. Modules also point + to their source files, both the definition module and implemention + module. Because modules can be textually nested within other + modules, a link to the parent (containing) module is required. This + module can textually contain other modules. A link to the contiguous + list of child (contained) modules is required. Variables, statements, + and types defined in the module are pointed to by indexing the head of + the contiguous lists of contained variables, contained statements, + and contained types. */ + +struct bfd_sym_modules_table_entry +{ + unsigned long mte_rte_index; /* Which resource it is in. */ + unsigned long mte_res_offset; /* Offset into the resource. */ + unsigned long mte_size; /* Size of module. */ + char mte_kind; /* What kind of module this is. */ + char mte_scope; /* How visible is it? */ + unsigned long mte_parent; /* Containing module. */ + bfd_sym_file_reference mte_imp_fref; /* Implementation source. */ + unsigned long mte_imp_end; /* End of implementation source. */ + unsigned long mte_nte_index; /* The name of the module. */ + unsigned long mte_cmte_index; /* Modules contained in this. */ + unsigned long mte_cvte_index; /* Variables contained in this. */ + unsigned long mte_clte_index; /* Local labels defined here. */ + unsigned long mte_ctte_index; /* Types contained in this. */ + unsigned long mte_csnte_idx_1; /* CSNTE index of mte_snbr_first. */ + unsigned long mte_csnte_idx_2; /* CSNTE index of mte_snbr_last. */ +}; +typedef struct bfd_sym_modules_table_entry bfd_sym_modules_table_entry; + +/* FILE REFERENCES TABLE (FRTE) + + The FILE REFERENCES TABLE maps from source file to module & offset. + The table is ordered by increasing file offset. Each new offset + references a module. + + FRT = FILE_SOURCE_START + FILE_SOURCE_INCREMENT* + END_OF_LIST. + + *** THIS MECHANISM IS VERY SLOW FOR FILE+STATEMENT_NUMBER TO + *** MODULE/CODE ADDRESS OPERATIONS. ANOTHER MECHANISM IS + *** REQUIRED!! */ + +union bfd_sym_file_references_table_entry +{ + struct + { + /* END_OF_LIST, FILE_NAME_INDEX, or module table entry. */ + unsigned long type; + } + generic; + + struct + { + /* FILE_NAME_INDEX. */ + unsigned long type; + unsigned long nte_index; + unsigned long mod_date; + } + filename; + + struct + { + /* < FILE_NAME_INDEX. */ + unsigned long mte_index; + unsigned long file_offset; + } + entry; +}; +typedef union bfd_sym_file_references_table_entry bfd_sym_file_references_table_entry; + +/* CONTAINED MODULES TABLE (CMTE) + + Contained Modules are lists of indices into the modules table. The + lists are terminated by an END_OF_LIST index. All entries are of the + same size, hence mapping an index into a CMTE list is simple. + + CMT = MTE_INDEX* END_OF_LIST. */ + +union bfd_sym_contained_modules_table_entry +{ + struct + { + /* END_OF_LIST, index. */ + unsigned long type; + } + generic; + + struct + { + unsigned long mte_index; /* Index into the Modules Table. */ + unsigned long nte_index; /* The name of the module. */ + } + entry; +}; +typedef union bfd_sym_contained_modules_table_entry bfd_sym_contained_modules_table_entry; + +/* CONTAINED VARIABLES TABLE (CVTE) + + Contained Variables map into the module table, file table, name table, and type + table. Contained Variables are a contiguous list of source file change record, + giving the name of and offset into the source file corresponding to all variables + following. Variable definition records contain an index into the name table (giving + the text of the variable as it appears in the source code), an index into the type + table giving the type of the variable, an increment added to the source file + offset giving the start of the implementation of the variable, and a storage + class address, giving information on variable's runtime address. + + CVT = SOURCE_FILE_CHANGE SYMBOL_INFO* END_OF_LIST. + SYMBOL_INFO = SYMBOL_DEFINITION | SOURCE_FILE_CHANGE . + + All entries are of the same size, making the fetching of data simple. The + variable entries in the list are in ALPHABETICAL ORDER to simplify the display of + available variables for several of the debugger's windows. */ + +/* 'la_size' determines the variant used below: + + == BFD_SYM_CVTE_SCA + Traditional STORAGE_CLASS_ADDRESS; + + <= BFD_SYM_CVTE_LA_MAX_SIZE + That many logical address bytes ("in-situ"); + + == BFD_SYM_CVTE_BIG_LA + Logical address bytes in constant pool, at offset 'big_la'. */ + +#define BFD_SYM_CVTE_SCA 0 /* Indicate SCA variant of CVTE. */ +#define BFD_SYM_CVTE_LA_MAX_SIZE 13 /* Max# of logical address bytes in a CVTE. */ +#define BFD_SYM_CVTE_BIG_LA 127 /* Indicates LA redirection to constant pool. */ + +union bfd_sym_contained_variables_table_entry +{ + struct + { + /* END_OF_LIST, SOURCE_FILE_CHANGE, or type table entry. */ + unsigned long type; + } + generic; + + struct + { + /* SOURCE_FILE_CHANGE. */ + unsigned long type; + bfd_sym_file_reference fref; + } + file; + + struct + { + /* < SOURCE_FILE_CHANGE. */ + unsigned long tte_index; + unsigned long nte_index; + unsigned long file_delta; /* Increment from previous source. */ + unsigned char scope; + unsigned char la_size; /* #bytes of LAs below. */ + + union + { + /* la_size == BFD_SYM_CVTE_SCA. */ + struct + { + unsigned char sca_kind; /* Distinguish local from value/var formal. */ + unsigned char sca_class; /* The storage class itself. */ + unsigned long sca_offset; + } + scstruct; + + /* la_size <= BFD_SYM_CVTE_LA_MAX_SIZE. */ + struct { + unsigned char la[BFD_SYM_CVTE_LA_MAX_SIZE]; /* Logical address bytes. */ + unsigned char la_kind; /* Eqv. cvte_location.sca_kind. */ + } + lastruct; + + /* la_size == BFD_SYM_CVTE_BIG_LA 127. */ + struct + { + unsigned long big_la; /* Logical address bytes in constant pool. */ + unsigned char big_la_kind; /* Eqv. cvte_location.sca_kind. */ + } + biglastruct; + } + address; + } + entry; +}; +typedef union bfd_sym_contained_variables_table_entry bfd_sym_contained_variables_table_entry; + +/* CONTAINED STATEMENTS TABLE (CSNTE) + + Contained Statements table. This table is similar to the Contained + Variables table except that instead of VARIABLE_DEFINITION entries, this + module contains STATEMENT_NUMBER_DEFINITION entries. A statement number + definition points back to the containing module (via an index into + the module entry table) and contains the file and resource deltas + to add to the previous values to get to this statement. + All entries are of the same size, making the fetching of data simple. The + entries in the table are in order of increasing statement number within the + source file. + + The Contained Statements table is indexed from two places. An MTE contains + an index to the first statement number within the module. An FRTE contains + an index to the first statement in the table (Possibly. This is slow.) Or + a table of fast statement number to CSNTE entry mappings indexes into the + table. Choice not yet made. */ + +union bfd_sym_contained_statements_table_entry +{ + struct + { + /* END_OF_LIST, SOURCE_FILE_CHANGE, or statement table entry. */ + unsigned long type; + } + generic; + + struct + { + /* SOURCE_FILE_CHANGE. */ + unsigned long type; + bfd_sym_file_reference fref; /* File name table. */ + } + file; + + struct + { + unsigned long mte_index; /* Which module contains it. */ + unsigned long file_delta; /* Where it is defined. */ + unsigned long mte_offset; /* Where it is in the module. */ + } + entry; +}; +typedef union bfd_sym_contained_statements_table_entry bfd_sym_contained_statements_table_entry; + +/* CONTAINED LABELS TABLE (CLTE) + + Contained Labels table names those labels local to the module. It is similar + to the Contained Statements table. */ + +union bfd_sym_contained_labels_table_entry +{ + struct + { + /* END_OF_LIST, SOURCE_FILE_CHANGE, index. */ + unsigned long type; + } + generic; + + struct + { + /* SOURCE_FILE_CHANGE. */ + unsigned long type; + bfd_sym_file_reference fref; + } + file; + + struct + { + /* < SOURCE_FILE_CHANGE. */ + unsigned long mte_index; /* Which module contains us. */ + unsigned long mte_offset; /* Where it is in the module. */ + unsigned long nte_index; /* The name of the label. */ + unsigned long file_delta; /* Where it is defined. */ + unsigned short scope; /* How visible the label is. */ + } + entry; +}; +typedef union bfd_sym_contained_labels_table_entry bfd_sym_contained_labels_table_entry; + +/* CONTAINED TYPES TABLE (CTTE) + + Contained Types define the named types that are in the module. It is used to + map name indices into type indices. The type entries in the table are in + alphabetical order by type name. */ + +union bfd_sym_contained_types_table_entry +{ + struct + { + /* END_OF_LIST, SOURCE_FILE_CHANGE, or type table entry. */ + unsigned long type; + } + generic; + + struct + { + /* SOURCE_FILE_CHANGE. */ + unsigned long type; + bfd_sym_file_reference fref; + } + file; + + struct + { + /* < SOURCE_FILE_CHANGE. */ + unsigned long tte_index; + unsigned long nte_index; + unsigned long file_delta; /* From last file definition. */ + } + entry; +}; +typedef union bfd_sym_contained_types_table_entry bfd_sym_contained_types_table_entry; + +/* TYPE TABLE (TTE). */ + +typedef unsigned long bfd_sym_type_table_entry; + +/* TYPE INFORMATION TABLE (TINFO). */ + +struct bfd_sym_type_information_table_entry +{ + unsigned long nte_index; + unsigned long physical_size; + unsigned long logical_size; + unsigned long offset; +}; +typedef struct bfd_sym_type_information_table_entry bfd_sym_type_information_table_entry; + +/* FILE REFERENCES INDEX TABLE (FITE) + + The FRTE INDEX TABLE indexes into the FILE REFERENCE TABLE above. The FRTE + at that index is the FILE_SOURCE_START for a series of files. The FRTEs are + indexed from 1. The list is terminated with an END_OF_LIST. */ + +union bfd_sym_file_references_index_table_entry +{ + struct + { + unsigned long type; + } + generic; + + struct + { + unsigned long frte_index; /* Index into the FRTE table. */ + unsigned long nte_index; /* Name table index, gives filename. */ + } + entry; +}; +typedef union bfd_sym_file_references_index_table_entry bfd_sym_file_references_index_table_entry; + +/* CONSTANT POOL (CONST) + + The CONSTANT_POOL consists of entries that start on word boundaries. The entries + are referenced by byte index into the constant pool, not by record number. + + Each entry takes the form: + + <16-bit size> + <that many bytes of stuff> + + Entries do not cross page boundaries. */ + +typedef short bfd_sym_constant_pool_entry; + +/* The DISK_SYMBOL_HEADER_BLOCK is the first record in a .SYM file, + defining the physical characteristics of the symbolic information. + The remainder of the * .SYM file is stored in fixed block + allocations. For the purposes of paging, the * file is considered + to be an array of dshb_page_size blocks, with block 0 (and * + possibly more) devoted to the DISK_SYMBOL_HEADER_BLOCK. + + The dti_object_count field means that the allowed indices for that + type of object are 0 .. dti_object_count. An index of 0, although + allowed, is never done. However, an 0th entry is created in the + table. That entry is filled with all zeroes. The reason for this + is to avoid off-by-one programming errors that would otherwise + occur: an index of k *MEANS* k, not k-1 when going to the disk + table. */ + +struct bfd_sym_table_info +{ + unsigned long dti_first_page; /* First page for this table. */ + unsigned long dti_page_count; /* Number of pages for the table. */ + unsigned long dti_object_count; /* Number of objects in the table. */ +}; +typedef struct bfd_sym_table_info bfd_sym_table_info; + +struct bfd_sym_header_block +{ + unsigned char dshb_id[32]; /* Version information. */ + unsigned short dshb_page_size; /* Size of the pages/blocks. */ + unsigned long dshb_hash_page; /* Disk page for the hash table. */ + unsigned long dshb_root_mte; /* MTE index of the program root. */ + unsigned long dshb_mod_date; /* modification date of executable. */ + bfd_sym_table_info dshb_frte; /* Per TABLE information. */ + bfd_sym_table_info dshb_rte; + bfd_sym_table_info dshb_mte; + bfd_sym_table_info dshb_cmte; + bfd_sym_table_info dshb_cvte; + bfd_sym_table_info dshb_csnte; + bfd_sym_table_info dshb_clte; + bfd_sym_table_info dshb_ctte; + bfd_sym_table_info dshb_tte; + bfd_sym_table_info dshb_nte; + bfd_sym_table_info dshb_tinfo; + bfd_sym_table_info dshb_fite; /* File information. */ + bfd_sym_table_info dshb_const; /* Constant pool. */ + + unsigned char dshb_file_creator[4]; /* Executable's creator. */ + unsigned char dshb_file_type[4]; /* Executable's file type. */ +}; +typedef struct bfd_sym_header_block bfd_sym_header_block; + +struct bfd_sym_data_struct +{ + unsigned char *name_table; + bfd_sym_header_block header; + bfd_sym_version version; + bfd *sbfd; +}; +typedef struct bfd_sym_data_struct bfd_sym_data_struct; + +extern boolean bfd_sym_mkobject + PARAMS ((bfd *)); +extern void bfd_sym_print_symbol + PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type)); +extern boolean bfd_sym_valid + PARAMS ((bfd *)); +extern unsigned char * bfd_sym_read_name_table + PARAMS ((bfd *, bfd_sym_header_block *)); +extern void bfd_sym_parse_file_reference_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_file_reference *)); +extern void bfd_sym_parse_disk_table_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_table_info *)); +extern void bfd_sym_parse_header_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_header_block *)); +extern int bfd_sym_read_header_v32 + PARAMS ((bfd *, bfd_sym_header_block *)); +extern int bfd_sym_read_header_v34 + PARAMS ((bfd *, bfd_sym_header_block *)); +extern int bfd_sym_read_header + PARAMS ((bfd *, bfd_sym_header_block *, bfd_sym_version)); +extern int bfd_sym_read_version + PARAMS ((bfd *, bfd_sym_version *)); +extern void bfd_sym_display_table_summary + PARAMS ((FILE *, bfd_sym_table_info *, const char *)); +extern void bfd_sym_display_header + PARAMS ((FILE *, bfd_sym_header_block *)); +extern void bfd_sym_parse_resources_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_resources_table_entry *)); +extern void bfd_sym_parse_modules_table_entry_v33 + PARAMS ((unsigned char *, size_t, bfd_sym_modules_table_entry *)); +extern void bfd_sym_parse_file_references_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_file_references_table_entry *)); +extern void bfd_sym_parse_contained_modules_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_contained_modules_table_entry *)); +extern void bfd_sym_parse_contained_variables_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_contained_variables_table_entry *)); +extern void bfd_sym_parse_contained_statements_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_contained_statements_table_entry *)); +extern void bfd_sym_parse_contained_labels_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_contained_labels_table_entry *)); +extern void bfd_sym_parse_type_table_entry_v32 + PARAMS ((unsigned char *, size_t, bfd_sym_type_table_entry *)); +extern int bfd_sym_fetch_resources_table_entry + PARAMS ((bfd *, bfd_sym_resources_table_entry *, unsigned long)); +extern int bfd_sym_fetch_modules_table_entry + PARAMS ((bfd *, bfd_sym_modules_table_entry *, unsigned long)); +extern int bfd_sym_fetch_file_references_table_entry + PARAMS ((bfd *, bfd_sym_file_references_table_entry *, unsigned long)); +extern int bfd_sym_fetch_contained_modules_table_entry + PARAMS ((bfd *, bfd_sym_contained_modules_table_entry *, unsigned long)); +extern int bfd_sym_fetch_contained_variables_table_entry + PARAMS ((bfd *, bfd_sym_contained_variables_table_entry *, unsigned long)); +extern int bfd_sym_fetch_contained_statements_table_entry + PARAMS ((bfd *, bfd_sym_contained_statements_table_entry *, unsigned long)); +extern int bfd_sym_fetch_contained_labels_table_entry + PARAMS ((bfd *, bfd_sym_contained_labels_table_entry *, unsigned long)); +extern int bfd_sym_fetch_contained_types_table_entry + PARAMS ((bfd *, bfd_sym_contained_types_table_entry *, unsigned long)); +extern int bfd_sym_fetch_file_references_index_table_entry + PARAMS ((bfd *, bfd_sym_file_references_index_table_entry *, unsigned long)); +extern int bfd_sym_fetch_constant_pool_entry + PARAMS ((bfd *, bfd_sym_constant_pool_entry *, unsigned long)); +extern int bfd_sym_fetch_type_table_entry + PARAMS ((bfd *, bfd_sym_type_table_entry *, unsigned long)); +extern int bfd_sym_fetch_type_information_table_entry + PARAMS ((bfd *, bfd_sym_type_information_table_entry *, unsigned long)); +extern int bfd_sym_fetch_type_table_information + PARAMS ((bfd *, bfd_sym_type_information_table_entry *, unsigned long)); +extern const unsigned char * bfd_sym_symbol_name + PARAMS ((bfd *, unsigned long)); +extern const unsigned char * bfd_sym_module_name + PARAMS ((bfd *, unsigned long)); +extern const char * bfd_sym_unparse_storage_kind + PARAMS ((enum bfd_sym_storage_kind)); +extern const char * bfd_sym_unparse_storage_class + PARAMS ((enum bfd_sym_storage_class)); +extern const char * bfd_sym_unparse_module_kind + PARAMS ((enum bfd_sym_module_kind)); +extern const char * bfd_sym_unparse_symbol_scope + PARAMS ((enum bfd_sym_symbol_scope)); +extern void bfd_sym_print_file_reference + PARAMS ((bfd *, FILE *, bfd_sym_file_reference *)); +extern void bfd_sym_print_resources_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_resources_table_entry *)); +extern void bfd_sym_print_modules_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_modules_table_entry *)); +extern void bfd_sym_print_file_references_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_file_references_table_entry *)); +extern void bfd_sym_print_contained_modules_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_contained_modules_table_entry *)); +extern void bfd_sym_print_contained_variables_table_entry + PARAMS ((bfd *, FILE *f, bfd_sym_contained_variables_table_entry *)); +extern void bfd_sym_print_contained_statements_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_contained_statements_table_entry *)); +extern void bfd_sym_print_contained_labels_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_contained_labels_table_entry *)); +extern void bfd_sym_print_contained_types_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_contained_types_table_entry *)); +extern const char * bfd_sym_type_operator_name + PARAMS ((unsigned char)); +extern const char * bfd_sym_type_basic_name + PARAMS ((unsigned char)); +extern int bfd_sym_fetch_long + PARAMS ((unsigned char *, unsigned long, unsigned long, unsigned long *, long *)); +extern void bfd_sym_print_type_information + PARAMS ((bfd *, FILE *, unsigned char *, unsigned long, unsigned long, unsigned long *)); +extern void bfd_sym_print_type_information_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_type_information_table_entry *)); +extern void bfd_sym_print_file_references_index_table_entry + PARAMS ((bfd *, FILE *, bfd_sym_file_references_index_table_entry *)); +extern void bfd_sym_print_constant_pool_entry + PARAMS ((bfd *, FILE *, bfd_sym_constant_pool_entry *)); +extern unsigned char * bfd_sym_display_name_table_entry + PARAMS ((bfd *, FILE *, unsigned char *)); +extern void bfd_sym_display_name_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_resources_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_modules_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_file_references_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_contained_modules_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_contained_variables_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_contained_statements_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_contained_labels_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_contained_types_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_file_references_index_table + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_constant_pool + PARAMS ((bfd *, FILE *)); +extern void bfd_sym_display_type_information_table + PARAMS ((bfd *, FILE *)); +extern const bfd_target * bfd_sym_object_p + PARAMS ((bfd *)); +extern asymbol * bfd_sym_make_empty_symbol + PARAMS ((bfd *)); +extern void bfd_sym_get_symbol_info + PARAMS ((bfd *, asymbol *, symbol_info *)); +extern long bfd_sym_get_symtab_upper_bound + PARAMS ((bfd *)); +extern long bfd_sym_get_symtab + PARAMS ((bfd *, asymbol **)); +extern int bfd_sym_sizeof_headers + PARAMS ((bfd *, boolean)); + +#endif /* __xSYM_H__ */ |