#line 1 "peXXigen.c"

/* Support for the generic parts of PE/PEI; the common executable parts.

   Copyright (C) 1995-2023 Free Software Foundation, Inc.

   Written by Cygnus Solutions.

   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 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.

   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 <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]!

   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.

   Another reference:

   "Peering Inside the PE: A Tour of the Win32 Portable Executable

   File Format", MSJ 1994, Volume 9.

   The PE/PEI format is also used by .NET. ECMA-335 describes this:

   "Standard ECMA-335 Common Language Infrastructure (CLI)", 6th Edition, June 2012.

   This is also available at

   https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf.

   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!)

   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.

   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.  */

/* This expands into COFF_WITH_pe, COFF_WITH_pep, COFF_WITH_pex64,

   COFF_WITH_peAArch64 or COFF_WITH_peLoongArch64 depending on whether we're

   compiling for straight PE or PE+.  */

#define COFF_WITH_pex64

#include "sysdep.h"

#include "bfd.h"

#include "libbfd.h"

#include "coff/internal.h"

#include "bfdver.h"

#include "libiberty.h"

#include <wchar.h>

#include <wctype.h>

/* NOTE: it's strange to be including an architecture specific header

   in what's supposed to be general (to PE/PEI) code.  However, that's

   where the definitions are, and they don't vary per architecture

   within PE/PEI, so we get them from there.  FIXME: The lack of

   variance is an assumption which may prove to be incorrect if new

   PE/PEI targets are created.  */

#if defined COFF_WITH_pex64

# include "coff/x86_64.h"

#elif defined COFF_WITH_pep

# include "coff/ia64.h"

#elif defined COFF_WITH_peAArch64

# include "coff/aarch64.h"

#elif defined COFF_WITH_peLoongArch64

# include "coff/loongarch64.h"

#else

# include "coff/i386.h"

#endif

#include "coff/pe.h"

#include "libcoff.h"

#include "libpei.h"

#include "safe-ctype.h"

#if defined COFF_WITH_pep || defined COFF_WITH_pex64 || defined COFF_WITH_peAArch64 || defined COFF_WITH_peLoongArch64

# undef AOUTSZ

# define AOUTSZ   PEPAOUTSZ

# define PEAOUTHDR  PEPAOUTHDR

#endif

#define HighBitSet(val)      ((val) & 0x80000000)

#define SetHighBit(val)      ((val) | 0x80000000)

#define WithoutHighBit(val)  ((val) & 0x7fffffff)

void

_bfd_pex64i_swap_sym_in (bfd * abfd, void * ext1, void * in1)

{

  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 = H_GET_32 (abfd, ext->e.e.e_offset);

    }

  else

    memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);

  in->n_value = H_GET_32 (abfd, ext->e_value);

  in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum);

  if (sizeof (ext->e_type) == 2)

    in->n_type = H_GET_16 (abfd, ext->e_type);

  else

    in->n_type = H_GET_32 (abfd, ext->e_type);

  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);

  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);

#ifndef STRICT_PE_FORMAT

  /* This is for Gnu-created DLLs.  */

  /* The section symbols for the .idata$ sections have class 0x68

     (C_SECTION), which MS documentation indicates is a section

     symbol.  Unfortunately, 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 so that

     they will be handled somewhat correctly in the bfd code.  */

  if (in->n_sclass == C_SECTION)

    {

      char namebuf[SYMNMLEN + 1];

      const char *name = NULL;

      in->n_value = 0x0;

      /* Create synthetic empty sections as needed.  DJ */

      if (in->n_scnum == 0)

  {

    asection *sec;

    name = _bfd_coff_internal_syment_name (abfd, in, namebuf);

    if (name == NULL)

      {

        _bfd_error_handler (_("%pB: unable to find name for empty section"),

          abfd);

        bfd_set_error (bfd_error_invalid_target);

        return;

      }

    sec = bfd_get_section_by_name (abfd, name);

    if (sec != NULL)

      in->n_scnum = sec->target_index;

  }

      if (in->n_scnum == 0)

  {

    int unused_section_number = 0;

    asection *sec;

    flagword flags;

    size_t name_len;

    char *sec_name;

    for (sec = abfd->sections; sec; sec = sec->next)

      if (unused_section_number <= sec->target_index)

        unused_section_number = sec->target_index + 1;

    name_len = strlen (name) + 1;

    sec_name = bfd_alloc (abfd, name_len);

    if (sec_name == NULL)

      {

        _bfd_error_handler (_("%pB: out of memory creating name "

            "for empty section"), abfd);

        return;

      }

    memcpy (sec_name, name, name_len);

    flags = (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD

       | SEC_LINKER_CREATED);

    sec = bfd_make_section_anyway_with_flags (abfd, sec_name, flags);

    if (sec == NULL)

      {

        _bfd_error_handler (_("%pB: unable to create fake empty section"),

          abfd);

        return;

      }

    sec->alignment_power = 2;

    sec->target_index = unused_section_number;

    in->n_scnum = unused_section_number;

  }

      in->n_sclass = C_STAT;

    }

#endif

}

static bool

abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)

{

  bfd_vma abs_val = * (bfd_vma *) data;

  return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);

}

unsigned int

_bfd_pex64i_swap_sym_out (bfd * abfd, void * inp, void * extp)

{

  struct internal_syment *in = (struct internal_syment *) inp;

  SYMENT *ext = (SYMENT *) extp;

  if (in->_n._n_name[0] == 0)

    {

      H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);

      H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);

    }

  else

    memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);

  /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a

     symbol.  This is a problem on 64-bit targets where we can generate

     absolute symbols with values >= 1^32.  We try to work around this

     problem by finding a section whose base address is sufficient to

     reduce the absolute value to < 1^32, and then transforming the

     symbol into a section relative symbol.  This of course is a hack.  */

  if (sizeof (in->n_value) > 4

      /* The strange computation of the shift amount is here in order to

   avoid a compile time warning about the comparison always being

   false.  It does not matter if this test fails to work as expected

   as the worst that can happen is that some absolute symbols are

   needlessly converted into section relative symbols.  */

      && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)

      && in->n_scnum == N_ABS)

    {

      asection * sec;

      sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);

      if (sec)

  {

    in->n_value -= sec->vma;

    in->n_scnum = sec->target_index;

  }

      /* else: FIXME: The value is outside the range of any section.  This

   happens for __image_base__ and __ImageBase and maybe some other

   symbols as well.  We should find a way to handle these values.  */

    }

  H_PUT_32 (abfd, in->n_value, ext->e_value);

  H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);

  if (sizeof (ext->e_type) == 2)

    H_PUT_16 (abfd, in->n_type, ext->e_type);

  else

    H_PUT_32 (abfd, in->n_type, ext->e_type);

  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);

  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);

  return SYMESZ;

}

void

_bfd_pex64i_swap_aux_in (bfd *  abfd,

          void *  ext1,

          int       type,

          int       in_class,

          int indx ATTRIBUTE_UNUSED,

          int numaux ATTRIBUTE_UNUSED,

          void *  in1)

{

  AUXENT *ext = (AUXENT *) ext1;

  union internal_auxent *in = (union internal_auxent *) in1;

  /* PR 17521: Make sure that all fields in the aux structure

     are initialised.  */

  memset (in, 0, sizeof * in);

  switch (in_class)

    {

    case C_FILE:

      if (ext->x_file.x_fname[0] == 0)

  {

    in->x_file.x_n.x_n.x_zeroes = 0;

    in->x_file.x_n.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);

  }

      else

  memcpy (in->x_file.x_n.x_fname, ext->x_file.x_fname, FILNMLEN);

      return;

    case C_STAT:

    case C_LEAFSTAT:

    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);

    in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);

    in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);

    in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);

    return;

  }

      break;

    }

  in->x_sym.x_tagndx.u32 = H_GET_32 (abfd, ext->x_sym.x_tagndx);

  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);

  if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)

      || ISTAG (in_class))

    {

      in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);

      in->x_sym.x_fcnary.x_fcn.x_endndx.u32 = GET_FCN_ENDNDX (abfd, ext);

    }

  else

    {

      in->x_sym.x_fcnary.x_ary.x_dimen[0] =

  H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);

      in->x_sym.x_fcnary.x_ary.x_dimen[1] =

  H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);

      in->x_sym.x_fcnary.x_ary.x_dimen[2] =

  H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);

      in->x_sym.x_fcnary.x_ary.x_dimen[3] =

  H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);

    }

  if (ISFCN (type))

    {

      in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, 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);

    }

}

unsigned int

_bfd_pex64i_swap_aux_out (bfd *  abfd,

           void * inp,

           int    type,

           int    in_class,

           int    indx ATTRIBUTE_UNUSED,

           int    numaux ATTRIBUTE_UNUSED,

           void * extp)

{

  union internal_auxent *in = (union internal_auxent *) inp;

  AUXENT *ext = (AUXENT *) extp;

  memset (ext, 0, AUXESZ);

  switch (in_class)

    {

    case C_FILE:

      if (in->x_file.x_n.x_fname[0] == 0)

  {

    H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);

    H_PUT_32 (abfd, in->x_file.x_n.x_n.x_offset, ext->x_file.x_n.x_offset);

  }

      else

  memcpy (ext->x_file.x_fname, in->x_file.x_n.x_fname, sizeof (ext->x_file.x_fname));

      return AUXESZ;

    case C_STAT:

    case C_LEAFSTAT:

    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);

    H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);

    H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);

    H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);

    return AUXESZ;

  }

      break;

    }

  H_PUT_32 (abfd, in->x_sym.x_tagndx.u32, ext->x_sym.x_tagndx);

  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);

  if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)

      || ISTAG (in_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.u32, ext);

    }

  else

    {

      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],

    ext->x_sym.x_fcnary.x_ary.x_dimen[0]);

      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],

    ext->x_sym.x_fcnary.x_ary.x_dimen[1]);

      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],

    ext->x_sym.x_fcnary.x_ary.x_dimen[2]);

      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],

    ext->x_sym.x_fcnary.x_ary.x_dimen[3]);

    }

  if (ISFCN (type))

    H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, 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);

    }

  return AUXESZ;

}

void

_bfd_pex64i_swap_lineno_in (bfd * abfd, void * ext1, void * in1)

{

  LINENO *ext = (LINENO *) ext1;

  struct internal_lineno *in = (struct internal_lineno *) in1;

  in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);

  in->l_lnno = GET_LINENO_LNNO (abfd, ext);

}

unsigned int

_bfd_pex64i_swap_lineno_out (bfd * abfd, void * inp, void * outp)

{

  struct internal_lineno *in = (struct internal_lineno *) inp;

  struct external_lineno *ext = (struct external_lineno *) outp;

  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);

  PUT_LINENO_LNNO (abfd, in->l_lnno, ext);

  return LINESZ;

}

void

_bfd_pex64i_swap_aouthdr_in (bfd * abfd,

        void * aouthdr_ext1,

        void * aouthdr_int1)

{

  PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;

  AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;

  struct internal_aouthdr *aouthdr_int

    = (struct internal_aouthdr *) aouthdr_int1;

  struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;

  aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);

  aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);

  aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);

  aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);

  aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);

  aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);

  aouthdr_int->text_start =

    GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

  /* PE32+ does not have data_start member!  */

  aouthdr_int->data_start =

    GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);

  a->BaseOfData = aouthdr_int->data_start;

#endif

  a->Magic = aouthdr_int->magic;

  a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);

  a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);

  a->SizeOfCode = aouthdr_int->tsize ;

  a->SizeOfInitializedData = aouthdr_int->dsize ;

  a->SizeOfUninitializedData = aouthdr_int->bsize ;

  a->AddressOfEntryPoint = aouthdr_int->entry;

  a->BaseOfCode = aouthdr_int->text_start;

  a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);

  a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);

  a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);

  a->MajorOperatingSystemVersion =

    H_GET_16 (abfd, src->MajorOperatingSystemVersion);

  a->MinorOperatingSystemVersion =

    H_GET_16 (abfd, src->MinorOperatingSystemVersion);

  a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);

  a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);

  a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);

  a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);

  a->Reserved1 = H_GET_32 (abfd, src->Reserved1);

  a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);

  a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);

  a->CheckSum = H_GET_32 (abfd, src->CheckSum);

  a->Subsystem = H_GET_16 (abfd, src->Subsystem);

  a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);

  a->SizeOfStackReserve =

    GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);

  a->SizeOfStackCommit =

    GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);

  a->SizeOfHeapReserve =

    GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);

  a->SizeOfHeapCommit =

    GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);

  a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);

  a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);

  /* PR 17512: Don't blindly trust NumberOfRvaAndSizes.  */

  unsigned idx;

  for (idx = 0;

       idx < a->NumberOfRvaAndSizes && idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES;

       idx++)

    {

      /* If data directory is empty, rva also should be 0.  */

      int size = H_GET_32 (abfd, src->DataDirectory[idx][1]);

      int vma = size ? H_GET_32 (abfd, src->DataDirectory[idx][0]) : 0;

      a->DataDirectory[idx].Size = size;

      a->DataDirectory[idx].VirtualAddress = vma;

    }

  while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)

    {

      a->DataDirectory[idx].Size = 0;

      a->DataDirectory[idx].VirtualAddress = 0;

      idx++;

    }

  if (aouthdr_int->entry)

    {

      aouthdr_int->entry += a->ImageBase;

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

      aouthdr_int->entry &= 0xffffffff;

#endif

    }

  if (aouthdr_int->tsize)

    {

      aouthdr_int->text_start += a->ImageBase;

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

      aouthdr_int->text_start &= 0xffffffff;

#endif

    }

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

  /* PE32+ does not have data_start member!  */

  if (aouthdr_int->dsize)

    {

      aouthdr_int->data_start += a->ImageBase;

      aouthdr_int->data_start &= 0xffffffff;

    }

#endif

}

/* A support function for below.  */

static void

add_data_entry (bfd * abfd,

    struct internal_extra_pe_aouthdr *aout,

    int idx,

    char *name,

    bfd_vma base)

{

  asection *sec = bfd_get_section_by_name (abfd, name);

  /* Add import directory information if it exists.  */

  if ((sec != NULL)

      && (coff_section_data (abfd, sec) != NULL)

      && (pei_section_data (abfd, sec) != NULL))

    {

      /* If data directory is empty, rva also should be 0.  */

      int size = pei_section_data (abfd, sec)->virt_size;

      aout->DataDirectory[idx].Size = size;

      if (size)

  {

    aout->DataDirectory[idx].VirtualAddress =

      (sec->vma - base) & 0xffffffff;

    sec->flags |= SEC_DATA;

  }

    }

}

unsigned int

_bfd_pex64i_swap_aouthdr_out (bfd * abfd, void * in, void * out)

{

  struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;

  pe_data_type *pe = pe_data (abfd);

  struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;

  PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;

  bfd_vma sa, fa, ib;

  IMAGE_DATA_DIRECTORY idata2, idata5, tls;

  sa = extra->SectionAlignment;

  fa = extra->FileAlignment;

  ib = extra->ImageBase;

  idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];

  idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];

  tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];

  if (aouthdr_in->tsize)

    {

      aouthdr_in->text_start -= ib;

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

      aouthdr_in->text_start &= 0xffffffff;

#endif

    }

  if (aouthdr_in->dsize)

    {

      aouthdr_in->data_start -= ib;

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

      aouthdr_in->data_start &= 0xffffffff;

#endif

    }

  if (aouthdr_in->entry)

    {

      aouthdr_in->entry -= ib;

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

      aouthdr_in->entry &= 0xffffffff;

#endif

    }

#define FA(x) (((x) + fa -1 ) & (- fa))

#define SA(x) (((x) + sa -1 ) & (- sa))

  /* We like to have the sizes aligned.  */

  aouthdr_in->bsize = FA (aouthdr_in->bsize);

  extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;

  add_data_entry (abfd, extra, PE_EXPORT_TABLE, ".edata", ib);

  add_data_entry (abfd, extra, PE_RESOURCE_TABLE, ".rsrc", ib);

  add_data_entry (abfd, extra, PE_EXCEPTION_TABLE, ".pdata", ib);

  /* In theory we do not need to call add_data_entry for .idata$2 or

     .idata$5.  It will be done in bfd_coff_final_link where all the

     required information is available.  If however, we are not going

     to perform a final link, eg because we have been invoked by objcopy

     or strip, then we need to make sure that these Data Directory

     entries are initialised properly.

     So - we copy the input values into the output values, and then, if

     a final link is going to be performed, it can overwrite them.  */

  extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;

  extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;

  extra->DataDirectory[PE_TLS_TABLE] = tls;

  if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)

    /* Until other .idata fixes are made (pending patch), the entry for

       .idata is needed for backwards compatibility.  FIXME.  */

    add_data_entry (abfd, extra, PE_IMPORT_TABLE, ".idata", ib);

  /* For some reason, the virtual size (which is what's set by

     add_data_entry) for .reloc is not the same as the size recorded

     in this slot by MSVC; it doesn't seem to cause problems (so far),

     but since it's the best we've got, use it.  It does do the right

     thing for .pdata.  */

  if (pe->has_reloc_section)

    add_data_entry (abfd, extra, PE_BASE_RELOCATION_TABLE, ".reloc", ib);

  {

    asection *sec;

    bfd_vma hsize = 0;

    bfd_vma dsize = 0;

    bfd_vma isize = 0;

    bfd_vma tsize = 0;

    for (sec = abfd->sections; sec; sec = sec->next)

      {

  int rounded = FA (sec->size);

  if (rounded == 0)

    continue;

  /* The first non-zero section filepos is the header size.

     Sections without contents will have a filepos of 0.  */

  if (hsize == 0)

    hsize = sec->filepos;

  if (sec->flags & SEC_DATA)

    dsize += rounded;

  if (sec->flags & SEC_CODE)

    tsize += rounded;

  /* The image size is the total VIRTUAL size (which is what is

     in the virt_size field).  Files have been seen (from MSVC

     5.0 link.exe) where the file size of the .data segment is

     quite small compared to the virtual size.  Without this

     fix, strip munges the file.

     FIXME: We need to handle holes between sections, which may

     happpen when we covert from another format.  We just use

     the virtual address and virtual size of the last section

     for the image size.  */

  if (coff_section_data (abfd, sec) != NULL

      && pei_section_data (abfd, sec) != NULL)

    isize = (sec->vma - extra->ImageBase

       + SA (FA (pei_section_data (abfd, sec)->virt_size)));

      }

    aouthdr_in->dsize = dsize;

    aouthdr_in->tsize = tsize;

    extra->SizeOfHeaders = hsize;

    extra->SizeOfImage = isize;

  }

  H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);

  if (extra->MajorLinkerVersion || extra->MinorLinkerVersion)

    {

      H_PUT_8 (abfd, extra->MajorLinkerVersion,

         aouthdr_out->standard.vstamp);

      H_PUT_8 (abfd, extra->MinorLinkerVersion,

         aouthdr_out->standard.vstamp + 1);

    }

  else

    {

/* e.g. 219510000 is linker version 2.19  */

#define LINKER_VERSION ((short) (BFD_VERSION / 1000000))

      /* This piece of magic sets the "linker version" field to

   LINKER_VERSION.  */

      H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),

    aouthdr_out->standard.vstamp);

    }

  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);

  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);

  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);

  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);

  PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,

        aouthdr_out->standard.text_start);

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

  /* PE32+ does not have data_start member!  */

  PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,

        aouthdr_out->standard.data_start);

#endif

  PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);

  H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);

  H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);

  H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,

      aouthdr_out->MajorOperatingSystemVersion);

  H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,

      aouthdr_out->MinorOperatingSystemVersion);

  H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);

  H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);

  H_PUT_16 (abfd, extra->MajorSubsystemVersion,

      aouthdr_out->MajorSubsystemVersion);

  H_PUT_16 (abfd, extra->MinorSubsystemVersion,

      aouthdr_out->MinorSubsystemVersion);

  H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);

  H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);

  H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);

  H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);

  H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);

  H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);

  PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,

            aouthdr_out->SizeOfStackReserve);

  PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,

           aouthdr_out->SizeOfStackCommit);

  PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,

           aouthdr_out->SizeOfHeapReserve);

  PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,

          aouthdr_out->SizeOfHeapCommit);

  H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);

  H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,

      aouthdr_out->NumberOfRvaAndSizes);

  {

    int idx;

    for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)

      {

  H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,

      aouthdr_out->DataDirectory[idx][0]);

  H_PUT_32 (abfd, extra->DataDirectory[idx].Size,

      aouthdr_out->DataDirectory[idx][1]);

      }

  }

  return AOUTSZ;

}

unsigned int

_bfd_pex64i_only_swap_filehdr_out (bfd * abfd, void * in, void * out)

{

  int idx;

  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;

  struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;

  if (pe_data (abfd)->has_reloc_section

      || pe_data (abfd)->dont_strip_reloc)

    filehdr_in->f_flags &= ~F_RELFLG;

  if (pe_data (abfd)->dll)

    filehdr_in->f_flags |= F_DLL;

  filehdr_in->pe.e_magic    = IMAGE_DOS_SIGNATURE;

  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.  */

  memcpy (filehdr_in->pe.dos_message, pe_data (abfd)->dos_message,

    sizeof (filehdr_in->pe.dos_message));

  filehdr_in->pe.nt_signature = IMAGE_NT_SIGNATURE;

  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);

  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);

  /* Use a real timestamp by default, unless the no-insert-timestamp

     option was chosen.  */

  if ((pe_data (abfd)->timestamp) == -1)

    {

      time_t now;

      char *source_date_epoch;

      /* If the SOURCE_DATE_EPOCH environment variable is

   defined then use that as the time, otherwise use

   the current time.  */

      source_date_epoch = getenv ("SOURCE_DATE_EPOCH");

      if (source_date_epoch)

  now = (time_t) strtoll (source_date_epoch, NULL, 10);

      else

  now = time (NULL);

      H_PUT_32 (abfd, now, filehdr_out->f_timdat);

    }

  else

    H_PUT_32 (abfd, pe_data (abfd)->timestamp, filehdr_out->f_timdat);

  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,

          filehdr_out->f_symptr);

  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);

  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);

  H_PUT_16 (abfd, filehdr_in->f_flags, 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.  */

  H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);

  H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);

  H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);

  H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);

  H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);

  H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);

  H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);

  H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);

  H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);

  H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);

  H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);

  H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);

  H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);

  H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);

  for (idx = 0; idx < 4; idx++)

    H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);

  H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);

  H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);

  for (idx = 0; idx < 10; idx++)

    H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);

  H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);

  memcpy (filehdr_out->dos_message, filehdr_in->pe.dos_message,

    sizeof (filehdr_out->dos_message));

  /* Also put in the NT signature.  */

  H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);

  return FILHSZ;

}

unsigned int

_bfd_pex64_only_swap_filehdr_out (bfd * abfd, void * in, void * out)

{

  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;

  FILHDR *filehdr_out = (FILHDR *) out;

  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);

  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);

  H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);

  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);

  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);

  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);

  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);

  return FILHSZ;

}

unsigned int

_bfd_pex64i_swap_scnhdr_out (bfd * abfd, void * in, void * out)

{

  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;

  SCNHDR *scnhdr_ext = (SCNHDR *) out;

  unsigned int ret = SCNHSZ;

  bfd_vma ps;

  bfd_vma ss;

  memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));

  ss = scnhdr_int->s_vaddr - pe_data (abfd)->pe_opthdr.ImageBase;

  if (scnhdr_int->s_vaddr < pe_data (abfd)->pe_opthdr.ImageBase)

    _bfd_error_handler (_("%pB:%.8s: section below image base"),

                        abfd, scnhdr_int->s_name);

  /* Do not compare lower 32-bits for 64-bit vma.  */

#if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)

  else if(ss != (ss & 0xffffffff))

    _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd, scnhdr_int->s_name);

  PUT_SCNHDR_VADDR (abfd, ss & 0xffffffff, scnhdr_ext->s_vaddr);

#else

  PUT_SCNHDR_VADDR (abfd, ss, scnhdr_ext->s_vaddr);

#endif

  /* NT wants the size data to be rounded up to the next

     NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,

     sometimes).  */

  if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)

    {

      if (bfd_pei_p (abfd))

  {

    ps = scnhdr_int->s_size;

    ss = 0;

  }

      else

       {

   ps = 0;

   ss = scnhdr_int->s_size;

       }

    }

  else

    {

      if (bfd_pei_p (abfd))

  ps = scnhdr_int->s_paddr;

      else

  ps = 0;

      ss = scnhdr_int->s_size;

    }

  PUT_SCNHDR_SIZE (abfd, ss,

       scnhdr_ext->s_size);

  /* s_paddr in PE is really the virtual size.  */

  PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);

  PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,

         scnhdr_ext->s_scnptr);

  PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,

         scnhdr_ext->s_relptr);

  PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,

          scnhdr_ext->s_lnnoptr);

  {

    /* Extra flags must be set when dealing with PE.  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

       ARM-WINCE.  Although - how do we get the original alignment field

       back ?  */

    typedef struct

    {

      char section_name[SCNNMLEN];

      unsigned long must_have;

    }

    pe_required_section_flags;

    pe_required_section_flags known_sections [] =

      {

  { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },

  { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },

  { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },

  { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },

  { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },

  { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },

  { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },

  { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },

  { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },

  { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },

  { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },

  { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },

      };

    pe_required_section_flags * p;

    /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now

       we know exactly what this specific section wants so we remove it

       and then allow the must_have field to add it back in if necessary.

       However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the

       default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared

       by ld --enable-auto-import (if auto-import is actually needed),

       by ld --omagic, or by obcopy --writable-text.  */

    for (p = known_sections;

   p < known_sections + ARRAY_SIZE (known_sections);

   p++)

      if (memcmp (scnhdr_int->s_name, p->section_name, SCNNMLEN) == 0)

  {

    if (memcmp (scnhdr_int->s_name, ".text", sizeof ".text")

        || (bfd_get_file_flags (abfd) & WP_TEXT))

      scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;

    scnhdr_int->s_flags |= p->must_have;