contrib/gdb-7/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   int dll_name_len = strlen (dll_name);
 162
 163   /* Generate a (hopefully unique) qualified name using the first part
 164      of the dll name, e.g. KERNEL32!AddAtomA.  This matches the style
 165      used by windbg from the "Microsoft Debugging Tools for Windows".  */
 166
 167   if (sym_name == NULL || *sym_name == '\0')
 168     bare_name = xstrprintf ("#%d", ordinal);
 169   else
 170     bare_name = xstrdup (sym_name);
 171
 172   qualified_name = xstrprintf ("%s!%s", dll_name, bare_name);
 173
 174   if ((section_data->ms_type == mst_unknown) && debug_coff_pe_read)
 175     fprintf_unfiltered (gdb_stdlog , _("Unknown section type for \"%s\""
 176                         " for entry \"%s\" in dll \"%s\"\n"),
 177                         section_data->section_name, sym_name, dll_name);
 178
 179   prim_record_minimal_symbol (qualified_name, vma,
 180                               section_data->ms_type, objfile);
 181
 182   /* Enter the plain name as well, which might not be unique.  */
 183   prim_record_minimal_symbol (bare_name, vma, section_data->ms_type, objfile);
 184   if (debug_coff_pe_read > 1)
 185     fprintf_unfiltered (gdb_stdlog, _("Adding exported symbol \"%s\""
 186                         " in dll \"%s\"\n"), sym_name, dll_name);
 187   xfree (qualified_name);
 188   xfree (bare_name);
 189 }
 190
 191 /* Create a minimal symbol entry for an exported forward symbol.
 192    Return 1 if the forwarded function was found 0 otherwise.
 193    SYM_NAME contains the exported name or NULL if exported by ordinal,
 194    FORWARD_DLL_NAME is the name of the DLL in which the target symobl resides,
 195    FORWARD_FUNC_NAME is the name of the target symbol in that DLL,
 196    ORDINAL is the ordinal index value of the symbol,
 197    DLL_NAME is the internal name of the DLL file,
 198    OBJFILE is the objfile struct of DLL_NAME.  */
 199
 200 static int
 201 add_pe_forwarded_sym (const char *sym_name, const char *forward_dll_name,
 202                       const char *forward_func_name, int ordinal,
 203                       const char *dll_name, struct objfile *objfile)
 204 {
 205   CORE_ADDR vma;
 206   struct objfile *forward_objfile;
 207   struct minimal_symbol *msymbol;
 208   short section;
 209   enum minimal_symbol_type msymtype;
 210   int dll_name_len = strlen (dll_name);
 211   char *qualified_name, *bare_name;
 212   int forward_dll_name_len = strlen (forward_dll_name);
 213   int forward_func_name_len = strlen (forward_func_name);
 214   int forward_len = forward_dll_name_len + forward_func_name_len + 2;
 215   char *forward_qualified_name = alloca (forward_len);
 216
 217   xsnprintf (forward_qualified_name, forward_len, "%s!%s", forward_dll_name,
 218              forward_func_name);
 219
 220
 221   msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name,
 222                                                &forward_objfile);
 223
 224   if (!msymbol)
 225     {
 226       int i;
 227
 228       for (i = 0; i < forward_dll_name_len; i++)
 229         forward_qualified_name[i] = tolower (forward_qualified_name[i]);
 230       msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name,
 231                                                    &forward_objfile);
 232     }
 233
 234   if (!msymbol)
 235     {
 236       if (debug_coff_pe_read)
 237         fprintf_unfiltered (gdb_stdlog, _("Unable to find function \"%s\" in"
 238                             " dll \"%s\", forward of \"%s\" in dll \"%s\"\n"),
 239                             forward_func_name, forward_dll_name, sym_name,
 240                             dll_name);
 241       return 0;
 242     }
 243
 244   if (debug_coff_pe_read > 1)
 245     fprintf_unfiltered (gdb_stdlog, _("Adding forwarded exported symbol"
 246                         " \"%s\" in dll \"%s\", pointing to \"%s\"\n"),
 247                         sym_name, dll_name, forward_qualified_name);
 248
 249   vma = SYMBOL_VALUE_ADDRESS (msymbol);
 250   section = SYMBOL_SECTION (msymbol);
 251   msymtype = MSYMBOL_TYPE (msymbol);
 252
 253   /* Generate a (hopefully unique) qualified name using the first part
 254      of the dll name, e.g. KERNEL32!AddAtomA.  This matches the style
 255      used by windbg from the "Microsoft Debugging Tools for Windows".  */
 256
 257   if (sym_name == NULL || *sym_name == '\0')
 258     bare_name = xstrprintf ("#%d", ordinal);
 259   else
 260     bare_name = xstrdup (sym_name);
 261
 262   qualified_name = xstrprintf ("%s!%s", dll_name, bare_name);
 263
 264   prim_record_minimal_symbol (qualified_name, vma, msymtype, objfile);
 265
 266   /* Enter the plain name as well, which might not be unique.  */
 267   prim_record_minimal_symbol (bare_name, vma, msymtype, objfile);
 268   xfree (qualified_name);
 269   xfree (bare_name);
 270
 271   return 1;
 272 }
 273
 274 /* Truncate a dll_name at the last dot character.  */
 275
 276 static void
 277 read_pe_truncate_name (char *dll_name)
 278 {
 279   char *last_point = strrchr (dll_name, '.');
 280
 281   if (last_point != NULL)
 282     *last_point = '\0';
 283 }
 284 \f
 285 /* Low-level support functions, direct from the ld module pe-dll.c.  */
 286 static unsigned int
 287 pe_get16 (bfd *abfd, int where)
 288 {
 289   unsigned char b[2];
 290
 291   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
 292   bfd_bread (b, (bfd_size_type) 2, abfd);
 293   return b[0] + (b[1] << 8);
 294 }
 295
 296 static unsigned int
 297 pe_get32 (bfd *abfd, int where)
 298 {
 299   unsigned char b[4];
 300
 301   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
 302   bfd_bread (b, (bfd_size_type) 4, abfd);
 303   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
 304 }
 305
 306 static unsigned int
 307 pe_as16 (void *ptr)
 308 {
 309   unsigned char *b = ptr;
 310
 311   return b[0] + (b[1] << 8);
 312 }
 313
 314 static unsigned int
 315 pe_as32 (void *ptr)
 316 {
 317   unsigned char *b = ptr;
 318
 319   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
 320 }
 321 \f
 322 /* Read the (non-debug) export symbol table from a portable
 323    executable.  Code originally lifted from the ld function
 324    pe_implied_import_dll in pe-dll.c.  */
 325
 326 void
 327 read_pe_exported_syms (struct objfile *objfile)
 328 {
 329   bfd *dll = objfile->obfd;
 330   unsigned long nbnormal, nbforward;
 331   unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
 332   unsigned long export_opthdrrva, export_opthdrsize;
 333   unsigned long export_rva, export_size, nsections, secptr, expptr;
 334   unsigned long exp_funcbase;
 335   unsigned char *expdata, *erva;
 336   unsigned long name_rvas, ordinals, nexp, ordbase;
 337   char *dll_name = (char *) dll->filename;
 338   int otherix = PE_SECTION_TABLE_SIZE;
 339   int exportix = -1;
 340   int is_pe64 = 0;
 341   int is_pe32 = 0;
 342
 343   /* Array elements are for text, data and bss in that order
 344      Initialization with RVA_START > RVA_END guarantees that
 345      unused sections won't be matched.  */
 346   struct read_pe_section_data *section_data;
 347   struct pe_sections_info pe_sections_info;
 348
 349   struct cleanup *back_to = make_cleanup (null_cleanup, 0);
 350
 351   char const *target = bfd_get_target (objfile->obfd);
 352
 353   section_data = xzalloc (PE_SECTION_TABLE_SIZE
 354                          * sizeof (struct read_pe_section_data));
 355
 356   make_cleanup (free_current_contents, &section_data);
 357
 358   for (i=0; i < PE_SECTION_TABLE_SIZE; i++)
 359     {
 360       section_data[i].vma_offset = 0;
 361       section_data[i].rva_start = 1;
 362       section_data[i].rva_end = 0;
 363     };
 364   section_data[PE_SECTION_INDEX_TEXT].ms_type = mst_text;
 365   section_data[PE_SECTION_INDEX_TEXT].section_name = ".text";
 366   section_data[PE_SECTION_INDEX_DATA].ms_type = mst_data;
 367   section_data[PE_SECTION_INDEX_DATA].section_name = ".data";
 368   section_data[PE_SECTION_INDEX_BSS].ms_type = mst_bss;
 369   section_data[PE_SECTION_INDEX_BSS].section_name = ".bss";
 370
 371   is_pe64 = (strcmp (target, "pe-x86-64") == 0
 372              || strcmp (target, "pei-x86-64") == 0);
 373   is_pe32 = (strcmp (target, "pe-i386") == 0
 374              || strcmp (target, "pei-i386") == 0
 375              || strcmp (target, "pe-arm-wince-little") == 0
 376              || strcmp (target, "pei-arm-wince-little") == 0);
 377   if (!is_pe32 && !is_pe64)
 378     {
 379       /* This is not a recognized PE format file.  Abort now, because
 380          the code is untested on anything else.  *FIXME* test on
 381          further architectures and loosen or remove this test.  */
 382       do_cleanups (back_to);
 383       return;
 384     }
 385
 386   /* Get pe_header, optional header and numbers of export entries.  */
 387   pe_header_offset = pe_get32 (dll, 0x3c);
 388   opthdr_ofs = pe_header_offset + 4 + 20;
 389   if (is_pe64)
 390     num_entries = pe_get32 (dll, opthdr_ofs + 108);
 391   else
 392     num_entries = pe_get32 (dll, opthdr_ofs + 92);
 393
 394   if (num_entries < 1)          /* No exports.  */
 395     {
 396       do_cleanups (back_to);
 397       return;
 398     }
 399   if (is_pe64)
 400     {
 401       export_opthdrrva = pe_get32 (dll, opthdr_ofs + 112);
 402       export_opthdrsize = pe_get32 (dll, opthdr_ofs + 116);
 403     }
 404   else
 405     {
 406       export_opthdrrva = pe_get32 (dll, opthdr_ofs + 96);
 407       export_opthdrsize = pe_get32 (dll, opthdr_ofs + 100);
 408     }
 409   nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
 410   secptr = (pe_header_offset + 4 + 20 +
 411             pe_get16 (dll, pe_header_offset + 4 + 16));
 412   expptr = 0;
 413   export_size = 0;
 414
 415   /* Get the rva and size of the export section.  */
 416   for (i = 0; i < nsections; i++)
 417     {
 418       char sname[8];
 419       unsigned long secptr1 = secptr + 40 * i;
 420       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
 421       unsigned long vsize = pe_get32 (dll, secptr1 + 16);
 422       unsigned long fptr = pe_get32 (dll, secptr1 + 20);
 423
 424       bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
 425       bfd_bread (sname, (bfd_size_type) sizeof (sname), dll);
 426
 427       if ((strcmp (sname, ".edata") == 0)
 428           || (vaddr <= export_opthdrrva && export_opthdrrva < vaddr + vsize))
 429         {
 430           if (strcmp (sname, ".edata") != 0)
 431             {
 432               if (debug_coff_pe_read)
 433                 fprintf_unfiltered (gdb_stdlog, _("Export RVA for dll "
 434                                     "\"%s\" is in section \"%s\"\n"),
 435                                     dll_name, sname);
 436             }
 437           else if (export_opthdrrva != vaddr && debug_coff_pe_read)
 438             fprintf_unfiltered (gdb_stdlog, _("Wrong value of export RVA"
 439                                 " for dll \"%s\": 0x%lx instead of 0x%lx\n"),
 440                                 dll_name, export_opthdrrva, vaddr);
 441           expptr = fptr + (export_opthdrrva - vaddr);
 442           exportix = i;
 443           break;
 444         }
 445     }
 446
 447   export_rva = export_opthdrrva;
 448   export_size = export_opthdrsize;
 449
 450   if (export_size == 0)
 451     {
 452       /* Empty export table.  */
 453       do_cleanups (back_to);
 454       return;
 455     }
 456
 457   /* Scan sections and store the base and size of the relevant
 458      sections.  */
 459   for (i = 0; i < nsections; i++)
 460     {
 461       unsigned long secptr1 = secptr + 40 * i;
 462       unsigned long vsize = pe_get32 (dll, secptr1 + 8);
 463       unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
 464       unsigned long characteristics = pe_get32 (dll, secptr1 + 36);
 465       char sec_name[SCNNMLEN + 1];
 466       int sectix;
 467
 468       bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
 469       bfd_bread (sec_name, (bfd_size_type) SCNNMLEN, dll);
 470       sec_name[SCNNMLEN] = '\0';
 471
 472       sectix = read_pe_section_index (sec_name);
 473
 474       if (sectix != PE_SECTION_INDEX_INVALID)
 475         {
 476           section_data[sectix].rva_start = vaddr;
 477           section_data[sectix].rva_end = vaddr + vsize;
 478         }
 479       else
 480         {
 481           char *name;
 482
 483           section_data = xrealloc (section_data, (otherix + 1)
 484                                    * sizeof (struct read_pe_section_data));
 485           name = xstrdup (sec_name);
 486           section_data[otherix].section_name = name;
 487           make_cleanup (xfree, name);
 488           section_data[otherix].rva_start = vaddr;
 489           section_data[otherix].rva_end = vaddr + vsize;
 490           section_data[otherix].vma_offset = 0;
 491           if (characteristics & IMAGE_SCN_CNT_CODE)
 492             section_data[otherix].ms_type = mst_text;
 493           else if (characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
 494             section_data[otherix].ms_type = mst_data;
 495           else if (characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
 496             section_data[otherix].ms_type = mst_bss;
 497           else
 498             section_data[otherix].ms_type = mst_unknown;
 499           otherix++;
 500         }
 501     }
 502
 503   expdata = (unsigned char *) xmalloc (export_size);
 504   make_cleanup (xfree, expdata);
 505
 506   bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
 507   bfd_bread (expdata, (bfd_size_type) export_size, dll);
 508   erva = expdata - export_rva;
 509
 510   nexp = pe_as32 (expdata + 24);
 511   name_rvas = pe_as32 (expdata + 32);
 512   ordinals = pe_as32 (expdata + 36);
 513   ordbase = pe_as32 (expdata + 16);
 514   exp_funcbase = pe_as32 (expdata + 28);
 515
 516   /* Use internal dll name instead of full pathname.  */
 517   dll_name = pe_as32 (expdata + 12) + erva;
 518
 519   pe_sections_info.nb_sections = otherix;
 520   pe_sections_info.sections = section_data;
 521
 522   bfd_map_over_sections (dll, get_section_vmas, &pe_sections_info);
 523
 524   /* Adjust the vma_offsets in case this PE got relocated. This
 525      assumes that *all* sections share the same relocation offset
 526      as the text section.  */
 527   for (i = 0; i < otherix; i++)
 528     {
 529       section_data[i].vma_offset
 530         += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
 531     }
 532
 533   /* Truncate name at first dot. Should maybe also convert to all
 534      lower case for convenience on Windows.  */
 535   read_pe_truncate_name (dll_name);
 536
 537   if (debug_coff_pe_read)
 538     fprintf_unfiltered (gdb_stdlog, _("DLL \"%s\" has %ld export entries,"
 539                         " base=%ld\n"), dll_name, nexp, ordbase);
 540   nbforward = 0;
 541   nbnormal = 0;
 542   /* Iterate through the list of symbols.  */
 543   for (i = 0; i < nexp; i++)
 544     {
 545       /* Pointer to the names vector.  */
 546       unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
 547       /* Retrieve ordinal value.  */
 548
 549       unsigned long ordinal = pe_as16 (erva + ordinals + i * 2);
 550
 551
 552       /* Pointer to the function address vector.  */
 553       /* This is relatived to ordinal value. */
 554       unsigned long func_rva = pe_as32 (erva + exp_funcbase +
 555                                         ordinal * 4);
 556
 557       /* Find this symbol's section in our own array.  */
 558       int sectix = 0;
 559       int section_found = 0;
 560
 561       /* First handle forward cases.  */
 562       if (func_rva >= export_rva && func_rva < export_rva + export_size)
 563         {
 564           char *forward_name = (char *) (erva + func_rva);
 565           char *funcname = (char *) (erva + name_rva);
 566           char *forward_dll_name = forward_name;
 567           char *forward_func_name = forward_name;
 568           char *sep = strrchr (forward_name, '.');
 569
 570           if (sep)
 571             {
 572               int len = (int) (sep - forward_name);
 573
 574               forward_dll_name = alloca (len + 1);
 575               strncpy (forward_dll_name, forward_name, len);
 576               forward_dll_name[len] = '\0';
 577               forward_func_name = ++sep;
 578             }
 579           if (add_pe_forwarded_sym (funcname, forward_dll_name,
 580                                     forward_func_name, ordinal,
 581                                     dll_name, objfile) != 0)
 582             ++nbforward;
 583           continue;
 584         }
 585
 586       for (sectix = 0; sectix < otherix; ++sectix)
 587         {
 588           if ((func_rva >= section_data[sectix].rva_start)
 589               && (func_rva < section_data[sectix].rva_end))
 590             {
 591               section_found = 1;
 592               add_pe_exported_sym (erva + name_rva,
 593                                    func_rva, ordinal,
 594                                    section_data + sectix, dll_name, objfile);
 595               ++nbnormal;
 596               break;
 597             }
 598         }
 599       if (!section_found)
 600         {
 601           char *funcname = (char *) (erva + name_rva);
 602
 603           if (name_rva == 0)
 604             {
 605               add_pe_exported_sym (NULL, func_rva, ordinal,
 606                                    section_data, dll_name, objfile);
 607               ++nbnormal;
 608             }
 609           else if (debug_coff_pe_read)
 610             fprintf_unfiltered (gdb_stdlog, _("Export name \"%s\" ord. %lu,"
 611                                 " RVA 0x%lx in dll \"%s\" not handled\n"),
 612                                 funcname, ordinal, func_rva, dll_name);
 613         }
 614     }
 615
 616   if (debug_coff_pe_read)
 617     fprintf_unfiltered (gdb_stdlog, _("Finished reading \"%s\", exports %ld,"
 618                         " forwards %ld, total %ld/%ld.\n"), dll_name, nbnormal,
 619                         nbforward, nbnormal + nbforward, nexp);
 620   /* Discard expdata and section_data.  */
 621   do_cleanups (back_to);
 622 }
 623
 624 /* Extract from ABFD the offset of the .text section.
 625    This offset is mainly related to the offset within the file.
 626    The value was previously expected to be 0x1000 for all files,
 627    but some Windows OS core DLLs seem to use 0x10000 section alignement
 628    which modified the return value of that function.
 629    Still return default 0x1000 value if ABFD is NULL or
 630    if '.text' section is not found, but that should not happen...  */
 631
 632 #define DEFAULT_COFF_PE_TEXT_SECTION_OFFSET 0x1000
 633
 634 CORE_ADDR
 635 pe_text_section_offset (struct bfd *abfd)
 636
 637 {
 638   unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
 639   unsigned long export_rva, export_size, nsections, secptr, expptr;
 640   unsigned long exp_funcbase;
 641   unsigned char *expdata, *erva;
 642   unsigned long name_rvas, ordinals, nexp, ordbase;
 643   char *dll_name;
 644   int is_pe64 = 0;
 645   int is_pe32 = 0;
 646   char const *target;
 647
 648   if (!abfd)
 649     return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
 650
 651   target = bfd_get_target (abfd);
 652
 653   is_pe64 = (strcmp (target, "pe-x86-64") == 0
 654              || strcmp (target, "pei-x86-64") == 0);
 655   is_pe32 = (strcmp (target, "pe-i386") == 0
 656              || strcmp (target, "pei-i386") == 0
 657              || strcmp (target, "pe-arm-wince-little") == 0
 658              || strcmp (target, "pei-arm-wince-little") == 0);
 659
 660   if (!is_pe32 && !is_pe64)
 661     {
 662       /* This is not a recognized PE format file.  Abort now, because
 663          the code is untested on anything else.  *FIXME* test on
 664          further architectures and loosen or remove this test.  */
 665       return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
 666     }
 667
 668   /* Get pe_header, optional header and numbers of sections.  */
 669   pe_header_offset = pe_get32 (abfd, 0x3c);
 670   opthdr_ofs = pe_header_offset + 4 + 20;
 671   nsections = pe_get16 (abfd, pe_header_offset + 4 + 2);
 672   secptr = (pe_header_offset + 4 + 20 +
 673             pe_get16 (abfd, pe_header_offset + 4 + 16));
 674
 675   /* Get the rva and size of the export section.  */
 676   for (i = 0; i < nsections; i++)
 677     {
 678       char sname[SCNNMLEN + 1];
 679       unsigned long secptr1 = secptr + 40 * i;
 680       unsigned long vaddr = pe_get32 (abfd, secptr1 + 12);
 681
 682       bfd_seek (abfd, (file_ptr) secptr1, SEEK_SET);
 683       bfd_bread (sname, (bfd_size_type) SCNNMLEN, abfd);
 684       sname[SCNNMLEN] = '\0';
 685       if (strcmp (sname, ".text") == 0)
 686         return vaddr;
 687     }
 688
 689   return DEFAULT_COFF_PE_TEXT_SECTION_OFFSET;
 690 }
 691
 692 /* Implements "show debug coff_pe_read" command.  */
 693
 694 static void
 695 show_debug_coff_pe_read (struct ui_file *file, int from_tty,
 696                          struct cmd_list_element *c, const char *value)
 697 {
 698   fprintf_filtered (file, _("Coff PE read debugging is %s.\n"), value);
 699 }
 700
 701 /* Provide a prototype to silence -Wmissing-prototypes.  */
 702
 703 void _initialize_coff_pe_read (void);
 704
 705 /* Adds "Set/show debug coff_pe_read" commands.  */
 706
 707 void
 708 _initialize_coff_pe_read (void)
 709 {
 710   add_setshow_zuinteger_cmd ("coff-pe-read", class_maintenance,
 711                              &debug_coff_pe_read,
 712                              _("Set coff PE read debugging."),
 713                              _("Show coff PE read debugging."),
 714                              _("When set, debugging messages for coff reading "
 715                                "of exported symbols are displayed."),
 716                              NULL, show_debug_coff_pe_read,
 717                              &setdebuglist, &showdebuglist);
 718 }