bfd/pei-x86_64.c

   1 /* BFD back-end for Intel 386 PE IMAGE COFF files.
   2    Copyright 2006, 2007, 2009 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_64pei_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 static const char *pex_regs[16] = {
  80   "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
  81   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
  82 };
  83
  84 static void
  85 pex64_get_runtime_function (bfd *abfd, struct pex64_runtime_function *rf,
  86                             const void *data)
  87 {
  88   const struct external_pex64_runtime_function *ex_rf =
  89     (const struct external_pex64_runtime_function *) data;
  90   rf->rva_BeginAddress = bfd_get_32 (abfd, ex_rf->rva_BeginAddress);
  91   rf->rva_EndAddress = bfd_get_32 (abfd, ex_rf->rva_EndAddress);
  92   rf->rva_UnwindData =  bfd_get_32 (abfd, ex_rf->rva_UnwindData);
  93   rf->isChained = PEX64_IS_RUNTIME_FUNCTION_CHAINED (rf);
  94   rf->rva_UnwindData = PEX64_GET_UNWINDDATA_UNIFIED_RVA (rf);
  95 }
  96
  97 static void
  98 pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui, void *data)
  99 {
 100   struct external_pex64_unwind_info *ex_ui =
 101     (struct external_pex64_unwind_info *) data;
 102   bfd_byte *ex_dta = (bfd_byte *) data;
 103
 104   memset (ui, 0, sizeof (struct pex64_unwind_info));
 105   ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
 106   ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
 107   ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
 108   ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
 109   ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
 110   ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
 111   ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
 112   ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
 113   ui->rawUnwindCodes = &ex_dta[4];
 114   ex_dta += ui->SizeOfBlock;
 115   switch (ui->Flags)
 116     {
 117     case UNW_FLAG_CHAININFO:
 118       ui->rva_FunctionEntry = bfd_get_32 (abfd, ex_dta);
 119       ui->SizeOfBlock += 4;
 120       return;
 121     default:
 122       return;
 123     }
 124 }
 125
 126 static void
 127 pex64_xdata_print_uwd_codes (FILE *file, struct pex64_unwind_info *ui,
 128                              bfd_vma pc_addr)
 129 {
 130   bfd_vma i;
 131   bfd_vma tmp = 0;
 132   const bfd_byte *insns[256];
 133   bfd_vma insns_count = 0;
 134   const bfd_byte *dta = ui->rawUnwindCodes;
 135
 136   if (ui->CountOfCodes == 0 || !dta)
 137     return;
 138
 139   /* Sort array ascending. Note: it is stored in reversed order.  */
 140   for (i = 0; i < ui->CountOfCodes; i++)
 141     {
 142       const bfd_byte *t;
 143
 144       t = insns[insns_count++] = &dta[i * 2];
 145       switch (PEX64_UNWCODE_CODE (t[1]))
 146         {
 147         case UWOP_PUSH_NONVOL:
 148         case UWOP_ALLOC_SMALL:
 149         case UWOP_SET_FPREG:
 150         case UWOP_PUSH_MACHFRAME:
 151           break;
 152         case UWOP_ALLOC_LARGE:
 153           if (PEX64_UNWCODE_INFO (t[1]) == 0)
 154             {
 155               i += 1;
 156               break;
 157             }
 158           else if (PEX64_UNWCODE_INFO (t[1]) == 1)
 159             {
 160               i += 2;
 161               break;
 162             }
 163           /* fall through.  */
 164         default:
 165           fprintf (file, "\t contains unknown code (%u).\n",
 166                    (unsigned int) PEX64_UNWCODE_CODE (t[1]));
 167           return;
 168         case UWOP_SAVE_NONVOL:
 169         case UWOP_SAVE_XMM:
 170         case UWOP_SAVE_XMM128:
 171           i++;
 172           break;
 173         case UWOP_SAVE_NONVOL_FAR:
 174         case UWOP_SAVE_XMM_FAR:
 175         case UWOP_SAVE_XMM128_FAR:
 176           i += 2;
 177           break;
 178         }
 179     }
 180   fprintf (file, "\t At pc 0x");
 181   fprintf_vma (file, pc_addr);
 182   fprintf (file, " there are the following saves (in logical order).\n");
 183   for (i = insns_count; i > 0;)
 184     {
 185       --i;
 186       dta = insns[i];
 187       fprintf (file, "\t  insn ends at pc+0x%02x: ", (unsigned int) dta[0]);
 188       switch (PEX64_UNWCODE_CODE (dta[1]))
 189         {
 190         case UWOP_PUSH_NONVOL:
 191           fprintf (file, "push %s.\n", pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
 192           break;
 193         case UWOP_ALLOC_LARGE:
 194           if (PEX64_UNWCODE_INFO (dta[1]) == 0)
 195             {
 196               tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
 197               tmp *= 8;
 198             }
 199           else
 200             tmp = (bfd_vma) (*((unsigned int *)&dta[2]));
 201           fprintf (file, "save stack region of size 0x");
 202           fprintf_vma (file, tmp);
 203           fprintf (file,".\n");
 204           break;
 205         case UWOP_ALLOC_SMALL:
 206           tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
 207           tmp += 1;
 208           tmp *= 8;
 209           fprintf (file, "save stack region of size 0x");
 210           fprintf_vma (file, tmp);
 211           fprintf (file,".\n");
 212           break;
 213         case UWOP_SET_FPREG:
 214           tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
 215           tmp *= 16;
 216           fprintf (file, "FPReg = (FrameReg) + 0x");
 217           fprintf_vma (file, tmp);
 218           fprintf (file, ".\n");
 219           break;
 220         case UWOP_SAVE_NONVOL:
 221           fprintf (file, "mov %s at 0x",
 222                    pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
 223           tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
 224           tmp *= 8;
 225           fprintf_vma (file, tmp);
 226           fprintf (file, ".\n");
 227           break;
 228         case UWOP_SAVE_NONVOL_FAR:
 229           fprintf (file, "mov %s at 0x",
 230                    pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
 231           tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
 232           fprintf_vma (file, tmp);
 233           fprintf (file, ".\n");
 234           break;
 235         case UWOP_SAVE_XMM:
 236           tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
 237           tmp *= 8;
 238           fprintf (file, "mov mm%u at 0x",
 239                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
 240           fprintf_vma (file, tmp);
 241           fprintf (file, ".\n");
 242           break;
 243         case UWOP_SAVE_XMM_FAR:
 244           tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
 245           fprintf (file, "mov mm%u at 0x",
 246                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
 247           fprintf_vma (file, tmp);
 248           fprintf (file, ".\n");
 249           break;
 250         case UWOP_SAVE_XMM128:
 251           tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
 252           tmp *= 16;
 253           fprintf (file, "mov xmm%u at 0x",
 254                    (unsigned int) PEX64_UNWCODE_INFO ( dta[1]));
 255           fprintf_vma (file, tmp);
 256           fprintf (file, ".\n");
 257           break;
 258         case UWOP_SAVE_XMM128_FAR:
 259           tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
 260           fprintf (file, "mov xmm%u at 0x",
 261                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
 262           fprintf_vma (file, tmp);
 263           fprintf (file, ".\n");
 264           break;
 265         case UWOP_PUSH_MACHFRAME:
 266           fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
 267           if (PEX64_UNWCODE_INFO (dta[1]) == 0)
 268             {
 269               fprintf (file, ")");
 270             }
 271           else if (PEX64_UNWCODE_INFO (dta[1]) == 1)
 272             {
 273               fprintf (file, ",ErrorCode)");
 274             }
 275           else
 276             fprintf (file, ", unknown(%u))",
 277                      (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
 278           fprintf (file,".\n");
 279           break;
 280         default:
 281           fprintf (file, "unknown code %u.\n",
 282                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
 283           break;
 284       }
 285     }
 286 }
 287
 288 static asection *
 289 pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
 290 {
 291   asection *section = bfd_get_section_by_name (abfd, sec_name);
 292   bfd_vma vsize;
 293   bfd_size_type datasize = 0;
 294
 295   if (section == NULL
 296       || coff_section_data (abfd, section) == NULL
 297       || pei_section_data (abfd, section) == NULL)
 298     return NULL;
 299   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 300   datasize = section->size;
 301   if (!datasize || vsize > addr || (vsize + datasize) < addr)
 302     return NULL;
 303   return section;
 304 }
 305
 306 static void
 307 pex64_dump_xdata (FILE *file, bfd *abfd, bfd_vma addr, bfd_vma pc_addr,
 308                   bfd_vma *endx)
 309 {
 310   asection *section = pex64_get_section_by_rva (abfd, addr, ".rdata");
 311   bfd_vma vsize;
 312   bfd_byte *data = NULL;
 313   bfd_vma end_addr;
 314
 315   if (!section)
 316     section = pex64_get_section_by_rva (abfd, addr, ".data");
 317   if (!section)
 318     section = pex64_get_section_by_rva (abfd, addr, ".xdata");
 319   if (!section)
 320     {
 321       section = pex64_get_section_by_rva (abfd, addr, ".pdata");
 322       if (section)
 323         {
 324           fprintf (file, "\t Shares information with pdata element at 0x");
 325           fprintf_vma (file, addr + pe_data (abfd)->pe_opthdr.ImageBase);
 326           fprintf (file, ".\n");
 327         }
 328     }
 329   if (!section)
 330     return;
 331
 332   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 333   addr -= vsize;
 334
 335   if (endx)
 336     end_addr = endx[0] - vsize;
 337   else
 338     end_addr = (section->rawsize != 0 ? section->rawsize : section->size);
 339
 340   if (bfd_malloc_and_get_section (abfd, section, &data))
 341     {
 342       struct pex64_unwind_info ui;
 343
 344       if (!data)
 345         return;
 346
 347       pex64_get_unwind_info (abfd, &ui, &data[addr]);
 348
 349       if (ui.Version != 1)
 350         {
 351           fprintf (file, "\tVersion %u (unknown).\n", (unsigned int) ui.Version);
 352           return;
 353         }
 354
 355       fprintf (file, "\tFlags: ");
 356       switch (ui.Flags)
 357         {
 358         case UNW_FLAG_NHANDLER:
 359           fprintf (file, "UNW_FLAG_NHANDLER");
 360           break;
 361         case UNW_FLAG_EHANDLER:
 362           fprintf (file, "UNW_FLAG_EHANDLER");
 363           break;
 364         case UNW_FLAG_UHANDLER:
 365           fprintf (file, "UNW_FLAG_UHANDLER");
 366           break;
 367         case UNW_FLAG_FHANDLER:
 368           fprintf (file, "UNW_FLAG_FHANDLER = (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER)");
 369           break;
 370         case UNW_FLAG_CHAININFO:
 371           fprintf (file, "UNW_FLAG_CHAININFO");
 372           break;
 373         default:
 374           fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
 375           break;
 376         }
 377       fprintf (file, ".\n");
 378       if (ui.CountOfCodes != 0)
 379         fprintf (file, "\tEntry has %u codes.", (unsigned int) ui.CountOfCodes);
 380       fprintf (file, "\tPrologue size: %u, Frame offset = 0x%x.\n",
 381                (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
 382       fprintf (file, "\tFrame register is %s.\n",
 383         ui.FrameRegister == 0 ? "none"
 384                               : pex_regs[(unsigned int) ui.FrameRegister]);
 385
 386       pex64_xdata_print_uwd_codes (file, &ui, pc_addr);
 387
 388       /* Now we need end of this xdata block.  */
 389       addr += ui.SizeOfBlock;
 390       if (addr < end_addr)
 391         {
 392           unsigned int i;
 393           fprintf (file,"\tUser data:\n");
 394           for (i = 0; addr < end_addr; addr += 1, i++)
 395             {
 396               if ((i & 15) == 0)
 397                 fprintf (file, "\t  %03x:", i);
 398               fprintf (file, " %02x", data[addr]);
 399               if ((i & 15) == 15)
 400                 fprintf (file, "\n");
 401             }
 402           if ((i & 15) != 0)
 403             fprintf (file, "\n");
 404         }
 405     }
 406   if (data != NULL)
 407     free (data);
 408 }
 409
 410 static int
 411 sort_xdata_arr (const void *l, const void *r)
 412 {
 413   const bfd_vma *lp = (const bfd_vma *) l;
 414   const bfd_vma *rp = (const bfd_vma *) r;
 415
 416   if (*lp == *rp)
 417     return 0;
 418   return (*lp < *rp ? -1 : 1);
 419 }
 420
 421 static bfd_boolean
 422 pex64_bfd_print_pdata (bfd *abfd, void *vfile)
 423 {
 424   FILE *file = (FILE *) vfile;
 425   bfd_byte *data = NULL;
 426   asection *section = bfd_get_section_by_name (abfd, ".pdata");
 427   bfd_size_type datasize = 0;
 428   bfd_size_type i;
 429   bfd_size_type stop;
 430   bfd_vma prev_beginaddress = 0;
 431   int onaline = PDATA_ROW_SIZE;
 432   int seen_error = 0;
 433   bfd_vma *xdata_arr;
 434   int xdata_arr_cnt;
 435
 436   if (section == NULL
 437       || coff_section_data (abfd, section) == NULL
 438       || pei_section_data (abfd, section) == NULL)
 439     return TRUE;
 440
 441   stop = pei_section_data (abfd, section)->virt_size;
 442   if ((stop % onaline) != 0)
 443     fprintf (file,
 444              _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
 445              (long) stop, onaline);
 446
 447   fprintf (file,
 448            _("\nThe Function Table (interpreted .pdata section contents)\n"));
 449
 450   fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
 451
 452   datasize = section->size;
 453   if (datasize == 0)
 454     return TRUE;
 455
 456   if (!bfd_malloc_and_get_section (abfd, section, &data))
 457     {
 458       if (data != NULL)
 459         free (data);
 460       return FALSE;
 461     }
 462
 463   xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1));
 464   xdata_arr_cnt = 0;
 465   /* Do sanity check of pdata.  */
 466   for (i = 0; i < stop; i += onaline)
 467     {
 468       struct pex64_runtime_function rf;
 469
 470       if (i + PDATA_ROW_SIZE > stop)
 471         break;
 472       pex64_get_runtime_function (abfd, &rf, &data[i]);
 473
 474       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 475           && rf.rva_UnwindData == 0)
 476         /* We are probably into the padding of the section now.  */
 477         break;
 478       fputc (' ', file);
 479       fprintf_vma (file, i + section->vma);
 480       fprintf (file, ":\t");
 481       fprintf_vma (file, rf.rva_BeginAddress);
 482       fputc (' ', file);
 483       fprintf_vma (file, rf.rva_EndAddress);
 484       fputc (' ', file);
 485       fprintf_vma (file, rf.rva_UnwindData);
 486       fprintf (file, "\n");
 487       if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
 488         {
 489           seen_error = 1;
 490           fprintf (file, "  has %s begin address as predecessor\n",
 491             (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
 492         }
 493       prev_beginaddress = rf.rva_BeginAddress;
 494       /* Now we check for negative addresses.  */
 495       if ((prev_beginaddress & 0x80000000) != 0)
 496         {
 497           seen_error = 1;
 498           fprintf (file, "  has negative begin address\n");
 499         }
 500       if ((rf.rva_EndAddress & 0x80000000) != 0)
 501         {
 502           seen_error = 1;
 503           fprintf (file, "  has negative end address\n");
 504         }
 505       if ((rf.rva_UnwindData & 0x80000000) != 0)
 506         {
 507           seen_error = 1;
 508           fprintf (file, "  has negative unwind address\n");
 509         }
 510       if (rf.rva_UnwindData && !rf.isChained)
 511         xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
 512     }
 513
 514   if (seen_error)
 515     {
 516       free (data);
 517       free (xdata_arr);
 518
 519       return TRUE;
 520     }
 521
 522   /* Add end of list marker.  */
 523   xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);
 524
 525   /* Sort start RVAs of xdata.  */
 526   if (xdata_arr_cnt > 1)
 527     qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 528            sort_xdata_arr);
 529
 530   /* Do dump of pdata related xdata.  */
 531
 532   for (i = 0; i < stop; i += onaline)
 533     {
 534       struct pex64_runtime_function rf;
 535
 536       if (i + PDATA_ROW_SIZE > stop)
 537         break;
 538       pex64_get_runtime_function (abfd, &rf, &data[i]);
 539
 540       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 541           && rf.rva_UnwindData == 0)
 542         /* We are probably into the padding of the section now.  */
 543         break;
 544       if (i == 0)
 545         fprintf (file, "\nDump of .xdata\n");
 546       fputc (' ', file);
 547       fprintf_vma (file, rf.rva_UnwindData);
 548       fprintf (file, ":\n");
 549
 550       rf.rva_BeginAddress += pe_data (abfd)->pe_opthdr.ImageBase;
 551       rf.rva_EndAddress += pe_data (abfd)->pe_opthdr.ImageBase;
 552
 553       if (rf.rva_UnwindData != 0)
 554         {
 555           if (rf.isChained)
 556             {
 557               fprintf (file, "\t shares information with pdata element at 0x");
 558               fprintf_vma (file, rf.rva_UnwindData);
 559               fprintf (file, ".\n");
 560             }
 561           else
 562             {
 563               bfd_vma *p;
 564
 565               /* Search for the current entry in the sorted array.  */
 566               p = (bfd_vma *)
 567                   bsearch (&rf.rva_UnwindData, xdata_arr,
 568                            (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 569                            sort_xdata_arr);
 570
 571               /* Advance to the next pointer into the xdata section.  We may
 572                  have shared xdata entries, which will result in a string of
 573                  identical pointers in the array; advance past all of them.  */
 574               while (p[0] <= rf.rva_UnwindData)
 575                 ++p;
 576               if (p[0] == ~((bfd_vma) 0))
 577                 p = NULL;
 578
 579               pex64_dump_xdata (file, abfd, rf.rva_UnwindData,
 580                                 rf.rva_BeginAddress, p);
 581             }
 582         }
 583     }
 584
 585   free (data);
 586   free (xdata_arr);
 587
 588   return TRUE;
 589 }
 590
 591 #define bfd_pe_print_pdata   pex64_bfd_print_pdata
 592
 593 #include "coff-x86_64.c"