[deliverable/binutils-gdb.git] / gdb / coff-pe-read.c

/* Read the export table symbols from a portable executable and
   convert to internal format, for GDB. Used as a last resort if no
   debugging symbols recognized.

   Copyright (C) 2003, 2007, 2008, 2009, 2010, 2011
   Free Software Foundation, Inc.

   This file is part of GDB.

   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, see <http://www.gnu.org/licenses/>.

   Contributed by Raoul M. Gough (RaoulGough@yahoo.co.uk).  */

#include "coff-pe-read.h"

#include "bfd.h"

#include "defs.h"
#include "gdbtypes.h"

#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"

/* Internal section information */

struct read_pe_section_data
{
  CORE_ADDR vma_offset;		/* Offset to loaded address of section.  */
  unsigned long rva_start;	/* Start offset within the pe.  */
  unsigned long rva_end;	/* End offset within the pe.  */
  enum minimal_symbol_type ms_type;	/* Type to assign symbols in
					   section.  */
};

#define PE_SECTION_INDEX_TEXT     0
#define PE_SECTION_INDEX_DATA     1
#define PE_SECTION_INDEX_BSS      2
#define PE_SECTION_TABLE_SIZE     3
#define PE_SECTION_INDEX_INVALID -1
\f
/* Get the index of the named section in our own array, which contains
   text, data and bss in that order.  Return PE_SECTION_INDEX_INVALID
   if passed an unrecognised section name.  */

static int
read_pe_section_index (const char *section_name)
{
  if (strcmp (section_name, ".text") == 0)
    {
      return PE_SECTION_INDEX_TEXT;
    }

  else if (strcmp (section_name, ".data") == 0)
    {
      return PE_SECTION_INDEX_DATA;
    }

  else if (strcmp (section_name, ".bss") == 0)
    {
      return PE_SECTION_INDEX_BSS;
    }

  else
    {
      return PE_SECTION_INDEX_INVALID;
    }
}

/* Record the virtual memory address of a section.  */

static void
get_section_vmas (bfd *abfd, asection *sectp, void *context)
{
  struct read_pe_section_data *sections = context;
  int sectix = read_pe_section_index (sectp->name);

  if (sectix != PE_SECTION_INDEX_INVALID)
    {
      /* Data within the section start at rva_start in the pe and at
         bfd_get_section_vma() within memory.  Store the offset.  */

      sections[sectix].vma_offset
	= bfd_get_section_vma (abfd, sectp) - sections[sectix].rva_start;
    }
}
\f
/* Create a minimal symbol entry for an exported symbol.  */

static void
add_pe_exported_sym (char *sym_name,
		     unsigned long func_rva,
		     const struct read_pe_section_data *section_data,
		     const char *dll_name, struct objfile *objfile)
{
  /* Add the stored offset to get the loaded address of the symbol.  */

  CORE_ADDR vma = func_rva + section_data->vma_offset;

  char *qualified_name = 0;
  int dll_name_len = strlen (dll_name);

  /* Generate a (hopefully unique) qualified name using the first part
     of the dll name, e.g. KERNEL32!AddAtomA.  This matches the style
     used by windbg from the "Microsoft Debugging Tools for Windows".  */

  qualified_name = xmalloc (dll_name_len + strlen (sym_name) + 2);

  strncpy (qualified_name, dll_name, dll_name_len);
  qualified_name[dll_name_len] = '!';
  strcpy (qualified_name + dll_name_len + 1, sym_name);

  prim_record_minimal_symbol (qualified_name,
			      vma, section_data->ms_type, objfile);

  xfree (qualified_name);

  /* Enter the plain name as well, which might not be unique.  */
  prim_record_minimal_symbol (sym_name, vma, 
			      section_data->ms_type, objfile);
}

/* Truncate a dll_name at the first dot character.  */

static void
read_pe_truncate_name (char *dll_name)
{
  while (*dll_name)
    {
      if ((*dll_name) == '.')
	{
	  *dll_name = '\0';	/* truncates and causes loop exit.  */
	}

      else
	{
	  ++dll_name;
	}
    }
}
\f
/* Low-level support functions, direct from the ld module pe-dll.c.  */
static unsigned int
pe_get16 (bfd *abfd, int where)
{
  unsigned char b[2];

  bfd_seek (abfd, (file_ptr) where, SEEK_SET);
  bfd_bread (b, (bfd_size_type) 2, abfd);
  return b[0] + (b[1] << 8);
}

static unsigned int
pe_get32 (bfd *abfd, int where)
{
  unsigned char b[4];

  bfd_seek (abfd, (file_ptr) where, SEEK_SET);
  bfd_bread (b, (bfd_size_type) 4, abfd);
  return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
}

static unsigned int
pe_as32 (void *ptr)
{
  unsigned char *b = ptr;

  return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
}
\f
/* Read the (non-debug) export symbol table from a portable
   executable.  Code originally lifted from the ld function
   pe_implied_import_dll in pe-dll.c.  */

void
read_pe_exported_syms (struct objfile *objfile)
{
  bfd *dll = objfile->obfd;
  unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
  unsigned long export_rva, export_size, nsections, secptr, expptr;
  unsigned long exp_funcbase;
  unsigned char *expdata, *erva;
  unsigned long name_rvas, ordinals, nexp, ordbase;
  char *dll_name;
  int is_pe64 = 0;
  int is_pe32 = 0;

  /* Array elements are for text, data and bss in that order
     Initialization with start_rva > end_rva guarantees that
     unused sections won't be matched.  */
  struct read_pe_section_data section_data[PE_SECTION_TABLE_SIZE]
    = { {0, 1, 0, mst_text},
  {0, 1, 0, mst_data},
  {0, 1, 0, mst_bss}
  };

  struct cleanup *back_to = 0;

  char const *target = bfd_get_target (objfile->obfd);

  is_pe64 = (strcmp (target, "pe-x86-64") == 0
	     || strcmp (target, "pei-x86-64") == 0);
  is_pe32 = (strcmp (target, "pe-i386") == 0
	     || strcmp (target, "pei-i386") == 0
	     || strcmp (target, "pe-arm-wince-little") == 0
	     || strcmp (target, "pei-arm-wince-little") == 0);

  if (!is_pe32 && !is_pe64)
    {
      /* This is not a recognized PE format file.  Abort now, because
	 the code is untested on anything else.  *FIXME* test on
	 further architectures and loosen or remove this test.  */
      return;
    }

  /* Get pe_header, optional header and numbers of export entries.  */
  pe_header_offset = pe_get32 (dll, 0x3c);
  opthdr_ofs = pe_header_offset + 4 + 20;
  if (is_pe64)
    num_entries = pe_get32 (dll, opthdr_ofs + 108);
  else
    num_entries = pe_get32 (dll, opthdr_ofs + 92);

  if (num_entries < 1)		/* No exports.  */
    {
      return;
    }

  if (is_pe64)
    {
      export_rva = pe_get32 (dll, opthdr_ofs + 112);
      export_size = pe_get32 (dll, opthdr_ofs + 116);
    }
  else
    {
      export_rva = pe_get32 (dll, opthdr_ofs + 96);
      export_size = pe_get32 (dll, opthdr_ofs + 100);
    }
  nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
  secptr = (pe_header_offset + 4 + 20 +
	    pe_get16 (dll, pe_header_offset + 4 + 16));
  expptr = 0;

  /* Get the rva and size of the export section.  */
  for (i = 0; i < nsections; i++)
    {
      char sname[8];
      unsigned long secptr1 = secptr + 40 * i;
      unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
      unsigned long vsize = pe_get32 (dll, secptr1 + 16);
      unsigned long fptr = pe_get32 (dll, secptr1 + 20);

      bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
      bfd_bread (sname, (bfd_size_type) 8, dll);

      if (vaddr <= export_rva && vaddr + vsize > export_rva)
	{
	  expptr = fptr + (export_rva - vaddr);
	  if (export_rva + export_size > vaddr + vsize)
	    export_size = vsize - (export_rva - vaddr);
	  break;
	}
    }

  if (export_size == 0)
    {
      /* Empty export table.  */
      return;
    }

  /* Scan sections and store the base and size of the relevant
     sections.  */
  for (i = 0; i < nsections; i++)
    {
      unsigned long secptr1 = secptr + 40 * i;
      unsigned long vsize = pe_get32 (dll, secptr1 + 8);
      unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
      char sec_name[9];
      int sectix;

      sec_name[8] = '\0';
      bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
      bfd_bread (sec_name, (bfd_size_type) 8, dll);

      sectix = read_pe_section_index (sec_name);

      if (sectix != PE_SECTION_INDEX_INVALID)
	{
	  section_data[sectix].rva_start = vaddr;
	  section_data[sectix].rva_end = vaddr + vsize;
	}
    }

  expdata = (unsigned char *) xmalloc (export_size);
  back_to = make_cleanup (xfree, expdata);

  bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
  bfd_bread (expdata, (bfd_size_type) export_size, dll);
  erva = expdata - export_rva;

  nexp = pe_as32 (expdata + 24);
  name_rvas = pe_as32 (expdata + 32);
  ordinals = pe_as32 (expdata + 36);
  ordbase = pe_as32 (expdata + 16);
  exp_funcbase = pe_as32 (expdata + 28);

  /* Use internal dll name instead of full pathname.  */
  dll_name = pe_as32 (expdata + 12) + erva;

  bfd_map_over_sections (dll, get_section_vmas, section_data);

  /* Adjust the vma_offsets in case this PE got relocated. This
     assumes that *all* sections share the same relocation offset
     as the text section.  */
  for (i = 0; i < PE_SECTION_TABLE_SIZE; i++)
    {
      section_data[i].vma_offset
	+= ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
    }

  /* Truncate name at first dot. Should maybe also convert to all
     lower case for convenience on Windows.  */
  read_pe_truncate_name (dll_name);

  /* Iterate through the list of symbols.  */
  for (i = 0; i < nexp; i++)
    {
      /* Pointer to the names vector.  */
      unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);

      /* Pointer to the function address vector.  */
      unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);

      /* Find this symbol's section in our own array.  */
      int sectix = 0;

      for (sectix = 0; sectix < PE_SECTION_TABLE_SIZE; ++sectix)
	{
	  if ((func_rva >= section_data[sectix].rva_start)
	      && (func_rva < section_data[sectix].rva_end))
	    {
	      add_pe_exported_sym (erva + name_rva,
				   func_rva,
				   section_data + sectix, dll_name, objfile);
	      break;
	    }
	}
    }

  /* Discard expdata.  */
  do_cleanups (back_to);
}
Commit	Line	Data
1b6bc7e0 CF	1	/* Read the export table symbols from a portable executable and
	2	convert to internal format, for GDB. Used as a last resort if no
	3	debugging symbols recognized.
	4
7b6bb8da JB	5	Copyright (C) 2003, 2007, 2008, 2009, 2010, 2011
7b6bb8da JB	6	Free Software Foundation, Inc.
1b6bc7e0 CF	7
	8	This file is part of GDB.
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
a9762ec7	12	the Free Software Foundation; either version 3 of the License, or
1b6bc7e0 CF	13	(at your option) any later version.
	14
	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
a9762ec7	21	along with this program. If not, see <http://www.gnu.org/licenses/>.
1b6bc7e0	22
aff410f1	23	Contributed by Raoul M. Gough (RaoulGough@yahoo.co.uk). */
1b6bc7e0 CF	24
	25	#include "coff-pe-read.h"
	26
	27	#include "bfd.h"
	28
	29	#include "defs.h"
	30	#include "gdbtypes.h"
	31
	32	#include "symtab.h"
	33	#include "symfile.h"
	34	#include "objfiles.h"
	35
	36	/* Internal section information */
	37
	38	struct read_pe_section_data
	39	{
aff410f1 MS	40	CORE_ADDR vma_offset; /* Offset to loaded address of section. */
	41	unsigned long rva_start; /* Start offset within the pe. */
	42	unsigned long rva_end; /* End offset within the pe. */
	43	enum minimal_symbol_type ms_type; /* Type to assign symbols in
	44	section. */
1b6bc7e0 CF	45	};
	46
	47	#define PE_SECTION_INDEX_TEXT 0
	48	#define PE_SECTION_INDEX_DATA 1
	49	#define PE_SECTION_INDEX_BSS 2
	50	#define PE_SECTION_TABLE_SIZE 3
	51	#define PE_SECTION_INDEX_INVALID -1
	52	\f
	53	/* Get the index of the named section in our own array, which contains
aff410f1 MS	54	text, data and bss in that order. Return PE_SECTION_INDEX_INVALID
aff410f1 MS	55	if passed an unrecognised section name. */
1b6bc7e0 CF	56
	57	static int
	58	read_pe_section_index (const char *section_name)
	59	{
	60	if (strcmp (section_name, ".text") == 0)
	61	{
	62	return PE_SECTION_INDEX_TEXT;
	63	}
	64
	65	else if (strcmp (section_name, ".data") == 0)
	66	{
	67	return PE_SECTION_INDEX_DATA;
	68	}
	69
	70	else if (strcmp (section_name, ".bss") == 0)
	71	{
	72	return PE_SECTION_INDEX_BSS;
	73	}
	74
	75	else
	76	{
	77	return PE_SECTION_INDEX_INVALID;
	78	}
	79	}
	80
aff410f1	81	/* Record the virtual memory address of a section. */
1b6bc7e0 CF	82
	83	static void
	84	get_section_vmas (bfd abfd, asection sectp, void *context)
	85	{
	86	struct read_pe_section_data *sections = context;
	87	int sectix = read_pe_section_index (sectp->name);
	88
	89	if (sectix != PE_SECTION_INDEX_INVALID)
	90	{
	91	/* Data within the section start at rva_start in the pe and at
aff410f1	92	bfd_get_section_vma() within memory. Store the offset. */
1b6bc7e0 CF	93
	94	sections[sectix].vma_offset
	95	= bfd_get_section_vma (abfd, sectp) - sections[sectix].rva_start;
	96	}
	97	}
	98	\f
aff410f1	99	/* Create a minimal symbol entry for an exported symbol. */
1b6bc7e0 CF	100
	101	static void
	102	add_pe_exported_sym (char *sym_name,
	103	unsigned long func_rva,
	104	const struct read_pe_section_data *section_data,
	105	const char dll_name, struct objfile objfile)
	106	{
aff410f1	107	/* Add the stored offset to get the loaded address of the symbol. */
1b6bc7e0 CF	108
	109	CORE_ADDR vma = func_rva + section_data->vma_offset;
	110
	111	char *qualified_name = 0;
	112	int dll_name_len = strlen (dll_name);
1b6bc7e0 CF	113
1b6bc7e0 CF	114	/* Generate a (hopefully unique) qualified name using the first part
aff410f1 MS	115	of the dll name, e.g. KERNEL32!AddAtomA. This matches the style
aff410f1 MS	116	used by windbg from the "Microsoft Debugging Tools for Windows". */
1b6bc7e0 CF	117
	118	qualified_name = xmalloc (dll_name_len + strlen (sym_name) + 2);
	119
	120	strncpy (qualified_name, dll_name, dll_name_len);
	121	qualified_name[dll_name_len] = '!';
	122	strcpy (qualified_name + dll_name_len + 1, sym_name);
	123
	124	prim_record_minimal_symbol (qualified_name,
	125	vma, section_data->ms_type, objfile);
	126
	127	xfree (qualified_name);
	128
aff410f1 MS	129	/* Enter the plain name as well, which might not be unique. */
	130	prim_record_minimal_symbol (sym_name, vma,
	131	section_data->ms_type, objfile);
1b6bc7e0 CF	132	}
1b6bc7e0 CF	133
aff410f1	134	/* Truncate a dll_name at the first dot character. */
1b6bc7e0 CF	135
	136	static void
	137	read_pe_truncate_name (char *dll_name)
	138	{
	139	while (*dll_name)
	140	{
	141	if ((*dll_name) == '.')
	142	{
aff410f1	143	dll_name = '\0'; / truncates and causes loop exit. */
1b6bc7e0 CF	144	}
	145
	146	else
	147	{
	148	++dll_name;
	149	}
	150	}
	151	}
	152	\f
aff410f1	153	/* Low-level support functions, direct from the ld module pe-dll.c. */
1b6bc7e0 CF	154	static unsigned int
	155	pe_get16 (bfd *abfd, int where)
	156	{
	157	unsigned char b[2];
	158
	159	bfd_seek (abfd, (file_ptr) where, SEEK_SET);
	160	bfd_bread (b, (bfd_size_type) 2, abfd);
	161	return b[0] + (b[1] << 8);
	162	}
	163
	164	static unsigned int
	165	pe_get32 (bfd *abfd, int where)
	166	{
	167	unsigned char b[4];
	168
	169	bfd_seek (abfd, (file_ptr) where, SEEK_SET);
	170	bfd_bread (b, (bfd_size_type) 4, abfd);
	171	return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
	172	}
	173
	174	static unsigned int
	175	pe_as32 (void *ptr)
	176	{
	177	unsigned char *b = ptr;
	178
	179	return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
	180	}
	181	\f
	182	/* Read the (non-debug) export symbol table from a portable
aff410f1 MS	183	executable. Code originally lifted from the ld function
aff410f1 MS	184	pe_implied_import_dll in pe-dll.c. */
1b6bc7e0 CF	185
	186	void
	187	read_pe_exported_syms (struct objfile *objfile)
	188	{
	189	bfd *dll = objfile->obfd;
	190	unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
	191	unsigned long export_rva, export_size, nsections, secptr, expptr;
	192	unsigned long exp_funcbase;
	193	unsigned char expdata, erva;
	194	unsigned long name_rvas, ordinals, nexp, ordbase;
	195	char *dll_name;
a68ddad5 KT	196	int is_pe64 = 0;
a68ddad5 KT	197	int is_pe32 = 0;
1b6bc7e0 CF	198
	199	/* Array elements are for text, data and bss in that order
	200	Initialization with start_rva > end_rva guarantees that
aff410f1	201	unused sections won't be matched. */
1b6bc7e0 CF	202	struct read_pe_section_data section_data[PE_SECTION_TABLE_SIZE]
	203	= { {0, 1, 0, mst_text},
	204	{0, 1, 0, mst_data},
	205	{0, 1, 0, mst_bss}
	206	};
	207
	208	struct cleanup *back_to = 0;
	209
	210	char const *target = bfd_get_target (objfile->obfd);
	211
5e13bd89 PA	212	is_pe64 = (strcmp (target, "pe-x86-64") == 0
	213	\|\| strcmp (target, "pei-x86-64") == 0);
	214	is_pe32 = (strcmp (target, "pe-i386") == 0
	215	\|\| strcmp (target, "pei-i386") == 0
	216	\|\| strcmp (target, "pe-arm-wince-little") == 0
	217	\|\| strcmp (target, "pei-arm-wince-little") == 0);
	218
a68ddad5	219	if (!is_pe32 && !is_pe64)
1b6bc7e0	220	{
5e13bd89 PA	221	/* This is not a recognized PE format file. Abort now, because
5e13bd89 PA	222	the code is untested on anything else. FIXME test on
aff410f1	223	further architectures and loosen or remove this test. */
1b6bc7e0 CF	224	return;
	225	}
	226
	227	/* Get pe_header, optional header and numbers of export entries. */
	228	pe_header_offset = pe_get32 (dll, 0x3c);
	229	opthdr_ofs = pe_header_offset + 4 + 20;
a68ddad5	230	if (is_pe64)
1dac1b47	231	num_entries = pe_get32 (dll, opthdr_ofs + 108);
a68ddad5 KT	232	else
a68ddad5 KT	233	num_entries = pe_get32 (dll, opthdr_ofs + 92);
1b6bc7e0 CF	234
	235	if (num_entries < 1) /* No exports. */
	236	{
	237	return;
	238	}
	239
a68ddad5 KT	240	if (is_pe64)
	241	{
	242	export_rva = pe_get32 (dll, opthdr_ofs + 112);
	243	export_size = pe_get32 (dll, opthdr_ofs + 116);
	244	}
	245	else
	246	{
	247	export_rva = pe_get32 (dll, opthdr_ofs + 96);
	248	export_size = pe_get32 (dll, opthdr_ofs + 100);
	249	}
1b6bc7e0 CF	250	nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
	251	secptr = (pe_header_offset + 4 + 20 +
	252	pe_get16 (dll, pe_header_offset + 4 + 16));
	253	expptr = 0;
	254
	255	/* Get the rva and size of the export section. */
	256	for (i = 0; i < nsections; i++)
	257	{
	258	char sname[8];
	259	unsigned long secptr1 = secptr + 40 * i;
	260	unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
	261	unsigned long vsize = pe_get32 (dll, secptr1 + 16);
	262	unsigned long fptr = pe_get32 (dll, secptr1 + 20);
	263
	264	bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
	265	bfd_bread (sname, (bfd_size_type) 8, dll);
	266
	267	if (vaddr <= export_rva && vaddr + vsize > export_rva)
	268	{
	269	expptr = fptr + (export_rva - vaddr);
	270	if (export_rva + export_size > vaddr + vsize)
	271	export_size = vsize - (export_rva - vaddr);
	272	break;
	273	}
	274	}
	275
	276	if (export_size == 0)
	277	{
aff410f1	278	/* Empty export table. */
1b6bc7e0 CF	279	return;
	280	}
	281
aff410f1 MS	282	/* Scan sections and store the base and size of the relevant
aff410f1 MS	283	sections. */
1b6bc7e0 CF	284	for (i = 0; i < nsections; i++)
	285	{
	286	unsigned long secptr1 = secptr + 40 * i;
	287	unsigned long vsize = pe_get32 (dll, secptr1 + 8);
	288	unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
1b6bc7e0 CF	289	char sec_name[9];
	290	int sectix;
	291
	292	sec_name[8] = '\0';
	293	bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
	294	bfd_bread (sec_name, (bfd_size_type) 8, dll);
	295
	296	sectix = read_pe_section_index (sec_name);
	297
	298	if (sectix != PE_SECTION_INDEX_INVALID)
	299	{
	300	section_data[sectix].rva_start = vaddr;
	301	section_data[sectix].rva_end = vaddr + vsize;
	302	}
	303	}
	304
	305	expdata = (unsigned char *) xmalloc (export_size);
	306	back_to = make_cleanup (xfree, expdata);
	307
	308	bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
	309	bfd_bread (expdata, (bfd_size_type) export_size, dll);
	310	erva = expdata - export_rva;
	311
	312	nexp = pe_as32 (expdata + 24);
	313	name_rvas = pe_as32 (expdata + 32);
	314	ordinals = pe_as32 (expdata + 36);
	315	ordbase = pe_as32 (expdata + 16);
	316	exp_funcbase = pe_as32 (expdata + 28);
	317
aff410f1	318	/* Use internal dll name instead of full pathname. */
1b6bc7e0 CF	319	dll_name = pe_as32 (expdata + 12) + erva;
	320
	321	bfd_map_over_sections (dll, get_section_vmas, section_data);
	322
	323	/* Adjust the vma_offsets in case this PE got relocated. This
	324	assumes that all sections share the same relocation offset
aff410f1	325	as the text section. */
1b6bc7e0 CF	326	for (i = 0; i < PE_SECTION_TABLE_SIZE; i++)
	327	{
	328	section_data[i].vma_offset
	329	+= ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
	330	}
	331
1b6bc7e0	332	/* Truncate name at first dot. Should maybe also convert to all
aff410f1	333	lower case for convenience on Windows. */
1b6bc7e0 CF	334	read_pe_truncate_name (dll_name);
	335
	336	/* Iterate through the list of symbols. */
	337	for (i = 0; i < nexp; i++)
	338	{
	339	/* Pointer to the names vector. */
	340	unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
	341
	342	/* Pointer to the function address vector. */
	343	unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
	344
aff410f1	345	/* Find this symbol's section in our own array. */
1b6bc7e0 CF	346	int sectix = 0;
	347
	348	for (sectix = 0; sectix < PE_SECTION_TABLE_SIZE; ++sectix)
	349	{
	350	if ((func_rva >= section_data[sectix].rva_start)
	351	&& (func_rva < section_data[sectix].rva_end))
	352	{
	353	add_pe_exported_sym (erva + name_rva,
	354	func_rva,
	355	section_data + sectix, dll_name, objfile);
	356	break;
	357	}
	358	}
	359	}
	360
aff410f1	361	/* Discard expdata. */
1b6bc7e0 CF	362	do_cleanups (back_to);
1b6bc7e0 CF	363	}