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-2013 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   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.
  13
  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.
  18
  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/>.
  21
  22    Contributed by Raoul M. Gough (RaoulGough@yahoo.co.uk).  */
  23
  24 #include "defs.h"
  25
  26 #include "coff-pe-read.h"
  27
  28 #include "bfd.h"
  29 #include "gdbtypes.h"
  30
  31 #include "command.h"
  32 #include "gdbcmd.h"
  33 #include "symtab.h"
  34 #include "symfile.h"
  35 #include "objfiles.h"
  36 #include "common/common-utils.h"
  37 #include "coff/internal.h"
  38
  39 #include <ctype.h>
  40
  41 /* Internal section information */
  42
  43 /* Coff PE read debugging flag:
  44    default value is 0,
  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;
  48
  49 struct read_pe_section_data
  50 {
  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
  55                                            section.  */
  56   char *section_name;           /* Recorded section name.  */
  57 };
  58
  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
  67 \f
  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.  */
  71
  72 static int
  73 read_pe_section_index (const char *section_name)
  74 {
  75   if (strcmp (section_name, ".text") == 0)
  76     {
  77       return PE_SECTION_INDEX_TEXT;
  78     }
  79
  80   else if (strcmp (section_name, ".data") == 0)
  81     {
  82       return PE_SECTION_INDEX_DATA;
  83     }
  84
  85   else if (strcmp (section_name, ".bss") == 0)
  86     {
  87       return PE_SECTION_INDEX_BSS;
  88     }
  89
  90   else
  91     {
  92       return PE_SECTION_INDEX_INVALID;
  93     }
  94 }
  95
  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.  */
  99
 100 static int
 101 get_pe_section_index (const char *section_name,
 102                       struct read_pe_section_data *sections,
 103                       int nb_sections)
 104 {
 105   int i;
 106
 107   for (i = 0; i < nb_sections; i++)
 108     if (strcmp (sections[i].section_name, section_name) == 0)
 109       return i;
 110   return PE_SECTION_INDEX_INVALID;
 111 }
 112
 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
 117 {
 118   int nb_sections;
 119   struct read_pe_section_data *sections;
 120 };
 121
 122 /* Record the virtual memory address of a section.  */
 123
 124 static void
 125 get_section_vmas (bfd *abfd, asection *sectp, void *context)
 126 {
 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,
 130                                      data->nb_sections);
 131
 132   if (sectix != PE_SECTION_INDEX_INVALID)
 133     {
 134       /* Data within the section start at rva_start in the pe and at
 135          bfd_get_section_vma() within memory.  Store the offset.  */
 136
 137       sections[sectix].vma_offset
 138         = bfd_get_section_vma (abfd, sectp) - sections[sectix].rva_start;
 139     }
 140 }
 141 \f
 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
 147    symbol is declared,
 148    DLL_NAME is the internal name of the DLL file,
 149    OBJFILE is the objfile struct of DLL_NAME.  */
 150
 151 static void
 152 add_pe_exported_sym (const char *sym_name,
 153                      unsigned long func_rva,
 154                      int ordinal,
 155                      const struct read_pe_section_data *section_data,
 156                      const char *dll_name, struct objfile *objfile)
 157 {
 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;
 161
 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".  */
 165
 166   if (sym_name == NULL || *sym_name == '\0')
 167     bare_name = xstrprintf ("#%d", ordinal);
 168   else
 169     bare_name = xstrdup (sym_name);
 170
 171   qualified_name = xstrprintf ("%s!%s", dll_name, bare_name);
 172
 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);
 177
 178   prim_record_minimal_symbol (qualified_name, vma,
 179                               section_data->ms_type, objfile);
 180
 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);
 187   xfree (bare_name);
 188 }
 189
 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.  */
 198
 199 static int
 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)
 203 {
 204   CORE_ADDR vma;
 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);
 212
 213   xsnprintf (forward_qualified_name, forward_len, "%s!%s", forward_dll_name,
 214              forward_func_name);
 215
 216
 217   msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name);
 218
 219   if (!msymbol.minsym)
 220     {
 221       int i;
 222
 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);
 226     }
 227
 228   if (!msymbol.minsym)
 229     {
 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,
 234                             dll_name);
 235       return 0;
 236     }
 237
 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);
 242
 243   vma = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
 244   msymtype = MSYMBOL_TYPE (msymbol.minsym);
 245
 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".  */
 249
 250   if (sym_name == NULL || *sym_name == '\0')
 251     bare_name = xstrprintf ("#%d", ordinal);
 252   else
 253     bare_name = xstrdup (sym_name);
 254
 255   qualified_name = xstrprintf ("%s!%s", dll_name, bare_name);
 256
 257   prim_record_minimal_symbol (qualified_name, vma, msymtype, objfile);
 258
 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);
 262   xfree (bare_name);
 263
 264   return 1;
 265 }
 266
 267 /* Truncate a dll_name at the last dot character.  */
 268
 269 static void
 270 read_pe_truncate_name (char *dll_name)
 271 {
 272   char *last_point = strrchr (dll_name, '.');
 273
 274   if (last_point != NULL)
 275     *last_point = '\0';
 276 }
 277 \f
 278 /* Low-level support functions, direct from the ld module pe-dll.c.  */
 279 static unsigned int
 280 pe_get16 (bfd *abfd, int where)
 281 {
 282   unsigned char b[2];
 283
 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);
 287 }
 288
 289 static unsigned int
 290 pe_get32 (bfd *abfd, int where)
 291 {
 292   unsigned char b[4];
 293
 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);
 297 }
 298
 299 static unsigned int
 300 pe_as16 (void *ptr)
 301 {
 302   unsigned char *b = ptr;
 303
 304   return b[0] + (b[1] << 8);
 305 }
 306
 307 static unsigned int
 308 pe_as32 (void *ptr)
 309 {
 310   unsigned char *b = ptr;
 311
 312   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
 313 }
 314 \f
 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.  */
 318
 319 void
 320 read_pe_exported_syms (struct objfile *objfile)
 321 {
 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;
 332   int is_pe64 = 0;
 333   int is_pe32 = 0;
 334
 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;
 340
 341   struct cleanup *back_to = make_cleanup (null_cleanup, 0);
 342
 343   char const *target = bfd_get_target (objfile->obfd);
 344
 345   section_data = xzalloc (PE_SECTION_TABLE_SIZE
 346                          * sizeof (struct read_pe_section_data));
 347
 348   make_cleanup (free_current_contents, &section_data);
 349
 350   for (i=0; i < PE_SECTION_TABLE_SIZE; i++)
 351     {
 352       section_data[i].vma_offset = 0;
 353       section_data[i].rva_start = 1;
 354       section_data[i].rva_end = 0;
 355     };
 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";
 362
 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)
 370     {
 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);
 375       return;
 376     }
 377
 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;
 381   if (is_pe64)
 382     num_entries = pe_get32 (dll, opthdr_ofs + 108);
 383   else
 384     num_entries = pe_get32 (dll, opthdr_ofs + 92);
 385
 386   if (num_entries < 1)          /* No exports.  */
 387     {
 388       do_cleanups (back_to);
 389       return;
 390     }
 391   if (is_pe64)
 392     {
 393       export_opthdrrva = pe_get32 (dll, opthdr_ofs + 112);
 394       export_opthdrsize = pe_get32 (dll, opthdr_ofs + 116);
 395     }
 396   else
 397     {
 398       export_opthdrrva = pe_get32 (dll, opthdr_ofs + 96);
 399       export_opthdrsize = pe_get32 (dll, opthdr_ofs + 100);
 400     }
 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));
 404   expptr = 0;
 405   export_size = 0;
 406
 407   /* Get the rva and size of the export section.  */
 408   for (i = 0; i < nsections; i++)
 409     {
 410       char sname[8];
 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);
 415
 416       bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
 417       bfd_bread (sname, (bfd_size_type) sizeof (sname), dll);
 418
 419       if ((strcmp (sname, ".edata") == 0)
 420           || (vaddr <= export_opthdrrva && export_opthdrrva < vaddr + vsize))
 421         {
 422           if (strcmp (sname, ".edata") != 0)
 423             {
 424               if (debug_coff_pe_read)
 425                 fprintf_unfiltered (gdb_stdlog, _("Export RVA for dll "
 426                                     "\"%s\" is in section \"%s\"\n"),
 427                                     dll_name, sname);
 428             }
 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);
 434           break;
 435         }
 436     }
 437
 438   export_rva = export_opthdrrva;
 439   export_size = export_opthdrsize;
 440
 441   if (export_size == 0)
 442     {
 443       /* Empty export table.  */
 444       do_cleanups (back_to);
 445       return;
 446     }
 447
 448   /* Scan sections and store the base and size of the relevant
 449      sections.  */
 450   for (i = 0; i < nsections; i++)
 451     {
 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];
 457       int sectix;
 458
 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';
 462
 463       sectix = read_pe_section_index (sec_name);
 464
 465       if (sectix != PE_SECTION_INDEX_INVALID)
 466         {
 467           section_data[sectix].rva_start = vaddr;
 468           section_data[sectix].rva_end = vaddr + vsize;
 469         }
 470       else
 471         {
 472           char *name;
 473
 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;
 488           else
 489             section_data[otherix].ms_type = mst_unknown;
 490           otherix++;
 491         }
 492     }
 493
 494   expdata = (unsigned char *) xmalloc (export_size);
 495   make_cleanup (xfree, expdata);
 496
 497   bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
 498   bfd_bread (expdata, (bfd_size_type) export_size, dll);
 499   erva = expdata - export_rva;
 500
 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);
 506
 507   /* Use internal dll name instead of full pathname.  */
 508   dll_name = (char *) (pe_as32 (expdata + 12) + erva);
 509
 510   pe_sections_info.nb_sections = otherix;
 511   pe_sections_info.sections = section_data;
 512
 513   bfd_map_over_sections (dll, get_section_vmas, &pe_sections_info);
 514
 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++)
 519     {
 520       section_data[i].vma_offset
 521         += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 522     }
 523
 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);
 527
 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);
 531   nbforward = 0;
 532   nbnormal = 0;
 533   /* Iterate through the list of symbols.  */
 534   for (i = 0; i < nexp; i++)
 535     {
 536       /* Pointer to the names vector.  */
 537       unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
 538       /* Retrieve ordinal value.  */
 539
 540       unsigned long ordinal = pe_as16 (erva + ordinals + i * 2);
 541
 542
 543       /* Pointer to the function address vector.  */
 544       /* This is relatived to ordinal value. */
 545       unsigned long func_rva = pe_as32 (erva + exp_funcbase +
 546                                         ordinal * 4);
 547
 548       /* Find this symbol's section in our own array.  */
 549       int sectix = 0;
 550       int section_found = 0;
 551
 552       /* First handle forward cases.  */
 553       if (func_rva >= export_rva && func_rva < export_rva + export_size)
 554         {
 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, '.');
 560
 561           if (sep)
 562             {
 563               int len = (int) (sep - forward_name);
 564
 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;
 569             }
 570           if (add_pe_forwarded_sym (funcname, forward_dll_name,
 571                                     forward_func_name, ordinal,
 572                                     dll_name, objfile) != 0)
 573             ++nbforward;
 574           continue;
 575         }
 576
 577       for (sectix = 0; sectix < otherix; ++sectix)
 578         {
 579           if ((func_rva >= section_data[sectix].rva_start)
 580               && (func_rva < section_data[sectix].rva_end))
 581             {
 582               char *sym_name = (char *) (erva + name_rva);
 583
 584               section_found = 1;
 585               add_pe_exported_sym (sym_name, func_rva, ordinal,
 586                                    section_data + sectix, dll_name, objfile);
 587               ++nbnormal;
 588               break;
 589             }
 590         }
 591       if (!section_found)
 592         {
 593           char *funcname = (char *) (erva + name_rva);
 594
 595           if (name_rva == 0)
 596             {
 597               add_pe_exported_sym (NULL, func_rva, ordinal,
 598                                    section_data, dll_name, objfile);
 599               ++nbnormal;
 600             }
 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);
 605         }
 606     }
 607
 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);
 614 }
 615
 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...  */
 623
 624 #define DEFAULT_COFF_PE_TEXT_SECTION_OFFSET 0x1000
 625
 626 CORE_ADDR
 627 pe_text_section_offset (struct bfd *abfd)
 628
 629 {
 630   unsigned long pe_header_offset, i;
 631   unsigned long nsections, secptr;
 632   int is_pe64 = 0;
 633   int is_pe32 = 0;
 634   char const *target;
 635
 636   if (!abfd)
 637     return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
 638
 639   target = bfd_get_target (abfd);
 640
 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);
 647
 648   if (!is_pe32 && !is_pe64)
 649     {
 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;
 654     }
 655
 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));
 661
 662   /* Get the rva and size of the export section.  */
 663   for (i = 0; i < nsections; i++)
 664     {
 665       char sname[SCNNMLEN + 1];
 666       unsigned long secptr1 = secptr + 40 * i;
 667       unsigned long vaddr = pe_get32 (abfd, secptr1 + 12);
 668
 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)
 673         return vaddr;
 674     }
 675
 676   return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
 677 }
 678
 679 /* Implements "show debug coff_pe_read" command.  */
 680
 681 static void
 682 show_debug_coff_pe_read (struct ui_file *file, int from_tty,
 683                          struct cmd_list_element *c, const char *value)
 684 {
 685   fprintf_filtered (file, _("Coff PE read debugging is %s.\n"), value);
 686 }
 687
 688 /* Provide a prototype to silence -Wmissing-prototypes.  */
 689
 690 void _initialize_coff_pe_read (void);
 691
 692 /* Adds "Set/show debug coff_pe_read" commands.  */
 693
 694 void
 695 _initialize_coff_pe_read (void)
 696 {
 697   add_setshow_zuinteger_cmd ("coff-pe-read", class_maintenance,
 698                              &debug_coff_pe_read,
 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);
 705 }