[deliverable/binutils-gdb.git] / bfd / pei-x86_64.c

/* BFD back-end for Intel 386 PE IMAGE COFF files.
   Copyright 2006, 2007, 2009 Free Software Foundation, Inc.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 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.
   
   Written by Kai Tietz, OneVision Software GmbH&CoKg.  */

#include "sysdep.h"
#include "bfd.h"

#define TARGET_SYM 		x86_64pei_vec
#define TARGET_NAME 		"pei-x86-64"
#define COFF_IMAGE_WITH_PE
#define COFF_WITH_PE
#define COFF_WITH_pex64
#define PCRELOFFSET 		TRUE
#if defined (USE_MINGW64_LEADING_UNDERSCORES)
#define TARGET_UNDERSCORE 	'_'
#else
#define TARGET_UNDERSCORE 	0
#endif
/* Long section names not allowed in executable images, only object files.  */
#define COFF_LONG_SECTION_NAMES 0
#define COFF_SUPPORT_GNU_LINKONCE
#define COFF_LONG_FILENAMES
#define PDATA_ROW_SIZE	(3 * 4)

#define COFF_SECTION_ALIGNMENT_ENTRIES \
{ COFF_SECTION_NAME_EXACT_MATCH (".bss"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".data"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".rdata"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".text"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".idata"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".pdata"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi."), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }

/* Note we have to make sure not to include headers twice.
   Not all headers are wrapped in #ifdef guards, so we define
   PEI_HEADERS to prevent double including in coff-x86_64.c  */
#define PEI_HEADERS
#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include "coff/x86_64.h"
#include "coff/internal.h"
#include "coff/pe.h"
#include "libcoff.h"
#include "libpei.h"
#include "libiberty.h"

#undef AOUTSZ
#define AOUTSZ		PEPAOUTSZ
#define PEAOUTHDR	PEPAOUTHDR

static const char *pex_regs[16] = {
  "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
};

static void
pex64_get_runtime_function (bfd *abfd, struct pex64_runtime_function *rf,
			    const void *data)
{
  const struct external_pex64_runtime_function *ex_rf =
    (const struct external_pex64_runtime_function *) data;
  rf->rva_BeginAddress = bfd_get_32 (abfd, ex_rf->rva_BeginAddress);
  rf->rva_EndAddress = bfd_get_32 (abfd, ex_rf->rva_EndAddress);
  rf->rva_UnwindData =	bfd_get_32 (abfd, ex_rf->rva_UnwindData);
  rf->isChained = PEX64_IS_RUNTIME_FUNCTION_CHAINED (rf);
  rf->rva_UnwindData = PEX64_GET_UNWINDDATA_UNIFIED_RVA (rf);
}

static void
pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui, void *data)
{
  struct external_pex64_unwind_info *ex_ui =
    (struct external_pex64_unwind_info *) data;
  bfd_byte *ex_dta = (bfd_byte *) data;

  memset (ui, 0, sizeof (struct pex64_unwind_info));
  ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
  ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
  ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
  ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
  ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
  ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
  ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
  ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
  ui->rawUnwindCodes = &ex_dta[4];
  ex_dta += ui->SizeOfBlock;
  switch (ui->Flags)
    {
    case UNW_FLAG_CHAININFO:
      ui->rva_FunctionEntry = bfd_get_32 (abfd, ex_dta);
      ui->SizeOfBlock += 4;
      return;
    default:
      return;
    }
}

static void
pex64_xdata_print_uwd_codes (FILE *file, struct pex64_unwind_info *ui,
			     bfd_vma pc_addr)
{
  bfd_vma i;
  bfd_vma tmp = 0;
  const bfd_byte *insns[256];
  bfd_vma insns_count = 0;
  const bfd_byte *dta = ui->rawUnwindCodes;

  if (ui->CountOfCodes == 0 || !dta)
    return;

  /* Sort array ascending. Note: it is stored in reversed order.  */
  for (i = 0; i < ui->CountOfCodes; i++)
    {
      const bfd_byte *t;

      t = insns[insns_count++] = &dta[i * 2];
      switch (PEX64_UNWCODE_CODE (t[1]))
	{
	case UWOP_PUSH_NONVOL:
	case UWOP_ALLOC_SMALL:
	case UWOP_SET_FPREG:
	case UWOP_PUSH_MACHFRAME:
	  break;
	case UWOP_ALLOC_LARGE:
	  if (PEX64_UNWCODE_INFO (t[1]) == 0)
	    {
	      i += 1;
	      break;
	    }
	  else if (PEX64_UNWCODE_INFO (t[1]) == 1)
	    {
	      i += 2;
	      break;
	    }
	  /* fall through.  */
	default:
	  fprintf (file, "\t contains unknown code (%u).\n",
		   (unsigned int) PEX64_UNWCODE_CODE (t[1]));
	  return;
	case UWOP_SAVE_NONVOL:
	case UWOP_SAVE_XMM:
	case UWOP_SAVE_XMM128:
	  i++;
	  break;
	case UWOP_SAVE_NONVOL_FAR:
	case UWOP_SAVE_XMM_FAR:
	case UWOP_SAVE_XMM128_FAR:
	  i += 2;
	  break;
	}
    }
  fprintf (file, "\t At pc 0x");
  fprintf_vma (file, pc_addr);
  fprintf (file, " there are the following saves (in logical order).\n");
  for (i = insns_count; i > 0;)
    {
      --i;
      dta = insns[i];
      fprintf (file, "\t  insn ends at pc+0x%02x: ", (unsigned int) dta[0]);
      switch (PEX64_UNWCODE_CODE (dta[1]))
	{
	case UWOP_PUSH_NONVOL:
	  fprintf (file, "push %s.\n", pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
	  break;
	case UWOP_ALLOC_LARGE:
	  if (PEX64_UNWCODE_INFO (dta[1]) == 0)
	    {
	      tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
	      tmp *= 8;
	    }
	  else
	    tmp = (bfd_vma) (*((unsigned int *)&dta[2]));
	  fprintf (file, "save stack region of size 0x");
	  fprintf_vma (file, tmp);
	  fprintf (file,".\n");
	  break;
	case UWOP_ALLOC_SMALL:
	  tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
	  tmp += 1;
	  tmp *= 8;
	  fprintf (file, "save stack region of size 0x");
	  fprintf_vma (file, tmp);
	  fprintf (file,".\n");
	  break;
	case UWOP_SET_FPREG:
	  tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
	  tmp *= 16;
	  fprintf (file, "FPReg = (FrameReg) + 0x");
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_SAVE_NONVOL:
	  fprintf (file, "mov %s at 0x",
		   pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
	  tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
	  tmp *= 8;
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_SAVE_NONVOL_FAR:
	  fprintf (file, "mov %s at 0x",
		   pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
	  tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_SAVE_XMM:
	  tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
	  tmp *= 8;
	  fprintf (file, "mov mm%u at 0x",
		   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_SAVE_XMM_FAR:
	  tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
	  fprintf (file, "mov mm%u at 0x",
		   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_SAVE_XMM128:
	  tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
	  tmp *= 16;
	  fprintf (file, "mov xmm%u at 0x",
		   (unsigned int) PEX64_UNWCODE_INFO ( dta[1]));
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_SAVE_XMM128_FAR:
	  tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
	  fprintf (file, "mov xmm%u at 0x",
		   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
	  fprintf_vma (file, tmp);
	  fprintf (file, ".\n");
	  break;
	case UWOP_PUSH_MACHFRAME:
	  fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
	  if (PEX64_UNWCODE_INFO (dta[1]) == 0)
	    {
	      fprintf (file, ")");
	    }
	  else if (PEX64_UNWCODE_INFO (dta[1]) == 1)
	    {
	      fprintf (file, ",ErrorCode)");
	    }
	  else
	    fprintf (file, ", unknown(%u))",
		     (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
	  fprintf (file,".\n");
	  break;
	default:
	  fprintf (file, "unknown code %u.\n",
		   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
	  break;
      }
    }
}

static asection *
pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
{
  asection *section = bfd_get_section_by_name (abfd, sec_name);
  bfd_vma vsize;
  bfd_size_type datasize = 0;

  if (section == NULL
      || coff_section_data (abfd, section) == NULL
      || pei_section_data (abfd, section) == NULL)
    return NULL;
  vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
  datasize = section->size;
  if (!datasize || vsize > addr || (vsize + datasize) < addr)
    return NULL;
  return section;
}

static void
pex64_dump_xdata (FILE *file, bfd *abfd, bfd_vma addr, bfd_vma pc_addr,
		  bfd_vma *endx)
{
  asection *section = pex64_get_section_by_rva (abfd, addr, ".rdata");
  bfd_vma vsize;
  bfd_byte *data = NULL;
  bfd_vma end_addr;

  if (!section)
    section = pex64_get_section_by_rva (abfd, addr, ".data");
  if (!section)
    section = pex64_get_section_by_rva (abfd, addr, ".xdata");
  if (!section)
    {
      section = pex64_get_section_by_rva (abfd, addr, ".pdata");
      if (section)
	{
	  fprintf (file, "\t Shares information with pdata element at 0x");
	  fprintf_vma (file, addr + pe_data (abfd)->pe_opthdr.ImageBase);
	  fprintf (file, ".\n");
	}
    }
  if (!section)
    return;

  vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
  addr -= vsize;

  if (endx)
    end_addr = endx[0] - vsize;
  else
    end_addr = (section->rawsize != 0 ? section->rawsize : section->size);

  if (bfd_malloc_and_get_section (abfd, section, &data))
    {
      struct pex64_unwind_info ui;

      if (!data)
	return;

      pex64_get_unwind_info (abfd, &ui, &data[addr]);

      if (ui.Version != 1)
	{
	  fprintf (file, "\tVersion %u (unknown).\n", (unsigned int) ui.Version);
	  return;
	}

      fprintf (file, "\tFlags: ");
      switch (ui.Flags)
	{
	case UNW_FLAG_NHANDLER:
	  fprintf (file, "UNW_FLAG_NHANDLER");
	  break;
	case UNW_FLAG_EHANDLER:
	  fprintf (file, "UNW_FLAG_EHANDLER");
	  break;
	case UNW_FLAG_UHANDLER:
	  fprintf (file, "UNW_FLAG_UHANDLER");
	  break;
	case UNW_FLAG_FHANDLER:
	  fprintf (file, "UNW_FLAG_FHANDLER = (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER)");
	  break;
	case UNW_FLAG_CHAININFO:
	  fprintf (file, "UNW_FLAG_CHAININFO");
	  break;
	default:
	  fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
	  break;
	}
      fprintf (file, ".\n");
      if (ui.CountOfCodes != 0)
	fprintf (file, "\tEntry has %u codes.", (unsigned int) ui.CountOfCodes);
      fprintf (file, "\tPrologue size: %u, Frame offset = 0x%x.\n",
	       (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
      fprintf (file, "\tFrame register is %s.\n",
	ui.FrameRegister == 0 ? "none"
			      : pex_regs[(unsigned int) ui.FrameRegister]);

      pex64_xdata_print_uwd_codes (file, &ui, pc_addr);
      
      /* Now we need end of this xdata block.  */
      addr += ui.SizeOfBlock;
      if (addr < end_addr)
        {
	  unsigned int i;
	  fprintf (file,"\tUser data:\n");
	  for (i = 0; addr < end_addr; addr += 1, i++)
	    {
	      if ((i & 15) == 0)
	        fprintf (file, "\t  %03x:", i);
	      fprintf (file, " %02x", data[addr]);
	      if ((i & 15) == 15)
	        fprintf (file, "\n");
	    }
	  if ((i & 15) != 0)
	    fprintf (file, "\n");
        }
    }
  if (data != NULL)
    free (data);
}

static int
sort_xdata_arr (const void *l, const void *r)
{
  const bfd_vma *lp = (const bfd_vma *) l;
  const bfd_vma *rp = (const bfd_vma *) r;

  if (*lp == *rp)
    return 0;
  return (*lp < *rp ? -1 : 1);
}

static bfd_boolean
pex64_bfd_print_pdata (bfd *abfd, void *vfile)
{
  FILE *file = (FILE *) vfile;
  bfd_byte *data = NULL;
  asection *section = bfd_get_section_by_name (abfd, ".pdata");
  bfd_size_type datasize = 0;
  bfd_size_type i;
  bfd_size_type stop;
  bfd_vma prev_beginaddress = 0;
  int onaline = PDATA_ROW_SIZE;
  int seen_error = 0;
  bfd_vma *xdata_arr;
  int xdata_arr_cnt;

  if (section == NULL
      || coff_section_data (abfd, section) == NULL
      || pei_section_data (abfd, section) == NULL)
    return TRUE;

  stop = pei_section_data (abfd, section)->virt_size;
  if ((stop % onaline) != 0)
    fprintf (file,
	     _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
	     (long) stop, onaline);

  fprintf (file,
	   _("\nThe Function Table (interpreted .pdata section contents)\n"));

  fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));

  datasize = section->size;
  if (datasize == 0)
    return TRUE;

  if (!bfd_malloc_and_get_section (abfd, section, &data))
    {
      if (data != NULL)
	free (data);
      return FALSE;
    }

  xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1));
  xdata_arr_cnt = 0;
  /* Do sanity check of pdata.  */
  for (i = 0; i < stop; i += onaline)
    {
      struct pex64_runtime_function rf;

      if (i + PDATA_ROW_SIZE > stop)
	break;
      pex64_get_runtime_function (abfd, &rf, &data[i]);

      if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	  && rf.rva_UnwindData == 0)
	/* We are probably into the padding of the section now.  */
	break;
      fputc (' ', file);
      fprintf_vma (file, i + section->vma);
      fprintf (file, ":\t");
      fprintf_vma (file, rf.rva_BeginAddress);
      fputc (' ', file);
      fprintf_vma (file, rf.rva_EndAddress);
      fputc (' ', file);
      fprintf_vma (file, rf.rva_UnwindData);
      fprintf (file, "\n");
      if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
	{
	  seen_error = 1;
	  fprintf (file, "  has %s begin address as predecessor\n",
	    (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
        }
      prev_beginaddress = rf.rva_BeginAddress;
      /* Now we check for negative addresses.  */
      if ((prev_beginaddress & 0x80000000) != 0)
	{
	  seen_error = 1;
	  fprintf (file, "  has negative begin address\n");
	}
      if ((rf.rva_EndAddress & 0x80000000) != 0)
	{
	  seen_error = 1;
	  fprintf (file, "  has negative end address\n");
	}
      if ((rf.rva_UnwindData & 0x80000000) != 0)
	{
	  seen_error = 1;
	  fprintf (file, "  has negative unwind address\n");
	}
      if (rf.rva_UnwindData && !rf.isChained)
        xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
    }

  if (seen_error)
    {
      free (data);
      free (xdata_arr);

      return TRUE;
    }

  /* Add end of list marker.  */
  xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);

  /* Sort start RVAs of xdata.  */
  if (xdata_arr_cnt > 1)
    qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
	   sort_xdata_arr);

  /* Do dump of pdata related xdata.  */

  for (i = 0; i < stop; i += onaline)
    {
      struct pex64_runtime_function rf;

      if (i + PDATA_ROW_SIZE > stop)
	break;
      pex64_get_runtime_function (abfd, &rf, &data[i]);

      if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	  && rf.rva_UnwindData == 0)
	/* We are probably into the padding of the section now.  */
	break;
      if (i == 0)
        fprintf (file, "\nDump of .xdata\n");
      fputc (' ', file);
      fprintf_vma (file, rf.rva_UnwindData);
      fprintf (file, ":\n");

      rf.rva_BeginAddress += pe_data (abfd)->pe_opthdr.ImageBase;
      rf.rva_EndAddress += pe_data (abfd)->pe_opthdr.ImageBase;

      if (rf.rva_UnwindData != 0)
	{
	  if (rf.isChained)
	    {
	      fprintf (file, "\t shares information with pdata element at 0x");
	      fprintf_vma (file, rf.rva_UnwindData);
	      fprintf (file, ".\n");
	    }
	  else
	    {
	      bfd_vma *p;

	      /* Search for the current entry in the sorted array.  */
	      p = (bfd_vma *)
	          bsearch (&rf.rva_UnwindData, xdata_arr,
			   (size_t) xdata_arr_cnt, sizeof (bfd_vma),
			   sort_xdata_arr);

	      /* Advance to the next pointer into the xdata section.  We may
		 have shared xdata entries, which will result in a string of
		 identical pointers in the array; advance past all of them.  */
	      while (p[0] <= rf.rva_UnwindData)
		++p;
	      if (p[0] == ~((bfd_vma) 0))
		p = NULL;

	      pex64_dump_xdata (file, abfd, rf.rva_UnwindData,
				rf.rva_BeginAddress, p);
	    }
	}
    }

  free (data);
  free (xdata_arr);

  return TRUE;
}

#define bfd_pe_print_pdata   pex64_bfd_print_pdata

#include "coff-x86_64.c"
Commit	Line	Data
99ad8390	1	/* BFD back-end for Intel 386 PE IMAGE COFF files.
88183869	2	Copyright 2006, 2007, 2009 Free Software Foundation, Inc.
99ad8390 NC	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
cd123cb7	8	the Free Software Foundation; either version 3 of the License, or
99ad8390 NC	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
cd123cb7 NC	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
cd123cb7 NC	19	MA 02110-1301, USA.
99ad8390 NC	20
	21	Written by Kai Tietz, OneVision Software GmbH&CoKg. */
	22
99ad8390	23	#include "sysdep.h"
3db64b00	24	#include "bfd.h"
99ad8390 NC	25
	26	#define TARGET_SYM x86_64pei_vec
	27	#define TARGET_NAME "pei-x86-64"
	28	#define COFF_IMAGE_WITH_PE
	29	#define COFF_WITH_PE
	30	#define COFF_WITH_pex64
	31	#define PCRELOFFSET TRUE
ef72a554	32	#if defined (USE_MINGW64_LEADING_UNDERSCORES)
99ad8390	33	#define TARGET_UNDERSCORE '_'
ef72a554 KT	34	#else
	35	#define TARGET_UNDERSCORE 0
	36	#endif
88183869 DK	37	/* Long section names not allowed in executable images, only object files. */
88183869 DK	38	#define COFF_LONG_SECTION_NAMES 0
99ad8390 NC	39	#define COFF_SUPPORT_GNU_LINKONCE
99ad8390 NC	40	#define COFF_LONG_FILENAMES
e48570bb	41	#define PDATA_ROW_SIZE (3 * 4)
99ad8390 NC	42
	43	#define COFF_SECTION_ALIGNMENT_ENTRIES \
	44	{ COFF_SECTION_NAME_EXACT_MATCH (".bss"), \
	45	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
51ec9544	46	{ COFF_SECTION_NAME_PARTIAL_MATCH (".data"), \
99ad8390	47	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
51ec9544	48	{ COFF_SECTION_NAME_PARTIAL_MATCH (".rdata"), \
99ad8390	49	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
51ec9544	50	{ COFF_SECTION_NAME_PARTIAL_MATCH (".text"), \
99ad8390 NC	51	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
	52	{ COFF_SECTION_NAME_PARTIAL_MATCH (".idata"), \
	53	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
	54	{ COFF_SECTION_NAME_EXACT_MATCH (".pdata"), \
	55	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
	56	{ COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
	57	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
	58	{ COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi."), \
	59	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }
	60
e48570bb DK	61	/* Note we have to make sure not to include headers twice.
	62	Not all headers are wrapped in #ifdef guards, so we define
	63	PEI_HEADERS to prevent double including in coff-x86_64.c */
	64	#define PEI_HEADERS
	65	#include "sysdep.h"
	66	#include "bfd.h"
	67	#include "libbfd.h"
	68	#include "coff/x86_64.h"
	69	#include "coff/internal.h"
	70	#include "coff/pe.h"
	71	#include "libcoff.h"
	72	#include "libpei.h"
	73	#include "libiberty.h"
	74
	75	#undef AOUTSZ
	76	#define AOUTSZ PEPAOUTSZ
	77	#define PEAOUTHDR PEPAOUTHDR
	78
	79	static const char *pex_regs[16] = {
	80	"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
	81	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
	82	};
	83
	84	static void
	85	pex64_get_runtime_function (bfd abfd, struct pex64_runtime_function rf,
	86	const void *data)
	87	{
	88	const struct external_pex64_runtime_function *ex_rf =
	89	(const struct external_pex64_runtime_function *) data;
	90	rf->rva_BeginAddress = bfd_get_32 (abfd, ex_rf->rva_BeginAddress);
	91	rf->rva_EndAddress = bfd_get_32 (abfd, ex_rf->rva_EndAddress);
	92	rf->rva_UnwindData = bfd_get_32 (abfd, ex_rf->rva_UnwindData);
	93	rf->isChained = PEX64_IS_RUNTIME_FUNCTION_CHAINED (rf);
	94	rf->rva_UnwindData = PEX64_GET_UNWINDDATA_UNIFIED_RVA (rf);
	95	}
	96
	97	static void
	98	pex64_get_unwind_info (bfd abfd, struct pex64_unwind_info ui, void *data)
	99	{
	100	struct external_pex64_unwind_info *ex_ui =
	101	(struct external_pex64_unwind_info *) data;
	102	bfd_byte ex_dta = (bfd_byte ) data;
	103
	104	memset (ui, 0, sizeof (struct pex64_unwind_info));
	105	ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
	106	ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
	107	ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
	108	ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
	109	ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
	110	ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
	111	ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
	112	ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
	113	ui->rawUnwindCodes = &ex_dta[4];
	114	ex_dta += ui->SizeOfBlock;
	115	switch (ui->Flags)
	116	{
e48570bb DK	117	case UNW_FLAG_CHAININFO:
	118	ui->rva_FunctionEntry = bfd_get_32 (abfd, ex_dta);
	119	ui->SizeOfBlock += 4;
	120	return;
	121	default:
	122	return;
	123	}
e48570bb DK	124	}
	125
	126	static void
	127	pex64_xdata_print_uwd_codes (FILE file, struct pex64_unwind_info ui,
	128	bfd_vma pc_addr)
	129	{
	130	bfd_vma i;
	131	bfd_vma tmp = 0;
	132	const bfd_byte *insns[256];
	133	bfd_vma insns_count = 0;
	134	const bfd_byte *dta = ui->rawUnwindCodes;
	135
	136	if (ui->CountOfCodes == 0 \|\| !dta)
	137	return;
	138
	139	/* Sort array ascending. Note: it is stored in reversed order. */
	140	for (i = 0; i < ui->CountOfCodes; i++)
	141	{
	142	const bfd_byte *t;
	143
	144	t = insns[insns_count++] = &dta[i * 2];
	145	switch (PEX64_UNWCODE_CODE (t[1]))
	146	{
	147	case UWOP_PUSH_NONVOL:
	148	case UWOP_ALLOC_SMALL:
	149	case UWOP_SET_FPREG:
	150	case UWOP_PUSH_MACHFRAME:
	151	break;
	152	case UWOP_ALLOC_LARGE:
	153	if (PEX64_UNWCODE_INFO (t[1]) == 0)
	154	{
	155	i += 1;
	156	break;
	157	}
	158	else if (PEX64_UNWCODE_INFO (t[1]) == 1)
	159	{
	160	i += 2;
	161	break;
	162	}
	163	/* fall through. */
	164	default:
	165	fprintf (file, "\t contains unknown code (%u).\n",
	166	(unsigned int) PEX64_UNWCODE_CODE (t[1]));
	167	return;
	168	case UWOP_SAVE_NONVOL:
	169	case UWOP_SAVE_XMM:
	170	case UWOP_SAVE_XMM128:
	171	i++;
	172	break;
	173	case UWOP_SAVE_NONVOL_FAR:
	174	case UWOP_SAVE_XMM_FAR:
	175	case UWOP_SAVE_XMM128_FAR:
	176	i += 2;
	177	break;
	178	}
	179	}
	180	fprintf (file, "\t At pc 0x");
	181	fprintf_vma (file, pc_addr);
	182	fprintf (file, " there are the following saves (in logical order).\n");
	183	for (i = insns_count; i > 0;)
	184	{
	185	--i;
	186	dta = insns[i];
	187	fprintf (file, "\t insn ends at pc+0x%02x: ", (unsigned int) dta[0]);
188	switch (PEX64_UNWCODE_CODE (dta[1]))
189	{
190	case UWOP_PUSH_NONVOL:
191	fprintf (file, "push %s.\n", pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
192	break;
193	case UWOP_ALLOC_LARGE:
194	if (PEX64_UNWCODE_INFO (dta[1]) == 0)
195	{
196	tmp = (bfd_vma) (((unsigned short ) &dta[2]));
197	tmp *= 8;
198	}
199	else
200	tmp = (bfd_vma) (((unsigned int )&dta[2]));
201	fprintf (file, "save stack region of size 0x");
202	fprintf_vma (file, tmp);
203	fprintf (file,".\n");
204	break;
205	case UWOP_ALLOC_SMALL:
206	tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
207	tmp += 1;
208	tmp *= 8;
209	fprintf (file, "save stack region of size 0x");
210	fprintf_vma (file, tmp);
211	fprintf (file,".\n");
212	break;
213	case UWOP_SET_FPREG:
214	tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
215	tmp *= 16;
216	fprintf (file, "FPReg = (FrameReg) + 0x");
217	fprintf_vma (file, tmp);
218	fprintf (file, ".\n");
219	break;
220	case UWOP_SAVE_NONVOL:
221	fprintf (file, "mov %s at 0x",
222	pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
223	tmp = (bfd_vma) (((unsigned short ) &dta[2]));
224	tmp *= 8;
225	fprintf_vma (file, tmp);
226	fprintf (file, ".\n");
227	break;
228	case UWOP_SAVE_NONVOL_FAR:
229	fprintf (file, "mov %s at 0x",
230	pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
231	tmp = (bfd_vma) (((unsigned int ) &dta[2]));
232	fprintf_vma (file, tmp);
233	fprintf (file, ".\n");
234	break;
235	case UWOP_SAVE_XMM:
236	tmp = (bfd_vma) (((unsigned short ) &dta[2]));
237	tmp *= 8;
238	fprintf (file, "mov mm%u at 0x",
239	(unsigned int) PEX64_UNWCODE_INFO (dta[1]));
240	fprintf_vma (file, tmp);
241	fprintf (file, ".\n");
242	break;
243	case UWOP_SAVE_XMM_FAR:
244	tmp = (bfd_vma) (((unsigned int ) &dta[2]));
245	fprintf (file, "mov mm%u at 0x",
246	(unsigned int) PEX64_UNWCODE_INFO (dta[1]));
247	fprintf_vma (file, tmp);
248	fprintf (file, ".\n");
249	break;
250	case UWOP_SAVE_XMM128:
251	tmp = (bfd_vma) (((unsigned short ) &dta[2]));
252	tmp *= 16;
253	fprintf (file, "mov xmm%u at 0x",
254	(unsigned int) PEX64_UNWCODE_INFO ( dta[1]));
255	fprintf_vma (file, tmp);
256	fprintf (file, ".\n");
257	break;
258	case UWOP_SAVE_XMM128_FAR:
259	tmp = (bfd_vma) (((unsigned int ) &dta[2]));
260	fprintf (file, "mov xmm%u at 0x",
261	(unsigned int) PEX64_UNWCODE_INFO (dta[1]));
262	fprintf_vma (file, tmp);
263	fprintf (file, ".\n");
264	break;
265	case UWOP_PUSH_MACHFRAME:
266	fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
267	if (PEX64_UNWCODE_INFO (dta[1]) == 0)
268	{
269	fprintf (file, ")");
270	}
271	else if (PEX64_UNWCODE_INFO (dta[1]) == 1)
272	{
273	fprintf (file, ",ErrorCode)");
274	}
275	else
276	fprintf (file, ", unknown(%u))",
277	(unsigned int) PEX64_UNWCODE_INFO (dta[1]));
278	fprintf (file,".\n");
279	break;
280	default:
281	fprintf (file, "unknown code %u.\n",
282	(unsigned int) PEX64_UNWCODE_INFO (dta[1]));
283	break;
284	}
285	}
286	}
287
288	static asection *
289	pex64_get_section_by_rva (bfd abfd, bfd_vma addr, const char sec_name)
290	{
291	asection *section = bfd_get_section_by_name (abfd, sec_name);
292	bfd_vma vsize;
293	bfd_size_type datasize = 0;
294
295	if (section == NULL
296	\|\| coff_section_data (abfd, section) == NULL
297	\|\| pei_section_data (abfd, section) == NULL)
298	return NULL;
299	vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
300	datasize = section->size;
301	if (!datasize \|\| vsize > addr \|\| (vsize + datasize) < addr)
302	return NULL;
303	return section;
304	}
305
306	static void
2eb03909	307	pex64_dump_xdata (FILE file, bfd abfd, bfd_vma addr, bfd_vma pc_addr,
1360ae66	308	bfd_vma *endx)
e48570bb DK	309	{
	310	asection *section = pex64_get_section_by_rva (abfd, addr, ".rdata");
	311	bfd_vma vsize;
	312	bfd_byte *data = NULL;
2eb03909	313	bfd_vma end_addr;
e48570bb DK	314
	315	if (!section)
	316	section = pex64_get_section_by_rva (abfd, addr, ".data");
	317	if (!section)
	318	section = pex64_get_section_by_rva (abfd, addr, ".xdata");
	319	if (!section)
	320	{
	321	section = pex64_get_section_by_rva (abfd, addr, ".pdata");
	322	if (section)
	323	{
	324	fprintf (file, "\t Shares information with pdata element at 0x");
	325	fprintf_vma (file, addr + pe_data (abfd)->pe_opthdr.ImageBase);
	326	fprintf (file, ".\n");
	327	}
	328	}
	329	if (!section)
	330	return;
2eb03909	331
e48570bb DK	332	vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
e48570bb DK	333	addr -= vsize;
2eb03909	334
1360ae66 KT	335	if (endx)
	336	end_addr = endx[0] - vsize;
	337	else
	338	end_addr = (section->rawsize != 0 ? section->rawsize : section->size);
2eb03909	339
e48570bb DK	340	if (bfd_malloc_and_get_section (abfd, section, &data))
	341	{
	342	struct pex64_unwind_info ui;
	343
	344	if (!data)
	345	return;
	346
	347	pex64_get_unwind_info (abfd, &ui, &data[addr]);
	348
	349	if (ui.Version != 1)
	350	{
	351	fprintf (file, "\tVersion %u (unknown).\n", (unsigned int) ui.Version);
	352	return;
	353	}
	354
	355	fprintf (file, "\tFlags: ");
	356	switch (ui.Flags)
	357	{
	358	case UNW_FLAG_NHANDLER:
	359	fprintf (file, "UNW_FLAG_NHANDLER");
	360	break;
	361	case UNW_FLAG_EHANDLER:
	362	fprintf (file, "UNW_FLAG_EHANDLER");
	363	break;
	364	case UNW_FLAG_UHANDLER:
	365	fprintf (file, "UNW_FLAG_UHANDLER");
	366	break;
	367	case UNW_FLAG_FHANDLER:
	368	fprintf (file, "UNW_FLAG_FHANDLER = (UNW_FLAG_EHANDLER \| UNW_FLAG_UHANDLER)");
	369	break;
	370	case UNW_FLAG_CHAININFO:
	371	fprintf (file, "UNW_FLAG_CHAININFO");
	372	break;
	373	default:
	374	fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
	375	break;
	376	}
	377	fprintf (file, ".\n");
	378	if (ui.CountOfCodes != 0)
	379	fprintf (file, "\tEntry has %u codes.", (unsigned int) ui.CountOfCodes);
	380	fprintf (file, "\tPrologue size: %u, Frame offset = 0x%x.\n",
	381	(unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
	382	fprintf (file, "\tFrame register is %s.\n",
1360ae66	383	ui.FrameRegister == 0 ? "none"
e48570bb DK	384	: pex_regs[(unsigned int) ui.FrameRegister]);
	385
	386	pex64_xdata_print_uwd_codes (file, &ui, pc_addr);
	387
2eb03909 KT	388	/* Now we need end of this xdata block. */
	389	addr += ui.SizeOfBlock;
	390	if (addr < end_addr)
	391	{
	392	unsigned int i;
	393	fprintf (file,"\tUser data:\n");
	394	for (i = 0; addr < end_addr; addr += 1, i++)
	395	{
	396	if ((i & 15) == 0)
	397	fprintf (file, "\t %03x:", i);
	398	fprintf (file, " %02x", data[addr]);
	399	if ((i & 15) == 15)
	400	fprintf (file, "\n");
	401	}
	402	if ((i & 15) != 0)
	403	fprintf (file, "\n");
	404	}
e48570bb DK	405	}
	406	if (data != NULL)
	407	free (data);
	408	}
	409
1360ae66 KT	410	static int
	411	sort_xdata_arr (const void l, const void r)
	412	{
	413	const bfd_vma lp = (const bfd_vma ) l;
	414	const bfd_vma rp = (const bfd_vma ) r;
	415
	416	if (lp == rp)
	417	return 0;
	418	return (lp < rp ? -1 : 1);
	419	}
	420
e48570bb DK	421	static bfd_boolean
	422	pex64_bfd_print_pdata (bfd abfd, void vfile)
	423	{
	424	FILE file = (FILE ) vfile;
	425	bfd_byte *data = NULL;
	426	asection *section = bfd_get_section_by_name (abfd, ".pdata");
	427	bfd_size_type datasize = 0;
	428	bfd_size_type i;
2eb03909 KT	429	bfd_size_type stop;
2eb03909 KT	430	bfd_vma prev_beginaddress = 0;
e48570bb	431	int onaline = PDATA_ROW_SIZE;
2eb03909	432	int seen_error = 0;
1360ae66 KT	433	bfd_vma *xdata_arr;
1360ae66 KT	434	int xdata_arr_cnt;
e48570bb DK	435
	436	if (section == NULL
	437	\|\| coff_section_data (abfd, section) == NULL
	438	\|\| pei_section_data (abfd, section) == NULL)
	439	return TRUE;
	440
	441	stop = pei_section_data (abfd, section)->virt_size;
	442	if ((stop % onaline) != 0)
	443	fprintf (file,
	444	_("warning: .pdata section size (%ld) is not a multiple of %d\n"),
	445	(long) stop, onaline);
	446
	447	fprintf (file,
	448	_("\nThe Function Table (interpreted .pdata section contents)\n"));
	449
	450	fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t UnwindData\n"));
	451
	452	datasize = section->size;
	453	if (datasize == 0)
	454	return TRUE;
	455
	456	if (!bfd_malloc_and_get_section (abfd, section, &data))
	457	{
	458	if (data != NULL)
	459	free (data);
	460	return FALSE;
	461	}
	462
1360ae66 KT	463	xdata_arr = (bfd_vma ) xmalloc (sizeof (bfd_vma) ((stop / onaline) + 1));
1360ae66 KT	464	xdata_arr_cnt = 0;
2eb03909 KT	465	/* Do sanity check of pdata. */
2eb03909 KT	466	for (i = 0; i < stop; i += onaline)
e48570bb DK	467	{
	468	struct pex64_runtime_function rf;
	469
	470	if (i + PDATA_ROW_SIZE > stop)
	471	break;
	472	pex64_get_runtime_function (abfd, &rf, &data[i]);
	473
	474	if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	475	&& rf.rva_UnwindData == 0)
	476	/* We are probably into the padding of the section now. */
	477	break;
e48570bb DK	478	fputc (' ', file);
	479	fprintf_vma (file, i + section->vma);
	480	fprintf (file, ":\t");
e48570bb DK	481	fprintf_vma (file, rf.rva_BeginAddress);
e48570bb DK	482	fputc (' ', file);
e48570bb DK	483	fprintf_vma (file, rf.rva_EndAddress);
	484	fputc (' ', file);
	485	fprintf_vma (file, rf.rva_UnwindData);
	486	fprintf (file, "\n");
2eb03909 KT	487	if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
	488	{
	489	seen_error = 1;
	490	fprintf (file, " has %s begin address as predecessor\n",
	491	(rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
	492	}
	493	prev_beginaddress = rf.rva_BeginAddress;
	494	/* Now we check for negative addresses. */
	495	if ((prev_beginaddress & 0x80000000) != 0)
	496	{
	497	seen_error = 1;
	498	fprintf (file, " has negative begin address\n");
	499	}
	500	if ((rf.rva_EndAddress & 0x80000000) != 0)
	501	{
	502	seen_error = 1;
	503	fprintf (file, " has negative end address\n");
	504	}
	505	if ((rf.rva_UnwindData & 0x80000000) != 0)
	506	{
	507	seen_error = 1;
	508	fprintf (file, " has negative unwind address\n");
	509	}
1360ae66 KT	510	if (rf.rva_UnwindData && !rf.isChained)
1360ae66 KT	511	xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
2eb03909 KT	512	}
	513
	514	if (seen_error)
	515	{
	516	free (data);
1360ae66	517	free (xdata_arr);
2eb03909 KT	518
	519	return TRUE;
	520	}
1360ae66 KT	521
	522	/* Add end of list marker. */
	523	xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);
	524
	525	/* Sort start RVAs of xdata. */
	526	if (xdata_arr_cnt > 1)
	527	qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
	528	sort_xdata_arr);
	529
2eb03909 KT	530	/* Do dump of pdata related xdata. */
	531
	532	for (i = 0; i < stop; i += onaline)
	533	{
	534	struct pex64_runtime_function rf;
	535
	536	if (i + PDATA_ROW_SIZE > stop)
	537	break;
	538	pex64_get_runtime_function (abfd, &rf, &data[i]);
	539
	540	if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	541	&& rf.rva_UnwindData == 0)
	542	/* We are probably into the padding of the section now. */
	543	break;
	544	if (i == 0)
	545	fprintf (file, "\nDump of .xdata\n");
	546	fputc (' ', file);
	547	fprintf_vma (file, rf.rva_UnwindData);
	548	fprintf (file, ":\n");
	549
	550	rf.rva_BeginAddress += pe_data (abfd)->pe_opthdr.ImageBase;
	551	rf.rva_EndAddress += pe_data (abfd)->pe_opthdr.ImageBase;
e48570bb DK	552
	553	if (rf.rva_UnwindData != 0)
	554	{
	555	if (rf.isChained)
	556	{
	557	fprintf (file, "\t shares information with pdata element at 0x");
2eb03909	558	fprintf_vma (file, rf.rva_UnwindData);
e48570bb DK	559	fprintf (file, ".\n");
	560	}
	561	else
1360ae66 KT	562	{
	563	bfd_vma *p;
	564
	565	/* Search for the current entry in the sorted array. */
	566	p = (bfd_vma *)
	567	bsearch (&rf.rva_UnwindData, xdata_arr,
	568	(size_t) xdata_arr_cnt, sizeof (bfd_vma),
	569	sort_xdata_arr);
	570
	571	/* Advance to the next pointer into the xdata section. We may
	572	have shared xdata entries, which will result in a string of
	573	identical pointers in the array; advance past all of them. */
	574	while (p[0] <= rf.rva_UnwindData)
	575	++p;
	576	if (p[0] == ~((bfd_vma) 0))
	577	p = NULL;
	578
	579	pex64_dump_xdata (file, abfd, rf.rva_UnwindData,
	580	rf.rva_BeginAddress, p);
	581	}
e48570bb DK	582	}
	583	}
	584
	585	free (data);
1360ae66	586	free (xdata_arr);
e48570bb DK	587
	588	return TRUE;
	589	}
	590
	591	#define bfd_pe_print_pdata pex64_bfd_print_pdata
	592
99ad8390	593	#include "coff-x86_64.c"