X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fpeicode.h;h=339925d94d40cd3b8c4398b507880b109c5b2f03;hb=53e09e0aaf3d13e4b893744e2fe79edde7edfd20;hp=79c427eceb8d0db58eec8d65854b1e2bf45c0279;hpb=b00c57ec37e4c971d96b40cf76ce21f8837b84a5;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/peicode.h b/bfd/peicode.h index 79c427eceb..339925d94d 100644 --- a/bfd/peicode.h +++ b/bfd/peicode.h @@ -1,1584 +1,1273 @@ -/* Support for the generic parts of most COFF variants, for BFD. - Copyright 1995 Free Software Foundation, Inc. - Written by Cygnus Support. +/* Support for the generic parts of PE/PEI, for BFD. + Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, + 2005 Free Software Foundation, Inc. + Written by Cygnus Solutions. -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 02110-1301, USA. */ -/* -Most of this hacked by Steve Chamberlain, +/* Most of this hacked by Steve Chamberlain, sac@cygnus.com -*/ + PE/PEI rearrangement (and code added): Donn Terry + Softway Systems, Inc. */ +/* Hey look, some documentation [and in a place you expect to find it]! -#define coff_bfd_print_private_bfd_data pe_print_private_bfd_data -#define coff_mkobject pe_mkobject -#define coff_mkobject_hook pe_mkobject_hook + The main reference for the pei format is "Microsoft Portable Executable + and Common Object File Format Specification 4.1". Get it if you need to + do some serious hacking on this code. -#ifndef GET_FCN_LNNOPTR -#define GET_FCN_LNNOPTR(abfd, ext) \ - bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr) -#endif + Another reference: + "Peering Inside the PE: A Tour of the Win32 Portable Executable + File Format", MSJ 1994, Volume 9. -#ifndef GET_FCN_ENDNDX -#define GET_FCN_ENDNDX(abfd, ext) \ - bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx) -#endif + The *sole* difference between the pe format and the pei format is that the + latter has an MSDOS 2.0 .exe header on the front that prints the message + "This app must be run under Windows." (or some such). + (FIXME: Whether that statement is *really* true or not is unknown. + Are there more subtle differences between pe and pei formats? + For now assume there aren't. If you find one, then for God sakes + document it here!) -#ifndef PUT_FCN_LNNOPTR -#define PUT_FCN_LNNOPTR(abfd, in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr) -#endif -#ifndef PUT_FCN_ENDNDX -#define PUT_FCN_ENDNDX(abfd, in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx) -#endif -#ifndef GET_LNSZ_LNNO -#define GET_LNSZ_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_lnno) -#endif -#ifndef GET_LNSZ_SIZE -#define GET_LNSZ_SIZE(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_misc.x_lnsz.x_size) -#endif -#ifndef PUT_LNSZ_LNNO -#define PUT_LNSZ_LNNO(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_sym.x_misc.x_lnsz.x_lnno) -#endif -#ifndef PUT_LNSZ_SIZE -#define PUT_LNSZ_SIZE(abfd, in, ext) bfd_h_put_16(abfd, in, (bfd_byte*) ext->x_sym.x_misc.x_lnsz.x_size) -#endif -#ifndef GET_SCN_SCNLEN -#define GET_SCN_SCNLEN(abfd, ext) bfd_h_get_32(abfd, (bfd_byte *) ext->x_scn.x_scnlen) -#endif -#ifndef GET_SCN_NRELOC -#define GET_SCN_NRELOC(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nreloc) -#endif -#ifndef GET_SCN_NLINNO -#define GET_SCN_NLINNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *)ext->x_scn.x_nlinno) -#endif -#ifndef PUT_SCN_SCNLEN -#define PUT_SCN_SCNLEN(abfd,in, ext) bfd_h_put_32(abfd, in, (bfd_byte *) ext->x_scn.x_scnlen) -#endif -#ifndef PUT_SCN_NRELOC -#define PUT_SCN_NRELOC(abfd,in, ext) bfd_h_put_16(abfd, in, (bfd_byte *)ext->x_scn.x_nreloc) -#endif -#ifndef PUT_SCN_NLINNO -#define PUT_SCN_NLINNO(abfd,in, ext) bfd_h_put_16(abfd,in, (bfd_byte *) ext->x_scn.x_nlinno) -#endif -#ifndef GET_LINENO_LNNO -#define GET_LINENO_LNNO(abfd, ext) bfd_h_get_16(abfd, (bfd_byte *) (ext->l_lnno)); -#endif -#ifndef PUT_LINENO_LNNO -#define PUT_LINENO_LNNO(abfd,val, ext) bfd_h_put_16(abfd,val, (bfd_byte *) (ext->l_lnno)); -#endif + The Microsoft docs use the word "image" instead of "executable" because + the former can also refer to a DLL (shared library). Confusion can arise + because the `i' in `pei' also refers to "image". The `pe' format can + also create images (i.e. executables), it's just that to run on a win32 + system you need to use the pei format. -/* The f_symptr field in the filehdr is sometimes 64 bits. */ -#ifndef GET_FILEHDR_SYMPTR -#define GET_FILEHDR_SYMPTR bfd_h_get_32 -#endif -#ifndef PUT_FILEHDR_SYMPTR -#define PUT_FILEHDR_SYMPTR bfd_h_put_32 -#endif + FIXME: Please add more docs here so the next poor fool that has to hack + on this code has a chance of getting something accomplished without + wasting too much time. */ -/* Some fields in the aouthdr are sometimes 64 bits. */ -#ifndef GET_AOUTHDR_TSIZE -#define GET_AOUTHDR_TSIZE bfd_h_get_32 -#endif -#ifndef PUT_AOUTHDR_TSIZE -#define PUT_AOUTHDR_TSIZE bfd_h_put_32 -#endif -#ifndef GET_AOUTHDR_DSIZE -#define GET_AOUTHDR_DSIZE bfd_h_get_32 -#endif -#ifndef PUT_AOUTHDR_DSIZE -#define PUT_AOUTHDR_DSIZE bfd_h_put_32 -#endif -#ifndef GET_AOUTHDR_BSIZE -#define GET_AOUTHDR_BSIZE bfd_h_get_32 -#endif -#ifndef PUT_AOUTHDR_BSIZE -#define PUT_AOUTHDR_BSIZE bfd_h_put_32 -#endif -#ifndef GET_AOUTHDR_ENTRY -#define GET_AOUTHDR_ENTRY bfd_h_get_32 -#endif -#ifndef PUT_AOUTHDR_ENTRY -#define PUT_AOUTHDR_ENTRY bfd_h_put_32 -#endif -#ifndef GET_AOUTHDR_TEXT_START -#define GET_AOUTHDR_TEXT_START bfd_h_get_32 -#endif -#ifndef PUT_AOUTHDR_TEXT_START -#define PUT_AOUTHDR_TEXT_START bfd_h_put_32 -#endif -#ifndef GET_AOUTHDR_DATA_START -#define GET_AOUTHDR_DATA_START bfd_h_get_32 -#endif -#ifndef PUT_AOUTHDR_DATA_START -#define PUT_AOUTHDR_DATA_START bfd_h_put_32 -#endif +#include "libpei.h" -/* Some fields in the scnhdr are sometimes 64 bits. */ -#ifndef GET_SCNHDR_PADDR -#define GET_SCNHDR_PADDR bfd_h_get_32 -#endif -#ifndef PUT_SCNHDR_PADDR -#define PUT_SCNHDR_PADDR bfd_h_put_32 -#endif -#ifndef GET_SCNHDR_VADDR -#define GET_SCNHDR_VADDR bfd_h_get_32 -#endif -#ifndef PUT_SCNHDR_VADDR -#define PUT_SCNHDR_VADDR bfd_h_put_32 -#endif -#ifndef GET_SCNHDR_SIZE -#define GET_SCNHDR_SIZE bfd_h_get_32 -#endif -#ifndef PUT_SCNHDR_SIZE -#define PUT_SCNHDR_SIZE bfd_h_put_32 -#endif -#ifndef GET_SCNHDR_SCNPTR -#define GET_SCNHDR_SCNPTR bfd_h_get_32 -#endif -#ifndef PUT_SCNHDR_SCNPTR -#define PUT_SCNHDR_SCNPTR bfd_h_put_32 -#endif -#ifndef GET_SCNHDR_RELPTR -#define GET_SCNHDR_RELPTR bfd_h_get_32 -#endif -#ifndef PUT_SCNHDR_RELPTR -#define PUT_SCNHDR_RELPTR bfd_h_put_32 -#endif -#ifndef GET_SCNHDR_LNNOPTR -#define GET_SCNHDR_LNNOPTR bfd_h_get_32 +static bfd_boolean (*pe_saved_coff_bfd_print_private_bfd_data) (bfd *, void *) = +#ifndef coff_bfd_print_private_bfd_data + NULL; +#else + coff_bfd_print_private_bfd_data; +#undef coff_bfd_print_private_bfd_data #endif -#ifndef PUT_SCNHDR_LNNOPTR -#define PUT_SCNHDR_LNNOPTR bfd_h_put_32 + +static bfd_boolean pe_print_private_bfd_data (bfd *, void *); +#define coff_bfd_print_private_bfd_data pe_print_private_bfd_data + +static bfd_boolean (*pe_saved_coff_bfd_copy_private_bfd_data) (bfd *, bfd *) = +#ifndef coff_bfd_copy_private_bfd_data + NULL; +#else + coff_bfd_copy_private_bfd_data; +#undef coff_bfd_copy_private_bfd_data #endif +static bfd_boolean pe_bfd_copy_private_bfd_data (bfd *, bfd *); +#define coff_bfd_copy_private_bfd_data pe_bfd_copy_private_bfd_data + +#define coff_mkobject pe_mkobject +#define coff_mkobject_hook pe_mkobject_hook + +#ifdef COFF_IMAGE_WITH_PE +/* This structure contains static variables used by the ILF code. */ +typedef asection * asection_ptr; + +typedef struct +{ + bfd * abfd; + bfd_byte * data; + struct bfd_in_memory * bim; + unsigned short magic; + + arelent * reltab; + unsigned int relcount; + + coff_symbol_type * sym_cache; + coff_symbol_type * sym_ptr; + unsigned int sym_index; + + unsigned int * sym_table; + unsigned int * table_ptr; + + combined_entry_type * native_syms; + combined_entry_type * native_ptr; + + coff_symbol_type ** sym_ptr_table; + coff_symbol_type ** sym_ptr_ptr; + unsigned int sec_index; -/**********************************************************************/ + char * string_table; + char * string_ptr; + char * end_string_ptr; + SYMENT * esym_table; + SYMENT * esym_ptr; + + struct internal_reloc * int_reltab; +} +pe_ILF_vars; +#endif /* COFF_IMAGE_WITH_PE */ + +#ifndef NO_COFF_RELOCS static void -coff_swap_reloc_in (abfd, src, dst) - bfd *abfd; - PTR src; - PTR dst; +coff_swap_reloc_in (bfd * abfd, void * src, void * dst) { RELOC *reloc_src = (RELOC *) src; struct internal_reloc *reloc_dst = (struct internal_reloc *) dst; - reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr); - reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx); - - reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type); - + reloc_dst->r_vaddr = H_GET_32 (abfd, reloc_src->r_vaddr); + reloc_dst->r_symndx = H_GET_S32 (abfd, reloc_src->r_symndx); + reloc_dst->r_type = H_GET_16 (abfd, reloc_src->r_type); #ifdef SWAP_IN_RELOC_OFFSET - reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd, - (bfd_byte *) reloc_src->r_offset); + reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET (abfd, reloc_src->r_offset); #endif } - static unsigned int -coff_swap_reloc_out (abfd, src, dst) - bfd *abfd; - PTR src; - PTR dst; +coff_swap_reloc_out (bfd * abfd, void * src, void * dst) { - struct internal_reloc *reloc_src = (struct internal_reloc *)src; - struct external_reloc *reloc_dst = (struct external_reloc *)dst; - bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr); - bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx); - - bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *) - reloc_dst->r_type); - -#ifdef SWAP_OUT_RELOC_OFFSET - SWAP_OUT_RELOC_OFFSET(abfd, - reloc_src->r_offset, - (bfd_byte *) reloc_dst->r_offset); + struct internal_reloc *reloc_src = (struct internal_reloc *) src; + struct external_reloc *reloc_dst = (struct external_reloc *) dst; + + H_PUT_32 (abfd, reloc_src->r_vaddr, reloc_dst->r_vaddr); + H_PUT_32 (abfd, reloc_src->r_symndx, reloc_dst->r_symndx); + H_PUT_16 (abfd, reloc_src->r_type, reloc_dst->r_type); + +#ifdef SWAP_OUT_RELOC_OFFSET + SWAP_OUT_RELOC_OFFSET (abfd, reloc_src->r_offset, reloc_dst->r_offset); #endif #ifdef SWAP_OUT_RELOC_EXTRA - SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst); + SWAP_OUT_RELOC_EXTRA (abfd, reloc_src, reloc_dst); #endif - return sizeof(struct external_reloc); + return RELSZ; } - +#endif /* not NO_COFF_RELOCS */ static void -coff_swap_filehdr_in (abfd, src, dst) - bfd *abfd; - PTR src; - PTR dst; +coff_swap_filehdr_in (bfd * abfd, void * src, void * dst) { FILHDR *filehdr_src = (FILHDR *) src; struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst; - filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic); - filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns); - filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat); - filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms); - filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags); - filehdr_dst->f_symptr = bfd_h_get_32 (abfd, (bfd_byte *) filehdr_src->f_symptr); + filehdr_dst->f_magic = H_GET_16 (abfd, filehdr_src->f_magic); + filehdr_dst->f_nscns = H_GET_16 (abfd, filehdr_src->f_nscns); + filehdr_dst->f_timdat = H_GET_32 (abfd, filehdr_src->f_timdat); + filehdr_dst->f_nsyms = H_GET_32 (abfd, filehdr_src->f_nsyms); + filehdr_dst->f_flags = H_GET_16 (abfd, filehdr_src->f_flags); + filehdr_dst->f_symptr = H_GET_32 (abfd, filehdr_src->f_symptr); - /* Other people's tools sometimes generate headers - with an nsyms but a zero symptr. */ - if (filehdr_dst->f_nsyms && filehdr_dst->f_symptr) + /* Other people's tools sometimes generate headers with an nsyms but + a zero symptr. */ + if (filehdr_dst->f_nsyms != 0 && filehdr_dst->f_symptr == 0) { - filehdr_dst->f_flags |= HAS_SYMS; - } - else - { - filehdr_dst->f_symptr = 0; filehdr_dst->f_nsyms = 0; - filehdr_dst->f_flags &= ~HAS_SYMS; + filehdr_dst->f_flags |= F_LSYMS; } - filehdr_dst->f_opthdr = bfd_h_get_16(abfd, - (bfd_byte *)filehdr_src-> f_opthdr); + filehdr_dst->f_opthdr = H_GET_16 (abfd, filehdr_src-> f_opthdr); } #ifdef COFF_IMAGE_WITH_PE - -static unsigned int -coff_swap_filehdr_out (abfd, in, out) - bfd *abfd; - PTR in; - PTR out; -{ - int idx; - struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in; - FILHDR *filehdr_out = (FILHDR *)out; - - if (pe_data (abfd)->has_reloc_section) - filehdr_in->f_flags &= ~F_RELFLG; - - if (pe_data (abfd)->dll) - filehdr_in->f_flags |= F_DLL; - - filehdr_in->pe.e_magic = DOSMAGIC; - filehdr_in->pe.e_cblp = 0x90; - filehdr_in->pe.e_cp = 0x3; - filehdr_in->pe.e_crlc = 0x0; - filehdr_in->pe.e_cparhdr = 0x4; - filehdr_in->pe.e_minalloc = 0x0; - filehdr_in->pe.e_maxalloc = 0xffff; - filehdr_in->pe.e_ss = 0x0; - filehdr_in->pe.e_sp = 0xb8; - filehdr_in->pe.e_csum = 0x0; - filehdr_in->pe.e_ip = 0x0; - filehdr_in->pe.e_cs = 0x0; - filehdr_in->pe.e_lfarlc = 0x40; - filehdr_in->pe.e_ovno = 0x0; - - for (idx=0; idx < 4; idx++) - filehdr_in->pe.e_res[idx] = 0x0; - - filehdr_in->pe.e_oemid = 0x0; - filehdr_in->pe.e_oeminfo = 0x0; - - for (idx=0; idx < 10; idx++) - filehdr_in->pe.e_res2[idx] = 0x0; - - filehdr_in->pe.e_lfanew = 0x80; - - /* this next collection of data are mostly just characters. It appears - to be constant within the headers put on NT exes */ - filehdr_in->pe.dos_message[0] = 0x0eba1f0e; - filehdr_in->pe.dos_message[1] = 0xcd09b400; - filehdr_in->pe.dos_message[2] = 0x4c01b821; - filehdr_in->pe.dos_message[3] = 0x685421cd; - filehdr_in->pe.dos_message[4] = 0x70207369; - filehdr_in->pe.dos_message[5] = 0x72676f72; - filehdr_in->pe.dos_message[6] = 0x63206d61; - filehdr_in->pe.dos_message[7] = 0x6f6e6e61; - filehdr_in->pe.dos_message[8] = 0x65622074; - filehdr_in->pe.dos_message[9] = 0x6e757220; - filehdr_in->pe.dos_message[10] = 0x206e6920; - filehdr_in->pe.dos_message[11] = 0x20534f44; - filehdr_in->pe.dos_message[12] = 0x65646f6d; - filehdr_in->pe.dos_message[13] = 0x0a0d0d2e; - filehdr_in->pe.dos_message[14] = 0x24; - filehdr_in->pe.dos_message[15] = 0x0; - filehdr_in->pe.nt_signature = NT_SIGNATURE; - - - - bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic); - bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns); - - bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat); - PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr, - (bfd_byte *) filehdr_out->f_symptr); - bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms); - bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr); - bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags); - - /* put in extra dos header stuff. This data remains essentially - constant, it just has to be tacked on to the beginning of all exes - for NT */ - bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic); - bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp); - bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp); - bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc); - bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr, - (bfd_byte *) filehdr_out->e_cparhdr); - bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc, - (bfd_byte *) filehdr_out->e_minalloc); - bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc, - (bfd_byte *) filehdr_out->e_maxalloc); - bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss); - bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp); - bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum); - bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip); - bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs); - bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc); - bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno); - { - int idx; - for (idx=0; idx < 4; idx++) - bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx], - (bfd_byte *) filehdr_out->e_res[idx]); - } - bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid); - bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo, - (bfd_byte *) filehdr_out->e_oeminfo); - { - int idx; - for (idx=0; idx < 10; idx++) - bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx], - (bfd_byte *) filehdr_out->e_res2[idx]); - } - bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew); - - { - int idx; - for (idx=0; idx < 16; idx++) - bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx], - (bfd_byte *) filehdr_out->dos_message[idx]); - } - - /* also put in the NT signature */ - bfd_h_put_32(abfd, filehdr_in->pe.nt_signature, - (bfd_byte *) filehdr_out->nt_signature); - - - - - return sizeof(FILHDR); -} +# define coff_swap_filehdr_out _bfd_XXi_only_swap_filehdr_out #else - -static unsigned int -coff_swap_filehdr_out (abfd, in, out) - bfd *abfd; - PTR in; - PTR out; -{ - struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in; - FILHDR *filehdr_out = (FILHDR *)out; - - bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic); - bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns); - bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat); - PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr, - (bfd_byte *) filehdr_out->f_symptr); - bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms); - bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr); - bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags); - - return sizeof(FILHDR); -} - +# define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out #endif - static void -coff_swap_sym_in (abfd, ext1, in1) - bfd *abfd; - PTR ext1; - PTR in1; +coff_swap_scnhdr_in (bfd * abfd, void * ext, void * in) { - SYMENT *ext = (SYMENT *)ext1; - struct internal_syment *in = (struct internal_syment *)in1; - - if( ext->e.e_name[0] == 0) { - in->_n._n_n._n_zeroes = 0; - in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset); - } - else { -#if SYMNMLEN != E_SYMNMLEN - -> Error, we need to cope with truncating or extending SYMNMLEN!; -#else - memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN); -#endif - } - - in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value); - in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum); - if (sizeof(ext->e_type) == 2){ - in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type); - } - else { - in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type); - } - in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass); - in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux); - - /* The section symbols for the .idata$ sections have class 68, which MS - documentation indicates is a section symbol. The problem is that the - value field in the symbol is simply a copy of the .idata section's flags - rather than something useful. When these symbols are encountered, change - the value to 0 and the section number to 1 so that they will be handled - somewhat correctly in the bfd code. */ - if (in->n_sclass == 0x68) { - in->n_value = 0x0; - in->n_scnum = 1; - /* I have tried setting the class to 3 and using the following to set - the section number. This will put the address of the pointer to the - string kernel32.dll at addresses 0 and 0x10 off start of idata section - which is not correct */ - /* if (strcmp (in->_n._n_name, ".idata$4") == 0) */ - /* in->n_scnum = 3; */ - /* else */ - /* in->n_scnum = 2; */ - } - -#ifdef coff_swap_sym_in_hook - coff_swap_sym_in_hook(abfd, ext1, in1); -#endif -} + SCNHDR *scnhdr_ext = (SCNHDR *) ext; + struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; -static unsigned int -coff_swap_sym_out (abfd, inp, extp) - bfd *abfd; - PTR inp; - PTR extp; -{ - struct internal_syment *in = (struct internal_syment *)inp; - SYMENT *ext =(SYMENT *)extp; - if(in->_n._n_name[0] == 0) { - bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes); - bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset); - } - else { -#if SYMNMLEN != E_SYMNMLEN - -> Error, we need to cope with truncating or extending SYMNMLEN!; + memcpy (scnhdr_int->s_name, scnhdr_ext->s_name, sizeof (scnhdr_int->s_name)); + + scnhdr_int->s_vaddr = GET_SCNHDR_VADDR (abfd, scnhdr_ext->s_vaddr); + scnhdr_int->s_paddr = GET_SCNHDR_PADDR (abfd, scnhdr_ext->s_paddr); + scnhdr_int->s_size = GET_SCNHDR_SIZE (abfd, scnhdr_ext->s_size); + scnhdr_int->s_scnptr = GET_SCNHDR_SCNPTR (abfd, scnhdr_ext->s_scnptr); + scnhdr_int->s_relptr = GET_SCNHDR_RELPTR (abfd, scnhdr_ext->s_relptr); + scnhdr_int->s_lnnoptr = GET_SCNHDR_LNNOPTR (abfd, scnhdr_ext->s_lnnoptr); + scnhdr_int->s_flags = H_GET_32 (abfd, scnhdr_ext->s_flags); + + /* MS handles overflow of line numbers by carrying into the reloc + field (it appears). Since it's supposed to be zero for PE + *IMAGE* format, that's safe. This is still a bit iffy. */ +#ifdef COFF_IMAGE_WITH_PE + scnhdr_int->s_nlnno = (H_GET_16 (abfd, scnhdr_ext->s_nlnno) + + (H_GET_16 (abfd, scnhdr_ext->s_nreloc) << 16)); + scnhdr_int->s_nreloc = 0; #else - memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN); + scnhdr_int->s_nreloc = H_GET_16 (abfd, scnhdr_ext->s_nreloc); + scnhdr_int->s_nlnno = H_GET_16 (abfd, scnhdr_ext->s_nlnno); #endif - } - bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value); - bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum); - if (sizeof(ext->e_type) == 2) + if (scnhdr_int->s_vaddr != 0) { - bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type); - } - else - { - bfd_h_put_32(abfd, in->n_type , (bfd_byte *) ext->e_type); + scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase; + scnhdr_int->s_vaddr &= 0xffffffff; } - bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass); - bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux); - return sizeof(SYMENT); +#ifndef COFF_NO_HACK_SCNHDR_SIZE + /* If this section holds uninitialized data and is from an object file + or from an executable image that has not initialized the field, + or if the image is an executable file and the physical size is padded, + use the virtual size (stored in s_paddr) instead. */ + if (scnhdr_int->s_paddr > 0 + && (((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0 + && (! bfd_pe_executable_p (abfd) || scnhdr_int->s_size == 0)) + || (bfd_pe_executable_p (abfd) && scnhdr_int->s_size > scnhdr_int->s_paddr))) + /* This code used to set scnhdr_int->s_paddr to 0. However, + coff_set_alignment_hook stores s_paddr in virt_size, which + only works if it correctly holds the virtual size of the + section. */ + scnhdr_int->s_size = scnhdr_int->s_paddr; +#endif } -static void -coff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1) - bfd *abfd; - PTR ext1; - int type; - int class; - int indx; - int numaux; - PTR in1; +static bfd_boolean +pe_mkobject (bfd * abfd) { - AUXENT *ext = (AUXENT *)ext1; - union internal_auxent *in = (union internal_auxent *)in1; - - switch (class) { - case C_FILE: - if (ext->x_file.x_fname[0] == 0) { - in->x_file.x_n.x_zeroes = 0; - in->x_file.x_n.x_offset = - bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset); - } else { -#if FILNMLEN != E_FILNMLEN - -> Error, we need to cope with truncating or extending FILNMLEN!; -#else - memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN); -#endif - } - return; + pe_data_type *pe; + bfd_size_type amt = sizeof (pe_data_type); + abfd->tdata.pe_obj_data = (struct pe_tdata *) bfd_zalloc (abfd, amt); - case C_STAT: -#ifdef C_LEAFSTAT - case C_LEAFSTAT: -#endif - case C_HIDDEN: - if (type == T_NULL) { - in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext); - in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext); - in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext); - return; - } - break; - } + if (abfd->tdata.pe_obj_data == 0) + return FALSE; - in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx); -#ifndef NO_TVNDX - in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx); -#endif + pe = pe_data (abfd); - if (class == C_BLOCK || ISFCN (type) || ISTAG (class)) - { - in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext); - in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext); - } - else - { -#if DIMNUM != E_DIMNUM - #error we need to cope with truncating or extending DIMNUM + pe->coff.pe = 1; + + /* in_reloc_p is architecture dependent. */ + pe->in_reloc_p = in_reloc_p; + +#ifdef PEI_FORCE_MINIMUM_ALIGNMENT + pe->force_minimum_alignment = 1; +#endif +#ifdef PEI_TARGET_SUBSYSTEM + pe->target_subsystem = PEI_TARGET_SUBSYSTEM; #endif - in->x_sym.x_fcnary.x_ary.x_dimen[0] = - bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]); - in->x_sym.x_fcnary.x_ary.x_dimen[1] = - bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]); - in->x_sym.x_fcnary.x_ary.x_dimen[2] = - bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]); - in->x_sym.x_fcnary.x_ary.x_dimen[3] = - bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]); - } - if (ISFCN(type)) { - in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize); - } - else { - in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext); - in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext); - } + return TRUE; } -static unsigned int -coff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp) - bfd *abfd; - PTR inp; - int type; - int class; - int indx; - int numaux; - PTR extp; +/* Create the COFF backend specific information. */ + +static void * +pe_mkobject_hook (bfd * abfd, + void * filehdr, + void * aouthdr ATTRIBUTE_UNUSED) { - union internal_auxent *in = (union internal_auxent *)inp; - AUXENT *ext = (AUXENT *)extp; - - memset((PTR)ext, 0, AUXESZ); - switch (class) { - case C_FILE: - if (in->x_file.x_fname[0] == 0) { - bfd_h_put_32(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes); - bfd_h_put_32(abfd, - in->x_file.x_n.x_offset, - (bfd_byte *) ext->x_file.x_n.x_offset); - } - else { -#if FILNMLEN != E_FILNMLEN - -> Error, we need to cope with truncating or extending FILNMLEN!; -#else - memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN); -#endif - } - return sizeof (AUXENT); + struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; + pe_data_type *pe; + if (! pe_mkobject (abfd)) + return NULL; - case C_STAT: -#ifdef C_LEAFSTAT - case C_LEAFSTAT: -#endif - case C_HIDDEN: - if (type == T_NULL) { - PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext); - PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext); - PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext); - return sizeof (AUXENT); - } - break; - } + pe = pe_data (abfd); + pe->coff.sym_filepos = internal_f->f_symptr; + /* These members communicate important constants about the symbol + table to GDB's symbol-reading code. These `constants' + unfortunately vary among coff implementations... */ + pe->coff.local_n_btmask = N_BTMASK; + pe->coff.local_n_btshft = N_BTSHFT; + pe->coff.local_n_tmask = N_TMASK; + pe->coff.local_n_tshift = N_TSHIFT; + pe->coff.local_symesz = SYMESZ; + pe->coff.local_auxesz = AUXESZ; + pe->coff.local_linesz = LINESZ; - bfd_h_put_32(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx); -#ifndef NO_TVNDX - bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx); -#endif + pe->coff.timestamp = internal_f->f_timdat; - if (class == C_BLOCK || ISFCN (type) || ISTAG (class)) - { - PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext); - PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext); - } - else - { -#if DIMNUM != E_DIMNUM - #error we need to cope with truncating or extending DIMNUM + obj_raw_syment_count (abfd) = + obj_conv_table_size (abfd) = + internal_f->f_nsyms; + + pe->real_flags = internal_f->f_flags; + + if ((internal_f->f_flags & F_DLL) != 0) + pe->dll = 1; + + if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) + abfd->flags |= HAS_DEBUG; + +#ifdef COFF_IMAGE_WITH_PE + if (aouthdr) + pe->pe_opthdr = ((struct internal_aouthdr *) aouthdr)->pe; #endif - bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], - (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]); - bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], - (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]); - bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], - (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]); - bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], - (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]); - } - if (ISFCN (type)) - bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize, - (bfd_byte *) ext->x_sym.x_misc.x_fsize); - else - { - PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext); - PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext); - } +#ifdef ARM + if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) + coff_data (abfd) ->flags = 0; +#endif - return sizeof(AUXENT); + return (void *) pe; } - -static void -coff_swap_lineno_in (abfd, ext1, in1) - bfd *abfd; - PTR ext1; - PTR in1; +static bfd_boolean +pe_print_private_bfd_data (bfd *abfd, void * vfile) { - LINENO *ext = (LINENO *)ext1; - struct internal_lineno *in = (struct internal_lineno *)in1; + FILE *file = (FILE *) vfile; + + if (!_bfd_XX_print_private_bfd_data_common (abfd, vfile)) + return FALSE; + + if (pe_saved_coff_bfd_print_private_bfd_data == NULL) + return TRUE; + + fputc ('\n', file); - in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx); - in->l_lnno = GET_LINENO_LNNO(abfd, ext); + return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile); } -static unsigned int -coff_swap_lineno_out (abfd, inp, outp) - bfd *abfd; - PTR inp; - PTR outp; +/* Copy any private info we understand from the input bfd + to the output bfd. */ + +static bfd_boolean +pe_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) { - struct internal_lineno *in = (struct internal_lineno *)inp; - struct external_lineno *ext = (struct external_lineno *)outp; - bfd_h_put_32(abfd, in->l_addr.l_symndx, (bfd_byte *) - ext->l_addr.l_symndx); + /* PR binutils/716: Copy the large address aware flag. + XXX: Should we be copying other flags or other fields in the pe_data() + structure ? */ + if (pe_data (obfd) != NULL + && pe_data (ibfd) != NULL + && pe_data (ibfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE) + pe_data (obfd)->real_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; + + if (!_bfd_XX_bfd_copy_private_bfd_data_common (ibfd, obfd)) + return FALSE; + + if (pe_saved_coff_bfd_copy_private_bfd_data) + return pe_saved_coff_bfd_copy_private_bfd_data (ibfd, obfd); - PUT_LINENO_LNNO (abfd, in->l_lnno, ext); - return sizeof(struct external_lineno); + return TRUE; } +#define coff_bfd_copy_private_section_data \ + _bfd_XX_bfd_copy_private_section_data +#define coff_get_symbol_info _bfd_XX_get_symbol_info + +#ifdef COFF_IMAGE_WITH_PE + +/* Code to handle Microsoft's Image Library Format. + Also known as LINK6 format. + Documentation about this format can be found at: + + http://msdn.microsoft.com/library/specs/pecoff_section8.htm */ + +/* The following constants specify the sizes of the various data + structures that we have to create in order to build a bfd describing + an ILF object file. The final "+ 1" in the definitions of SIZEOF_IDATA6 + and SIZEOF_IDATA7 below is to allow for the possibility that we might + need a padding byte in order to ensure 16 bit alignment for the section's + contents. + + The value for SIZEOF_ILF_STRINGS is computed as follows: + + There will be NUM_ILF_SECTIONS section symbols. Allow 9 characters + per symbol for their names (longest section name is .idata$x). + + There will be two symbols for the imported value, one the symbol name + and one with _imp__ prefixed. Allowing for the terminating nul's this + is strlen (symbol_name) * 2 + 8 + 21 + strlen (source_dll). + + The strings in the string table must start STRING__SIZE_SIZE bytes into + the table in order to for the string lookup code in coffgen/coffcode to + work. */ +#define NUM_ILF_RELOCS 8 +#define NUM_ILF_SECTIONS 6 +#define NUM_ILF_SYMS (2 + NUM_ILF_SECTIONS) + +#define SIZEOF_ILF_SYMS (NUM_ILF_SYMS * sizeof (* vars.sym_cache)) +#define SIZEOF_ILF_SYM_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_table)) +#define SIZEOF_ILF_NATIVE_SYMS (NUM_ILF_SYMS * sizeof (* vars.native_syms)) +#define SIZEOF_ILF_SYM_PTR_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_ptr_table)) +#define SIZEOF_ILF_EXT_SYMS (NUM_ILF_SYMS * sizeof (* vars.esym_table)) +#define SIZEOF_ILF_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.reltab)) +#define SIZEOF_ILF_INT_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.int_reltab)) +#define SIZEOF_ILF_STRINGS (strlen (symbol_name) * 2 + 8 \ + + 21 + strlen (source_dll) \ + + NUM_ILF_SECTIONS * 9 \ + + STRING_SIZE_SIZE) +#define SIZEOF_IDATA2 (5 * 4) +#define SIZEOF_IDATA4 (1 * 4) +#define SIZEOF_IDATA5 (1 * 4) +#define SIZEOF_IDATA6 (2 + strlen (symbol_name) + 1 + 1) +#define SIZEOF_IDATA7 (strlen (source_dll) + 1 + 1) +#define SIZEOF_ILF_SECTIONS (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata)) + +#define ILF_DATA_SIZE \ + sizeof (* vars.bim) \ + + SIZEOF_ILF_SYMS \ + + SIZEOF_ILF_SYM_TABLE \ + + SIZEOF_ILF_NATIVE_SYMS \ + + SIZEOF_ILF_SYM_PTR_TABLE \ + + SIZEOF_ILF_EXT_SYMS \ + + SIZEOF_ILF_RELOCS \ + + SIZEOF_ILF_INT_RELOCS \ + + SIZEOF_ILF_STRINGS \ + + SIZEOF_IDATA2 \ + + SIZEOF_IDATA4 \ + + SIZEOF_IDATA5 \ + + SIZEOF_IDATA6 \ + + SIZEOF_IDATA7 \ + + SIZEOF_ILF_SECTIONS \ + + MAX_TEXT_SECTION_SIZE + +/* Create an empty relocation against the given symbol. */ static void -coff_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1) - bfd *abfd; - PTR aouthdr_ext1; - PTR aouthdr_int1; +pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars, + bfd_vma address, + bfd_reloc_code_real_type reloc, + struct bfd_symbol ** sym, + unsigned int sym_index) { - struct internal_extra_pe_aouthdr *a; - PEAOUTHDR *src = (PEAOUTHDR *)(aouthdr_ext1); - AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1; - struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1; - - aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic); - aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp); - aouthdr_int->tsize = - GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize); - aouthdr_int->dsize = - GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize); - aouthdr_int->bsize = - GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize); - aouthdr_int->entry = - GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry); - aouthdr_int->text_start = - GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start); - aouthdr_int->data_start = - GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start); - - a = &aouthdr_int->pe; - a->ImageBase = bfd_h_get_32 (abfd, src->ImageBase); - a->SectionAlignment = bfd_h_get_32 (abfd, src->SectionAlignment); - a->FileAlignment = bfd_h_get_32 (abfd, src->FileAlignment); - a->MajorOperatingSystemVersion = - bfd_h_get_16 (abfd, src->MajorOperatingSystemVersion); - a->MinorOperatingSystemVersion = - bfd_h_get_16 (abfd, src->MinorOperatingSystemVersion); - a->MajorImageVersion = bfd_h_get_16 (abfd, src->MajorImageVersion); - a->MinorImageVersion = bfd_h_get_16 (abfd, src->MinorImageVersion); - a->MajorSubsystemVersion = bfd_h_get_16 (abfd, src->MajorSubsystemVersion); - a->MinorSubsystemVersion = bfd_h_get_16 (abfd, src->MinorSubsystemVersion); - a->Reserved1 = bfd_h_get_32 (abfd, src->Reserved1); - a->SizeOfImage = bfd_h_get_32 (abfd, src->SizeOfImage); - a->SizeOfHeaders = bfd_h_get_32 (abfd, src->SizeOfHeaders); - a->CheckSum = bfd_h_get_32 (abfd, src->CheckSum); - a->Subsystem = bfd_h_get_16 (abfd, src->Subsystem); - a->DllCharacteristics = bfd_h_get_16 (abfd, src->DllCharacteristics); - a->SizeOfStackReserve = bfd_h_get_32 (abfd, src->SizeOfStackReserve); - a->SizeOfStackCommit = bfd_h_get_32 (abfd, src->SizeOfStackCommit); - a->SizeOfHeapReserve = bfd_h_get_32 (abfd, src->SizeOfHeapReserve); - a->SizeOfHeapCommit = bfd_h_get_32 (abfd, src->SizeOfHeapCommit); - a->LoaderFlags = bfd_h_get_32 (abfd, src->LoaderFlags); - a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, src->NumberOfRvaAndSizes); - - { - int idx; - for (idx=0; idx < 16; idx++) - { - a->DataDirectory[idx].VirtualAddress = - bfd_h_get_32 (abfd, src->DataDirectory[idx][0]); - a->DataDirectory[idx].Size = - bfd_h_get_32 (abfd, src->DataDirectory[idx][1]); - } - } - - if (aouthdr_int->entry) - aouthdr_int->entry += a->ImageBase; - if (aouthdr_int->tsize) - aouthdr_int->text_start += a->ImageBase; - if (aouthdr_int->dsize) - aouthdr_int->data_start += a->ImageBase; -} + arelent * entry; + struct internal_reloc * internal; + entry = vars->reltab + vars->relcount; + internal = vars->int_reltab + vars->relcount; -static void add_data_entry (abfd, aout, idx, name, base) - bfd *abfd; - struct internal_extra_pe_aouthdr *aout; - int idx; - char *name; - bfd_vma base; -{ - asection *sec = bfd_get_section_by_name (abfd, name); + entry->address = address; + entry->addend = 0; + entry->howto = bfd_reloc_type_lookup (vars->abfd, reloc); + entry->sym_ptr_ptr = sym; - /* add import directory information if it exists */ - if (sec != NULL) - { - aout->DataDirectory[idx].VirtualAddress = sec->lma - base; - aout->DataDirectory[idx].Size = sec->_cooked_size; - sec->flags |= SEC_DATA; - } + internal->r_vaddr = address; + internal->r_symndx = sym_index; + internal->r_type = entry->howto->type; + + vars->relcount ++; + + BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS); } -static unsigned int -coff_swap_aouthdr_out (abfd, in, out) - bfd *abfd; - PTR in; - PTR out; +/* Create an empty relocation against the given section. */ + +static void +pe_ILF_make_a_reloc (pe_ILF_vars * vars, + bfd_vma address, + bfd_reloc_code_real_type reloc, + asection_ptr sec) { - struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in; - struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr; - PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out; + pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr, + coff_section_data (vars->abfd, sec)->i); +} - bfd_vma sa = extra->SectionAlignment; - bfd_vma fa = extra->FileAlignment; - bfd_vma ib = extra->ImageBase ; +/* Move the queued relocs into the given section. */ - if (aouthdr_in->tsize) - aouthdr_in->text_start -= ib; - if (aouthdr_in->dsize) - aouthdr_in->data_start -= ib; - if (aouthdr_in->entry) - aouthdr_in->entry -= ib; +static void +pe_ILF_save_relocs (pe_ILF_vars * vars, + asection_ptr sec) +{ + /* Make sure that there is somewhere to store the internal relocs. */ + if (coff_section_data (vars->abfd, sec) == NULL) + /* We should probably return an error indication here. */ + abort (); -#define FA(x) (((x) + fa -1 ) & (- fa)) -#define SA(x) (((x) + sa -1 ) & (- sa)) + coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab; + coff_section_data (vars->abfd, sec)->keep_relocs = TRUE; - /* We like to have the sizes aligned */ + sec->relocation = vars->reltab; + sec->reloc_count = vars->relcount; + sec->flags |= SEC_RELOC; - aouthdr_in->bsize = FA (aouthdr_in->bsize); + vars->reltab += vars->relcount; + vars->int_reltab += vars->relcount; + vars->relcount = 0; + BFD_ASSERT ((bfd_byte *) vars->int_reltab < (bfd_byte *) vars->string_table); +} - extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; +/* Create a global symbol and add it to the relevant tables. */ - /* first null out all data directory entries .. */ - memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0); +static void +pe_ILF_make_a_symbol (pe_ILF_vars * vars, + const char * prefix, + const char * symbol_name, + asection_ptr section, + flagword extra_flags) +{ + coff_symbol_type * sym; + combined_entry_type * ent; + SYMENT * esym; + unsigned short sclass; - add_data_entry (abfd, extra, 0, ".edata", ib); - add_data_entry (abfd, extra, 1, ".idata", ib); - add_data_entry (abfd, extra, 2, ".rsrc" ,ib); + if (extra_flags & BSF_LOCAL) + sclass = C_STAT; + else + sclass = C_EXT; -#ifdef POWERPC_LE_PE - /* FIXME: do other PE platforms use this? */ - add_data_entry (abfd, extra, 3, ".pdata" ,ib); +#ifdef THUMBPEMAGIC + if (vars->magic == THUMBPEMAGIC) + { + if (extra_flags & BSF_FUNCTION) + sclass = C_THUMBEXTFUNC; + else if (extra_flags & BSF_LOCAL) + sclass = C_THUMBSTAT; + else + sclass = C_THUMBEXT; + } #endif - add_data_entry (abfd, extra, 5, ".reloc", ib); - -#ifdef POWERPC_LE_PE - /* On the PPC NT system, this field is set up as follows. It is - not an "officially" reserved field, so it currently has no title. - first_thunk_address is idata$5, and the thunk_size is the size - of the idata$5 chunk of the idata section. - */ - extra->DataDirectory[12].VirtualAddress = first_thunk_address; - extra->DataDirectory[12].Size = thunk_size; - - /* On the PPC NT system, the size of the directory entry is not the - size of the entire section. It's actually offset to the end of - the idata$3 component of the idata section. This is the size of - the entire import table. (also known as the start of idata$4) - */ - extra->DataDirectory[1].Size = import_table_size; -#endif + BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS); - { - asection *sec; - bfd_vma dsize= 0; - bfd_vma isize = SA(abfd->sections->filepos); - bfd_vma tsize= 0; -#ifdef PPC - isize = 0; -#endif - for (sec = abfd->sections; sec; sec = sec->next) - { - int rounded = FA(sec->_raw_size); - if (sec->flags & SEC_DATA) - dsize += rounded; - if (sec->flags & SEC_CODE) - tsize += rounded; - isize += SA(rounded); - } + sym = vars->sym_ptr; + ent = vars->native_ptr; + esym = vars->esym_ptr; - aouthdr_in->dsize = dsize; - aouthdr_in->tsize = tsize; - extra->SizeOfImage = isize; - } + /* Copy the symbol's name into the string table. */ + sprintf (vars->string_ptr, "%s%s", prefix, symbol_name); - extra->SizeOfHeaders = abfd->sections->filepos; - bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic); + if (section == NULL) + section = (asection_ptr) & bfd_und_section; -#ifdef POWERPC_LE_PE - /* this little piece of magic sets the "linker version" field to 2.60 */ - bfd_h_put_16(abfd, 2 + 60 * 256, (bfd_byte *) aouthdr_out->standard.vstamp); -#else - /* this little piece of magic sets the "linker version" field to 2.55 */ - bfd_h_put_16(abfd, 2 + 55 * 256, (bfd_byte *) aouthdr_out->standard.vstamp); -#endif + /* Initialise the external symbol. */ + H_PUT_32 (vars->abfd, vars->string_ptr - vars->string_table, + esym->e.e.e_offset); + H_PUT_16 (vars->abfd, section->target_index, esym->e_scnum); + esym->e_sclass[0] = sclass; - PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize); - PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize); - PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize); - PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry); - PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start, - (bfd_byte *) aouthdr_out->standard.text_start); - - PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start, - (bfd_byte *) aouthdr_out->standard.data_start); - - - bfd_h_put_32 (abfd, extra->ImageBase, - (bfd_byte *) aouthdr_out->ImageBase); - bfd_h_put_32 (abfd, extra->SectionAlignment, - (bfd_byte *) aouthdr_out->SectionAlignment); - bfd_h_put_32 (abfd, extra->FileAlignment, - (bfd_byte *) aouthdr_out->FileAlignment); - bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion, - (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion); - bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion, - (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion); - bfd_h_put_16 (abfd, extra->MajorImageVersion, - (bfd_byte *) aouthdr_out->MajorImageVersion); - bfd_h_put_16 (abfd, extra->MinorImageVersion, - (bfd_byte *) aouthdr_out->MinorImageVersion); - bfd_h_put_16 (abfd, extra->MajorSubsystemVersion, - (bfd_byte *) aouthdr_out->MajorSubsystemVersion); - bfd_h_put_16 (abfd, extra->MinorSubsystemVersion, - (bfd_byte *) aouthdr_out->MinorSubsystemVersion); - bfd_h_put_32 (abfd, extra->Reserved1, - (bfd_byte *) aouthdr_out->Reserved1); - bfd_h_put_32 (abfd, extra->SizeOfImage, - (bfd_byte *) aouthdr_out->SizeOfImage); - bfd_h_put_32 (abfd, extra->SizeOfHeaders, - (bfd_byte *) aouthdr_out->SizeOfHeaders); - bfd_h_put_32 (abfd, extra->CheckSum, - (bfd_byte *) aouthdr_out->CheckSum); - bfd_h_put_16 (abfd, extra->Subsystem, - (bfd_byte *) aouthdr_out->Subsystem); - bfd_h_put_16 (abfd, extra->DllCharacteristics, - (bfd_byte *) aouthdr_out->DllCharacteristics); - bfd_h_put_32 (abfd, extra->SizeOfStackReserve, - (bfd_byte *) aouthdr_out->SizeOfStackReserve); - bfd_h_put_32 (abfd, extra->SizeOfStackCommit, - (bfd_byte *) aouthdr_out->SizeOfStackCommit); - bfd_h_put_32 (abfd, extra->SizeOfHeapReserve, - (bfd_byte *) aouthdr_out->SizeOfHeapReserve); - bfd_h_put_32 (abfd, extra->SizeOfHeapCommit, - (bfd_byte *) aouthdr_out->SizeOfHeapCommit); - bfd_h_put_32 (abfd, extra->LoaderFlags, - (bfd_byte *) aouthdr_out->LoaderFlags); - bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes, - (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes); - { - int idx; - for (idx=0; idx < 16; idx++) - { - bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress, - (bfd_byte *) aouthdr_out->DataDirectory[idx][0]); - bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size, - (bfd_byte *) aouthdr_out->DataDirectory[idx][1]); - } - } + /* The following initialisations are unnecessary - the memory is + zero initialised. They are just kept here as reminders. */ - return sizeof(AOUTHDR); -} + /* Initialise the internal symbol structure. */ + ent->u.syment.n_sclass = sclass; + ent->u.syment.n_scnum = section->target_index; + ent->u.syment._n._n_n._n_offset = (long) sym; -static void - coff_swap_scnhdr_in (abfd, ext, in) - bfd *abfd; - PTR ext; - PTR in; -{ - SCNHDR *scnhdr_ext = (SCNHDR *) ext; - struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; + sym->symbol.the_bfd = vars->abfd; + sym->symbol.name = vars->string_ptr; + sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags; + sym->symbol.section = section; + sym->native = ent; - memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name)); - scnhdr_int->s_vaddr = - GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr); - scnhdr_int->s_paddr = - GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr); - scnhdr_int->s_size = - GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size); - scnhdr_int->s_scnptr = - GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr); - scnhdr_int->s_relptr = - GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr); - scnhdr_int->s_lnnoptr = - GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr); - scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags); - - scnhdr_int->s_nreloc = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nreloc); - scnhdr_int->s_nlnno = bfd_h_get_16(abfd, (bfd_byte *) scnhdr_ext->s_nlnno); - - if (scnhdr_int->s_vaddr != 0) - { - scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase; - } - if (strcmp (scnhdr_int->s_name, _BSS) == 0) - { - scnhdr_int->s_size = scnhdr_int->s_paddr; - scnhdr_int->s_paddr = 0; - } + * vars->table_ptr = vars->sym_index; + * vars->sym_ptr_ptr = sym; + + /* Adjust pointers for the next symbol. */ + vars->sym_index ++; + vars->sym_ptr ++; + vars->sym_ptr_ptr ++; + vars->table_ptr ++; + vars->native_ptr ++; + vars->esym_ptr ++; + vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1; + + BFD_ASSERT (vars->string_ptr < vars->end_string_ptr); } -static unsigned int -coff_swap_scnhdr_out (abfd, in, out) - bfd *abfd; - PTR in; - PTR out; +/* Create a section. */ + +static asection_ptr +pe_ILF_make_a_section (pe_ILF_vars * vars, + const char * name, + unsigned int size, + flagword extra_flags) { - struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in; - SCNHDR *scnhdr_ext = (SCNHDR *)out; - unsigned int ret = sizeof (SCNHDR); - bfd_vma ps; - bfd_vma ss; + asection_ptr sec; + flagword flags; - memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name)); + sec = bfd_make_section_old_way (vars->abfd, name); + if (sec == NULL) + return NULL; - PUT_SCNHDR_VADDR (abfd, - (scnhdr_int->s_vaddr - - pe_data(abfd)->pe_opthdr.ImageBase), - (bfd_byte *) scnhdr_ext->s_vaddr); + flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY; - /* NT wants the size data to be rounded up to the next NT_FILE_ALIGNMENT - value except for the BSS section, its s_size should be 0 */ + bfd_set_section_flags (vars->abfd, sec, flags | extra_flags); + bfd_set_section_alignment (vars->abfd, sec, 2); - if (strcmp (scnhdr_int->s_name, _BSS) == 0) - { - ps = scnhdr_int->s_size; - ss = 0; - } - else - { - ps = scnhdr_int->s_paddr; - ss = scnhdr_int->s_size; - } + /* Check that we will not run out of space. */ + BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size); - PUT_SCNHDR_SIZE (abfd, ss, - (bfd_byte *) scnhdr_ext->s_size); - - - PUT_SCNHDR_PADDR (abfd, ps, (bfd_byte *) scnhdr_ext->s_paddr); - - PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr, - (bfd_byte *) scnhdr_ext->s_scnptr); - PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr, - (bfd_byte *) scnhdr_ext->s_relptr); - PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, - (bfd_byte *) scnhdr_ext->s_lnnoptr); - - /* Extra flags must be set when dealing with NT. All sections should also - have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the - .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data - sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set - (this is especially important when dealing with the .idata section since - the addresses for routines from .dlls must be overwritten). If .reloc - section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE - (0x02000000). Also, the resource data should also be read and - writable. */ - - /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */ - /* FIXME: even worse, I don't see how to get the original alignment field*/ - /* back... */ - - { - int flags = scnhdr_int->s_flags; - if (strcmp (scnhdr_int->s_name, ".data") == 0 || - strcmp (scnhdr_int->s_name, ".CRT") == 0 || - strcmp (scnhdr_int->s_name, ".rsrc") == 0 || - strcmp (scnhdr_int->s_name, ".bss") == 0) - flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE; - else if (strcmp (scnhdr_int->s_name, ".text") == 0) - flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE; - else if (strcmp (scnhdr_int->s_name, ".reloc") == 0) - flags = SEC_DATA| IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE; - else if (strcmp (scnhdr_int->s_name, ".idata") == 0) - flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | SEC_DATA; - else if (strcmp (scnhdr_int->s_name, ".rdata") == 0 - || strcmp (scnhdr_int->s_name, ".edata") == 0) - flags = IMAGE_SCN_MEM_READ | SEC_DATA; - /* ppc-nt additions */ - else if (strcmp (scnhdr_int->s_name, ".pdata") == 0) - flags = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | - IMAGE_SCN_MEM_READ ; - /* Remember this field is a max of 8 chars, so the null is _not_ there - for an 8 character name like ".reldata". (yep. Stupid bug) */ - else if (strncmp (scnhdr_int->s_name, ".reldata", strlen(".reldata")) == 0) - flags = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_8BYTES | - IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE ; - else if (strcmp (scnhdr_int->s_name, ".ydata") == 0) - flags = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_8BYTES | - IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE ; - else if (strcmp (scnhdr_int->s_name, ".drectve") == 0) - flags = IMAGE_SCN_LNK_INFO | IMAGE_SCN_LNK_REMOVE ; - /* end of ppc-nt additions */ - - bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags); - } - - if (scnhdr_int->s_nlnno <= 0xffff) - bfd_h_put_16(abfd, scnhdr_int->s_nlnno, (bfd_byte *) scnhdr_ext->s_nlnno); - else - { - (*_bfd_error_handler) ("%s: line number overflow: 0x%lx > 0xffff", - bfd_get_filename (abfd), - scnhdr_int->s_nlnno); - bfd_set_error (bfd_error_file_truncated); - bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno); - ret = 0; - } - if (scnhdr_int->s_nreloc <= 0xffff) - bfd_h_put_16(abfd, scnhdr_int->s_nreloc, (bfd_byte *) scnhdr_ext->s_nreloc); - else - { - (*_bfd_error_handler) ("%s: reloc overflow: 0x%lx > 0xffff", - bfd_get_filename (abfd), - scnhdr_int->s_nreloc); - bfd_set_error (bfd_error_file_truncated); - bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc); - ret = 0; - } - return ret; + /* Set the section size and contents. The actual + contents are filled in by our parent. */ + bfd_set_section_size (vars->abfd, sec, (bfd_size_type) size); + sec->contents = vars->data; + sec->target_index = vars->sec_index ++; + + /* Advance data pointer in the vars structure. */ + vars->data += size; + + /* Skip the padding byte if it was not needed. + The logic here is that if the string length is odd, + then the entire string length, including the null byte, + is even and so the extra, padding byte, is not needed. */ + if (size & 1) + vars->data --; + + /* Create a coff_section_tdata structure for our use. */ + sec->used_by_bfd = (struct coff_section_tdata *) vars->data; + vars->data += sizeof (struct coff_section_tdata); + + BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size); + + /* Create a symbol to refer to this section. */ + pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL); + + /* Cache the index to the symbol in the coff_section_data structure. */ + coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1; + + return sec; } -static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] = +/* This structure contains the code that goes into the .text section + in order to perform a jump into the DLL lookup table. The entries + in the table are index by the magic number used to represent the + machine type in the PE file. The contents of the data[] arrays in + these entries are stolen from the jtab[] arrays in ld/pe-dll.c. + The SIZE field says how many bytes in the DATA array are actually + used. The OFFSET field says where in the data array the address + of the .idata$5 section should be placed. */ +#define MAX_TEXT_SECTION_SIZE 32 + +typedef struct { - "Export Directory [.edata]", - "Import Directory [parts of .idata]", - "Resource Directory [.rsrc]", - "Exception Directory [.pdata]", - "Security Directory", - "Base Relocation Directory [.reloc]", - "Debug Directory", - "Description Directory", - "Special Directory", - "Thread Storage Directory [.tls]", - "Load Configuration Directory", - "Bound Import Directory", - "Import Address Table Directory", - "Reserved", - "Reserved", - "Reserved" -}; + unsigned short magic; + unsigned char data[MAX_TEXT_SECTION_SIZE]; + unsigned int size; + unsigned int offset; +} +jump_table; -/**********************************************************************/ -static boolean -pe_print_idata(abfd, vfile) - bfd*abfd; - void *vfile; +static jump_table jtab[] = { - FILE *file = vfile; - bfd_byte *data = 0; - asection *section = bfd_get_section_by_name (abfd, ".idata"); +#ifdef I386MAGIC + { I386MAGIC, + { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, + 8, 2 + }, +#endif + +#ifdef MC68MAGIC + { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 }, +#endif +#ifdef MIPS_ARCH_MAGIC_WINCE + { MIPS_ARCH_MAGIC_WINCE, + { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d, + 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 }, + 16, 0 + }, +#endif -#ifdef POWERPC_LE_PE - asection *rel_section = bfd_get_section_by_name (abfd, ".reldata"); +#ifdef SH_ARCH_MAGIC_WINCE + { SH_ARCH_MAGIC_WINCE, + { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, + 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 }, + 12, 8 + }, #endif - bfd_size_type datasize = 0; - bfd_size_type i; - bfd_size_type start, stop; - int onaline = 20; - bfd_vma addr_value; - bfd_vma loadable_toc_address; - bfd_vma toc_address; - bfd_vma start_address; +#ifdef ARMPEMAGIC + { ARMPEMAGIC, + { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0, + 0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00}, + 12, 8 + }, +#endif + +#ifdef THUMBPEMAGIC + { THUMBPEMAGIC, + { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46, + 0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 }, + 16, 12 + }, +#endif + { 0, { 0 }, 0, 0 } +}; - pe_data_type *pe = pe_data (abfd); - struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr; +#ifndef NUM_ENTRIES +#define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0]) +#endif - if (section == 0) - return true; +/* Build a full BFD from the information supplied in a ILF object. */ -#ifdef POWERPC_LE_PE - if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0) +static bfd_boolean +pe_ILF_build_a_bfd (bfd * abfd, + unsigned int magic, + char * symbol_name, + char * source_dll, + unsigned int ordinal, + unsigned int types) +{ + bfd_byte * ptr; + pe_ILF_vars vars; + struct internal_filehdr internal_f; + unsigned int import_type; + unsigned int import_name_type; + asection_ptr id4, id5, id6 = NULL, text = NULL; + coff_symbol_type ** imp_sym; + unsigned int imp_index; + + /* Decode and verify the types field of the ILF structure. */ + import_type = types & 0x3; + import_name_type = (types & 0x1c) >> 2; + + switch (import_type) { - /* The toc address can be found by taking the starting address, - which on the PPC locates a function descriptor. The descriptor - consists of the function code starting address followed by the - address of the toc. The starting address we get from the bfd, - and the descriptor is supposed to be in the .reldata section. - */ - - bfd_byte *data = 0; - int offset; - data = (bfd_byte *) malloc ((size_t) bfd_section_size (abfd, - rel_section)); - if (data == NULL && bfd_section_size (abfd, rel_section) != 0) - { - bfd_set_error (bfd_error_no_memory); - return false; - } - datasize = bfd_section_size (abfd, rel_section); - - bfd_get_section_contents (abfd, - rel_section, - (PTR) data, 0, - bfd_section_size (abfd, rel_section)); - - offset = abfd->start_address - rel_section->vma; - - start_address = bfd_get_32(abfd, data+offset); - loadable_toc_address = bfd_get_32(abfd, data+offset+4); - toc_address = loadable_toc_address - 32768; - fprintf(file, - "\nFunction descriptor located at the start address:\n"); - fprintf (file, - " %04lx code-base %08lx toc (loadable) %08lx toc (actual) %08lx\n", - (unsigned long int) (abfd->start_address), - start_address, loadable_toc_address, toc_address); + case IMPORT_CODE: + case IMPORT_DATA: + break; + + case IMPORT_CONST: + /* XXX code yet to be written. */ + _bfd_error_handler (_("%B: Unhandled import type; %x"), + abfd, import_type); + return FALSE; + + default: + _bfd_error_handler (_("%B: Unrecognised import type; %x"), + abfd, import_type); + return FALSE; } - else + + switch (import_name_type) { - loadable_toc_address = 0; - toc_address = 0; - start_address = 0; + case IMPORT_ORDINAL: + case IMPORT_NAME: + case IMPORT_NAME_NOPREFIX: + case IMPORT_NAME_UNDECORATE: + break; + + default: + _bfd_error_handler (_("%B: Unrecognised import name type; %x"), + abfd, import_name_type); + return FALSE; } -#endif - - fprintf(file, - "\nThe Import Tables (interpreted .idata section contents)\n"); - fprintf(file, - " vma: Hint Time Forward DLL First\n"); - fprintf(file, - " Table Stamp Chain Name Thunk\n"); - if (bfd_section_size (abfd, section) == 0) - return true; - - data = (bfd_byte *) malloc ((size_t) bfd_section_size (abfd, section)); - datasize = bfd_section_size (abfd, section); - if (data == NULL && datasize != 0) + /* Initialise local variables. + + Note these are kept in a structure rather than being + declared as statics since bfd frowns on global variables. + + We are going to construct the contents of the BFD in memory, + so allocate all the space that we will need right now. */ + ptr = bfd_zalloc (abfd, (bfd_size_type) ILF_DATA_SIZE); + if (ptr == NULL) + return FALSE; + + /* Create a bfd_in_memory structure. */ + vars.bim = (struct bfd_in_memory *) ptr; + vars.bim->buffer = ptr; + vars.bim->size = ILF_DATA_SIZE; + ptr += sizeof (* vars.bim); + + /* Initialise the pointers to regions of the memory and the + other contents of the pe_ILF_vars structure as well. */ + vars.sym_cache = (coff_symbol_type *) ptr; + vars.sym_ptr = (coff_symbol_type *) ptr; + vars.sym_index = 0; + ptr += SIZEOF_ILF_SYMS; + + vars.sym_table = (unsigned int *) ptr; + vars.table_ptr = (unsigned int *) ptr; + ptr += SIZEOF_ILF_SYM_TABLE; + + vars.native_syms = (combined_entry_type *) ptr; + vars.native_ptr = (combined_entry_type *) ptr; + ptr += SIZEOF_ILF_NATIVE_SYMS; + + vars.sym_ptr_table = (coff_symbol_type **) ptr; + vars.sym_ptr_ptr = (coff_symbol_type **) ptr; + ptr += SIZEOF_ILF_SYM_PTR_TABLE; + + vars.esym_table = (SYMENT *) ptr; + vars.esym_ptr = (SYMENT *) ptr; + ptr += SIZEOF_ILF_EXT_SYMS; + + vars.reltab = (arelent *) ptr; + vars.relcount = 0; + ptr += SIZEOF_ILF_RELOCS; + + vars.int_reltab = (struct internal_reloc *) ptr; + ptr += SIZEOF_ILF_INT_RELOCS; + + vars.string_table = (char *) ptr; + vars.string_ptr = (char *) ptr + STRING_SIZE_SIZE; + ptr += SIZEOF_ILF_STRINGS; + vars.end_string_ptr = (char *) ptr; + + /* The remaining space in bim->buffer is used + by the pe_ILF_make_a_section() function. */ + vars.data = ptr; + vars.abfd = abfd; + vars.sec_index = 0; + vars.magic = magic; + + /* Create the initial .idata$ sections: + [.idata$2: Import Directory Table -- not needed] + .idata$4: Import Lookup Table + .idata$5: Import Address Table + + Note we do not create a .idata$3 section as this is + created for us by the linker script. */ + id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0); + id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0); + if (id4 == NULL || id5 == NULL) + return FALSE; + + /* Fill in the contents of these sections. */ + if (import_name_type == IMPORT_ORDINAL) { - bfd_set_error (bfd_error_no_memory); - return false; + if (ordinal == 0) + /* XXX - treat as IMPORT_NAME ??? */ + abort (); + + * (unsigned int *) id4->contents = ordinal | 0x80000000; + * (unsigned int *) id5->contents = ordinal | 0x80000000; } + else + { + char * symbol; + unsigned int len; - bfd_get_section_contents (abfd, - section, - (PTR) data, 0, - bfd_section_size (abfd, section)); + /* Create .idata$6 - the Hint Name Table. */ + id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0); + if (id6 == NULL) + return FALSE; - start = 0; + /* If necessary, trim the import symbol name. */ + symbol = symbol_name; - stop = bfd_section_size (abfd, section); + /* As used by MS compiler, '_', '@', and '?' are alternative + forms of USER_LABEL_PREFIX, with '?' for c++ mangled names, + '@' used for fastcall (in C), '_' everywhere else. Only one + of these is used for a symbol. We strip this leading char for + IMPORT_NAME_NOPREFIX and IMPORT_NAME_UNDECORATE as per the + PE COFF 6.0 spec (section 8.3, Import Name Type). */ - for (i = start; i < stop; i += onaline) - { - bfd_vma hint_addr; - bfd_vma time_stamp; - bfd_vma forward_chain; - bfd_vma dll_name; - bfd_vma first_thunk; - int idx; - int j; - char *dll; - int adj = extra->ImageBase - section->vma; - - fprintf (file, - " %04lx\t", - (unsigned long int) (i + section->vma)); - - if (i+20 > stop) + if (import_name_type != IMPORT_NAME) { - /* check stuff */ - ; + char c = symbol[0]; + if (c == '_' || c == '@' || c == '?') + symbol++; } - hint_addr = bfd_get_32(abfd, data+i); - time_stamp = bfd_get_32(abfd, data+i+4); - forward_chain = bfd_get_32(abfd, data+i+8); - dll_name = bfd_get_32(abfd, data+i+12); - first_thunk = bfd_get_32(abfd, data+i+16); - - fprintf(file, "%08lx %08lx %08lx %08lx %08lx\n", - hint_addr, - time_stamp, - forward_chain, - dll_name, - first_thunk); - - if (hint_addr ==0) + len = strlen (symbol); + if (import_name_type == IMPORT_NAME_UNDECORATE) { - break; + /* Truncate at the first '@'. */ + char *at = strchr (symbol, '@'); + + if (at != NULL) + len = at - symbol; } - /* the image base is present in the section->vma */ - dll = data + dll_name + adj; - fprintf(file, "\n\tDLL Name: %s\n", dll); - fprintf(file, "\tvma: Ordinal Member-Name\n"); + id6->contents[0] = ordinal & 0xff; + id6->contents[1] = ordinal >> 8; + + memcpy ((char *) id6->contents + 2, symbol, len); + id6->contents[len + 2] = '\0'; + } + + if (import_name_type != IMPORT_ORDINAL) + { + pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); + pe_ILF_save_relocs (&vars, id4); + + pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6); + pe_ILF_save_relocs (&vars, id5); + } - idx = hint_addr + adj; + /* Create extra sections depending upon the type of import we are dealing with. */ + switch (import_type) + { + int i; - for (j=0;jcontents, jtab[i].data, jtab[i].size); + + /* Create an import symbol. */ + pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0); + imp_sym = vars.sym_ptr_ptr - 1; + imp_index = vars.sym_index - 1; + + /* Create a reloc for the data in the text section. */ +#ifdef MIPS_ARCH_MAGIC_WINCE + if (magic == MIPS_ARCH_MAGIC_WINCE) { - int differ = 0; - int idx2; - - idx2 = first_thunk + adj; - - for (j=0;j>> Ran out of IAT members!\n"); - } - else - { - ordinal = bfd_get_16(abfd, - data + iat_member + adj); - member_name = data + iat_member + adj + 2; - fprintf(file, "\t%04lx\t %4d %s\n", - iat_member, ordinal, member_name); - } - break; - } - if (hint_member == 0) - break; - } - if (differ == 0) - { - fprintf(file, - "\tThe Import Address Table is identical\n"); - } + pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S, + (struct bfd_symbol **) imp_sym, + imp_index); + pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_LO16, text); + pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 4, BFD_RELOC_LO16, + (struct bfd_symbol **) imp_sym, + imp_index); } + else +#endif + pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset, + BFD_RELOC_32, (asymbol **) imp_sym, + imp_index); - fprintf(file, "\n"); + pe_ILF_save_relocs (& vars, text); + break; + case IMPORT_DATA: + break; + + default: + /* XXX code not yet written. */ + abort (); } + /* Initialise the bfd. */ + memset (& internal_f, 0, sizeof (internal_f)); - free (data); -} -static boolean -pe_print_pdata(abfd, vfile) - bfd*abfd; - void *vfile; -{ - FILE *file = vfile; - bfd_byte *data = 0; - asection *section = bfd_get_section_by_name (abfd, ".pdata"); - bfd_size_type datasize = 0; - bfd_size_type i; - bfd_size_type start, stop; - int onaline = 20; - bfd_vma addr_value; - - if (section == 0) - return true; - - fprintf(file, - "\nThe Function Table (interpreted .pdata section contents)\n"); - fprintf(file, - " vma: Begin End EH EH PrologEnd\n"); - fprintf(file, - " Address Address Handler Data Address\n"); - - if (bfd_section_size (abfd, section) == 0) - return true; - - data = (bfd_byte *) malloc ((size_t) bfd_section_size (abfd, section)); - datasize = bfd_section_size (abfd, section); - if (data == NULL && datasize != 0) - { - bfd_set_error (bfd_error_no_memory); - return false; - } + internal_f.f_magic = magic; + internal_f.f_symptr = 0; + internal_f.f_nsyms = 0; + internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */ - bfd_get_section_contents (abfd, - section, - (PTR) data, 0, - bfd_section_size (abfd, section)); + if ( ! bfd_set_start_address (abfd, (bfd_vma) 0) + || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) + return FALSE; - start = 0; + if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL) + return FALSE; - stop = bfd_section_size (abfd, section); + coff_data (abfd)->pe = 1; +#ifdef THUMBPEMAGIC + if (vars.magic == THUMBPEMAGIC) + /* Stop some linker warnings about thumb code not supporting interworking. */ + coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET; +#endif - for (i = start; i < stop; i += onaline) + /* Switch from file contents to memory contents. */ + bfd_cache_close (abfd); + + abfd->iostream = (void *) vars.bim; + abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; + abfd->where = 0; + obj_sym_filepos (abfd) = 0; + + /* Now create a symbol describing the imported value. */ + switch (import_type) { - bfd_vma begin_addr; - bfd_vma end_addr; - bfd_vma eh_handler; - bfd_vma eh_data; - bfd_vma prolog_end_addr; - - if (i+20 > stop) - break; - - begin_addr = bfd_get_32(abfd, data+i); - end_addr = bfd_get_32(abfd, data+i+4); - eh_handler = bfd_get_32(abfd, data+i+8); - eh_data = bfd_get_32(abfd, data+i+12); - prolog_end_addr = bfd_get_32(abfd, data+i+16); - - if (begin_addr == 0) - { - /* We are probably into the padding of the - section now */ - break; - } + case IMPORT_CODE: + pe_ILF_make_a_symbol (& vars, "", symbol_name, text, + BSF_NOT_AT_END | BSF_FUNCTION); + + /* Create an import symbol for the DLL, without the + .dll suffix. */ + ptr = (bfd_byte *) strrchr (source_dll, '.'); + if (ptr) + * ptr = 0; + pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0); + if (ptr) + * ptr = '.'; + break; + + case IMPORT_DATA: + /* Nothing to do here. */ + break; + + default: + /* XXX code not yet written. */ + abort (); + } - fprintf (file, - " %04lx\t", - (unsigned long int) (i + section->vma)); + /* Point the bfd at the symbol table. */ + obj_symbols (abfd) = vars.sym_cache; + bfd_get_symcount (abfd) = vars.sym_index; - fprintf(file, "%08lx %08lx %08lx %08lx %08lx", - begin_addr, - end_addr, - eh_handler, - eh_data, - prolog_end_addr); + obj_raw_syments (abfd) = vars.native_syms; + obj_raw_syment_count (abfd) = vars.sym_index; -#ifdef POWERPC_LE_PE - if (eh_handler == 0 && eh_data != 0) - { - /* Special bits here, although the meaning may */ - /* be a little mysterious. The only one I know */ - /* for sure is 0x03. */ - /* Code Significance */ - /* 0x00 None */ - /* 0x01 Register Save Millicode */ - /* 0x02 Register Restore Millicode */ - /* 0x03 Glue Code Sequence */ - switch (eh_data) - { - case 0x01: - fprintf(file, " Register save millicode"); - break; - case 0x02: - fprintf(file, " Register restore millicode"); - break; - case 0x03: - fprintf(file, " Glue code sequence"); - break; - default: - break; - } - } -#endif - fprintf(file, "\n"); - } + obj_coff_external_syms (abfd) = (void *) vars.esym_table; + obj_coff_keep_syms (abfd) = TRUE; + + obj_convert (abfd) = vars.sym_table; + obj_conv_table_size (abfd) = vars.sym_index; - free (data); + obj_coff_strings (abfd) = vars.string_table; + obj_coff_keep_strings (abfd) = TRUE; + + abfd->flags |= HAS_SYMS; + + return TRUE; } -static boolean -pe_print_private_bfd_data (abfd, vfile) - bfd *abfd; - PTR vfile; +/* We have detected a Image Library Format archive element. + Decode the element and return the appropriate target. */ + +static const bfd_target * +pe_ILF_object_p (bfd * abfd) { - FILE *file = (FILE *) vfile; - int j; - pe_data_type *pe = pe_data (abfd); - struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr; - - fprintf (file,"\nImageBase\t\t"); - fprintf_vma (file, i->ImageBase); - fprintf (file,"\nSectionAlignment\t"); - fprintf_vma (file, i->SectionAlignment); - fprintf (file,"\nFileAlignment\t\t"); - fprintf_vma (file, i->FileAlignment); - fprintf (file,"\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion); - fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion); - fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion); - fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion); - fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion); - fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion); - fprintf (file,"Reserved1\t\t%08lx\n", i->Reserved1); - fprintf (file,"SizeOfImage\t\t%08lx\n", i->SizeOfImage); - fprintf (file,"SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders); - fprintf (file,"CheckSum\t\t%08lx\n", i->CheckSum); - fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem); - fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics); - fprintf (file,"SizeOfStackReserve\t"); - fprintf_vma (file, i->SizeOfStackReserve); - fprintf (file,"\nSizeOfStackCommit\t"); - fprintf_vma (file, i->SizeOfStackCommit); - fprintf (file,"\nSizeOfHeapReserve\t"); - fprintf_vma (file, i->SizeOfHeapReserve); - fprintf (file,"\nSizeOfHeapCommit\t"); - fprintf_vma (file, i->SizeOfHeapCommit); - fprintf (file,"\nLoaderFlags\t\t%08lx\n", i->LoaderFlags); - fprintf (file,"NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes); - - fprintf (file,"\nThe Data Directory\n"); - for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++) + bfd_byte buffer[16]; + bfd_byte * ptr; + char * symbol_name; + char * source_dll; + unsigned int machine; + bfd_size_type size; + unsigned int ordinal; + unsigned int types; + unsigned int magic; + + /* Upon entry the first four buyes of the ILF header have + already been read. Now read the rest of the header. */ + if (bfd_bread (buffer, (bfd_size_type) 16, abfd) != 16) + return NULL; + + ptr = buffer; + + /* We do not bother to check the version number. + version = H_GET_16 (abfd, ptr); */ + ptr += 2; + + machine = H_GET_16 (abfd, ptr); + ptr += 2; + + /* Check that the machine type is recognised. */ + magic = 0; + + switch (machine) { - fprintf (file, "Entry %1x ", j); - fprintf_vma (file, i->DataDirectory[j].VirtualAddress); - fprintf (file, " %08lx ", i->DataDirectory[j].Size); - fprintf (file, "%s\n", dir_names[j]); + case IMAGE_FILE_MACHINE_UNKNOWN: + case IMAGE_FILE_MACHINE_ALPHA: + case IMAGE_FILE_MACHINE_ALPHA64: + case IMAGE_FILE_MACHINE_IA64: + break; + + case IMAGE_FILE_MACHINE_I386: +#ifdef I386MAGIC + magic = I386MAGIC; +#endif + break; + + case IMAGE_FILE_MACHINE_M68K: +#ifdef MC68AGIC + magic = MC68MAGIC; +#endif + break; + + case IMAGE_FILE_MACHINE_R3000: + case IMAGE_FILE_MACHINE_R4000: + case IMAGE_FILE_MACHINE_R10000: + + case IMAGE_FILE_MACHINE_MIPS16: + case IMAGE_FILE_MACHINE_MIPSFPU: + case IMAGE_FILE_MACHINE_MIPSFPU16: +#ifdef MIPS_ARCH_MAGIC_WINCE + magic = MIPS_ARCH_MAGIC_WINCE; +#endif + break; + + case IMAGE_FILE_MACHINE_SH3: + case IMAGE_FILE_MACHINE_SH4: +#ifdef SH_ARCH_MAGIC_WINCE + magic = SH_ARCH_MAGIC_WINCE; +#endif + break; + + case IMAGE_FILE_MACHINE_ARM: +#ifdef ARMPEMAGIC + magic = ARMPEMAGIC; +#endif + break; + + case IMAGE_FILE_MACHINE_THUMB: +#ifdef THUMBPEMAGIC + { + extern const bfd_target TARGET_LITTLE_SYM; + + if (abfd->xvec == & TARGET_LITTLE_SYM) + magic = THUMBPEMAGIC; + } +#endif + break; + + case IMAGE_FILE_MACHINE_POWERPC: + /* We no longer support PowerPC. */ + default: + _bfd_error_handler + (_("%B: Unrecognised machine type (0x%x)" + " in Import Library Format archive"), + abfd, machine); + bfd_set_error (bfd_error_malformed_archive); + + return NULL; + break; } - pe_print_idata(abfd, vfile); - pe_print_pdata(abfd, vfile); + if (magic == 0) + { + _bfd_error_handler + (_("%B: Recognised but unhandled machine type (0x%x)" + " in Import Library Format archive"), + abfd, machine); + bfd_set_error (bfd_error_wrong_format); - return true; -} + return NULL; + } -static boolean -pe_mkobject (abfd) - bfd * abfd; -{ - pe_data_type *pe; - abfd->tdata.pe_obj_data = - (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type)); + /* We do not bother to check the date. + date = H_GET_32 (abfd, ptr); */ + ptr += 4; - if (abfd->tdata.pe_obj_data == 0) - return false; + size = H_GET_32 (abfd, ptr); + ptr += 4; - pe = pe_data (abfd); + if (size == 0) + { + _bfd_error_handler + (_("%B: size field is zero in Import Library Format header"), abfd); + bfd_set_error (bfd_error_malformed_archive); - pe->coff.pe = 1; - pe->in_reloc_p = in_reloc_p; - return true; -} + return NULL; + } -/* Create the COFF backend specific information. */ -static PTR -pe_mkobject_hook (abfd, filehdr, aouthdr) - bfd * abfd; - PTR filehdr; - PTR aouthdr; -{ - struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; - pe_data_type *pe; + ordinal = H_GET_16 (abfd, ptr); + ptr += 2; + + types = H_GET_16 (abfd, ptr); + /* ptr += 2; */ - if (pe_mkobject (abfd) == false) + /* Now read in the two strings that follow. */ + ptr = bfd_alloc (abfd, size); + if (ptr == NULL) return NULL; - pe = pe_data (abfd); - pe->coff.sym_filepos = internal_f->f_symptr; - /* These members communicate important constants about the symbol - table to GDB's symbol-reading code. These `constants' - unfortunately vary among coff implementations... */ - pe->coff.local_n_btmask = N_BTMASK; - pe->coff.local_n_btshft = N_BTSHFT; - pe->coff.local_n_tmask = N_TMASK; - pe->coff.local_n_tshift = N_TSHIFT; - pe->coff.local_symesz = SYMESZ; - pe->coff.local_auxesz = AUXESZ; - pe->coff.local_linesz = LINESZ; + if (bfd_bread (ptr, size, abfd) != size) + { + bfd_release (abfd, ptr); + return NULL; + } - obj_raw_syment_count (abfd) = - obj_conv_table_size (abfd) = - internal_f->f_nsyms; + symbol_name = (char *) ptr; + source_dll = symbol_name + strlen (symbol_name) + 1; - pe->real_flags = internal_f->f_flags; + /* Verify that the strings are null terminated. */ + if (ptr[size - 1] != 0 + || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size) + { + _bfd_error_handler + (_("%B: string not null terminated in ILF object file."), abfd); + bfd_set_error (bfd_error_malformed_archive); + bfd_release (abfd, ptr); + return NULL; + } -#ifdef COFF_IMAGE_WITH_PE - if (aouthdr) + /* Now construct the bfd. */ + if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name, + source_dll, ordinal, types)) { - pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe; + bfd_release (abfd, ptr); + return NULL; } -#endif - return (PTR) pe; + return abfd->xvec; } +static const bfd_target * +pe_bfd_object_p (bfd * abfd) +{ + bfd_byte buffer[4]; + struct external_PEI_DOS_hdr dos_hdr; + struct external_PEI_IMAGE_hdr image_hdr; + file_ptr offset; + + /* Detect if this a Microsoft Import Library Format element. */ + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 + || bfd_bread (buffer, (bfd_size_type) 4, abfd) != 4) + { + if (bfd_get_error () != bfd_error_system_call) + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + if (H_GET_32 (abfd, buffer) == 0xffff0000) + return pe_ILF_object_p (abfd); -/* Copy any private info we understand from the input bfd - to the output bfd. */ + if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 + || bfd_bread (&dos_hdr, (bfd_size_type) sizeof (dos_hdr), abfd) + != sizeof (dos_hdr)) + { + if (bfd_get_error () != bfd_error_system_call) + bfd_set_error (bfd_error_wrong_format); + return NULL; + } -#define coff_bfd_copy_private_bfd_data pe_bfd_copy_private_bfd_data + /* There are really two magic numbers involved; the magic number + that says this is a NT executable (PEI) and the magic number that + determines the architecture. The former is DOSMAGIC, stored in + the e_magic field. The latter is stored in the f_magic field. + If the NT magic number isn't valid, the architecture magic number + could be mimicked by some other field (specifically, the number + of relocs in section 3). Since this routine can only be called + correctly for a PEI file, check the e_magic number here, and, if + it doesn't match, clobber the f_magic number so that we don't get + a false match. */ + if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC) + { + bfd_set_error (bfd_error_wrong_format); + return NULL; + } -static boolean -pe_bfd_copy_private_bfd_data (ibfd, obfd) - bfd *ibfd, *obfd; -{ - /* One day we may try to grok other private data. */ - if (ibfd->xvec->flavour != bfd_target_coff_flavour - || obfd->xvec->flavour != bfd_target_coff_flavour) - return true; + offset = H_GET_32 (abfd, dos_hdr.e_lfanew); + if (bfd_seek (abfd, offset, SEEK_SET) != 0 + || (bfd_bread (&image_hdr, (bfd_size_type) sizeof (image_hdr), abfd) + != sizeof (image_hdr))) + { + if (bfd_get_error () != bfd_error_system_call) + bfd_set_error (bfd_error_wrong_format); + return NULL; + } - pe_data(obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr; + if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550) + { + bfd_set_error (bfd_error_wrong_format); + return NULL; + } - return true; + /* Here is the hack. coff_object_p wants to read filhsz bytes to + pick up the COFF header for PE, see "struct external_PEI_filehdr" + in include/coff/pe.h. We adjust so that that will work. */ + if (bfd_seek (abfd, (file_ptr) (offset - sizeof (dos_hdr)), SEEK_SET) != 0) + { + if (bfd_get_error () != bfd_error_system_call) + bfd_set_error (bfd_error_wrong_format); + return NULL; + } + + return coff_object_p (abfd); } + +#define coff_object_p pe_bfd_object_p +#endif /* COFF_IMAGE_WITH_PE */