gdb/coff-pe-read.c

   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
   5    Copyright (C) 2003, 2007, 2008, 2009, 2010, 2011
   6    Free Software Foundation, Inc.
   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
  12    the Free Software Foundation; either version 3 of the License, or
  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
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22
  23    Contributed by Raoul M. Gough (RaoulGough@yahoo.co.uk).  */
  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 {
  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.  */
  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
  54    text, data and bss in that order.  Return PE_SECTION_INDEX_INVALID
  55    if passed an unrecognised section name.  */
  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
  81 /* Record the virtual memory address of a section.  */
  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
  92          bfd_get_section_vma() within memory.  Store the offset.  */
  93
  94       sections[sectix].vma_offset
  95         = bfd_get_section_vma (abfd, sectp) - sections[sectix].rva_start;
  96     }
  97 }
  98 \f
  99 /* Create a minimal symbol entry for an exported symbol.  */
 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 {
 107   /* Add the stored offset to get the loaded address of the symbol.  */
 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);
 113
 114   /* Generate a (hopefully unique) qualified name using the first part
 115      of the dll name, e.g. KERNEL32!AddAtomA.  This matches the style
 116      used by windbg from the "Microsoft Debugging Tools for Windows".  */
 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
 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);
 132 }
 133
 134 /* Truncate a dll_name at the first dot character.  */
 135
 136 static void
 137 read_pe_truncate_name (char *dll_name)
 138 {
 139   while (*dll_name)
 140     {
 141       if ((*dll_name) == '.')
 142         {
 143           *dll_name = '\0';     /* truncates and causes loop exit.  */
 144         }
 145
 146       else
 147         {
 148           ++dll_name;
 149         }
 150     }
 151 }
 152 \f
 153 /* Low-level support functions, direct from the ld module pe-dll.c.  */
 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
 183    executable.  Code originally lifted from the ld function
 184    pe_implied_import_dll in pe-dll.c.  */
 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;
 196   int is_pe64 = 0;
 197   int is_pe32 = 0;
 198
 199   /* Array elements are for text, data and bss in that order
 200      Initialization with start_rva > end_rva guarantees that
 201      unused sections won't be matched.  */
 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
 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
 219   if (!is_pe32 && !is_pe64)
 220     {
 221       /* This is not a recognized PE format file.  Abort now, because
 222          the code is untested on anything else.  *FIXME* test on
 223          further architectures and loosen or remove this test.  */
 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;
 230   if (is_pe64)
 231     num_entries = pe_get32 (dll, opthdr_ofs + 108);
 232   else
 233     num_entries = pe_get32 (dll, opthdr_ofs + 92);
 234
 235   if (num_entries < 1)          /* No exports.  */
 236     {
 237       return;
 238     }
 239
 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     }
 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     {
 278       /* Empty export table.  */
 279       return;
 280     }
 281
 282   /* Scan sections and store the base and size of the relevant
 283      sections.  */
 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);
 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
 318   /* Use internal dll name instead of full pathname.  */
 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
 325      as the text section.  */
 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
 332   /* Truncate name at first dot. Should maybe also convert to all
 333      lower case for convenience on Windows.  */
 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
 345       /* Find this symbol's section in our own array.  */
 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
 361   /* Discard expdata.  */
 362   do_cleanups (back_to);
 363 }