[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 bfd_vma
find_next_xdata_or_end (bfd *abfd, bfd_byte *pdata, bfd_size_type stop,
			int onaline, bfd_vma cur_address, bfd_vma max_size)
{
  bfd_size_type i;
  bfd_vma ret = 0;

  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, &pdata[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 (rf.rva_UnwindData != 0 && !rf.isChained)
        {
	  if (!ret && rf.rva_UnwindData > cur_address)
	    ret = rf.rva_UnwindData;
	  else if (rf.rva_UnwindData > cur_address && ret > rf.rva_UnwindData)
	    ret = rf.rva_UnwindData;
	}
    }
  if (!ret)
    return max_size;
  return ret;
}

static void
pex64_dump_xdata (FILE *file, bfd *abfd, bfd_vma addr, bfd_vma pc_addr,
		  bfd_size_type stop, int onaline, bfd_byte *pdata)
{
  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;

  end_addr = find_next_xdata_or_end (abfd, pdata, stop, onaline, addr + vsize,
  				     vsize + (section->rawsize != 0 ? section->rawsize : section->size));

  end_addr -= vsize;
  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 ? "CFA"
			      : 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 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;

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

  /* 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 (seen_error)
    {
      free (data);

      return TRUE;
    }
  /* 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
	    pex64_dump_xdata (file, abfd, rf.rva_UnwindData, rf.rva_BeginAddress,
	    		      stop, onaline, data);
	}
    }

  free (data);

  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
2eb03909 KT	306	static bfd_vma
	307	find_next_xdata_or_end (bfd abfd, bfd_byte pdata, bfd_size_type stop,
	308	int onaline, bfd_vma cur_address, bfd_vma max_size)
	309	{
	310	bfd_size_type i;
	311	bfd_vma ret = 0;
	312
	313	for (i = 0; i < stop; i += onaline)
	314	{
	315	struct pex64_runtime_function rf;
	316
	317	if (i + PDATA_ROW_SIZE > stop)
	318	break;
	319	pex64_get_runtime_function (abfd, &rf, &pdata[i]);
	320
	321	if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	322	&& rf.rva_UnwindData == 0)
	323	/* We are probably into the padding of the section now. */
	324	break;
	325	if (rf.rva_UnwindData != 0 && !rf.isChained)
	326	{
	327	if (!ret && rf.rva_UnwindData > cur_address)
	328	ret = rf.rva_UnwindData;
	329	else if (rf.rva_UnwindData > cur_address && ret > rf.rva_UnwindData)
	330	ret = rf.rva_UnwindData;
	331	}
	332	}
	333	if (!ret)
	334	return max_size;
	335	return ret;
	336	}
	337
e48570bb	338	static void
2eb03909 KT	339	pex64_dump_xdata (FILE file, bfd abfd, bfd_vma addr, bfd_vma pc_addr,
2eb03909 KT	340	bfd_size_type stop, int onaline, bfd_byte *pdata)
e48570bb DK	341	{
	342	asection *section = pex64_get_section_by_rva (abfd, addr, ".rdata");
	343	bfd_vma vsize;
	344	bfd_byte *data = NULL;
2eb03909	345	bfd_vma end_addr;
e48570bb DK	346
	347	if (!section)
	348	section = pex64_get_section_by_rva (abfd, addr, ".data");
	349	if (!section)
	350	section = pex64_get_section_by_rva (abfd, addr, ".xdata");
	351	if (!section)
	352	{
	353	section = pex64_get_section_by_rva (abfd, addr, ".pdata");
	354	if (section)
	355	{
	356	fprintf (file, "\t Shares information with pdata element at 0x");
	357	fprintf_vma (file, addr + pe_data (abfd)->pe_opthdr.ImageBase);
	358	fprintf (file, ".\n");
	359	}
	360	}
	361	if (!section)
	362	return;
2eb03909	363
e48570bb DK	364	vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
e48570bb DK	365	addr -= vsize;
2eb03909 KT	366
	367	end_addr = find_next_xdata_or_end (abfd, pdata, stop, onaline, addr + vsize,
	368	vsize + (section->rawsize != 0 ? section->rawsize : section->size));
	369
	370	end_addr -= vsize;
e48570bb DK	371	if (bfd_malloc_and_get_section (abfd, section, &data))
	372	{
	373	struct pex64_unwind_info ui;
	374
	375	if (!data)
	376	return;
	377
	378	pex64_get_unwind_info (abfd, &ui, &data[addr]);
	379
	380	if (ui.Version != 1)
	381	{
	382	fprintf (file, "\tVersion %u (unknown).\n", (unsigned int) ui.Version);
	383	return;
	384	}
	385
	386	fprintf (file, "\tFlags: ");
	387	switch (ui.Flags)
	388	{
	389	case UNW_FLAG_NHANDLER:
	390	fprintf (file, "UNW_FLAG_NHANDLER");
	391	break;
	392	case UNW_FLAG_EHANDLER:
	393	fprintf (file, "UNW_FLAG_EHANDLER");
	394	break;
	395	case UNW_FLAG_UHANDLER:
	396	fprintf (file, "UNW_FLAG_UHANDLER");
	397	break;
	398	case UNW_FLAG_FHANDLER:
	399	fprintf (file, "UNW_FLAG_FHANDLER = (UNW_FLAG_EHANDLER \| UNW_FLAG_UHANDLER)");
	400	break;
	401	case UNW_FLAG_CHAININFO:
	402	fprintf (file, "UNW_FLAG_CHAININFO");
	403	break;
	404	default:
	405	fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
	406	break;
	407	}
	408	fprintf (file, ".\n");
	409	if (ui.CountOfCodes != 0)
	410	fprintf (file, "\tEntry has %u codes.", (unsigned int) ui.CountOfCodes);
	411	fprintf (file, "\tPrologue size: %u, Frame offset = 0x%x.\n",
	412	(unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
	413	fprintf (file, "\tFrame register is %s.\n",
	414	ui.FrameRegister == 0 ? "CFA"
	415	: pex_regs[(unsigned int) ui.FrameRegister]);
	416
	417	pex64_xdata_print_uwd_codes (file, &ui, pc_addr);
	418
2eb03909 KT	419	/* Now we need end of this xdata block. */
	420	addr += ui.SizeOfBlock;
	421	if (addr < end_addr)
	422	{
	423	unsigned int i;
	424	fprintf (file,"\tUser data:\n");
	425	for (i = 0; addr < end_addr; addr += 1, i++)
	426	{
	427	if ((i & 15) == 0)
	428	fprintf (file, "\t %03x:", i);
	429	fprintf (file, " %02x", data[addr]);
	430	if ((i & 15) == 15)
	431	fprintf (file, "\n");
	432	}
	433	if ((i & 15) != 0)
	434	fprintf (file, "\n");
	435	}
e48570bb DK	436	}
	437	if (data != NULL)
	438	free (data);
	439	}
	440
	441	static bfd_boolean
	442	pex64_bfd_print_pdata (bfd abfd, void vfile)
	443	{
	444	FILE file = (FILE ) vfile;
	445	bfd_byte *data = NULL;
	446	asection *section = bfd_get_section_by_name (abfd, ".pdata");
	447	bfd_size_type datasize = 0;
	448	bfd_size_type i;
2eb03909 KT	449	bfd_size_type stop;
2eb03909 KT	450	bfd_vma prev_beginaddress = 0;
e48570bb	451	int onaline = PDATA_ROW_SIZE;
2eb03909	452	int seen_error = 0;
e48570bb DK	453
	454	if (section == NULL
	455	\|\| coff_section_data (abfd, section) == NULL
	456	\|\| pei_section_data (abfd, section) == NULL)
	457	return TRUE;
	458
	459	stop = pei_section_data (abfd, section)->virt_size;
	460	if ((stop % onaline) != 0)
	461	fprintf (file,
	462	_("warning: .pdata section size (%ld) is not a multiple of %d\n"),
	463	(long) stop, onaline);
	464
	465	fprintf (file,
	466	_("\nThe Function Table (interpreted .pdata section contents)\n"));
	467
	468	fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t UnwindData\n"));
	469
	470	datasize = section->size;
	471	if (datasize == 0)
	472	return TRUE;
	473
	474	if (!bfd_malloc_and_get_section (abfd, section, &data))
	475	{
	476	if (data != NULL)
	477	free (data);
	478	return FALSE;
	479	}
	480
2eb03909 KT	481	/* Do sanity check of pdata. */
2eb03909 KT	482	for (i = 0; i < stop; i += onaline)
e48570bb DK	483	{
	484	struct pex64_runtime_function rf;
	485
	486	if (i + PDATA_ROW_SIZE > stop)
	487	break;
	488	pex64_get_runtime_function (abfd, &rf, &data[i]);
	489
	490	if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	491	&& rf.rva_UnwindData == 0)
	492	/* We are probably into the padding of the section now. */
	493	break;
e48570bb DK	494	fputc (' ', file);
	495	fprintf_vma (file, i + section->vma);
	496	fprintf (file, ":\t");
e48570bb DK	497	fprintf_vma (file, rf.rva_BeginAddress);
e48570bb DK	498	fputc (' ', file);
e48570bb DK	499	fprintf_vma (file, rf.rva_EndAddress);
	500	fputc (' ', file);
	501	fprintf_vma (file, rf.rva_UnwindData);
	502	fprintf (file, "\n");
2eb03909 KT	503	if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
	504	{
	505	seen_error = 1;
	506	fprintf (file, " has %s begin address as predecessor\n",
	507	(rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
	508	}
	509	prev_beginaddress = rf.rva_BeginAddress;
	510	/* Now we check for negative addresses. */
	511	if ((prev_beginaddress & 0x80000000) != 0)
	512	{
	513	seen_error = 1;
	514	fprintf (file, " has negative begin address\n");
	515	}
	516	if ((rf.rva_EndAddress & 0x80000000) != 0)
	517	{
	518	seen_error = 1;
	519	fprintf (file, " has negative end address\n");
	520	}
	521	if ((rf.rva_UnwindData & 0x80000000) != 0)
	522	{
	523	seen_error = 1;
	524	fprintf (file, " has negative unwind address\n");
	525	}
	526	}
	527
	528	if (seen_error)
	529	{
	530	free (data);
	531
	532	return TRUE;
	533	}
	534	/* Do dump of pdata related xdata. */
	535
	536	for (i = 0; i < stop; i += onaline)
	537	{
	538	struct pex64_runtime_function rf;
	539
	540	if (i + PDATA_ROW_SIZE > stop)
	541	break;
	542	pex64_get_runtime_function (abfd, &rf, &data[i]);
	543
	544	if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
	545	&& rf.rva_UnwindData == 0)
	546	/* We are probably into the padding of the section now. */
	547	break;
	548	if (i == 0)
	549	fprintf (file, "\nDump of .xdata\n");
	550	fputc (' ', file);
	551	fprintf_vma (file, rf.rva_UnwindData);
	552	fprintf (file, ":\n");
	553
	554	rf.rva_BeginAddress += pe_data (abfd)->pe_opthdr.ImageBase;
	555	rf.rva_EndAddress += pe_data (abfd)->pe_opthdr.ImageBase;
e48570bb DK	556
	557	if (rf.rva_UnwindData != 0)
	558	{
	559	if (rf.isChained)
	560	{
	561	fprintf (file, "\t shares information with pdata element at 0x");
2eb03909	562	fprintf_vma (file, rf.rva_UnwindData);
e48570bb DK	563	fprintf (file, ".\n");
	564	}
	565	else
2eb03909 KT	566	pex64_dump_xdata (file, abfd, rf.rva_UnwindData, rf.rva_BeginAddress,
2eb03909 KT	567	stop, onaline, data);
e48570bb DK	568	}
	569	}
	570
	571	free (data);
	572
	573	return TRUE;
	574	}
	575
	576	#define bfd_pe_print_pdata pex64_bfd_print_pdata
	577
99ad8390	578	#include "coff-x86_64.c"