bfd/pei-x86_64.c

   1 /* BFD back-end for Intel 386 PE IMAGE COFF files.
   2    Copyright (C) 2006-2014 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 void
 102 pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui, void *data)
 103 {
 104   struct external_pex64_unwind_info *ex_ui =
 105     (struct external_pex64_unwind_info *) data;
 106   bfd_byte *ex_dta = (bfd_byte *) data;
 107
 108   memset (ui, 0, sizeof (struct pex64_unwind_info));
 109   ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
 110   ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
 111   ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
 112   ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
 113   ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
 114   ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
 115   ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
 116   ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
 117   ui->rawUnwindCodes = &ex_dta[4];
 118   ex_dta += ui->SizeOfBlock;
 119   switch (ui->Flags)
 120     {
 121     case UNW_FLAG_CHAININFO:
 122       ui->rva_BeginAddress = bfd_get_32 (abfd, ex_dta + 0);
 123       ui->rva_EndAddress = bfd_get_32 (abfd, ex_dta + 4);
 124       ui->rva_UnwindData = bfd_get_32 (abfd, ex_dta + 8);
 125       ui->SizeOfBlock += 12;
 126       return;
 127     case UNW_FLAG_EHANDLER:
 128     case UNW_FLAG_UHANDLER:
 129     case UNW_FLAG_FHANDLER:
 130       ui->rva_ExceptionHandler = bfd_get_32 (abfd, ex_dta);
 131       ui->SizeOfBlock += 4;
 132       return;
 133     default:
 134       return;
 135     }
 136 }
 137
 138 /* Display unwind codes.  */
 139
 140 static void
 141 pex64_xdata_print_uwd_codes (FILE *file, bfd *abfd,
 142                              struct pex64_unwind_info *ui,
 143                              struct pex64_runtime_function *rf)
 144 {
 145   unsigned int i;
 146   unsigned int tmp; /* At least 32 bits.  */
 147   int save_allowed;
 148
 149   if (ui->CountOfCodes == 0 || ui->rawUnwindCodes == NULL)
 150     return;
 151
 152   /* According to UNWIND_CODE documentation:
 153       If an FP reg is used, the any unwind code taking an offset must only be
 154       used after the FP reg is established in the prolog.
 155      But there are counter examples of that in system dlls...  */
 156   save_allowed = TRUE;
 157
 158   i = 0;
 159
 160   if (ui->Version == 2
 161       && PEX64_UNWCODE_CODE (ui->rawUnwindCodes[1]) == UWOP_EPILOG)
 162     {
 163       /* Display epilog opcode (whose docoding is not fully documented).
 164          Looks to be designed to speed-up unwinding, as there is no need
 165          to decode instruction flow if outside an epilog.  */
 166       unsigned int func_size = rf->rva_EndAddress - rf->rva_BeginAddress;
 167
 168       fprintf (file, "\tv2 epilog (length: %02x) at pc+:",
 169                ui->rawUnwindCodes[0]);
 170       if (PEX64_UNWCODE_INFO (ui->rawUnwindCodes[1]))
 171         fprintf (file, " 0x%x", func_size - ui->rawUnwindCodes[0]);
 172       i++;
 173       for (; i < ui->CountOfCodes; i++)
 174         {
 175           const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
 176           unsigned int off;
 177
 178           if (PEX64_UNWCODE_CODE (dta[1]) != UWOP_EPILOG)
 179             break;
 180           off = dta[0] | (PEX64_UNWCODE_INFO (dta[1]) << 8);
 181           if (off == 0)
 182             fprintf (file, " [pad]");
 183           else
 184             fprintf (file, " 0x%x", func_size - off);
 185         }
 186       fputc ('\n', file);
 187     }
 188
 189   for (; i < ui->CountOfCodes; i++)
 190     {
 191       const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
 192       unsigned int info = PEX64_UNWCODE_INFO (dta[1]);
 193       int unexpected = FALSE;
 194
 195       fprintf (file, "\t  pc+0x%02x: ", (unsigned int) dta[0]);
 196       switch (PEX64_UNWCODE_CODE (dta[1]))
 197         {
 198         case UWOP_PUSH_NONVOL:
 199           fprintf (file, "push %s", pex_regs[info]);
 200           break;
 201         case UWOP_ALLOC_LARGE:
 202           if (info == 0)
 203             {
 204               tmp = bfd_get_16 (abfd, &dta[2]) * 8;
 205               i++;
 206             }
 207           else
 208             {
 209               tmp = bfd_get_32 (abfd, &dta[2]);
 210               i += 2;
 211             }
 212           fprintf (file, "alloc large area: rsp = rsp - 0x%x", tmp);
 213           break;
 214         case UWOP_ALLOC_SMALL:
 215           fprintf (file, "alloc small area: rsp = rsp - 0x%x", (info + 1) * 8);
 216           break;
 217         case UWOP_SET_FPREG:
 218           /* According to the documentation, info field is unused.  */
 219           fprintf (file, "FPReg: %s = rsp + 0x%x (info = 0x%x)",
 220                    pex_regs[ui->FrameRegister],
 221                    (unsigned int) ui->FrameOffset * 16, info);
 222           unexpected = ui->FrameRegister == 0;
 223           save_allowed = FALSE;
 224           break;
 225         case UWOP_SAVE_NONVOL:
 226           tmp = bfd_get_16 (abfd, &dta[2]) * 8;
 227           i++;
 228           fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
 229           unexpected = !save_allowed;
 230           break;
 231         case UWOP_SAVE_NONVOL_FAR:
 232           tmp = bfd_get_32 (abfd, &dta[2]);
 233           i += 2;
 234           fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
 235           unexpected = !save_allowed;
 236           break;
 237         case UWOP_SAVE_XMM:
 238           if (ui->Version == 1)
 239             {
 240               tmp = bfd_get_16 (abfd, &dta[2]) * 8;
 241               i++;
 242               fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
 243               unexpected = !save_allowed;
 244             }
 245           else if (ui->Version == 2)
 246             {
 247               fprintf (file, "epilog %02x %01x", dta[0], info);
 248               unexpected = TRUE;
 249             }
 250           break;
 251         case UWOP_SAVE_XMM_FAR:
 252           tmp = bfd_get_32 (abfd, &dta[2]) * 8;
 253           i += 2;
 254           fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
 255           unexpected = !save_allowed;
 256           break;
 257         case UWOP_SAVE_XMM128:
 258           tmp = bfd_get_16 (abfd, &dta[2]) * 16;
 259           i++;
 260           fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
 261           unexpected = !save_allowed;
 262           break;
 263         case UWOP_SAVE_XMM128_FAR:
 264           tmp = bfd_get_32 (abfd, &dta[2]) * 16;
 265           i += 2;
 266           fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
 267           unexpected = !save_allowed;
 268           break;
 269         case UWOP_PUSH_MACHFRAME:
 270           fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
 271           if (info == 0)
 272             fprintf (file, ")");
 273           else if (info == 1)
 274             fprintf (file, ",ErrorCode)");
 275           else
 276             fprintf (file, ", unknown(%u))", info);
 277           break;
 278         default:
 279           /* Already caught by the previous scan.  */
 280           abort ();
 281       }
 282       if (unexpected)
 283         fprintf (file, " [Unexpected!]");
 284       fputc ('\n', file);
 285     }
 286 }
 287
 288 /* Check wether section SEC_NAME contains the xdata at address ADDR.  */
 289
 290 static asection *
 291 pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
 292 {
 293   asection *section = bfd_get_section_by_name (abfd, sec_name);
 294   bfd_vma vsize;
 295   bfd_size_type datasize = 0;
 296
 297   if (section == NULL
 298       || coff_section_data (abfd, section) == NULL
 299       || pei_section_data (abfd, section) == NULL)
 300     return NULL;
 301   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 302   datasize = section->size;
 303   if (!datasize || vsize > addr || (vsize + datasize) < addr)
 304     return NULL;
 305   return section;
 306 }
 307
 308 /* Dump xdata at for function RF to FILE.  The argument XDATA_SECTION
 309    designate the bfd section containing the xdata, XDATA is its content,
 310    and ENDX the size if known (or NULL).  */
 311
 312 static void
 313 pex64_dump_xdata (FILE *file, bfd *abfd,
 314                   asection *xdata_section, bfd_byte *xdata, bfd_vma *endx,
 315                   struct pex64_runtime_function *rf)
 316 {
 317   bfd_vma vaddr;
 318   bfd_vma end_addr;
 319   bfd_vma addr = rf->rva_UnwindData;
 320   struct pex64_unwind_info ui;
 321
 322   vaddr = xdata_section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 323   addr -= vaddr;
 324
 325   if (endx)
 326     end_addr = endx[0] - vaddr;
 327   else
 328     end_addr = (xdata_section->rawsize != 0 ?
 329                 xdata_section->rawsize : xdata_section->size);
 330
 331
 332   pex64_get_unwind_info (abfd, &ui, &xdata[addr]);
 333
 334   if (ui.Version != 1 && ui.Version != 2)
 335     {
 336       unsigned int i;
 337       fprintf (file, "\tVersion %u (unknown).\n",
 338                (unsigned int) ui.Version);
 339       for (i = 0; addr < end_addr; addr += 1, i++)
 340         {
 341           if ((i & 15) == 0)
 342             fprintf (file, "\t  %03x:", i);
 343           fprintf (file, " %02x", xdata[addr]);
 344           if ((i & 15) == 15)
 345             fprintf (file, "\n");
 346         }
 347       if ((i & 15) != 0)
 348         fprintf (file, "\n");
 349       return;
 350     }
 351
 352   fprintf (file, "\tVersion: %d, Flags: ", ui.Version);
 353   switch (ui.Flags)
 354     {
 355     case UNW_FLAG_NHANDLER:
 356       fprintf (file, "none");
 357       break;
 358     case UNW_FLAG_EHANDLER:
 359       fprintf (file, "UNW_FLAG_EHANDLER");
 360       break;
 361     case UNW_FLAG_UHANDLER:
 362       fprintf (file, "UNW_FLAG_UHANDLER");
 363       break;
 364     case UNW_FLAG_FHANDLER:
 365       fprintf
 366         (file, "UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER");
 367       break;
 368     case UNW_FLAG_CHAININFO:
 369       fprintf (file, "UNW_FLAG_CHAININFO");
 370       break;
 371     default:
 372       fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
 373       break;
 374     }
 375   fputc ('\n', file);
 376   fprintf (file, "\tNbr codes: %u, ", (unsigned int) ui.CountOfCodes);
 377   fprintf (file, "Prologue size: 0x%02x, Frame offset: 0x%x, ",
 378            (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
 379   fprintf (file, "Frame reg: %s\n",
 380            ui.FrameRegister == 0 ? "none"
 381            : pex_regs[(unsigned int) ui.FrameRegister]);
 382
 383   pex64_xdata_print_uwd_codes (file, abfd, &ui, rf);
 384
 385   switch (ui.Flags)
 386     {
 387     case UNW_FLAG_EHANDLER:
 388     case UNW_FLAG_UHANDLER:
 389     case UNW_FLAG_FHANDLER:
 390       fprintf (file, "\tHandler: ");
 391       fprintf_vma (file, (ui.rva_ExceptionHandler
 392                           + pe_data (abfd)->pe_opthdr.ImageBase));
 393       fprintf (file, ".\n");
 394       break;
 395     case UNW_FLAG_CHAININFO:
 396       fprintf (file, "\tChain: start: ");
 397       fprintf_vma (file, ui.rva_BeginAddress);
 398       fprintf (file, ", end: ");
 399       fprintf_vma (file, ui.rva_EndAddress);
 400       fprintf (file, "\n\t unwind data: ");
 401       fprintf_vma (file, ui.rva_UnwindData);
 402       fprintf (file, ".\n");
 403       break;
 404     }
 405
 406   /* Now we need end of this xdata block.  */
 407   addr += ui.SizeOfBlock;
 408   if (addr < end_addr)
 409     {
 410       unsigned int i;
 411       fprintf (file,"\tUser data:\n");
 412       for (i = 0; addr < end_addr; addr += 1, i++)
 413         {
 414           if ((i & 15) == 0)
 415             fprintf (file, "\t  %03x:", i);
 416           fprintf (file, " %02x", xdata[addr]);
 417           if ((i & 15) == 15)
 418             fprintf (file, "\n");
 419         }
 420       if ((i & 15) != 0)
 421         fprintf (file, "\n");
 422     }
 423 }
 424
 425 /* Helper function to sort xdata.  The entries of xdata are sorted to know
 426    the size of each entry.  */
 427
 428 static int
 429 sort_xdata_arr (const void *l, const void *r)
 430 {
 431   const bfd_vma *lp = (const bfd_vma *) l;
 432   const bfd_vma *rp = (const bfd_vma *) r;
 433
 434   if (*lp == *rp)
 435     return 0;
 436   return (*lp < *rp ? -1 : 1);
 437 }
 438
 439 /* Display unwind tables for x86-64.  */
 440
 441 static bfd_boolean
 442 pex64_bfd_print_pdata (bfd *abfd, void *vfile)
 443 {
 444   FILE *file = (FILE *) vfile;
 445   bfd_byte *pdata = NULL;
 446   bfd_byte *xdata = NULL;
 447   asection *pdata_section = bfd_get_section_by_name (abfd, ".pdata");
 448   asection *xdata_section;
 449   bfd_vma xdata_base;
 450   bfd_size_type i;
 451   bfd_size_type stop;
 452   bfd_vma prev_beginaddress = 0;
 453   bfd_vma prev_unwinddata_rva = 0;
 454   bfd_vma imagebase;
 455   int onaline = PDATA_ROW_SIZE;
 456   int seen_error = 0;
 457   bfd_vma *xdata_arr = NULL;
 458   int xdata_arr_cnt;
 459
 460   /* Sanity checks.  */
 461   if (pdata_section == NULL
 462       || coff_section_data (abfd, pdata_section) == NULL
 463       || pei_section_data (abfd, pdata_section) == NULL)
 464     return TRUE;
 465
 466   stop = pei_section_data (abfd, pdata_section)->virt_size;
 467   /* PR 17512: file: 005-181405-0.004.  */
 468   if (stop == 0 || pdata_section->size == 0)
 469     {
 470       fprintf (file, _("No unwind data in .pdata section\n"));
 471       return TRUE;
 472     }
 473   if ((stop % onaline) != 0)
 474     fprintf (file,
 475              _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
 476              (long) stop, onaline);
 477
 478   /* Display functions table.  */
 479   fprintf (file,
 480            _("\nThe Function Table (interpreted .pdata section contents)\n"));
 481
 482   fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
 483
 484   if (!bfd_malloc_and_get_section (abfd, pdata_section, &pdata))
 485     goto done;
 486
 487   /* Table of xdata entries.  */
 488   xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1));
 489   xdata_arr_cnt = 0;
 490
 491   imagebase = pe_data (abfd)->pe_opthdr.ImageBase;
 492
 493   for (i = 0; i < stop; i += onaline)
 494     {
 495       struct pex64_runtime_function rf;
 496
 497       if (i + PDATA_ROW_SIZE > stop)
 498         break;
 499
 500       pex64_get_runtime_function (abfd, &rf, &pdata[i]);
 501
 502       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 503           && rf.rva_UnwindData == 0)
 504         /* We are probably into the padding of the section now.  */
 505         break;
 506       fputc (' ', file);
 507       fprintf_vma (file, i + pdata_section->vma);
 508       fprintf (file, ":\t");
 509       fprintf_vma (file, imagebase + rf.rva_BeginAddress);
 510       fprintf (file, " ");
 511       fprintf_vma (file, imagebase + rf.rva_EndAddress);
 512       fprintf (file, " ");
 513       fprintf_vma (file, imagebase + rf.rva_UnwindData);
 514       fprintf (file, "\n");
 515       if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
 516         {
 517           seen_error = 1;
 518           fprintf (file, "  has %s begin address as predecessor\n",
 519             (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
 520         }
 521       prev_beginaddress = rf.rva_BeginAddress;
 522       /* Now we check for negative addresses.  */
 523       if ((prev_beginaddress & 0x80000000) != 0)
 524         {
 525           seen_error = 1;
 526           fprintf (file, "  has negative begin address\n");
 527         }
 528       if ((rf.rva_EndAddress & 0x80000000) != 0)
 529         {
 530           seen_error = 1;
 531           fprintf (file, "  has negative end address\n");
 532         }
 533       if ((rf.rva_UnwindData & 0x80000000) != 0)
 534         {
 535           seen_error = 1;
 536           fprintf (file, "  has negative unwind address\n");
 537         }
 538       if (rf.rva_UnwindData && !PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
 539         xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
 540     }
 541
 542   if (seen_error)
 543     goto done;
 544
 545   /* Add end of list marker.  */
 546   xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);
 547
 548   /* Sort start RVAs of xdata.  */
 549   if (xdata_arr_cnt > 1)
 550     qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 551            sort_xdata_arr);
 552
 553   /* Find the section containing the unwind data (.xdata).  */
 554   xdata_base = xdata_arr[0];
 555   xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".rdata");
 556
 557   if (!xdata_section)
 558     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".data");
 559   if (!xdata_section)
 560     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".xdata");
 561   if (!xdata_section)
 562     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".pdata");
 563   if (!xdata_section)
 564     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".text");
 565   if (!xdata_section
 566       || !bfd_malloc_and_get_section (abfd, xdata_section, &xdata))
 567     goto done;
 568
 569   /* Do dump of pdata related xdata.  */
 570   for (i = 0; i < stop; i += onaline)
 571     {
 572       struct pex64_runtime_function rf;
 573
 574       if (i + PDATA_ROW_SIZE > stop)
 575         break;
 576       pex64_get_runtime_function (abfd, &rf, &pdata[i]);
 577
 578       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 579           && rf.rva_UnwindData == 0)
 580         /* We are probably into the padding of the section now.  */
 581         break;
 582       if (i == 0)
 583         fprintf (file, "\nDump of .xdata\n");
 584
 585       fputc (' ', file);
 586       fprintf_vma (file, rf.rva_UnwindData + imagebase);
 587
 588       if (prev_unwinddata_rva == rf.rva_UnwindData)
 589         {
 590           /* Do not dump again the xdata for the same entry.  */
 591           fprintf (file, " also used for function at ");
 592           fprintf_vma (file, rf.rva_BeginAddress + imagebase);
 593           fputc ('\n', file);
 594           continue;
 595         }
 596       else
 597         prev_unwinddata_rva = rf.rva_UnwindData;
 598
 599       fprintf (file, " (rva: %08x): ",
 600                (unsigned int) rf.rva_UnwindData);
 601       fprintf_vma (file, rf.rva_BeginAddress + imagebase);
 602       fprintf (file, " - ");
 603       fprintf_vma (file, rf.rva_EndAddress + imagebase);
 604       fputc ('\n', file);
 605
 606       if (rf.rva_UnwindData != 0)
 607         {
 608           if (PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
 609             {
 610               bfd_vma altent = PEX64_GET_UNWINDDATA_UNIFIED_RVA (&rf);
 611               bfd_vma pdata_vma = bfd_get_section_vma (abfd, pdata_section);
 612               struct pex64_runtime_function arf;
 613
 614               fprintf (file, "\t shares information with ");
 615               altent += imagebase;
 616
 617               if (altent >= pdata_vma
 618                   && (altent + PDATA_ROW_SIZE <= pdata_vma
 619                       + pei_section_data (abfd, pdata_section)->virt_size))
 620                 {
 621                   pex64_get_runtime_function
 622                     (abfd, &arf, &pdata[altent - pdata_vma]);
 623                   fprintf (file, "pdata element at 0x");
 624                   fprintf_vma (file, arf.rva_UnwindData);
 625                 }
 626               else
 627                 fprintf (file, "unknown pdata element");
 628               fprintf (file, ".\n");
 629             }
 630           else
 631             {
 632               bfd_vma *p;
 633
 634               /* Search for the current entry in the sorted array.  */
 635               p = (bfd_vma *)
 636                   bsearch (&rf.rva_UnwindData, xdata_arr,
 637                            (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 638                            sort_xdata_arr);
 639
 640               /* Advance to the next pointer into the xdata section.  We may
 641                  have shared xdata entries, which will result in a string of
 642                  identical pointers in the array; advance past all of them.  */
 643               while (p[0] <= rf.rva_UnwindData)
 644                 ++p;
 645               if (p[0] == ~((bfd_vma) 0))
 646                 p = NULL;
 647
 648               pex64_dump_xdata (file, abfd, xdata_section, xdata, p, &rf);
 649             }
 650         }
 651     }
 652
 653  done:
 654   free (pdata);
 655   free (xdata_arr);
 656   free (xdata);
 657
 658   return TRUE;
 659 }
 660
 661 #define bfd_pe_print_pdata   pex64_bfd_print_pdata
 662
 663 #include "coff-x86_64.c"