X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fpeicode.h;h=8f25ef9b33440658c3a8c7fc6593a63547697659;hb=d2c7a1a63b98c1add3d78ba71ffa9f2a105c1cd4;hp=323b30d89d02f2d5edc9b7c958b1df7f7d57039e;hpb=8f615d07046056cd62e6916b1af80223df8641e8;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/peicode.h b/bfd/peicode.h index 323b30d89d..8f25ef9b33 100644 --- a/bfd/peicode.h +++ b/bfd/peicode.h @@ -1,31 +1,31 @@ /* Support for the generic parts of PE/PEI, for BFD. - Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001 - Free Software Foundation, Inc. + Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, + 2005, 2006, 2007, 2008, 2009 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 3 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., 51 Franklin Street - Fifth Floor, 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. -*/ + PE/PEI rearrangement (and code added): Donn Terry + Softway Systems, Inc. */ /* Hey look, some documentation [and in a place you expect to find it]! @@ -53,13 +53,11 @@ PE/PEI rearrangement (and code added): Donn Terry 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. -*/ + wasting too much time. */ #include "libpei.h" -static boolean (*pe_saved_coff_bfd_print_private_bfd_data) - PARAMS ((bfd *, PTR)) = +static bfd_boolean (*pe_saved_coff_bfd_print_private_bfd_data) (bfd *, void *) = #ifndef coff_bfd_print_private_bfd_data NULL; #else @@ -67,11 +65,10 @@ static boolean (*pe_saved_coff_bfd_print_private_bfd_data) #undef coff_bfd_print_private_bfd_data #endif -static boolean pe_print_private_bfd_data PARAMS ((bfd *, PTR)); +static bfd_boolean pe_print_private_bfd_data (bfd *, void *); #define coff_bfd_print_private_bfd_data pe_print_private_bfd_data -static boolean (*pe_saved_coff_bfd_copy_private_bfd_data) - PARAMS ((bfd *, bfd *)) = +static bfd_boolean (*pe_saved_coff_bfd_copy_private_bfd_data) (bfd *, bfd *) = #ifndef coff_bfd_copy_private_bfd_data NULL; #else @@ -79,21 +76,12 @@ static boolean (*pe_saved_coff_bfd_copy_private_bfd_data) #undef coff_bfd_copy_private_bfd_data #endif -static boolean pe_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *)); +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 -#ifndef NO_COFF_RELOCS -static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR)); -static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR)); -#endif -static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR)); -static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR)); -static boolean pe_mkobject PARAMS ((bfd *)); -static PTR pe_mkobject_hook PARAMS ((bfd *, PTR, PTR)); - #ifdef COFF_IMAGE_WITH_PE /* This structure contains static variables used by the ILF code. */ typedef asection * asection_ptr; @@ -133,76 +121,54 @@ typedef struct struct internal_reloc * int_reltab; } pe_ILF_vars; - -static asection_ptr pe_ILF_make_a_section PARAMS ((pe_ILF_vars *, const char *, unsigned int, flagword)); -static void pe_ILF_make_a_reloc PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, asection_ptr)); -static void pe_ILF_make_a_symbol PARAMS ((pe_ILF_vars *, const char *, const char *, asection_ptr, flagword)); -static void pe_ILF_save_relocs PARAMS ((pe_ILF_vars *, asection_ptr)); -static void pe_ILF_make_a_symbol_reloc PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, struct symbol_cache_entry **, unsigned int)); -static boolean pe_ILF_build_a_bfd PARAMS ((bfd *, unsigned int, bfd_byte *, bfd_byte *, unsigned int, unsigned int)); -static const bfd_target * pe_ILF_object_p PARAMS ((bfd *)); -static const bfd_target * pe_bfd_object_p PARAMS ((bfd *)); #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 = H_GET_32 (abfd, reloc_src->r_vaddr); + 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); - + 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, 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; + 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 +#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 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 = 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_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 @@ -218,27 +184,29 @@ coff_swap_filehdr_in (abfd, src, dst) #ifdef COFF_IMAGE_WITH_PE # define coff_swap_filehdr_out _bfd_XXi_only_swap_filehdr_out +#elif defined COFF_WITH_pex64 +# define coff_swap_filehdr_out _bfd_pex64_only_swap_filehdr_out +#elif defined COFF_WITH_pep +# define coff_swap_filehdr_out _bfd_pep_only_swap_filehdr_out #else # define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out #endif static void -coff_swap_scnhdr_in (abfd, ext, in) - bfd *abfd; - PTR ext; - PTR in; +coff_swap_scnhdr_in (bfd * abfd, void * ext, void * in) { SCNHDR *scnhdr_ext = (SCNHDR *) ext; struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in; - 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); + 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); + 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 @@ -255,27 +223,31 @@ coff_swap_scnhdr_in (abfd, ext, in) if (scnhdr_int->s_vaddr != 0) { scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase; + /* Do not cut upper 32-bits for 64-bit vma. */ +#ifndef COFF_WITH_pex64 scnhdr_int->s_vaddr &= 0xffffffff; +#endif } #ifndef COFF_NO_HACK_SCNHDR_SIZE - /* If this section holds uninitialized data, use the virtual size - (stored in s_paddr) instead of the physical size. */ - if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0 - && (scnhdr_int->s_paddr > 0)) - { - 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. */ - } + /* 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_pei_p (abfd) || scnhdr_int->s_size == 0)) + || (bfd_pei_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 boolean -pe_mkobject (abfd) - bfd * abfd; +static bfd_boolean +pe_mkobject (bfd * abfd) { pe_data_type *pe; bfd_size_type amt = sizeof (pe_data_type); @@ -283,7 +255,7 @@ pe_mkobject (abfd) abfd->tdata.pe_obj_data = (struct pe_tdata *) bfd_zalloc (abfd, amt); if (abfd->tdata.pe_obj_data == 0) - return false; + return FALSE; pe = pe_data (abfd); @@ -292,27 +264,20 @@ pe_mkobject (abfd) /* 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 - - return true; + return TRUE; } /* Create the COFF backend specific information. */ -static PTR -pe_mkobject_hook (abfd, filehdr, aouthdr) - bfd * abfd; - PTR filehdr; - PTR aouthdr ATTRIBUTE_UNUSED; + +static void * +pe_mkobject_hook (bfd * abfd, + void * filehdr, + void * aouthdr ATTRIBUTE_UNUSED) { struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; pe_data_type *pe; - if (pe_mkobject (abfd) == false) + if (! pe_mkobject (abfd)) return NULL; pe = pe_data (abfd); @@ -344,7 +309,7 @@ pe_mkobject_hook (abfd, filehdr, aouthdr) #ifdef COFF_IMAGE_WITH_PE if (aouthdr) - pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe; + pe->pe_opthdr = ((struct internal_aouthdr *) aouthdr)->pe; #endif #ifdef ARM @@ -352,43 +317,46 @@ pe_mkobject_hook (abfd, filehdr, aouthdr) coff_data (abfd) ->flags = 0; #endif - return (PTR) pe; + return (void *) pe; } -static boolean -pe_print_private_bfd_data (abfd, vfile) - bfd *abfd; - PTR vfile; +static bfd_boolean +pe_print_private_bfd_data (bfd *abfd, void * vfile) { FILE *file = (FILE *) vfile; if (!_bfd_XX_print_private_bfd_data_common (abfd, vfile)) - return false; + return FALSE; - if (pe_saved_coff_bfd_print_private_bfd_data != NULL) - { - fputc ('\n', file); + if (pe_saved_coff_bfd_print_private_bfd_data == NULL) + return TRUE; - return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile); - } + fputc ('\n', file); - return true; + return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile); } /* Copy any private info we understand from the input bfd to the output bfd. */ -static boolean -pe_bfd_copy_private_bfd_data (ibfd, obfd) - bfd *ibfd, *obfd; +static bfd_boolean +pe_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) { + /* 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; + return FALSE; if (pe_saved_coff_bfd_copy_private_bfd_data) return pe_saved_coff_bfd_copy_private_bfd_data (ibfd, obfd); - return true; + return TRUE; } #define coff_bfd_copy_private_section_data \ @@ -427,26 +395,33 @@ pe_bfd_copy_private_bfd_data (ibfd, obfd) #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_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 \ +#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) + +/* For PEx64 idata4 & 5 have thumb size of 8 bytes. */ +#ifdef COFF_WITH_pex64 +#define SIZEOF_IDATA4 (2 * 4) +#define SIZEOF_IDATA5 (2 * 4) +#else #define SIZEOF_IDATA4 (1 * 4) #define SIZEOF_IDATA5 (1 * 4) +#endif + #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 \ @@ -464,12 +439,13 @@ pe_bfd_copy_private_bfd_data (ibfd, obfd) + MAX_TEXT_SECTION_SIZE /* Create an empty relocation against the given symbol. */ + static void -pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars, - bfd_vma address, - bfd_reloc_code_real_type reloc, - struct symbol_cache_entry ** sym, - unsigned int sym_index) +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) { arelent * entry; struct internal_reloc * internal; @@ -485,11 +461,6 @@ pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars, internal->r_vaddr = address; internal->r_symndx = sym_index; internal->r_type = entry->howto->type; -#if 0 /* These fields do not need to be initialised. */ - internal->r_size = 0; - internal->r_extern = 0; - internal->r_offset = 0; -#endif vars->relcount ++; @@ -497,6 +468,7 @@ pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars, } /* Create an empty relocation against the given section. */ + static void pe_ILF_make_a_reloc (pe_ILF_vars * vars, bfd_vma address, @@ -508,6 +480,7 @@ pe_ILF_make_a_reloc (pe_ILF_vars * vars, } /* Move the queued relocs into the given section. */ + static void pe_ILF_save_relocs (pe_ILF_vars * vars, asection_ptr sec) @@ -518,7 +491,7 @@ pe_ILF_save_relocs (pe_ILF_vars * vars, abort (); coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab; - coff_section_data (vars->abfd, sec)->keep_relocs = true; + coff_section_data (vars->abfd, sec)->keep_relocs = TRUE; sec->relocation = vars->reltab; sec->reloc_count = vars->relcount; @@ -532,6 +505,7 @@ pe_ILF_save_relocs (pe_ILF_vars * vars, } /* Create a global symbol and add it to the relevant tables. */ + static void pe_ILF_make_a_symbol (pe_ILF_vars * vars, const char * prefix, @@ -581,25 +555,11 @@ pe_ILF_make_a_symbol (pe_ILF_vars * vars, /* The following initialisations are unnecessary - the memory is zero initialised. They are just kept here as reminders. */ -#if 0 - esym->e.e.e_zeroes = 0; - esym->e_value = 0; - esym->e_type = T_NULL; - esym->e_numaux = 0; -#endif /* 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; - -#if 0 /* See comment above. */ - ent->u.syment.n_value = 0; - ent->u.syment.n_flags = 0; - ent->u.syment.n_type = T_NULL; - ent->u.syment.n_numaux = 0; - ent->fix_value = 0; -#endif + ent->u.syment._n._n_n._n_offset = (bfd_hostptr_t) sym; sym->symbol.the_bfd = vars->abfd; sym->symbol.name = vars->string_ptr; @@ -607,13 +567,6 @@ pe_ILF_make_a_symbol (pe_ILF_vars * vars, sym->symbol.section = section; sym->native = ent; -#if 0 /* See comment above. */ - sym->symbol.value = 0; - sym->symbol.udata.i = 0; - sym->done_lineno = false; - sym->lineno = NULL; -#endif - * vars->table_ptr = vars->sym_index; * vars->sym_ptr_ptr = sym; @@ -630,6 +583,7 @@ pe_ILF_make_a_symbol (pe_ILF_vars * vars, } /* Create a section. */ + static asection_ptr pe_ILF_make_a_section (pe_ILF_vars * vars, const char * name, @@ -711,9 +665,20 @@ static jump_table jtab[] = }, #endif +#ifdef AMD64MAGIC + { AMD64MAGIC, + { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 }, + 8, 2 + }, +#endif + #ifdef MC68MAGIC - { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 }, + { 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, @@ -753,11 +718,12 @@ static jump_table jtab[] = #endif /* Build a full BFD from the information supplied in a ILF object. */ -static boolean + +static bfd_boolean pe_ILF_build_a_bfd (bfd * abfd, unsigned int magic, - bfd_byte * symbol_name, - bfd_byte * source_dll, + char * symbol_name, + char * source_dll, unsigned int ordinal, unsigned int types) { @@ -782,14 +748,14 @@ pe_ILF_build_a_bfd (bfd * abfd, case IMPORT_CONST: /* XXX code yet to be written. */ - _bfd_error_handler (_("%s: Unhandled import type; %x"), - bfd_archive_filename (abfd), import_type); - return false; + _bfd_error_handler (_("%B: Unhandled import type; %x"), + abfd, import_type); + return FALSE; default: - _bfd_error_handler (_("%s: Unrecognised import type; %x"), - bfd_archive_filename (abfd), import_type); - return false; + _bfd_error_handler (_("%B: Unrecognised import type; %x"), + abfd, import_type); + return FALSE; } switch (import_name_type) @@ -801,9 +767,9 @@ pe_ILF_build_a_bfd (bfd * abfd, break; default: - _bfd_error_handler (_("%s: Unrecognised import name type; %x"), - bfd_archive_filename (abfd), import_name_type); - return false; + _bfd_error_handler (_("%B: Unrecognised import name type; %x"), + abfd, import_name_type); + return FALSE; } /* Initialise local variables. @@ -813,15 +779,16 @@ pe_ILF_build_a_bfd (bfd * abfd, 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; + vars.bim + = (struct bfd_in_memory *) bfd_malloc ((bfd_size_type) sizeof (*vars.bim)); + if (vars.bim == NULL) + return FALSE; - /* Create a bfd_in_memory structure. */ - vars.bim = (struct bfd_in_memory *) ptr; + ptr = (bfd_byte *) bfd_zmalloc ((bfd_size_type) ILF_DATA_SIZE); vars.bim->buffer = ptr; vars.bim->size = ILF_DATA_SIZE; - ptr += sizeof (* vars.bim); + if (ptr == NULL) + goto error_return; /* Initialise the pointers to regions of the memory and the other contents of the pe_ILF_vars structure as well. */ @@ -853,10 +820,10 @@ pe_ILF_build_a_bfd (bfd * abfd, vars.int_reltab = (struct internal_reloc *) ptr; ptr += SIZEOF_ILF_INT_RELOCS; - vars.string_table = ptr; - vars.string_ptr = ptr + STRING_SIZE_SIZE; + vars.string_table = (char *) ptr; + vars.string_ptr = (char *) ptr + STRING_SIZE_SIZE; ptr += SIZEOF_ILF_STRINGS; - vars.end_string_ptr = ptr; + vars.end_string_ptr = (char *) ptr; /* The remaining space in bim->buffer is used by the pe_ILF_make_a_section() function. */ @@ -875,7 +842,7 @@ pe_ILF_build_a_bfd (bfd * abfd, 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; + goto error_return; /* Fill in the contents of these sections. */ if (import_name_type == IMPORT_ORDINAL) @@ -884,39 +851,58 @@ pe_ILF_build_a_bfd (bfd * abfd, /* XXX - treat as IMPORT_NAME ??? */ abort (); +#ifdef COFF_WITH_pex64 + ((unsigned int *) id4->contents)[0] = ordinal; + ((unsigned int *) id4->contents)[1] = 0x80000000; + ((unsigned int *) id5->contents)[0] = ordinal; + ((unsigned int *) id5->contents)[1] = 0x80000000; +#else * (unsigned int *) id4->contents = ordinal | 0x80000000; * (unsigned int *) id5->contents = ordinal | 0x80000000; +#endif } else { char * symbol; + unsigned int len; /* Create .idata$6 - the Hint Name Table. */ id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0); if (id6 == NULL) - return false; + goto error_return; /* If necessary, trim the import symbol name. */ symbol = symbol_name; - if (import_name_type != IMPORT_NAME) - /* Skip any prefix in symbol_name. */ - while (*symbol == '@' || * symbol == '?' || * symbol == '_') - ++ symbol; + /* 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). */ + if (import_name_type != IMPORT_NAME) + { + char c = symbol[0]; + if (c == '_' || c == '@' || c == '?') + symbol++; + } + + len = strlen (symbol); if (import_name_type == IMPORT_NAME_UNDECORATE) { - /* Truncate at the first '@' */ - while (* symbol != 0 && * symbol != '@') - symbol ++; + /* Truncate at the first '@'. */ + char *at = strchr (symbol, '@'); - * symbol = 0; + if (at != NULL) + len = at - symbol; } id6->contents[0] = ordinal & 0xff; id6->contents[1] = ordinal >> 8; - strcpy (id6->contents + 2, symbol); + memcpy ((char *) id6->contents + 2, symbol, len); + id6->contents[len + 2] = '\0'; } if (import_name_type != IMPORT_ORDINAL) @@ -950,7 +936,7 @@ pe_ILF_build_a_bfd (bfd * abfd, /* Create the .text section. */ text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE); if (text == NULL) - return false; + goto error_return; /* Copy in the jump code. */ memcpy (text->contents, jtab[i].data, jtab[i].size); @@ -965,11 +951,11 @@ pe_ILF_build_a_bfd (bfd * abfd, if (magic == MIPS_ARCH_MAGIC_WINCE) { pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) 0, BFD_RELOC_HI16_S, - (struct symbol_cache_entry **) imp_sym, + (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 symbol_cache_entry **) imp_sym, + (struct bfd_symbol **) imp_sym, imp_index); } else @@ -999,10 +985,10 @@ pe_ILF_build_a_bfd (bfd * abfd, if ( ! bfd_set_start_address (abfd, (bfd_vma) 0) || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f)) - return false; + goto error_return; - if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL) - return false; + if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL) + goto error_return; coff_data (abfd)->pe = 1; #ifdef THUMBPEMAGIC @@ -1014,7 +1000,7 @@ pe_ILF_build_a_bfd (bfd * abfd, /* Switch from file contents to memory contents. */ bfd_cache_close (abfd); - abfd->iostream = (PTR) vars.bim; + abfd->iostream = (void *) vars.bim; abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */; abfd->where = 0; obj_sym_filepos (abfd) = 0; @@ -1028,7 +1014,7 @@ pe_ILF_build_a_bfd (bfd * abfd, /* Create an import symbol for the DLL, without the .dll suffix. */ - ptr = strrchr (source_dll, '.'); + ptr = (bfd_byte *) strrchr (source_dll, '.'); if (ptr) * ptr = 0; pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0); @@ -1052,29 +1038,36 @@ pe_ILF_build_a_bfd (bfd * abfd, obj_raw_syments (abfd) = vars.native_syms; obj_raw_syment_count (abfd) = vars.sym_index; - obj_coff_external_syms (abfd) = (PTR) vars.esym_table; - obj_coff_keep_syms (abfd) = true; + 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; obj_coff_strings (abfd) = vars.string_table; - obj_coff_keep_strings (abfd) = true; + obj_coff_keep_strings (abfd) = TRUE; abfd->flags |= HAS_SYMS; - return true; + return TRUE; + + error_return: + if (vars.bim->buffer != NULL) + free (vars.bim->buffer); + free (vars.bim); + return FALSE; } /* 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) { bfd_byte buffer[16]; bfd_byte * ptr; - bfd_byte * symbol_name; - bfd_byte * source_dll; + char * symbol_name; + char * source_dll; unsigned int machine; bfd_size_type size; unsigned int ordinal; @@ -1112,6 +1105,12 @@ pe_ILF_object_p (bfd * abfd) #endif break; + case IMAGE_FILE_MACHINE_AMD64: +#ifdef AMD64MAGIC + magic = AMD64MAGIC; +#endif + break; + case IMAGE_FILE_MACHINE_M68K: #ifdef MC68AGIC magic = MC68MAGIC; @@ -1158,9 +1157,9 @@ pe_ILF_object_p (bfd * abfd) /* We no longer support PowerPC. */ default: _bfd_error_handler - ( -_("%s: Unrecognised machine type (0x%x) in Import Library Format archive"), - bfd_archive_filename (abfd), machine); + (_("%B: Unrecognised machine type (0x%x)" + " in Import Library Format archive"), + abfd, machine); bfd_set_error (bfd_error_malformed_archive); return NULL; @@ -1170,9 +1169,9 @@ _("%s: Unrecognised machine type (0x%x) in Import Library Format archive"), if (magic == 0) { _bfd_error_handler - ( -_("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"), - bfd_archive_filename (abfd), machine); + (_("%B: Recognised but unhandled machine type (0x%x)" + " in Import Library Format archive"), + abfd, machine); bfd_set_error (bfd_error_wrong_format); return NULL; @@ -1188,8 +1187,7 @@ _("%s: Recognised but unhandled machine type (0x%x) in Import Library Format arc if (size == 0) { _bfd_error_handler - (_("%s: size field is zero in Import Library Format header"), - bfd_archive_filename (abfd)); + (_("%B: size field is zero in Import Library Format header"), abfd); bfd_set_error (bfd_error_malformed_archive); return NULL; @@ -1202,31 +1200,37 @@ _("%s: Recognised but unhandled machine type (0x%x) in Import Library Format arc /* ptr += 2; */ /* Now read in the two strings that follow. */ - ptr = bfd_alloc (abfd, size); + ptr = (bfd_byte *) bfd_alloc (abfd, size); if (ptr == NULL) return NULL; if (bfd_bread (ptr, size, abfd) != size) - return NULL; + { + bfd_release (abfd, ptr); + return NULL; + } - symbol_name = ptr; - source_dll = ptr + strlen (ptr) + 1; + symbol_name = (char *) ptr; + source_dll = symbol_name + strlen (symbol_name) + 1; /* Verify that the strings are null terminated. */ - if (ptr[size - 1] != 0 || ((unsigned long) (source_dll - ptr) >= size)) + if (ptr[size - 1] != 0 + || (bfd_size_type) ((bfd_byte *) source_dll - ptr) >= size) { _bfd_error_handler - (_("%s: string not null terminated in ILF object file."), - bfd_archive_filename (abfd)); + (_("%B: string not null terminated in ILF object file."), abfd); bfd_set_error (bfd_error_malformed_archive); - + bfd_release (abfd, ptr); return NULL; } /* Now construct the bfd. */ if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name, source_dll, ordinal, types)) - return NULL; + { + bfd_release (abfd, ptr); + return NULL; + } return abfd->xvec; }