* elfxx-mips.c (mips16_stub_symndx) <sec>: Mark argument as

[binutils.git] / bfd / peicode.h

diff --git a/bfd/peicode.h b/bfd/peicode.h
index 20fe01cba65ac916296efae6d95c5e2a30819ec4..357d1c881efefb166e4caa53db6ba986fd992600 100644 (file)
--- a/bfd/peicode.h
+++ b/bfd/peicode.h
@@ -1,31 +1,31 @@
 /* Support for the generic parts of PE/PEI, for BFD.
 /* 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  Free Software Foundation, Inc.

    Written by Cygnus Solutions.
 
    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,

                        [email protected]
 
                        [email protected]
 

-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]!
 
 
 /* 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
 
    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"
 
 
 #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
 #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
 
 #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
 
 #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
 #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
 
 #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
 
 #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;
 #ifdef COFF_IMAGE_WITH_PE
 /* This structure contains static variables used by the ILF code.  */
 typedef asection * asection_ptr;


@@ -133,81 +121,55 @@ typedef struct
   struct internal_reloc * int_reltab;
 }
 pe_ILF_vars;
   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 short, 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 */
 #endif /* COFF_IMAGE_WITH_PE */

-
-/**********************************************************************/
-
+\f

 #ifndef NO_COFF_RELOCS
 static void
 #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 *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
 #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
 #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
 #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
 #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;
 {
   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.  */
 
   /* Other people's tools sometimes generate headers with an nsyms but
      a zero symptr.  */


@@ -217,86 +179,83 @@ coff_swap_filehdr_in (abfd, src, dst)
       filehdr_dst->f_flags |= F_LSYMS;
     }
 
       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
 # define coff_swap_filehdr_out _bfd_XXi_only_swap_filehdr_out
 }
 
 #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
 #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;
 
 {
   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, (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);
+  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
 
   /* 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 =
-    (bfd_h_get_16 (abfd, (bfd_byte *) scnhdr_ext->s_nlnno)
-     + (bfd_h_get_16 (abfd, (bfd_byte *) scnhdr_ext->s_nreloc) << 16));
+  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
   scnhdr_int->s_nreloc = 0;
 #else

-  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);
+  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
 
   if (scnhdr_int->s_vaddr != 0)
     {
       scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
 #endif
 
   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;
       scnhdr_int->s_vaddr &= 0xffffffff;

+#endif

     }
 
 #ifndef COFF_NO_HACK_SCNHDR_SIZE
     }
 
 #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_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
 }
 
 #endif
 }
 

-static boolean
-pe_mkobject (abfd)
-     bfd * abfd;
+static bfd_boolean
+pe_mkobject (bfd * abfd)

 {
   pe_data_type *pe;
 {
   pe_data_type *pe;

-  abfd->tdata.pe_obj_data =
-    (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
+  bfd_size_type amt = sizeof (pe_data_type);
+
+  abfd->tdata.pe_obj_data = (struct pe_tdata *) bfd_zalloc (abfd, amt);

 
   if (abfd->tdata.pe_obj_data == 0)
 
   if (abfd->tdata.pe_obj_data == 0)

-    return false;
+    return FALSE;

 
   pe = pe_data (abfd);
 
 
   pe = pe_data (abfd);
 


@@ -312,20 +271,20 @@ pe_mkobject (abfd)
   pe->target_subsystem = PEI_TARGET_SUBSYSTEM;
 #endif
 
   pe->target_subsystem = PEI_TARGET_SUBSYSTEM;
 #endif
 

-  return true;
+  return TRUE;

 }
 
 /* Create the COFF backend specific information.  */
 }
 
 /* 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;
 
 {
   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);
     return NULL;
 
   pe = pe_data (abfd);


@@ -357,7 +316,7 @@ pe_mkobject_hook (abfd, filehdr, aouthdr)
 
 #ifdef COFF_IMAGE_WITH_PE
   if (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
 #endif
 
 #ifdef ARM


@@ -365,43 +324,46 @@ pe_mkobject_hook (abfd, filehdr, aouthdr)
     coff_data (abfd) ->flags = 0;
 #endif
 
     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))
 {
   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.  */
 
 }
 
 /* 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))
   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);
 
 
   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 \
 }
 
 #define coff_bfd_copy_private_section_data \


@@ -440,20 +402,28 @@ pe_bfd_copy_private_bfd_data (ibfd, obfd)
 #define NUM_ILF_SECTIONS        6
 #define NUM_ILF_SYMS           (2 + NUM_ILF_SECTIONS)
 
 #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_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)
                                        + 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)
 #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 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))


@@ -477,12 +447,13 @@ pe_bfd_copy_private_bfd_data (ibfd, obfd)
     + MAX_TEXT_SECTION_SIZE
 
 /* Create an empty relocation against the given symbol.  */
     + MAX_TEXT_SECTION_SIZE
 
 /* Create an empty relocation against the given symbol.  */

+

 static void
 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;
 {
   arelent * entry;
   struct internal_reloc * internal;


@@ -498,11 +469,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;
   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 ++;
 
 
   vars->relcount ++;
 


@@ -510,6 +476,7 @@ pe_ILF_make_a_symbol_reloc (pe_ILF_vars *                 vars,
 }
 
 /* Create an empty relocation against the given section.  */
 }
 
 /* Create an empty relocation against the given section.  */

+

 static void
 pe_ILF_make_a_reloc (pe_ILF_vars *             vars,
                     bfd_vma                   address,
 static void
 pe_ILF_make_a_reloc (pe_ILF_vars *             vars,
                     bfd_vma                   address,


@@ -521,6 +488,7 @@ pe_ILF_make_a_reloc (pe_ILF_vars *             vars,
 }
 
 /* Move the queued relocs into the given section.  */
 }
 
 /* Move the queued relocs into the given section.  */

+

 static void
 pe_ILF_save_relocs (pe_ILF_vars * vars,
                    asection_ptr  sec)
 static void
 pe_ILF_save_relocs (pe_ILF_vars * vars,
                    asection_ptr  sec)


@@ -531,7 +499,7 @@ pe_ILF_save_relocs (pe_ILF_vars * vars,
     abort ();
 
   coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab;
     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;
 
   sec->relocation  = vars->reltab;
   sec->reloc_count = vars->relcount;


@@ -541,10 +509,11 @@ pe_ILF_save_relocs (pe_ILF_vars * vars,
   vars->int_reltab += vars->relcount;
   vars->relcount   = 0;
 
   vars->int_reltab += vars->relcount;
   vars->relcount   = 0;
 

-  BFD_ASSERT ((bfd_byte *)vars->int_reltab < (bfd_byte *)vars->string_table);
+  BFD_ASSERT ((bfd_byte *) vars->int_reltab < (bfd_byte *) vars->string_table);

 }
 
 /* Create a global symbol and add it to the relevant tables.  */
 }
 
 /* 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,
 static void
 pe_ILF_make_a_symbol (pe_ILF_vars *  vars,
                      const char *   prefix,


@@ -587,31 +556,18 @@ pe_ILF_make_a_symbol (pe_ILF_vars *  vars,
     section = (asection_ptr) & bfd_und_section;
 
   /* Initialise the external symbol.  */
     section = (asection_ptr) & bfd_und_section;
 
   /* Initialise the external symbol.  */

-  bfd_h_put_32 (vars->abfd, vars->string_ptr - vars->string_table, (bfd_byte *) esym->e.e.e_offset);
-  bfd_h_put_16 (vars->abfd, section->target_index, (bfd_byte *) esym->e_scnum);
+  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;
 
   /* The following initialisations are unnecessary - the memory is
      zero initialised.  They are just kept here as reminders.  */
   esym->e_sclass[0] = sclass;
 
   /* 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;
 
   /* 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;
 
   sym->symbol.the_bfd = vars->abfd;
   sym->symbol.name    = vars->string_ptr;


@@ -619,13 +575,6 @@ pe_ILF_make_a_symbol (pe_ILF_vars *  vars,
   sym->symbol.section = section;
   sym->native         = ent;
 
   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;
 
   * vars->table_ptr = vars->sym_index;
   * vars->sym_ptr_ptr = sym;
 


@@ -642,6 +591,7 @@ pe_ILF_make_a_symbol (pe_ILF_vars *  vars,
 }
 
 /* Create a section.  */
 }
 
 /* Create a section.  */

+

 static asection_ptr
 pe_ILF_make_a_section (pe_ILF_vars * vars,
                       const char *  name,
 static asection_ptr
 pe_ILF_make_a_section (pe_ILF_vars * vars,
                       const char *  name,


@@ -666,7 +616,7 @@ pe_ILF_make_a_section (pe_ILF_vars * vars,
 
   /* Set the section size and contents.  The actual
      contents are filled in by our parent.  */
 
   /* Set the section size and contents.  The actual
      contents are filled in by our parent.  */

-  bfd_set_section_size (vars->abfd, sec, size);
+  bfd_set_section_size (vars->abfd, sec, (bfd_size_type) size);

   sec->contents = vars->data;
   sec->target_index = vars->sec_index ++;
 
   sec->contents = vars->data;
   sec->target_index = vars->sec_index ++;
 


@@ -723,9 +673,20 @@ static jump_table jtab[] =
   },
 #endif
 
   },
 #endif
 

+#ifdef AMD64MAGIC
+  { AMD64MAGIC,
+    { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
+    8, 2
+  },
+#endif
+

 #ifdef  MC68MAGIC
 #ifdef  MC68MAGIC

-  { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 },
+  { MC68MAGIC,
+    { /* XXX fill me in */ },
+    0, 0
+  },

 #endif
 #endif

+

 #ifdef  MIPS_ARCH_MAGIC_WINCE
   { MIPS_ARCH_MAGIC_WINCE,
     { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
 #ifdef  MIPS_ARCH_MAGIC_WINCE
   { MIPS_ARCH_MAGIC_WINCE,
     { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,


@@ -765,11 +726,12 @@ static jump_table jtab[] =
 #endif
 
 /* Build a full BFD from the information supplied in a ILF object.  */
 #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,
 pe_ILF_build_a_bfd (bfd *           abfd,

-                   unsigned short  magic,
-                   bfd_byte *      symbol_name,
-                   bfd_byte *      source_dll,
+                   unsigned int    magic,
+                   char *          symbol_name,
+                   char *          source_dll,

                    unsigned int    ordinal,
                    unsigned int    types)
 {
                    unsigned int    ordinal,
                    unsigned int    types)
 {


@@ -794,14 +756,14 @@ pe_ILF_build_a_bfd (bfd *           abfd,
 
     case IMPORT_CONST:
       /* XXX code yet to be written.  */
 
     case IMPORT_CONST:
       /* XXX code yet to be written.  */

-      _bfd_error_handler (_("%s: Unhandled import type; %x"),
-                         bfd_get_filename (abfd), import_type);
-      return false;
+      _bfd_error_handler (_("%B: Unhandled import type; %x"),
+                         abfd, import_type);
+      return FALSE;

 
     default:
 
     default:

-      _bfd_error_handler (_("%s: Unrecognised import type; %x"),
-                         bfd_get_filename (abfd), import_type);
-      return false;
+      _bfd_error_handler (_("%B: Unrecognised import type; %x"),
+                         abfd, import_type);
+      return FALSE;

     }
 
   switch (import_name_type)
     }
 
   switch (import_name_type)


@@ -813,9 +775,9 @@ pe_ILF_build_a_bfd (bfd *           abfd,
       break;
 
     default:
       break;
 
     default:

-      _bfd_error_handler (_("%s: Unrecognised import name type; %x"),
-                         bfd_get_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.
     }
 
   /* Initialise local variables.


@@ -825,9 +787,9 @@ 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.  */
 
      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, ILF_DATA_SIZE);
+  ptr = bfd_zalloc (abfd, (bfd_size_type) ILF_DATA_SIZE);

   if (ptr == NULL)
   if (ptr == NULL)

-    return false;
+    return FALSE;

 
   /* Create a bfd_in_memory structure.  */
   vars.bim = (struct bfd_in_memory *) ptr;
 
   /* Create a bfd_in_memory structure.  */
   vars.bim = (struct bfd_in_memory *) ptr;


@@ -865,10 +827,10 @@ pe_ILF_build_a_bfd (bfd *           abfd,
   vars.int_reltab  = (struct internal_reloc *) ptr;
   ptr += SIZEOF_ILF_INT_RELOCS;
 
   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;
   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.  */
 
   /* The remaining space in bim->buffer is used
      by the pe_ILF_make_a_section() function.  */


@@ -887,7 +849,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)
   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;
+    return FALSE;

 
   /* Fill in the contents of these sections.  */
   if (import_name_type == IMPORT_ORDINAL)
 
   /* Fill in the contents of these sections.  */
   if (import_name_type == IMPORT_ORDINAL)


@@ -896,48 +858,67 @@ pe_ILF_build_a_bfd (bfd *           abfd,
        /* XXX - treat as IMPORT_NAME ??? */
        abort ();
 
        /* 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;
       * (unsigned int *) id4->contents = ordinal | 0x80000000;
       * (unsigned int *) id5->contents = ordinal | 0x80000000;

+#endif

     }
   else
     {
       char * symbol;
     }
   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)
 
       /* Create .idata$6 - the Hint Name Table.  */
       id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
       if (id6 == NULL)

-       return false;
+       return FALSE;

 
       /* If necessary, trim the import symbol name.  */
       symbol = symbol_name;
 
 
       /* 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)
        {
       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;
 
        }
 
       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)
     {
     }
 
   if (import_name_type != IMPORT_ORDINAL)
     {

-      pe_ILF_make_a_reloc (& vars, 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, id4);

 
 

-      pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
-      pe_ILF_save_relocs (& vars, id5);
+      pe_ILF_make_a_reloc (&vars, (bfd_vma) 0, BFD_RELOC_RVA, id6);
+      pe_ILF_save_relocs (&vars, id5);

     }
 
   /* Create extra sections depending upon the type of import we are dealing with.  */
     }
 
   /* Create extra sections depending upon the type of import we are dealing with.  */


@@ -962,7 +943,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)
       /* Create the .text section.  */
       text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
       if (text == NULL)

-       return false;
+       return FALSE;

 
       /* Copy in the jump code.  */
       memcpy (text->contents, jtab[i].data, jtab[i].size);
 
       /* Copy in the jump code.  */
       memcpy (text->contents, jtab[i].data, jtab[i].size);


@@ -976,16 +957,19 @@ pe_ILF_build_a_bfd (bfd *           abfd,
 #ifdef MIPS_ARCH_MAGIC_WINCE
       if (magic == MIPS_ARCH_MAGIC_WINCE)
        {
 #ifdef MIPS_ARCH_MAGIC_WINCE
       if (magic == MIPS_ARCH_MAGIC_WINCE)
        {

-         pe_ILF_make_a_symbol_reloc (& vars, 0, BFD_RELOC_HI16_S,
-                                     (struct symbol_cache_entry **) imp_sym, imp_index);
-         pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_LO16, text);
-         pe_ILF_make_a_symbol_reloc (& vars, 4, BFD_RELOC_LO16,
-                                     (struct symbol_cache_entry **) imp_sym, imp_index);
+         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
        }
       else
 #endif

-       pe_ILF_make_a_symbol_reloc (& vars, jtab[i].offset, BFD_RELOC_32,
-                                   (asymbol **) imp_sym, imp_index);
+       pe_ILF_make_a_symbol_reloc (&vars, (bfd_vma) jtab[i].offset,
+                                   BFD_RELOC_32, (asymbol **) imp_sym,
+                                   imp_index);

 
       pe_ILF_save_relocs (& vars, text);
       break;
 
       pe_ILF_save_relocs (& vars, text);
       break;


@@ -1006,12 +990,12 @@ pe_ILF_build_a_bfd (bfd *           abfd,
   internal_f.f_nsyms  = 0;
   internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
 
   internal_f.f_nsyms  = 0;
   internal_f.f_flags  = F_AR32WR | F_LNNO; /* XXX is this correct ?  */
 

-  if (   ! bfd_set_start_address (abfd, 0)
+  if (   ! bfd_set_start_address (abfd, (bfd_vma) 0)

       || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
       || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))

-    return false;
+    return FALSE;

 
 

-  if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL)
-    return false;
+  if (bfd_coff_mkobject_hook (abfd, (void *) & internal_f, NULL) == NULL)
+    return FALSE;

 
   coff_data (abfd)->pe = 1;
 #ifdef THUMBPEMAGIC
 
   coff_data (abfd)->pe = 1;
 #ifdef THUMBPEMAGIC


@@ -1023,7 +1007,7 @@ pe_ILF_build_a_bfd (bfd *           abfd,
   /* Switch from file contents to memory contents.  */
   bfd_cache_close (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;
   abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
   abfd->where = 0;
   obj_sym_filepos (abfd) = 0;


@@ -1031,15 +1015,13 @@ pe_ILF_build_a_bfd (bfd *           abfd,
   /* Now create a symbol describing the imported value.  */
   switch (import_type)
     {
   /* Now create a symbol describing the imported value.  */
   switch (import_type)
     {

-      bfd_byte * ptr;
-

     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.  */
     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 = 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);
       if (ptr)
        * ptr = 0;
       pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);


@@ -1063,47 +1045,48 @@ pe_ILF_build_a_bfd (bfd *           abfd,
   obj_raw_syments (abfd) = vars.native_syms;
   obj_raw_syment_count (abfd) = vars.sym_index;
 
   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_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;
 
 
   abfd->flags |= HAS_SYMS;
 

-  return true;
+  return TRUE;

 }
 
 /* We have detected a Image Library Format archive element.
    Decode the element and return the appropriate target.  */
 }
 
 /* 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;
 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;
   unsigned int    machine;

-  unsigned long   size;
+  bfd_size_type   size;

   unsigned int    ordinal;
   unsigned int    types;
   unsigned int    ordinal;
   unsigned int    types;

-  unsigned short  magic;
+  unsigned int    magic;

 
   /* Upon entry the first four buyes of the ILF header have
       already been read.  Now read the rest of the header.  */
 
   /* Upon entry the first four buyes of the ILF header have
       already been read.  Now read the rest of the header.  */

-  if (bfd_read (buffer, 1, 16, abfd) != 16)
+  if (bfd_bread (buffer, (bfd_size_type) 16, abfd) != 16)

     return NULL;
 
   ptr = buffer;
 
   /*  We do not bother to check the version number.
     return NULL;
 
   ptr = buffer;
 
   /*  We do not bother to check the version number.

-      version = bfd_h_get_16 (abfd, ptr);  */
+      version = H_GET_16 (abfd, ptr);  */

   ptr += 2;
 
   ptr += 2;
 

-  machine = bfd_h_get_16 (abfd, ptr);
+  machine = H_GET_16 (abfd, ptr);

   ptr += 2;
 
   /* Check that the machine type is recognised.  */
   ptr += 2;
 
   /* Check that the machine type is recognised.  */


@@ -1123,6 +1106,12 @@ pe_ILF_object_p (bfd * abfd)
 #endif
       break;
 
 #endif
       break;
 

+    case IMAGE_FILE_MACHINE_AMD64:
+#ifdef AMD64MAGIC
+      magic = AMD64MAGIC;
+#endif
+      break;
+

     case IMAGE_FILE_MACHINE_M68K:
 #ifdef MC68AGIC
       magic = MC68MAGIC;
     case IMAGE_FILE_MACHINE_M68K:
 #ifdef MC68AGIC
       magic = MC68MAGIC;


@@ -1169,9 +1158,9 @@ pe_ILF_object_p (bfd * abfd)
       /* We no longer support PowerPC.  */
     default:
       _bfd_error_handler
       /* We no longer support PowerPC.  */
     default:
       _bfd_error_handler

-       (
-_("%s: Unrecognised machine type (0x%x) in Import Library Format archive"),
-         bfd_get_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;
       bfd_set_error (bfd_error_malformed_archive);
 
       return NULL;


@@ -1181,35 +1170,34 @@ _("%s: Unrecognised machine type (0x%x) in Import Library Format archive"),
   if (magic == 0)
     {
       _bfd_error_handler
   if (magic == 0)
     {
       _bfd_error_handler

-       (
-_("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"),
-        bfd_get_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;
     }
 
   /* We do not bother to check the date.
       bfd_set_error (bfd_error_wrong_format);
 
       return NULL;
     }
 
   /* We do not bother to check the date.

-     date = bfd_h_get_32 (abfd, ptr);  */
+     date = H_GET_32 (abfd, ptr);  */

   ptr += 4;
 
   ptr += 4;
 

-  size = bfd_h_get_32 (abfd, ptr);
+  size = H_GET_32 (abfd, ptr);

   ptr += 4;
 
   if (size == 0)
     {
       _bfd_error_handler
   ptr += 4;
 
   if (size == 0)
     {
       _bfd_error_handler

-       (_("%s: size field is zero in Import Library Format header"),
-        bfd_get_filename (abfd));
+       (_("%B: size field is zero in Import Library Format header"), abfd);

       bfd_set_error (bfd_error_malformed_archive);
 
       return NULL;
     }
 
       bfd_set_error (bfd_error_malformed_archive);
 
       return NULL;
     }
 

-  ordinal = bfd_h_get_16 (abfd, ptr);
+  ordinal = H_GET_16 (abfd, ptr);

   ptr += 2;
 
   ptr += 2;
 

-  types = bfd_h_get_16 (abfd, ptr);
+  types = H_GET_16 (abfd, ptr);

   /* ptr += 2; */
 
   /* Now read in the two strings that follow.  */
   /* ptr += 2; */
 
   /* Now read in the two strings that follow.  */


@@ -1217,31 +1205,56 @@ _("%s: Recognised but unhandled machine type (0x%x) in Import Library Format arc
   if (ptr == NULL)
     return NULL;
 
   if (ptr == NULL)
     return NULL;
 

-  if (bfd_read (ptr, 1, size, abfd) != size)
-    return NULL;
+  if (bfd_bread (ptr, size, abfd) != size)
+    {
+      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.  */
 
   /* 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
     {
       _bfd_error_handler

-       (_("%s: string not null terminated in ILF object file."),
-        bfd_get_filename (abfd));
+       (_("%B: string not null terminated in ILF object file."), abfd);

       bfd_set_error (bfd_error_malformed_archive);
       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;
     }
 
   /* 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;
 }
 
 
   return abfd->xvec;
 }
 

+enum arch_type
+{
+  arch_type_unknown,
+  arch_type_i386,
+  arch_type_x86_64
+};
+
+static enum arch_type
+pe_arch (const char *arch)
+{
+  if (strcmp (arch, "i386") == 0 || strcmp (arch, "ia32") == 0)
+    return arch_type_i386;
+
+  if (strcmp (arch, "x86_64") == 0 || strcmp (arch, "x86-64") == 0)
+    return arch_type_x86_64;
+
+  return arch_type_unknown;
+}
+

 static const bfd_target *
 pe_bfd_object_p (bfd * abfd)
 {
 static const bfd_target *
 pe_bfd_object_p (bfd * abfd)
 {


@@ -1249,21 +1262,23 @@ pe_bfd_object_p (bfd * abfd)
   struct external_PEI_DOS_hdr dos_hdr;
   struct external_PEI_IMAGE_hdr image_hdr;
   file_ptr offset;
   struct external_PEI_DOS_hdr dos_hdr;
   struct external_PEI_IMAGE_hdr image_hdr;
   file_ptr offset;

+  const bfd_target *target;
+  struct bfd_preserve preserve;

 
   /* Detect if this a Microsoft Import Library Format element.  */
 
   /* Detect if this a Microsoft Import Library Format element.  */

-  if (bfd_seek (abfd, 0x00, SEEK_SET) != 0
-      || bfd_read (buffer, 1, 4, abfd) != 4)
+  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 (bfd_get_error () != bfd_error_system_call)
        bfd_set_error (bfd_error_wrong_format);
       return NULL;
     }
 

-  if (bfd_h_get_32 (abfd, buffer) == 0xffff0000)
+  if (H_GET_32 (abfd, buffer) == 0xffff0000)

     return pe_ILF_object_p (abfd);
 
     return pe_ILF_object_p (abfd);
 

-  if (bfd_seek (abfd, 0x00, SEEK_SET) != 0
-      || bfd_read (&dos_hdr, 1, sizeof (dos_hdr), abfd)
+  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)
         != sizeof (dos_hdr))
     {
       if (bfd_get_error () != bfd_error_system_call)


@@ -1281,24 +1296,23 @@ pe_bfd_object_p (bfd * abfd)
      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.  */
      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 (bfd_h_get_16 (abfd, (bfd_byte *) dos_hdr.e_magic) != DOSMAGIC)
+  if (H_GET_16 (abfd, dos_hdr.e_magic) != DOSMAGIC)

     {
       bfd_set_error (bfd_error_wrong_format);
       return NULL;
     }
 
     {
       bfd_set_error (bfd_error_wrong_format);
       return NULL;
     }
 

-  offset = bfd_h_get_32 (abfd, (bfd_byte *) dos_hdr.e_lfanew);
-  if (bfd_seek (abfd, (file_ptr) offset, SEEK_SET) != 0
-      || bfd_read (&image_hdr, 1, sizeof (image_hdr), abfd)
-        != sizeof (image_hdr))
+  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;
     }
 
     {
       if (bfd_get_error () != bfd_error_system_call)
        bfd_set_error (bfd_error_wrong_format);
       return NULL;
     }
 

-  if (bfd_h_get_32 (abfd, (bfd_byte *) image_hdr.nt_signature)
-      != 0x4550)
+  if (H_GET_32 (abfd, image_hdr.nt_signature) != 0x4550)

     {
       bfd_set_error (bfd_error_wrong_format);
       return NULL;
     {
       bfd_set_error (bfd_error_wrong_format);
       return NULL;


@@ -1307,17 +1321,117 @@ pe_bfd_object_p (bfd * abfd)
   /* 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. */
   /* 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_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;
     }
 
     {
       if (bfd_get_error () != bfd_error_system_call)
        bfd_set_error (bfd_error_wrong_format);
       return NULL;
     }
 

-  return coff_object_p (abfd);
+  preserve.marker = NULL;
+  if (! bfd_preserve_save (abfd, &preserve))
+    return NULL;
+
+  target = coff_object_p (abfd);
+  if (target)
+    {
+      pe_data_type *pe = pe_data (abfd);
+      struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
+      bfd_boolean efi = i->Subsystem == IMAGE_SUBSYSTEM_EFI_APPLICATION
+                     || i->Subsystem == IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
+                     || i->Subsystem == IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
+      enum arch_type arch;
+      const bfd_target * const *target_ptr;
+
+      /* Get the machine.  */
+      if (bfd_target_efi_app_p (abfd->xvec))
+       arch = pe_arch (bfd_target_efi_app_arch (abfd->xvec));
+      else if (bfd_target_efi_bsdrv_p (abfd->xvec))
+        arch = pe_arch (bfd_target_efi_bsdrv_arch (abfd->xvec));
+      else if (bfd_target_efi_rtdrv_p (abfd->xvec))
+        arch = pe_arch (bfd_target_efi_rtdrv_arch (abfd->xvec));
+      else
+       arch = pe_arch (bfd_target_pei_arch (abfd->xvec));
+
+      /* Don't check PE vs. EFI if arch is unknown.  */
+      if (arch == arch_type_unknown)
+       {
+         bfd_preserve_finish (abfd, &preserve);
+         return target;
+       }
+
+      for (target_ptr = bfd_target_vector; *target_ptr != NULL;
+          target_ptr++)
+       {
+         if (*target_ptr == target
+             || (*target_ptr)->flavour != bfd_target_coff_flavour)
+           continue;
+
+         if (bfd_target_efi_app_p (*target_ptr))
+           {
+             /* Skip incompatible arch.  */
+             if (pe_arch (bfd_target_efi_app_arch (*target_ptr)) != arch)
+               continue;
+
+             if (efi)
+               {
+                 /* TARGET_PTR is an EFI backend.  Don't match
+                    TARGET with a EFI file.  */
+                 bfd_set_error (bfd_error_wrong_format);
+                 return NULL;
+               }
+           }
+          else if (bfd_target_efi_bsdrv_p (*target_ptr))
+           {
+             /* Skip incompatible arch.  */
+             if (pe_arch (bfd_target_efi_bsdrv_arch (*target_ptr)) != arch)
+               continue;
+
+             if (efi)
+               {
+                 /* TARGET_PTR is an EFI backend.  Don't match
+                    TARGET with a EFI file.  */
+                 bfd_set_error (bfd_error_wrong_format);
+                 return NULL;
+               }
+           }
+          else if (bfd_target_efi_rtdrv_p (*target_ptr))
+           {
+             /* Skip incompatible arch.  */
+             if (pe_arch (bfd_target_efi_rtdrv_arch (*target_ptr)) != arch)
+               continue;
+
+             if (efi)
+               {
+no_match:
+                 /* TARGET_PTR is an EFI backend.  Don't match
+                    TARGET with a EFI file.  */
+                 bfd_preserve_restore (abfd, &preserve);
+                 bfd_set_error (bfd_error_wrong_format);
+                 return NULL;
+               }
+           }
+         else if (bfd_target_pei_p (*target_ptr))
+           {
+             /* Skip incompatible arch.  */
+             if (pe_arch (bfd_target_pei_arch (*target_ptr)) != arch)
+               continue;
+
+             if (!efi)
+               {
+                 /* TARGET_PTR is a PE backend.  Don't match
+                    TARGET with a PE file.  */
+                 goto no_match;
+               }
+           }
+       }
+
+      bfd_preserve_finish (abfd, &preserve);
+    }
+  else
+    bfd_preserve_restore (abfd, &preserve);
+
+  return target;

 }
 
 #define coff_object_p pe_bfd_object_p
 }
 
 #define coff_object_p pe_bfd_object_p