bfd/pei-x86_64.c

   1 /* BFD back-end for Intel 386 PE IMAGE COFF files.
   2    Copyright (C) 2006-2018 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.
  20
  21    Written by Kai Tietz, OneVision Software GmbH&CoKg.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25
  26 #define TARGET_SYM              x86_64_pei_vec
  27 #define TARGET_NAME             "pei-x86-64"
  28 #define COFF_IMAGE_WITH_PE
  29 #define COFF_WITH_PE
  30 #define COFF_WITH_pex64
  31 #define PCRELOFFSET             TRUE
  32 #if defined (USE_MINGW64_LEADING_UNDERSCORES)
  33 #define TARGET_UNDERSCORE       '_'
  34 #else
  35 #define TARGET_UNDERSCORE       0
  36 #endif
  37 /* Long section names not allowed in executable images, only object files.  */
  38 #define COFF_LONG_SECTION_NAMES 0
  39 #define COFF_SUPPORT_GNU_LINKONCE
  40 #define COFF_LONG_FILENAMES
  41 #define PDATA_ROW_SIZE  (3 * 4)
  42
  43 #define COFF_SECTION_ALIGNMENT_ENTRIES \
  44 { COFF_SECTION_NAME_EXACT_MATCH (".bss"), \
  45   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
  46 { COFF_SECTION_NAME_PARTIAL_MATCH (".data"), \
  47   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
  48 { COFF_SECTION_NAME_PARTIAL_MATCH (".rdata"), \
  49   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
  50 { COFF_SECTION_NAME_PARTIAL_MATCH (".text"), \
  51   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
  52 { COFF_SECTION_NAME_PARTIAL_MATCH (".idata"), \
  53   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
  54 { COFF_SECTION_NAME_EXACT_MATCH (".pdata"), \
  55   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
  56 { COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
  57   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
  58 { COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi."), \
  59   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }
  60
  61 /* Note we have to make sure not to include headers twice.
  62    Not all headers are wrapped in #ifdef guards, so we define
  63    PEI_HEADERS to prevent double including in coff-x86_64.c  */
  64 #define PEI_HEADERS
  65 #include "sysdep.h"
  66 #include "bfd.h"
  67 #include "libbfd.h"
  68 #include "coff/x86_64.h"
  69 #include "coff/internal.h"
  70 #include "coff/pe.h"
  71 #include "libcoff.h"
  72 #include "libpei.h"
  73 #include "libiberty.h"
  74
  75 #undef AOUTSZ
  76 #define AOUTSZ          PEPAOUTSZ
  77 #define PEAOUTHDR       PEPAOUTHDR
  78
  79 /* Name of registers according to SEH conventions.  */
  80
  81 static const char * const pex_regs[16] = {
  82   "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
  83   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
  84 };
  85
  86 /* Swap in a runtime function.  */
  87
  88 static void
  89 pex64_get_runtime_function (bfd *abfd, struct pex64_runtime_function *rf,
  90                             const void *data)
  91 {
  92   const struct external_pex64_runtime_function *ex_rf =
  93     (const struct external_pex64_runtime_function *) data;
  94   rf->rva_BeginAddress = bfd_get_32 (abfd, ex_rf->rva_BeginAddress);
  95   rf->rva_EndAddress = bfd_get_32 (abfd, ex_rf->rva_EndAddress);
  96   rf->rva_UnwindData =  bfd_get_32 (abfd, ex_rf->rva_UnwindData);
  97 }
  98
  99 /* Swap in unwind info header.  */
 100
 101 static bfd_boolean
 102 pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui,
 103                        void *data, void *data_end)
 104 {
 105   struct external_pex64_unwind_info *ex_ui =
 106     (struct external_pex64_unwind_info *) data;
 107   bfd_byte *ex_dta = (bfd_byte *) data;
 108   bfd_byte *ex_dta_end = (bfd_byte *) data_end;
 109
 110   memset (ui, 0, sizeof (struct pex64_unwind_info));
 111
 112   if (ex_dta >= ex_dta_end || ex_dta + 4 >= ex_dta_end)
 113     return FALSE;
 114
 115   ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
 116   ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
 117   ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
 118   ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
 119   ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
 120   ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
 121   ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
 122   ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
 123   ui->rawUnwindCodes = ex_dta + 4;
 124   ui->rawUnwindCodesEnd = ex_dta_end;
 125
 126   ex_dta += ui->SizeOfBlock;
 127   if (ex_dta >= ex_dta_end)
 128     return FALSE;
 129
 130   switch (ui->Flags)
 131     {
 132     case UNW_FLAG_CHAININFO:
 133       if (ex_dta + 12 >= ex_dta_end)
 134         return FALSE;
 135       ui->rva_BeginAddress = bfd_get_32 (abfd, ex_dta + 0);
 136       ui->rva_EndAddress = bfd_get_32 (abfd, ex_dta + 4);
 137       ui->rva_UnwindData = bfd_get_32 (abfd, ex_dta + 8);
 138       ui->SizeOfBlock += 12;
 139       return TRUE;
 140     case UNW_FLAG_EHANDLER:
 141     case UNW_FLAG_UHANDLER:
 142     case UNW_FLAG_FHANDLER:
 143       if (ex_dta + 4 >= ex_dta_end)
 144         return FALSE;
 145       ui->rva_ExceptionHandler = bfd_get_32 (abfd, ex_dta);
 146       ui->SizeOfBlock += 4;
 147       return TRUE;
 148     default:
 149       return TRUE;
 150     }
 151 }
 152
 153 /* Display unwind codes.  */
 154
 155 static void
 156 pex64_xdata_print_uwd_codes (FILE *file, bfd *abfd,
 157                              struct pex64_unwind_info *ui,
 158                              struct pex64_runtime_function *rf)
 159 {
 160   unsigned int i;
 161   unsigned int tmp; /* At least 32 bits.  */
 162   int save_allowed;
 163
 164   if (ui->CountOfCodes == 0 || ui->rawUnwindCodes == NULL)
 165     return;
 166
 167   /* According to UNWIND_CODE documentation:
 168       If an FP reg is used, the any unwind code taking an offset must only be
 169       used after the FP reg is established in the prolog.
 170      But there are counter examples of that in system dlls...  */
 171   save_allowed = TRUE;
 172
 173   i = 0;
 174
 175   if (ui->rawUnwindCodes + 1 >= ui->rawUnwindCodesEnd)
 176     {
 177       fprintf (file, _("warning: corrupt unwind data\n"));
 178       return;
 179     }
 180
 181   if (ui->Version == 2
 182       && PEX64_UNWCODE_CODE (ui->rawUnwindCodes[1]) == UWOP_EPILOG)
 183     {
 184       /* Display epilog opcode (whose docoding is not fully documented).
 185          Looks to be designed to speed-up unwinding, as there is no need
 186          to decode instruction flow if outside an epilog.  */
 187       unsigned int func_size = rf->rva_EndAddress - rf->rva_BeginAddress;
 188
 189       if (ui->rawUnwindCodes + 1 + (ui->CountOfCodes * 2) >= ui->rawUnwindCodesEnd)
 190         {
 191           fprintf (file, _("warning: corrupt unwind data\n"));
 192           return;
 193         }
 194
 195       fprintf (file, "\tv2 epilog (length: %02x) at pc+:",
 196                ui->rawUnwindCodes[0]);
 197
 198       if (PEX64_UNWCODE_INFO (ui->rawUnwindCodes[1]))
 199         fprintf (file, " 0x%x", func_size - ui->rawUnwindCodes[0]);
 200
 201       i++;
 202       for (; i < ui->CountOfCodes; i++)
 203         {
 204           const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
 205           unsigned int off;
 206
 207           if (PEX64_UNWCODE_CODE (dta[1]) != UWOP_EPILOG)
 208             break;
 209           off = dta[0] | (PEX64_UNWCODE_INFO (dta[1]) << 8);
 210           if (off == 0)
 211             fprintf (file, " [pad]");
 212           else
 213             fprintf (file, " 0x%x", func_size - off);
 214         }
 215       fputc ('\n', file);
 216     }
 217
 218   if (ui->rawUnwindCodes + 2 + (ui->CountOfCodes * 2) >= ui->rawUnwindCodesEnd)
 219     {
 220       fprintf (file, _("warning: corrupt unwind data\n"));
 221       return;
 222     }
 223
 224   for (; i < ui->CountOfCodes; i++)
 225     {
 226       const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
 227       unsigned int info = PEX64_UNWCODE_INFO (dta[1]);
 228       int unexpected = FALSE;
 229
 230       fprintf (file, "\t  pc+0x%02x: ", (unsigned int) dta[0]);
 231       switch (PEX64_UNWCODE_CODE (dta[1]))
 232         {
 233         case UWOP_PUSH_NONVOL:
 234           fprintf (file, "push %s", pex_regs[info]);
 235           break;
 236         case UWOP_ALLOC_LARGE:
 237           if (info == 0)
 238             {
 239               tmp = bfd_get_16 (abfd, &dta[2]) * 8;
 240               i++;
 241             }
 242           else
 243             {
 244               tmp = bfd_get_32 (abfd, &dta[2]);
 245               i += 2;
 246             }
 247           fprintf (file, "alloc large area: rsp = rsp - 0x%x", tmp);
 248           break;
 249         case UWOP_ALLOC_SMALL:
 250           fprintf (file, "alloc small area: rsp = rsp - 0x%x", (info + 1) * 8);
 251           break;
 252         case UWOP_SET_FPREG:
 253           /* According to the documentation, info field is unused.  */
 254           fprintf (file, "FPReg: %s = rsp + 0x%x (info = 0x%x)",
 255                    pex_regs[ui->FrameRegister],
 256                    (unsigned int) ui->FrameOffset * 16, info);
 257           unexpected = ui->FrameRegister == 0;
 258           save_allowed = FALSE;
 259           break;
 260         case UWOP_SAVE_NONVOL:
 261           tmp = bfd_get_16 (abfd, &dta[2]) * 8;
 262           i++;
 263           fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
 264           unexpected = !save_allowed;
 265           break;
 266         case UWOP_SAVE_NONVOL_FAR:
 267           tmp = bfd_get_32 (abfd, &dta[2]);
 268           i += 2;
 269           fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
 270           unexpected = !save_allowed;
 271           break;
 272         case UWOP_SAVE_XMM:
 273           if (ui->Version == 1)
 274             {
 275               tmp = bfd_get_16 (abfd, &dta[2]) * 8;
 276               i++;
 277               fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
 278               unexpected = !save_allowed;
 279             }
 280           else if (ui->Version == 2)
 281             {
 282               fprintf (file, "epilog %02x %01x", dta[0], info);
 283               unexpected = TRUE;
 284             }
 285           break;
 286         case UWOP_SAVE_XMM_FAR:
 287           tmp = bfd_get_32 (abfd, &dta[2]) * 8;
 288           i += 2;
 289           fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
 290           unexpected = !save_allowed;
 291           break;
 292         case UWOP_SAVE_XMM128:
 293           tmp = bfd_get_16 (abfd, &dta[2]) * 16;
 294           i++;
 295           fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
 296           unexpected = !save_allowed;
 297           break;
 298         case UWOP_SAVE_XMM128_FAR:
 299           tmp = bfd_get_32 (abfd, &dta[2]) * 16;
 300           i += 2;
 301           fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
 302           unexpected = !save_allowed;
 303           break;
 304         case UWOP_PUSH_MACHFRAME:
 305           fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
 306           if (info == 0)
 307             fprintf (file, ")");
 308           else if (info == 1)
 309             fprintf (file, ",ErrorCode)");
 310           else
 311             fprintf (file, ", unknown(%u))", info);
 312           break;
 313         default:
 314           /* PR 17512: file: 2245-7442-0.004.  */
 315           fprintf (file, _("Unknown: %x"), PEX64_UNWCODE_CODE (dta[1]));
 316           break;
 317       }
 318       if (unexpected)
 319         fprintf (file, " [Unexpected!]");
 320       fputc ('\n', file);
 321     }
 322 }
 323
 324 /* Check wether section SEC_NAME contains the xdata at address ADDR.  */
 325
 326 static asection *
 327 pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
 328 {
 329   asection *section = bfd_get_section_by_name (abfd, sec_name);
 330   bfd_vma vsize;
 331   bfd_size_type datasize = 0;
 332
 333   if (section == NULL
 334       || coff_section_data (abfd, section) == NULL
 335       || pei_section_data (abfd, section) == NULL)
 336     return NULL;
 337   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 338   datasize = section->size;
 339   if (!datasize || vsize > addr || (vsize + datasize) < addr)
 340     return NULL;
 341   return section;
 342 }
 343
 344 /* Dump xdata at for function RF to FILE.  The argument XDATA_SECTION
 345    designate the bfd section containing the xdata, XDATA is its content,
 346    and ENDX the size if known (or NULL).  */
 347
 348 static void
 349 pex64_dump_xdata (FILE *file, bfd *abfd,
 350                   asection *xdata_section, bfd_byte *xdata, bfd_vma *endx,
 351                   struct pex64_runtime_function *rf)
 352 {
 353   bfd_vma vaddr;
 354   bfd_vma end_addr;
 355   bfd_vma addr = rf->rva_UnwindData;
 356   bfd_size_type sec_size = xdata_section->rawsize > 0 ? xdata_section->rawsize : xdata_section->size;
 357   struct pex64_unwind_info ui;
 358
 359   vaddr = xdata_section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 360   addr -= vaddr;
 361
 362   /* PR 17512: file: 2245-7442-0.004.  */
 363   if (addr >= sec_size)
 364     {
 365       fprintf (file, _("warning: xdata section corrupt\n"));
 366       return;
 367     }
 368
 369   if (endx)
 370     {
 371       end_addr = endx[0] - vaddr;
 372       /* PR 17512: file: 2245-7442-0.004.  */
 373       if (end_addr > sec_size)
 374         {
 375           fprintf (file, _("warning: xdata section corrupt\n"));
 376           end_addr = sec_size;
 377         }
 378     }
 379   else
 380     end_addr = sec_size;
 381
 382   if (! pex64_get_unwind_info (abfd, &ui, xdata + addr, xdata + end_addr))
 383     {
 384       fprintf (file, _("warning: xdata section corrupt\n"));
 385       return;
 386     }
 387
 388   if (ui.Version != 1 && ui.Version != 2)
 389     {
 390       unsigned int i;
 391       fprintf (file, "\tVersion %u (unknown).\n",
 392                (unsigned int) ui.Version);
 393       for (i = 0; addr < end_addr; addr += 1, i++)
 394         {
 395           if ((i & 15) == 0)
 396             fprintf (file, "\t  %03x:", i);
 397           fprintf (file, " %02x", xdata[addr]);
 398           if ((i & 15) == 15)
 399             fprintf (file, "\n");
 400         }
 401       if ((i & 15) != 0)
 402         fprintf (file, "\n");
 403       return;
 404     }
 405
 406   fprintf (file, "\tVersion: %d, Flags: ", ui.Version);
 407   switch (ui.Flags)
 408     {
 409     case UNW_FLAG_NHANDLER:
 410       fprintf (file, "none");
 411       break;
 412     case UNW_FLAG_EHANDLER:
 413       fprintf (file, "UNW_FLAG_EHANDLER");
 414       break;
 415     case UNW_FLAG_UHANDLER:
 416       fprintf (file, "UNW_FLAG_UHANDLER");
 417       break;
 418     case UNW_FLAG_FHANDLER:
 419       fprintf
 420         (file, "UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER");
 421       break;
 422     case UNW_FLAG_CHAININFO:
 423       fprintf (file, "UNW_FLAG_CHAININFO");
 424       break;
 425     default:
 426       fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
 427       break;
 428     }
 429   fputc ('\n', file);
 430   fprintf (file, "\tNbr codes: %u, ", (unsigned int) ui.CountOfCodes);
 431   fprintf (file, "Prologue size: 0x%02x, Frame offset: 0x%x, ",
 432            (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
 433   fprintf (file, "Frame reg: %s\n",
 434            ui.FrameRegister == 0 ? "none"
 435            : pex_regs[(unsigned int) ui.FrameRegister]);
 436
 437   /* PR 17512: file: 2245-7442-0.004.  */
 438   if (ui.CountOfCodes * 2 + ui.rawUnwindCodes > xdata + xdata_section->size)
 439     fprintf (file, _("Too many unwind codes (%ld)\n"), (long) ui.CountOfCodes);
 440   else
 441     pex64_xdata_print_uwd_codes (file, abfd, &ui, rf);
 442
 443   switch (ui.Flags)
 444     {
 445     case UNW_FLAG_EHANDLER:
 446     case UNW_FLAG_UHANDLER:
 447     case UNW_FLAG_FHANDLER:
 448       fprintf (file, "\tHandler: ");
 449       fprintf_vma (file, (ui.rva_ExceptionHandler
 450                           + pe_data (abfd)->pe_opthdr.ImageBase));
 451       fprintf (file, ".\n");
 452       break;
 453     case UNW_FLAG_CHAININFO:
 454       fprintf (file, "\tChain: start: ");
 455       fprintf_vma (file, ui.rva_BeginAddress);
 456       fprintf (file, ", end: ");
 457       fprintf_vma (file, ui.rva_EndAddress);
 458       fprintf (file, "\n\t unwind data: ");
 459       fprintf_vma (file, ui.rva_UnwindData);
 460       fprintf (file, ".\n");
 461       break;
 462     }
 463
 464   /* Now we need end of this xdata block.  */
 465   addr += ui.SizeOfBlock;
 466   if (addr < end_addr)
 467     {
 468       unsigned int i;
 469       fprintf (file,"\tUser data:\n");
 470       for (i = 0; addr < end_addr; addr += 1, i++)
 471         {
 472           if ((i & 15) == 0)
 473             fprintf (file, "\t  %03x:", i);
 474           fprintf (file, " %02x", xdata[addr]);
 475           if ((i & 15) == 15)
 476             fprintf (file, "\n");
 477         }
 478       if ((i & 15) != 0)
 479         fprintf (file, "\n");
 480     }
 481 }
 482
 483 /* Helper function to sort xdata.  The entries of xdata are sorted to know
 484    the size of each entry.  */
 485
 486 static int
 487 sort_xdata_arr (const void *l, const void *r)
 488 {
 489   const bfd_vma *lp = (const bfd_vma *) l;
 490   const bfd_vma *rp = (const bfd_vma *) r;
 491
 492   if (*lp == *rp)
 493     return 0;
 494   return (*lp < *rp ? -1 : 1);
 495 }
 496
 497 /* Display unwind tables for x86-64.  */
 498
 499 static bfd_boolean
 500 pex64_bfd_print_pdata_section (bfd *abfd, void *vfile, asection *pdata_section)
 501 {
 502   FILE *file = (FILE *) vfile;
 503   bfd_byte *pdata = NULL;
 504   bfd_byte *xdata = NULL;
 505   asection *xdata_section = NULL;
 506   bfd_vma xdata_base;
 507   bfd_size_type i;
 508   bfd_size_type datasize;
 509   bfd_size_type stop;
 510   bfd_vma prev_beginaddress = (bfd_vma) -1;
 511   bfd_vma prev_unwinddata_rva = (bfd_vma) -1;
 512   bfd_vma imagebase;
 513   int onaline = PDATA_ROW_SIZE;
 514   int seen_error = 0;
 515   bfd_vma *xdata_arr = NULL;
 516   int xdata_arr_cnt;
 517   bfd_boolean virt_size_is_zero = FALSE;
 518
 519   /* Sanity checks.  */
 520   if (pdata_section == NULL
 521       || coff_section_data (abfd, pdata_section) == NULL
 522       || pei_section_data (abfd, pdata_section) == NULL)
 523     return TRUE;
 524
 525   stop = pei_section_data (abfd, pdata_section)->virt_size;
 526   if ((stop % onaline) != 0)
 527     fprintf (file,
 528              /* xgettext:c-format */
 529              _("Warning: %s section size (%ld) is not a multiple of %d\n"),
 530              pdata_section->name, (long) stop, onaline);
 531
 532   datasize = pdata_section->size;
 533   if (datasize == 0)
 534     {
 535       if (stop)
 536         fprintf (file, _("Warning: %s section size is zero\n"),
 537                  pdata_section->name);
 538       return TRUE;
 539     }
 540
 541   /* virt_size might be zero for objects.  */
 542   if (stop == 0 && strcmp (abfd->xvec->name, "pe-x86-64") == 0)
 543     {
 544       stop = (datasize / onaline) * onaline;
 545       virt_size_is_zero = TRUE;
 546     }
 547   else if (datasize < stop)
 548       {
 549         fprintf (file,
 550                  /* xgettext:c-format */
 551                  _("Warning: %s section size (%ld) is smaller than virtual size (%ld)\n"),
 552                  pdata_section->name, (unsigned long) datasize,
 553                  (unsigned long) stop);
 554         /* Be sure not to read passed datasize.  */
 555         stop = datasize / onaline;
 556       }
 557
 558   /* Display functions table.  */
 559   fprintf (file,
 560            _("\nThe Function Table (interpreted %s section contents)\n"),
 561            pdata_section->name);
 562
 563   fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
 564
 565   if (!bfd_malloc_and_get_section (abfd, pdata_section, &pdata))
 566     goto done;
 567
 568   /* Table of xdata entries.  */
 569   xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1));
 570   xdata_arr_cnt = 0;
 571
 572   if (strcmp (abfd->xvec->name, "pei-x86-64") == 0)
 573     imagebase = pe_data (abfd)->pe_opthdr.ImageBase;
 574   else
 575     imagebase = 0;
 576
 577   for (i = 0; i < stop; i += onaline)
 578     {
 579       struct pex64_runtime_function rf;
 580
 581       if (i + PDATA_ROW_SIZE > stop)
 582         break;
 583
 584       pex64_get_runtime_function (abfd, &rf, &pdata[i]);
 585
 586       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 587           && rf.rva_UnwindData == 0)
 588         /* We are probably into the padding of the section now.  */
 589         break;
 590       fputc (' ', file);
 591       fprintf_vma (file, i + pdata_section->vma);
 592       fprintf (file, ":\t");
 593       fprintf_vma (file, imagebase + rf.rva_BeginAddress);
 594       fprintf (file, " ");
 595       fprintf_vma (file, imagebase + rf.rva_EndAddress);
 596       fprintf (file, " ");
 597       fprintf_vma (file, imagebase + rf.rva_UnwindData);
 598       fprintf (file, "\n");
 599       if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
 600         {
 601           seen_error = 1;
 602           fprintf (file, "  has %s begin address as predecessor\n",
 603             (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
 604         }
 605       prev_beginaddress = rf.rva_BeginAddress;
 606       /* Now we check for negative addresses.  */
 607       if ((prev_beginaddress & 0x80000000) != 0)
 608         {
 609           seen_error = 1;
 610           fprintf (file, "  has negative begin address\n");
 611         }
 612       if ((rf.rva_EndAddress & 0x80000000) != 0)
 613         {
 614           seen_error = 1;
 615           fprintf (file, "  has negative end address\n");
 616         }
 617       if ((rf.rva_UnwindData & 0x80000000) != 0)
 618         {
 619           seen_error = 1;
 620           fprintf (file, "  has negative unwind address\n");
 621         }
 622       else if ((rf.rva_UnwindData && !PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
 623                 || virt_size_is_zero)
 624         xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
 625     }
 626
 627   if (seen_error)
 628     goto done;
 629
 630   /* Add end of list marker.  */
 631   xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);
 632
 633   /* Sort start RVAs of xdata.  */
 634   if (xdata_arr_cnt > 1)
 635     qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 636            sort_xdata_arr);
 637
 638   /* Find the section containing the unwind data (.xdata).  */
 639   xdata_base = xdata_arr[0];
 640   /* For sections with long names, first look for the same
 641      section name, replacing .pdata by .xdata prefix.  */
 642   if (strcmp (pdata_section->name, ".pdata") != 0)
 643     {
 644       size_t len = strlen (pdata_section->name);
 645       char *xdata_name = xmalloc (len + 1);
 646
 647       xdata_name = memcpy (xdata_name, pdata_section->name, len + 1);
 648       /* Transform .pdata prefix into .xdata prefix.  */
 649       if (len > 1)
 650         xdata_name [1] = 'x';
 651       xdata_section = pex64_get_section_by_rva (abfd, xdata_base,
 652                                                 xdata_name);
 653       free (xdata_name);
 654     }
 655   /* Second, try the .xdata section itself.  */
 656   if (!xdata_section)
 657     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".xdata");
 658   /* Otherwise, if xdata_base is non zero, search also inside
 659      other standard sections.  */
 660   if (!xdata_section && xdata_base)
 661     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".rdata");
 662   if (!xdata_section && xdata_base)
 663     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".data");
 664   if (!xdata_section && xdata_base)
 665     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".pdata");
 666   if (!xdata_section && xdata_base)
 667     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".text");
 668   /* Transfer xdata section into xdata array.  */
 669   if (!xdata_section
 670       || !bfd_malloc_and_get_section (abfd, xdata_section, &xdata))
 671     goto done;
 672
 673   /* Avoid "also used "... ouput for single unwind info
 674      in object file.  */
 675   prev_unwinddata_rva = (bfd_vma) -1;
 676
 677   /* Do dump of pdata related xdata.  */
 678   for (i = 0; i < stop; i += onaline)
 679     {
 680       struct pex64_runtime_function rf;
 681
 682       if (i + PDATA_ROW_SIZE > stop)
 683         break;
 684
 685       pex64_get_runtime_function (abfd, &rf, &pdata[i]);
 686
 687       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 688           && rf.rva_UnwindData == 0)
 689         /* We are probably into the padding of the section now.  */
 690         break;
 691       if (i == 0)
 692         fprintf (file, _("\nDump of %s\n"), xdata_section->name);
 693
 694       fputc (' ', file);
 695       fprintf_vma (file, rf.rva_UnwindData + imagebase);
 696
 697       if (prev_unwinddata_rva == rf.rva_UnwindData)
 698         {
 699           /* Do not dump again the xdata for the same entry.  */
 700           fprintf (file, " also used for function at ");
 701           fprintf_vma (file, rf.rva_BeginAddress + imagebase);
 702           fputc ('\n', file);
 703           continue;
 704         }
 705       else
 706         prev_unwinddata_rva = rf.rva_UnwindData;
 707
 708       fprintf (file, " (rva: %08x): ",
 709                (unsigned int) rf.rva_UnwindData);
 710       fprintf_vma (file, rf.rva_BeginAddress + imagebase);
 711       fprintf (file, " - ");
 712       fprintf_vma (file, rf.rva_EndAddress + imagebase);
 713       fputc ('\n', file);
 714
 715       if (rf.rva_UnwindData != 0 || virt_size_is_zero)
 716         {
 717           if (PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
 718             {
 719               bfd_vma altent = PEX64_GET_UNWINDDATA_UNIFIED_RVA (&rf);
 720               bfd_vma pdata_vma = bfd_get_section_vma (abfd, pdata_section);
 721               struct pex64_runtime_function arf;
 722
 723               fprintf (file, "\t shares information with ");
 724               altent += imagebase;
 725
 726               if (altent >= pdata_vma
 727                   && (altent + PDATA_ROW_SIZE <= pdata_vma
 728                       + pei_section_data (abfd, pdata_section)->virt_size))
 729                 {
 730                   pex64_get_runtime_function
 731                     (abfd, &arf, &pdata[altent - pdata_vma]);
 732                   fprintf (file, "pdata element at 0x");
 733                   fprintf_vma (file, arf.rva_UnwindData);
 734                 }
 735               else
 736                 fprintf (file, "unknown pdata element");
 737               fprintf (file, ".\n");
 738             }
 739           else
 740             {
 741               bfd_vma *p;
 742
 743               /* Search for the current entry in the sorted array.  */
 744               p = (bfd_vma *)
 745                   bsearch (&rf.rva_UnwindData, xdata_arr,
 746                            (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 747                            sort_xdata_arr);
 748
 749               /* Advance to the next pointer into the xdata section.  We may
 750                  have shared xdata entries, which will result in a string of
 751                  identical pointers in the array; advance past all of them.  */
 752               while (p[0] <= rf.rva_UnwindData)
 753                 ++p;
 754
 755               if (p[0] == ~((bfd_vma) 0))
 756                 p = NULL;
 757
 758               pex64_dump_xdata (file, abfd, xdata_section, xdata, p, &rf);
 759             }
 760         }
 761     }
 762
 763  done:
 764   free (pdata);
 765   free (xdata_arr);
 766   free (xdata);
 767
 768   return TRUE;
 769 }
 770
 771 /* Static counter of number of found pdata sections.  */
 772 static bfd_boolean pdata_count;
 773
 774 /* Functionn prototype.  */
 775 bfd_boolean pex64_bfd_print_pdata (bfd *, void *);
 776
 777 /* Helper function for bfd_map_over_section.  */
 778 static void
 779 pex64_print_all_pdata_sections (bfd *abfd, asection *pdata, void *obj)
 780 {
 781   if (CONST_STRNEQ (pdata->name, ".pdata"))
 782     {
 783       if (pex64_bfd_print_pdata_section (abfd, obj, pdata))
 784         pdata_count++;
 785     }
 786 }
 787
 788 bfd_boolean
 789 pex64_bfd_print_pdata (bfd *abfd, void *vfile)
 790 {
 791   asection *pdata_section = bfd_get_section_by_name (abfd, ".pdata");
 792
 793   if (pdata_section)
 794     return pex64_bfd_print_pdata_section (abfd, vfile, pdata_section);
 795
 796   pdata_count = 0;
 797   bfd_map_over_sections (abfd, pex64_print_all_pdata_sections, vfile);
 798   return (pdata_count > 0);
 799 }
 800
 801 #define bfd_pe_print_pdata   pex64_bfd_print_pdata
 802 #define bfd_coff_std_swap_table bfd_coff_pei_swap_table
 803
 804 #include "coff-x86_64.c"