bfd/pei-x86_64.c

   1 /* BFD back-end for Intel 386 PE IMAGE COFF files.
   2    Copyright (C) 2006-2023 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 bool
 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_end - ex_dta < 4)
 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   if ((size_t) (ex_dta_end - ex_dta) < ui->SizeOfBlock)
 127     return false;
 128   ex_dta += ui->SizeOfBlock;
 129
 130   switch (ui->Flags)
 131     {
 132     case UNW_FLAG_CHAININFO:
 133       if (ex_dta_end - ex_dta < 12)
 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_end - ex_dta < 4)
 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 ((size_t) (ui->rawUnwindCodesEnd - ui->rawUnwindCodes)
 176       < ui->CountOfCodes * 2)
 177     {
 178       fprintf (file, _("warning: corrupt unwind data\n"));
 179       return;
 180     }
 181
 182   if (ui->Version == 2
 183       && PEX64_UNWCODE_CODE (ui->rawUnwindCodes[1]) == UWOP_EPILOG)
 184     {
 185       /* Display epilog opcode (whose docoding is not fully documented).
 186          Looks to be designed to speed-up unwinding, as there is no need
 187          to decode instruction flow if outside an epilog.  */
 188       unsigned int func_size = rf->rva_EndAddress - rf->rva_BeginAddress;
 189
 190       fprintf (file, "\tv2 epilog (length: %02x) at pc+:",
 191                ui->rawUnwindCodes[0]);
 192
 193       if (PEX64_UNWCODE_INFO (ui->rawUnwindCodes[1]))
 194         fprintf (file, " 0x%x", func_size - ui->rawUnwindCodes[0]);
 195
 196       i++;
 197       for (; i < ui->CountOfCodes; i++)
 198         {
 199           const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
 200           unsigned int off;
 201
 202           if (PEX64_UNWCODE_CODE (dta[1]) != UWOP_EPILOG)
 203             break;
 204           off = dta[0] | (PEX64_UNWCODE_INFO (dta[1]) << 8);
 205           if (off == 0)
 206             fprintf (file, " [pad]");
 207           else
 208             fprintf (file, " 0x%x", func_size - off);
 209         }
 210       fputc ('\n', file);
 211     }
 212
 213   for (; i < ui->CountOfCodes; i++)
 214     {
 215       const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
 216       unsigned int info = PEX64_UNWCODE_INFO (dta[1]);
 217       int unexpected = false;
 218
 219       fprintf (file, "\t  pc+0x%02x: ", (unsigned int) dta[0]);
 220
 221       switch (PEX64_UNWCODE_CODE (dta[1]))
 222         {
 223         case UWOP_PUSH_NONVOL:
 224           fprintf (file, "push %s", pex_regs[info]);
 225           break;
 226
 227         case UWOP_ALLOC_LARGE:
 228           if (info == 0)
 229             {
 230               if (ui->rawUnwindCodesEnd - dta < 4)
 231                 {
 232                   fprintf (file, _("warning: corrupt unwind data\n"));
 233                   return;
 234                 }
 235               tmp = bfd_get_16 (abfd, dta + 2) * 8;
 236               i++;
 237             }
 238           else
 239             {
 240               if (ui->rawUnwindCodesEnd - dta < 6)
 241                 {
 242                   fprintf (file, _("warning: corrupt unwind data\n"));
 243                   return;
 244                 }
 245               tmp = bfd_get_32 (abfd, dta + 2);
 246               i += 2;
 247             }
 248           fprintf (file, "alloc large area: rsp = rsp - 0x%x", tmp);
 249           break;
 250
 251         case UWOP_ALLOC_SMALL:
 252           fprintf (file, "alloc small area: rsp = rsp - 0x%x", (info + 1) * 8);
 253           break;
 254
 255         case UWOP_SET_FPREG:
 256           /* According to the documentation, info field is unused.  */
 257           fprintf (file, "FPReg: %s = rsp + 0x%x (info = 0x%x)",
 258                    pex_regs[ui->FrameRegister],
 259                    (unsigned int) ui->FrameOffset * 16, info);
 260           unexpected = ui->FrameRegister == 0;
 261           save_allowed = false;
 262           break;
 263
 264         case UWOP_SAVE_NONVOL:
 265           if (ui->rawUnwindCodesEnd - dta < 4)
 266             {
 267               fprintf (file, _("warning: corrupt unwind data\n"));
 268               return;
 269             }
 270           tmp = bfd_get_16 (abfd, dta + 2) * 8;
 271           i++;
 272           fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
 273           unexpected = !save_allowed;
 274           break;
 275
 276         case UWOP_SAVE_NONVOL_FAR:
 277           if (ui->rawUnwindCodesEnd - dta < 6)
 278             {
 279               fprintf (file, _("warning: corrupt unwind data\n"));
 280               return;
 281             }
 282           tmp = bfd_get_32 (abfd, dta + 2);
 283           i += 2;
 284           fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
 285           unexpected = !save_allowed;
 286           break;
 287
 288         case UWOP_SAVE_XMM:
 289           if (ui->Version == 1)
 290             {
 291               if (ui->rawUnwindCodesEnd - dta < 4)
 292                 {
 293                   fprintf (file, _("warning: corrupt unwind data\n"));
 294                   return;
 295                 }
 296               tmp = bfd_get_16 (abfd, dta + 2) * 8;
 297               i++;
 298               fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
 299               unexpected = !save_allowed;
 300             }
 301           else if (ui->Version == 2)
 302             {
 303               fprintf (file, "epilog %02x %01x", dta[0], info);
 304               unexpected = true;
 305             }
 306           break;
 307
 308         case UWOP_SAVE_XMM_FAR:
 309           if (ui->rawUnwindCodesEnd - dta < 6)
 310             {
 311               fprintf (file, _("warning: corrupt unwind data\n"));
 312               return;
 313             }
 314           tmp = bfd_get_32 (abfd, dta + 2) * 8;
 315           i += 2;
 316           fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
 317           unexpected = !save_allowed;
 318           break;
 319
 320         case UWOP_SAVE_XMM128:
 321           if (ui->rawUnwindCodesEnd - dta < 4)
 322             {
 323               fprintf (file, _("warning: corrupt unwind data\n"));
 324               return;
 325             }
 326           tmp = bfd_get_16 (abfd, dta + 2) * 16;
 327           i++;
 328           fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
 329           unexpected = !save_allowed;
 330           break;
 331
 332         case UWOP_SAVE_XMM128_FAR:
 333           if (ui->rawUnwindCodesEnd - dta < 6)
 334             {
 335               fprintf (file, _("warning: corrupt unwind data\n"));
 336               return;
 337             }
 338           tmp = bfd_get_32 (abfd, dta + 2) * 16;
 339           i += 2;
 340           fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
 341           unexpected = !save_allowed;
 342           break;
 343
 344         case UWOP_PUSH_MACHFRAME:
 345           fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
 346           if (info == 0)
 347             fprintf (file, ")");
 348           else if (info == 1)
 349             fprintf (file, ",ErrorCode)");
 350           else
 351             fprintf (file, ", unknown(%u))", info);
 352           break;
 353
 354         default:
 355           /* PR 17512: file: 2245-7442-0.004.  */
 356           fprintf (file, _("Unknown: %x"), PEX64_UNWCODE_CODE (dta[1]));
 357           break;
 358         }
 359
 360       if (unexpected)
 361         fprintf (file, " [Unexpected!]");
 362       fputc ('\n', file);
 363     }
 364 }
 365
 366 /* Check wether section SEC_NAME contains the xdata at address ADDR.  */
 367
 368 static asection *
 369 pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
 370 {
 371   asection *section = bfd_get_section_by_name (abfd, sec_name);
 372   bfd_vma vsize;
 373   bfd_size_type datasize = 0;
 374
 375   if (section == NULL
 376       || coff_section_data (abfd, section) == NULL
 377       || pei_section_data (abfd, section) == NULL)
 378     return NULL;
 379   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 380   datasize = section->size;
 381   if (!datasize || vsize > addr || (vsize + datasize) < addr)
 382     return NULL;
 383   return section;
 384 }
 385
 386 /* Dump xdata at for function RF to FILE.  The argument XDATA_SECTION
 387    designate the bfd section containing the xdata, XDATA is its content,
 388    and ENDX the size if known (or NULL).  */
 389
 390 static void
 391 pex64_dump_xdata (FILE *file, bfd *abfd,
 392                   asection *xdata_section, bfd_byte *xdata, bfd_vma *endx,
 393                   struct pex64_runtime_function *rf)
 394 {
 395   bfd_vma vaddr;
 396   bfd_vma end_addr;
 397   bfd_vma addr = rf->rva_UnwindData;
 398   bfd_size_type sec_size = xdata_section->rawsize > 0 ? xdata_section->rawsize : xdata_section->size;
 399   struct pex64_unwind_info ui;
 400
 401   vaddr = xdata_section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
 402   addr -= vaddr;
 403
 404   /* PR 17512: file: 2245-7442-0.004.  */
 405   if (addr >= sec_size)
 406     {
 407       fprintf (file, _("warning: xdata section corrupt\n"));
 408       return;
 409     }
 410
 411   if (endx)
 412     {
 413       end_addr = endx[0] - vaddr;
 414       /* PR 17512: file: 2245-7442-0.004.  */
 415       if (end_addr > sec_size)
 416         {
 417           fprintf (file, _("warning: xdata section corrupt\n"));
 418           end_addr = sec_size;
 419         }
 420     }
 421   else
 422     end_addr = sec_size;
 423
 424   if (! pex64_get_unwind_info (abfd, &ui, xdata + addr, xdata + end_addr))
 425     {
 426       fprintf (file, _("warning: xdata section corrupt\n"));
 427       return;
 428     }
 429
 430   if (ui.Version != 1 && ui.Version != 2)
 431     {
 432       unsigned int i;
 433       fprintf (file, "\tVersion %u (unknown).\n",
 434                (unsigned int) ui.Version);
 435       for (i = 0; addr < end_addr; addr += 1, i++)
 436         {
 437           if ((i & 15) == 0)
 438             fprintf (file, "\t  %03x:", i);
 439           fprintf (file, " %02x", xdata[addr]);
 440           if ((i & 15) == 15)
 441             fprintf (file, "\n");
 442         }
 443       if ((i & 15) != 0)
 444         fprintf (file, "\n");
 445       return;
 446     }
 447
 448   fprintf (file, "\tVersion: %d, Flags: ", ui.Version);
 449   switch (ui.Flags)
 450     {
 451     case UNW_FLAG_NHANDLER:
 452       fprintf (file, "none");
 453       break;
 454     case UNW_FLAG_EHANDLER:
 455       fprintf (file, "UNW_FLAG_EHANDLER");
 456       break;
 457     case UNW_FLAG_UHANDLER:
 458       fprintf (file, "UNW_FLAG_UHANDLER");
 459       break;
 460     case UNW_FLAG_FHANDLER:
 461       fprintf
 462         (file, "UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER");
 463       break;
 464     case UNW_FLAG_CHAININFO:
 465       fprintf (file, "UNW_FLAG_CHAININFO");
 466       break;
 467     default:
 468       fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
 469       break;
 470     }
 471   fputc ('\n', file);
 472   fprintf (file, "\tNbr codes: %u, ", (unsigned int) ui.CountOfCodes);
 473   fprintf (file, "Prologue size: 0x%02x, Frame offset: 0x%x, ",
 474            (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
 475   fprintf (file, "Frame reg: %s\n",
 476            ui.FrameRegister == 0 ? "none"
 477            : pex_regs[(unsigned int) ui.FrameRegister]);
 478
 479   /* PR 17512: file: 2245-7442-0.004.  */
 480   if (ui.CountOfCodes * 2 + ui.rawUnwindCodes > xdata + xdata_section->size)
 481     fprintf (file, _("Too many unwind codes (%ld)\n"), (long) ui.CountOfCodes);
 482   else
 483     pex64_xdata_print_uwd_codes (file, abfd, &ui, rf);
 484
 485   switch (ui.Flags)
 486     {
 487     case UNW_FLAG_EHANDLER:
 488     case UNW_FLAG_UHANDLER:
 489     case UNW_FLAG_FHANDLER:
 490       fprintf (file, "\tHandler: %016" PRIx64 ".\n",
 491                ui.rva_ExceptionHandler + pe_data (abfd)->pe_opthdr.ImageBase);
 492       break;
 493     case UNW_FLAG_CHAININFO:
 494       fprintf (file, "\tChain: start: %016" PRIx64 ", end: %016" PRIx64,
 495                ui.rva_BeginAddress, ui.rva_EndAddress);
 496       fprintf (file, "\n\t unwind data: %016" PRIx64 ".\n",
 497                ui.rva_UnwindData);
 498       break;
 499     }
 500
 501   /* Now we need end of this xdata block.  */
 502   addr += ui.SizeOfBlock;
 503   if (addr < end_addr)
 504     {
 505       unsigned int i;
 506       fprintf (file,"\tUser data:\n");
 507       for (i = 0; addr < end_addr; addr += 1, i++)
 508         {
 509           if ((i & 15) == 0)
 510             fprintf (file, "\t  %03x:", i);
 511           fprintf (file, " %02x", xdata[addr]);
 512           if ((i & 15) == 15)
 513             fprintf (file, "\n");
 514         }
 515       if ((i & 15) != 0)
 516         fprintf (file, "\n");
 517     }
 518 }
 519
 520 /* Helper function to sort xdata.  The entries of xdata are sorted to know
 521    the size of each entry.  */
 522
 523 static int
 524 sort_xdata_arr (const void *l, const void *r)
 525 {
 526   const bfd_vma *lp = (const bfd_vma *) l;
 527   const bfd_vma *rp = (const bfd_vma *) r;
 528
 529   if (*lp == *rp)
 530     return 0;
 531   return (*lp < *rp ? -1 : 1);
 532 }
 533
 534 /* Display unwind tables for x86-64.  */
 535
 536 static bool
 537 pex64_bfd_print_pdata_section (bfd *abfd, void *vfile, asection *pdata_section)
 538 {
 539   FILE *file = (FILE *) vfile;
 540   bfd_byte *pdata = NULL;
 541   bfd_byte *xdata = NULL;
 542   asection *xdata_section = NULL;
 543   bfd_vma xdata_base;
 544   bfd_size_type i;
 545   bfd_size_type datasize;
 546   bfd_size_type stop;
 547   bfd_vma prev_beginaddress = (bfd_vma) -1;
 548   bfd_vma prev_unwinddata_rva = (bfd_vma) -1;
 549   bfd_vma imagebase;
 550   int onaline = PDATA_ROW_SIZE;
 551   int seen_error = 0;
 552   bfd_vma *xdata_arr = NULL;
 553   int xdata_arr_cnt;
 554   bool virt_size_is_zero = false;
 555
 556   /* Sanity checks.  */
 557   if (pdata_section == NULL
 558       || (pdata_section->flags & SEC_HAS_CONTENTS) == 0
 559       || coff_section_data (abfd, pdata_section) == NULL
 560       || pei_section_data (abfd, pdata_section) == NULL)
 561     return true;
 562
 563   stop = pei_section_data (abfd, pdata_section)->virt_size;
 564   if ((stop % onaline) != 0)
 565     fprintf (file,
 566              /* xgettext:c-format */
 567              _("Warning: %s section size (%ld) is not a multiple of %d\n"),
 568              pdata_section->name, (long) stop, onaline);
 569
 570   datasize = pdata_section->size;
 571   if (datasize == 0)
 572     {
 573       if (stop)
 574         fprintf (file, _("Warning: %s section size is zero\n"),
 575                  pdata_section->name);
 576       return true;
 577     }
 578
 579   /* virt_size might be zero for objects.  */
 580   if (stop == 0 && strcmp (abfd->xvec->name, "pe-x86-64") == 0)
 581     {
 582       stop = datasize;
 583       virt_size_is_zero = true;
 584     }
 585   else if (datasize < stop)
 586       {
 587         fprintf (file,
 588                  /* xgettext:c-format */
 589                  _("Warning: %s section size (%ld) is smaller than virtual size (%ld)\n"),
 590                  pdata_section->name, (unsigned long) datasize,
 591                  (unsigned long) stop);
 592         /* Be sure not to read past datasize.  */
 593         stop = datasize;
 594       }
 595
 596   /* Display functions table.  */
 597   fprintf (file,
 598            _("\nThe Function Table (interpreted %s section contents)\n"),
 599            pdata_section->name);
 600
 601   fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
 602
 603   if (!bfd_malloc_and_get_section (abfd, pdata_section, &pdata))
 604     goto done;
 605
 606   /* Table of xdata entries.  */
 607   xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1));
 608   xdata_arr_cnt = 0;
 609
 610   if (strcmp (abfd->xvec->name, "pei-x86-64") == 0)
 611     imagebase = pe_data (abfd)->pe_opthdr.ImageBase;
 612   else
 613     imagebase = 0;
 614
 615   for (i = 0; i < stop; i += onaline)
 616     {
 617       struct pex64_runtime_function rf;
 618
 619       if (i + PDATA_ROW_SIZE > stop)
 620         break;
 621
 622       pex64_get_runtime_function (abfd, &rf, &pdata[i]);
 623
 624       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 625           && rf.rva_UnwindData == 0)
 626         /* We are probably into the padding of the section now.  */
 627         break;
 628       fprintf (file, " %016" PRIx64, i + pdata_section->vma);
 629       fprintf (file, ":\t%016" PRIx64, imagebase + rf.rva_BeginAddress);
 630       fprintf (file, " %016" PRIx64, imagebase + rf.rva_EndAddress);
 631       fprintf (file, " %016" PRIx64 "\n", imagebase + rf.rva_UnwindData);
 632       if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
 633         {
 634           seen_error = 1;
 635           fprintf (file, "  has %s begin address as predecessor\n",
 636             (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
 637         }
 638       prev_beginaddress = rf.rva_BeginAddress;
 639       /* Now we check for negative addresses.  */
 640       if ((prev_beginaddress & 0x80000000) != 0)
 641         {
 642           seen_error = 1;
 643           fprintf (file, "  has negative begin address\n");
 644         }
 645       if ((rf.rva_EndAddress & 0x80000000) != 0)
 646         {
 647           seen_error = 1;
 648           fprintf (file, "  has negative end address\n");
 649         }
 650       if ((rf.rva_UnwindData & 0x80000000) != 0)
 651         {
 652           seen_error = 1;
 653           fprintf (file, "  has negative unwind address\n");
 654         }
 655       else if ((rf.rva_UnwindData && !PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
 656                 || virt_size_is_zero)
 657         xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
 658     }
 659
 660   if (seen_error)
 661     goto done;
 662
 663   /* Add end of list marker.  */
 664   xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);
 665
 666   /* Sort start RVAs of xdata.  */
 667   if (xdata_arr_cnt > 1)
 668     qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 669            sort_xdata_arr);
 670
 671   /* Find the section containing the unwind data (.xdata).  */
 672   xdata_base = xdata_arr[0];
 673   /* For sections with long names, first look for the same
 674      section name, replacing .pdata by .xdata prefix.  */
 675   if (strcmp (pdata_section->name, ".pdata") != 0)
 676     {
 677       size_t len = strlen (pdata_section->name);
 678       char *xdata_name = xmalloc (len + 1);
 679
 680       xdata_name = memcpy (xdata_name, pdata_section->name, len + 1);
 681       /* Transform .pdata prefix into .xdata prefix.  */
 682       if (len > 1)
 683         xdata_name [1] = 'x';
 684       xdata_section = pex64_get_section_by_rva (abfd, xdata_base,
 685                                                 xdata_name);
 686       free (xdata_name);
 687     }
 688   /* Second, try the .xdata section itself.  */
 689   if (!xdata_section)
 690     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".xdata");
 691   /* Otherwise, if xdata_base is non zero, search also inside
 692      other standard sections.  */
 693   if (!xdata_section && xdata_base)
 694     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".rdata");
 695   if (!xdata_section && xdata_base)
 696     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".data");
 697   if (!xdata_section && xdata_base)
 698     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".pdata");
 699   if (!xdata_section && xdata_base)
 700     xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".text");
 701   /* Transfer xdata section into xdata array.  */
 702   if (!xdata_section
 703       || (xdata_section->flags & SEC_HAS_CONTENTS) == 0
 704       || !bfd_malloc_and_get_section (abfd, xdata_section, &xdata))
 705     goto done;
 706
 707   /* Avoid "also used "... ouput for single unwind info
 708      in object file.  */
 709   prev_unwinddata_rva = (bfd_vma) -1;
 710
 711   /* Do dump of pdata related xdata.  */
 712   for (i = 0; i < stop; i += onaline)
 713     {
 714       struct pex64_runtime_function rf;
 715
 716       if (i + PDATA_ROW_SIZE > stop)
 717         break;
 718
 719       pex64_get_runtime_function (abfd, &rf, &pdata[i]);
 720
 721       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
 722           && rf.rva_UnwindData == 0)
 723         /* We are probably into the padding of the section now.  */
 724         break;
 725       if (i == 0)
 726         fprintf (file, _("\nDump of %s\n"), xdata_section->name);
 727
 728       fprintf (file, " %016" PRIx64, rf.rva_UnwindData + imagebase);
 729
 730       if (prev_unwinddata_rva == rf.rva_UnwindData)
 731         {
 732           /* Do not dump again the xdata for the same entry.  */
 733           fprintf (file, " also used for function at %016" PRIx64 "\n",
 734                    rf.rva_BeginAddress + imagebase);
 735           continue;
 736         }
 737       else
 738         prev_unwinddata_rva = rf.rva_UnwindData;
 739
 740       fprintf (file, " (rva: %08x): %016" PRIx64 " - %016" PRIx64 "\n",
 741                (unsigned int) rf.rva_UnwindData,
 742                rf.rva_BeginAddress + imagebase,
 743                rf.rva_EndAddress + imagebase);
 744
 745       if (rf.rva_UnwindData != 0 || virt_size_is_zero)
 746         {
 747           if (PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
 748             {
 749               bfd_vma altent = PEX64_GET_UNWINDDATA_UNIFIED_RVA (&rf);
 750               bfd_vma pdata_vma = bfd_section_vma (pdata_section);
 751               struct pex64_runtime_function arf;
 752
 753               fprintf (file, "\t shares information with ");
 754               altent += imagebase;
 755
 756               if (altent >= pdata_vma
 757                   && altent - pdata_vma + PDATA_ROW_SIZE <= stop)
 758                 {
 759                   pex64_get_runtime_function
 760                     (abfd, &arf, &pdata[altent - pdata_vma]);
 761                   fprintf (file, "pdata element at 0x%016" PRIx64,
 762                            arf.rva_UnwindData);
 763                 }
 764               else
 765                 fprintf (file, "unknown pdata element");
 766               fprintf (file, ".\n");
 767             }
 768           else
 769             {
 770               bfd_vma *p;
 771
 772               /* Search for the current entry in the sorted array.  */
 773               p = (bfd_vma *)
 774                   bsearch (&rf.rva_UnwindData, xdata_arr,
 775                            (size_t) xdata_arr_cnt, sizeof (bfd_vma),
 776                            sort_xdata_arr);
 777
 778               /* Advance to the next pointer into the xdata section.  We may
 779                  have shared xdata entries, which will result in a string of
 780                  identical pointers in the array; advance past all of them.  */
 781               while (p[0] <= rf.rva_UnwindData)
 782                 ++p;
 783
 784               if (p[0] == ~((bfd_vma) 0))
 785                 p = NULL;
 786
 787               pex64_dump_xdata (file, abfd, xdata_section, xdata, p, &rf);
 788             }
 789         }
 790     }
 791
 792  done:
 793   free (pdata);
 794   free (xdata_arr);
 795   free (xdata);
 796
 797   return true;
 798 }
 799
 800 struct pex64_paps
 801 {
 802   void *obj;
 803   /* Number of found pdata sections.  */
 804   unsigned int pdata_count;
 805 };
 806
 807 /* Functionn prototype.  */
 808 bool pex64_bfd_print_pdata (bfd *, void *);
 809
 810 /* Helper function for bfd_map_over_section.  */
 811 static void
 812 pex64_print_all_pdata_sections (bfd *abfd, asection *pdata, void *arg)
 813 {
 814   struct pex64_paps *paps = arg;
 815   if (startswith (pdata->name, ".pdata"))
 816     {
 817       if (pex64_bfd_print_pdata_section (abfd, paps->obj, pdata))
 818         paps->pdata_count++;
 819     }
 820 }
 821
 822 bool
 823 pex64_bfd_print_pdata (bfd *abfd, void *vfile)
 824 {
 825   asection *pdata_section = bfd_get_section_by_name (abfd, ".pdata");
 826   struct pex64_paps paps;
 827
 828   if (pdata_section)
 829     return pex64_bfd_print_pdata_section (abfd, vfile, pdata_section);
 830
 831   paps.obj = vfile;
 832   paps.pdata_count = 0;
 833   bfd_map_over_sections (abfd, pex64_print_all_pdata_sections, &paps);
 834   return paps.pdata_count != 0;
 835 }
 836
 837 #define bfd_pe_print_pdata   pex64_bfd_print_pdata
 838 #define bfd_coff_std_swap_table bfd_coff_pei_swap_table
 839
 840 #include "coff-x86_64.c"