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.
5 Copyright (C) 2003-2014 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 Contributed by Raoul M. Gough (RaoulGough@yahoo.co.uk). */
26 #include "coff-pe-read.h"
36 #include "common/common-utils.h"
37 #include "coff/internal.h"
41 /* Internal section information */
43 /* Coff PE read debugging flag:
45 value 1 outputs problems encountered while parsing PE file,
46 value above 1 also lists all generated minimal symbols. */
47 static unsigned int debug_coff_pe_read;
49 struct read_pe_section_data
51 CORE_ADDR vma_offset; /* Offset to loaded address of section. */
52 unsigned long rva_start; /* Start offset within the pe. */
53 unsigned long rva_end; /* End offset within the pe. */
54 enum minimal_symbol_type ms_type; /* Type to assign symbols in
56 char *section_name; /* Recorded section name. */
59 #define IMAGE_SCN_CNT_CODE 0x20
60 #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x40
61 #define IMAGE_SCN_CNT_UNINITIALIZED_DATA 0x80
62 #define PE_SECTION_INDEX_TEXT 0
63 #define PE_SECTION_INDEX_DATA 1
64 #define PE_SECTION_INDEX_BSS 2
65 #define PE_SECTION_TABLE_SIZE 3
66 #define PE_SECTION_INDEX_INVALID -1
68 /* Get the index of the named section in our own array, which contains
69 text, data and bss in that order. Return PE_SECTION_INDEX_INVALID
70 if passed an unrecognised section name. */
73 read_pe_section_index (const char *section_name)
75 if (strcmp (section_name, ".text") == 0)
77 return PE_SECTION_INDEX_TEXT;
80 else if (strcmp (section_name, ".data") == 0)
82 return PE_SECTION_INDEX_DATA;
85 else if (strcmp (section_name, ".bss") == 0)
87 return PE_SECTION_INDEX_BSS;
92 return PE_SECTION_INDEX_INVALID;
96 /* Get the index of the named section in our own full arrayi.
97 text, data and bss in that order. Return PE_SECTION_INDEX_INVALID
98 if passed an unrecognised section name. */
101 get_pe_section_index (const char *section_name,
102 struct read_pe_section_data *sections,
107 for (i = 0; i < nb_sections; i++)
108 if (strcmp (sections[i].section_name, section_name) == 0)
110 return PE_SECTION_INDEX_INVALID;
113 /* Structure used by get_section_vmas function below
114 to access section_data array and the size of the array
115 stored in nb_sections field. */
116 struct pe_sections_info
119 struct read_pe_section_data *sections;
122 /* Record the virtual memory address of a section. */
125 get_section_vmas (bfd *abfd, asection *sectp, void *context)
127 struct pe_sections_info *data = context;
128 struct read_pe_section_data *sections = data->sections;
129 int sectix = get_pe_section_index (sectp->name, sections,
132 if (sectix != PE_SECTION_INDEX_INVALID)
134 /* Data within the section start at rva_start in the pe and at
135 bfd_get_section_vma() within memory. Store the offset. */
137 sections[sectix].vma_offset
138 = bfd_get_section_vma (abfd, sectp) - sections[sectix].rva_start;
142 /* Create a minimal symbol entry for an exported symbol.
143 SYM_NAME contains the exported name or NULL if exported by ordinal,
144 FUNC_RVA contains the Relative Virtual Address of the symbol,
145 ORDINAL is the ordinal index value of the symbol,
146 SECTION_DATA contains information about the section in which the
148 DLL_NAME is the internal name of the DLL file,
149 OBJFILE is the objfile struct of DLL_NAME. */
152 add_pe_exported_sym (const char *sym_name,
153 unsigned long func_rva,
155 const struct read_pe_section_data *section_data,
156 const char *dll_name, struct objfile *objfile)
158 char *qualified_name, *bare_name;
159 /* Add the stored offset to get the loaded address of the symbol. */
160 CORE_ADDR vma = func_rva + section_data->vma_offset;
162 /* Generate a (hopefully unique) qualified name using the first part
163 of the dll name, e.g. KERNEL32!AddAtomA. This matches the style
164 used by windbg from the "Microsoft Debugging Tools for Windows". */
166 if (sym_name == NULL || *sym_name == '\0')
167 bare_name = xstrprintf ("#%d", ordinal);
169 bare_name = xstrdup (sym_name);
171 qualified_name = xstrprintf ("%s!%s", dll_name, bare_name);
173 if ((section_data->ms_type == mst_unknown) && debug_coff_pe_read)
174 fprintf_unfiltered (gdb_stdlog , _("Unknown section type for \"%s\""
175 " for entry \"%s\" in dll \"%s\"\n"),
176 section_data->section_name, sym_name, dll_name);
178 prim_record_minimal_symbol (qualified_name, vma,
179 section_data->ms_type, objfile);
181 /* Enter the plain name as well, which might not be unique. */
182 prim_record_minimal_symbol (bare_name, vma, section_data->ms_type, objfile);
183 if (debug_coff_pe_read > 1)
184 fprintf_unfiltered (gdb_stdlog, _("Adding exported symbol \"%s\""
185 " in dll \"%s\"\n"), sym_name, dll_name);
186 xfree (qualified_name);
190 /* Create a minimal symbol entry for an exported forward symbol.
191 Return 1 if the forwarded function was found 0 otherwise.
192 SYM_NAME contains the exported name or NULL if exported by ordinal,
193 FORWARD_DLL_NAME is the name of the DLL in which the target symobl resides,
194 FORWARD_FUNC_NAME is the name of the target symbol in that DLL,
195 ORDINAL is the ordinal index value of the symbol,
196 DLL_NAME is the internal name of the DLL file,
197 OBJFILE is the objfile struct of DLL_NAME. */
200 add_pe_forwarded_sym (const char *sym_name, const char *forward_dll_name,
201 const char *forward_func_name, int ordinal,
202 const char *dll_name, struct objfile *objfile)
205 struct bound_minimal_symbol msymbol;
206 enum minimal_symbol_type msymtype;
207 char *qualified_name, *bare_name;
208 int forward_dll_name_len = strlen (forward_dll_name);
209 int forward_func_name_len = strlen (forward_func_name);
210 int forward_len = forward_dll_name_len + forward_func_name_len + 2;
211 char *forward_qualified_name = alloca (forward_len);
213 xsnprintf (forward_qualified_name, forward_len, "%s!%s", forward_dll_name,
217 msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name);
223 for (i = 0; i < forward_dll_name_len; i++)
224 forward_qualified_name[i] = tolower (forward_qualified_name[i]);
225 msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name);
230 if (debug_coff_pe_read)
231 fprintf_unfiltered (gdb_stdlog, _("Unable to find function \"%s\" in"
232 " dll \"%s\", forward of \"%s\" in dll \"%s\"\n"),
233 forward_func_name, forward_dll_name, sym_name,
238 if (debug_coff_pe_read > 1)
239 fprintf_unfiltered (gdb_stdlog, _("Adding forwarded exported symbol"
240 " \"%s\" in dll \"%s\", pointing to \"%s\"\n"),
241 sym_name, dll_name, forward_qualified_name);
243 vma = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
244 msymtype = MSYMBOL_TYPE (msymbol.minsym);
246 /* Generate a (hopefully unique) qualified name using the first part
247 of the dll name, e.g. KERNEL32!AddAtomA. This matches the style
248 used by windbg from the "Microsoft Debugging Tools for Windows". */
250 if (sym_name == NULL || *sym_name == '\0')
251 bare_name = xstrprintf ("#%d", ordinal);
253 bare_name = xstrdup (sym_name);
255 qualified_name = xstrprintf ("%s!%s", dll_name, bare_name);
257 prim_record_minimal_symbol (qualified_name, vma, msymtype, objfile);
259 /* Enter the plain name as well, which might not be unique. */
260 prim_record_minimal_symbol (bare_name, vma, msymtype, objfile);
261 xfree (qualified_name);
267 /* Truncate a dll_name at the last dot character. */
270 read_pe_truncate_name (char *dll_name)
272 char *last_point = strrchr (dll_name, '.');
274 if (last_point != NULL)
278 /* Low-level support functions, direct from the ld module pe-dll.c. */
280 pe_get16 (bfd *abfd, int where)
284 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
285 bfd_bread (b, (bfd_size_type) 2, abfd);
286 return b[0] + (b[1] << 8);
290 pe_get32 (bfd *abfd, int where)
294 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
295 bfd_bread (b, (bfd_size_type) 4, abfd);
296 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
302 unsigned char *b = ptr;
304 return b[0] + (b[1] << 8);
310 unsigned char *b = ptr;
312 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
315 /* Read the (non-debug) export symbol table from a portable
316 executable. Code originally lifted from the ld function
317 pe_implied_import_dll in pe-dll.c. */
320 read_pe_exported_syms (struct objfile *objfile)
322 bfd *dll = objfile->obfd;
323 unsigned long nbnormal, nbforward;
324 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
325 unsigned long export_opthdrrva, export_opthdrsize;
326 unsigned long export_rva, export_size, nsections, secptr, expptr;
327 unsigned long exp_funcbase;
328 unsigned char *expdata, *erva;
329 unsigned long name_rvas, ordinals, nexp, ordbase;
330 char *dll_name = (char *) dll->filename;
331 int otherix = PE_SECTION_TABLE_SIZE;
335 /* Array elements are for text, data and bss in that order
336 Initialization with RVA_START > RVA_END guarantees that
337 unused sections won't be matched. */
338 struct read_pe_section_data *section_data;
339 struct pe_sections_info pe_sections_info;
341 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
343 char const *target = bfd_get_target (objfile->obfd);
345 section_data = xzalloc (PE_SECTION_TABLE_SIZE
346 * sizeof (struct read_pe_section_data));
348 make_cleanup (free_current_contents, §ion_data);
350 for (i=0; i < PE_SECTION_TABLE_SIZE; i++)
352 section_data[i].vma_offset = 0;
353 section_data[i].rva_start = 1;
354 section_data[i].rva_end = 0;
356 section_data[PE_SECTION_INDEX_TEXT].ms_type = mst_text;
357 section_data[PE_SECTION_INDEX_TEXT].section_name = ".text";
358 section_data[PE_SECTION_INDEX_DATA].ms_type = mst_data;
359 section_data[PE_SECTION_INDEX_DATA].section_name = ".data";
360 section_data[PE_SECTION_INDEX_BSS].ms_type = mst_bss;
361 section_data[PE_SECTION_INDEX_BSS].section_name = ".bss";
363 is_pe64 = (strcmp (target, "pe-x86-64") == 0
364 || strcmp (target, "pei-x86-64") == 0);
365 is_pe32 = (strcmp (target, "pe-i386") == 0
366 || strcmp (target, "pei-i386") == 0
367 || strcmp (target, "pe-arm-wince-little") == 0
368 || strcmp (target, "pei-arm-wince-little") == 0);
369 if (!is_pe32 && !is_pe64)
371 /* This is not a recognized PE format file. Abort now, because
372 the code is untested on anything else. *FIXME* test on
373 further architectures and loosen or remove this test. */
374 do_cleanups (back_to);
378 /* Get pe_header, optional header and numbers of export entries. */
379 pe_header_offset = pe_get32 (dll, 0x3c);
380 opthdr_ofs = pe_header_offset + 4 + 20;
382 num_entries = pe_get32 (dll, opthdr_ofs + 108);
384 num_entries = pe_get32 (dll, opthdr_ofs + 92);
386 if (num_entries < 1) /* No exports. */
388 do_cleanups (back_to);
393 export_opthdrrva = pe_get32 (dll, opthdr_ofs + 112);
394 export_opthdrsize = pe_get32 (dll, opthdr_ofs + 116);
398 export_opthdrrva = pe_get32 (dll, opthdr_ofs + 96);
399 export_opthdrsize = pe_get32 (dll, opthdr_ofs + 100);
401 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
402 secptr = (pe_header_offset + 4 + 20 +
403 pe_get16 (dll, pe_header_offset + 4 + 16));
407 /* Get the rva and size of the export section. */
408 for (i = 0; i < nsections; i++)
411 unsigned long secptr1 = secptr + 40 * i;
412 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
413 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
414 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
416 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
417 bfd_bread (sname, (bfd_size_type) sizeof (sname), dll);
419 if ((strcmp (sname, ".edata") == 0)
420 || (vaddr <= export_opthdrrva && export_opthdrrva < vaddr + vsize))
422 if (strcmp (sname, ".edata") != 0)
424 if (debug_coff_pe_read)
425 fprintf_unfiltered (gdb_stdlog, _("Export RVA for dll "
426 "\"%s\" is in section \"%s\"\n"),
429 else if (export_opthdrrva != vaddr && debug_coff_pe_read)
430 fprintf_unfiltered (gdb_stdlog, _("Wrong value of export RVA"
431 " for dll \"%s\": 0x%lx instead of 0x%lx\n"),
432 dll_name, export_opthdrrva, vaddr);
433 expptr = fptr + (export_opthdrrva - vaddr);
438 export_rva = export_opthdrrva;
439 export_size = export_opthdrsize;
441 if (export_size == 0)
443 /* Empty export table. */
444 do_cleanups (back_to);
448 /* Scan sections and store the base and size of the relevant
450 for (i = 0; i < nsections; i++)
452 unsigned long secptr1 = secptr + 40 * i;
453 unsigned long vsize = pe_get32 (dll, secptr1 + 8);
454 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
455 unsigned long characteristics = pe_get32 (dll, secptr1 + 36);
456 char sec_name[SCNNMLEN + 1];
459 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
460 bfd_bread (sec_name, (bfd_size_type) SCNNMLEN, dll);
461 sec_name[SCNNMLEN] = '\0';
463 sectix = read_pe_section_index (sec_name);
465 if (sectix != PE_SECTION_INDEX_INVALID)
467 section_data[sectix].rva_start = vaddr;
468 section_data[sectix].rva_end = vaddr + vsize;
474 section_data = xrealloc (section_data, (otherix + 1)
475 * sizeof (struct read_pe_section_data));
476 name = xstrdup (sec_name);
477 section_data[otherix].section_name = name;
478 make_cleanup (xfree, name);
479 section_data[otherix].rva_start = vaddr;
480 section_data[otherix].rva_end = vaddr + vsize;
481 section_data[otherix].vma_offset = 0;
482 if (characteristics & IMAGE_SCN_CNT_CODE)
483 section_data[otherix].ms_type = mst_text;
484 else if (characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
485 section_data[otherix].ms_type = mst_data;
486 else if (characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
487 section_data[otherix].ms_type = mst_bss;
489 section_data[otherix].ms_type = mst_unknown;
494 expdata = (unsigned char *) xmalloc (export_size);
495 make_cleanup (xfree, expdata);
497 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
498 bfd_bread (expdata, (bfd_size_type) export_size, dll);
499 erva = expdata - export_rva;
501 nexp = pe_as32 (expdata + 24);
502 name_rvas = pe_as32 (expdata + 32);
503 ordinals = pe_as32 (expdata + 36);
504 ordbase = pe_as32 (expdata + 16);
505 exp_funcbase = pe_as32 (expdata + 28);
507 /* Use internal dll name instead of full pathname. */
508 dll_name = (char *) (pe_as32 (expdata + 12) + erva);
510 pe_sections_info.nb_sections = otherix;
511 pe_sections_info.sections = section_data;
513 bfd_map_over_sections (dll, get_section_vmas, &pe_sections_info);
515 /* Adjust the vma_offsets in case this PE got relocated. This
516 assumes that *all* sections share the same relocation offset
517 as the text section. */
518 for (i = 0; i < otherix; i++)
520 section_data[i].vma_offset
521 += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
524 /* Truncate name at first dot. Should maybe also convert to all
525 lower case for convenience on Windows. */
526 read_pe_truncate_name (dll_name);
528 if (debug_coff_pe_read)
529 fprintf_unfiltered (gdb_stdlog, _("DLL \"%s\" has %ld export entries,"
530 " base=%ld\n"), dll_name, nexp, ordbase);
533 /* Iterate through the list of symbols. */
534 for (i = 0; i < nexp; i++)
536 /* Pointer to the names vector. */
537 unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
538 /* Retrieve ordinal value. */
540 unsigned long ordinal = pe_as16 (erva + ordinals + i * 2);
543 /* Pointer to the function address vector. */
544 /* This is relatived to ordinal value. */
545 unsigned long func_rva = pe_as32 (erva + exp_funcbase +
548 /* Find this symbol's section in our own array. */
550 int section_found = 0;
552 /* First handle forward cases. */
553 if (func_rva >= export_rva && func_rva < export_rva + export_size)
555 char *forward_name = (char *) (erva + func_rva);
556 char *funcname = (char *) (erva + name_rva);
557 char *forward_dll_name = forward_name;
558 char *forward_func_name = forward_name;
559 char *sep = strrchr (forward_name, '.');
563 int len = (int) (sep - forward_name);
565 forward_dll_name = alloca (len + 1);
566 strncpy (forward_dll_name, forward_name, len);
567 forward_dll_name[len] = '\0';
568 forward_func_name = ++sep;
570 if (add_pe_forwarded_sym (funcname, forward_dll_name,
571 forward_func_name, ordinal,
572 dll_name, objfile) != 0)
577 for (sectix = 0; sectix < otherix; ++sectix)
579 if ((func_rva >= section_data[sectix].rva_start)
580 && (func_rva < section_data[sectix].rva_end))
582 char *sym_name = (char *) (erva + name_rva);
585 add_pe_exported_sym (sym_name, func_rva, ordinal,
586 section_data + sectix, dll_name, objfile);
593 char *funcname = (char *) (erva + name_rva);
597 add_pe_exported_sym (NULL, func_rva, ordinal,
598 section_data, dll_name, objfile);
601 else if (debug_coff_pe_read)
602 fprintf_unfiltered (gdb_stdlog, _("Export name \"%s\" ord. %lu,"
603 " RVA 0x%lx in dll \"%s\" not handled\n"),
604 funcname, ordinal, func_rva, dll_name);
608 if (debug_coff_pe_read)
609 fprintf_unfiltered (gdb_stdlog, _("Finished reading \"%s\", exports %ld,"
610 " forwards %ld, total %ld/%ld.\n"), dll_name, nbnormal,
611 nbforward, nbnormal + nbforward, nexp);
612 /* Discard expdata and section_data. */
613 do_cleanups (back_to);
616 /* Extract from ABFD the offset of the .text section.
617 This offset is mainly related to the offset within the file.
618 The value was previously expected to be 0x1000 for all files,
619 but some Windows OS core DLLs seem to use 0x10000 section alignement
620 which modified the return value of that function.
621 Still return default 0x1000 value if ABFD is NULL or
622 if '.text' section is not found, but that should not happen... */
624 #define DEFAULT_COFF_PE_TEXT_SECTION_OFFSET 0x1000
627 pe_text_section_offset (struct bfd *abfd)
630 unsigned long pe_header_offset, i;
631 unsigned long nsections, secptr;
637 return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
639 target = bfd_get_target (abfd);
641 is_pe64 = (strcmp (target, "pe-x86-64") == 0
642 || strcmp (target, "pei-x86-64") == 0);
643 is_pe32 = (strcmp (target, "pe-i386") == 0
644 || strcmp (target, "pei-i386") == 0
645 || strcmp (target, "pe-arm-wince-little") == 0
646 || strcmp (target, "pei-arm-wince-little") == 0);
648 if (!is_pe32 && !is_pe64)
650 /* This is not a recognized PE format file. Abort now, because
651 the code is untested on anything else. *FIXME* test on
652 further architectures and loosen or remove this test. */
653 return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
656 /* Get pe_header, optional header and numbers of sections. */
657 pe_header_offset = pe_get32 (abfd, 0x3c);
658 nsections = pe_get16 (abfd, pe_header_offset + 4 + 2);
659 secptr = (pe_header_offset + 4 + 20 +
660 pe_get16 (abfd, pe_header_offset + 4 + 16));
662 /* Get the rva and size of the export section. */
663 for (i = 0; i < nsections; i++)
665 char sname[SCNNMLEN + 1];
666 unsigned long secptr1 = secptr + 40 * i;
667 unsigned long vaddr = pe_get32 (abfd, secptr1 + 12);
669 bfd_seek (abfd, (file_ptr) secptr1, SEEK_SET);
670 bfd_bread (sname, (bfd_size_type) SCNNMLEN, abfd);
671 sname[SCNNMLEN] = '\0';
672 if (strcmp (sname, ".text") == 0)
676 return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
679 /* Implements "show debug coff_pe_read" command. */
682 show_debug_coff_pe_read (struct ui_file *file, int from_tty,
683 struct cmd_list_element *c, const char *value)
685 fprintf_filtered (file, _("Coff PE read debugging is %s.\n"), value);
688 /* Provide a prototype to silence -Wmissing-prototypes. */
690 void _initialize_coff_pe_read (void);
692 /* Adds "Set/show debug coff_pe_read" commands. */
695 _initialize_coff_pe_read (void)
697 add_setshow_zuinteger_cmd ("coff-pe-read", class_maintenance,
699 _("Set coff PE read debugging."),
700 _("Show coff PE read debugging."),
701 _("When set, debugging messages for coff reading "
702 "of exported symbols are displayed."),
703 NULL, show_debug_coff_pe_read,
704 &setdebuglist, &showdebuglist);