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 if ((stop % onaline) != 0) 468 fprintf (file, 469 _("warning: .pdata section size (%ld) is not a multiple of %d\n"), 470 (long) stop, onaline); 471 472 /* Display functions table. */ 473 fprintf (file, 474 _("\nThe Function Table (interpreted .pdata section contents)\n")); 475 476 fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t UnwindData\n")); 477 478 if (!bfd_malloc_and_get_section (abfd, pdata_section, &pdata)) 479 goto done; 480 481 /* Table of xdata entries. */ 482 xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1)); 483 xdata_arr_cnt = 0; 484 485 imagebase = pe_data (abfd)->pe_opthdr.ImageBase; 486 487 for (i = 0; i < stop; i += onaline) 488 { 489 struct pex64_runtime_function rf; 490 491 if (i + PDATA_ROW_SIZE > stop) 492 break; 493 pex64_get_runtime_function (abfd, &rf, &pdata[i]); 494 495 if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0 496 && rf.rva_UnwindData == 0) 497 /* We are probably into the padding of the section now. */ 498 break; 499 fputc (' ', file); 500 fprintf_vma (file, i + pdata_section->vma); 501 fprintf (file, ":\t"); 502 fprintf_vma (file, imagebase + rf.rva_BeginAddress); 503 fprintf (file, " "); 504 fprintf_vma (file, imagebase + rf.rva_EndAddress); 505 fprintf (file, " "); 506 fprintf_vma (file, imagebase + rf.rva_UnwindData); 507 fprintf (file, "\n"); 508 if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress) 509 { 510 seen_error = 1; 511 fprintf (file, " has %s begin address as predecessor\n", 512 (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same")); 513 } 514 prev_beginaddress = rf.rva_BeginAddress; 515 /* Now we check for negative addresses. */ 516 if ((prev_beginaddress & 0x80000000) != 0) 517 { 518 seen_error = 1; 519 fprintf (file, " has negative begin address\n"); 520 } 521 if ((rf.rva_EndAddress & 0x80000000) != 0) 522 { 523 seen_error = 1; 524 fprintf (file, " has negative end address\n"); 525 } 526 if ((rf.rva_UnwindData & 0x80000000) != 0) 527 { 528 seen_error = 1; 529 fprintf (file, " has negative unwind address\n"); 530 } 531 if (rf.rva_UnwindData && !PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf)) 532 xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData; 533 } 534 535 if (seen_error) 536 goto done; 537 538 /* Add end of list marker. */ 539 xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0); 540 541 /* Sort start RVAs of xdata. */ 542 if (xdata_arr_cnt > 1) 543 qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma), 544 sort_xdata_arr); 545 546 /* Find the section containing the unwind data (.xdata). */ 547 xdata_base = xdata_arr[0]; 548 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".rdata"); 549 550 if (!xdata_section) 551 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".data"); 552 if (!xdata_section) 553 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".xdata"); 554 if (!xdata_section) 555 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".pdata"); 556 if (!xdata_section) 557 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".text"); 558 if (!xdata_section 559 || !bfd_malloc_and_get_section (abfd, xdata_section, &xdata)) 560 goto done; 561 562 /* Do dump of pdata related xdata. */ 563 for (i = 0; i < stop; i += onaline) 564 { 565 struct pex64_runtime_function rf; 566 567 if (i + PDATA_ROW_SIZE > stop) 568 break; 569 pex64_get_runtime_function (abfd, &rf, &pdata[i]); 570 571 if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0 572 && rf.rva_UnwindData == 0) 573 /* We are probably into the padding of the section now. */ 574 break; 575 if (i == 0) 576 fprintf (file, "\nDump of .xdata\n"); 577 578 fputc (' ', file); 579 fprintf_vma (file, rf.rva_UnwindData + imagebase); 580 581 if (prev_unwinddata_rva == rf.rva_UnwindData) 582 { 583 /* Do not dump again the xdata for the same entry. */ 584 fprintf (file, " also used for function at "); 585 fprintf_vma (file, rf.rva_BeginAddress + imagebase); 586 fputc ('\n', file); 587 continue; 588 } 589 else 590 prev_unwinddata_rva = rf.rva_UnwindData; 591 592 fprintf (file, " (rva: %08x): ", 593 (unsigned int) rf.rva_UnwindData); 594 fprintf_vma (file, rf.rva_BeginAddress + imagebase); 595 fprintf (file, " - "); 596 fprintf_vma (file, rf.rva_EndAddress + imagebase); 597 fputc ('\n', file); 598 599 if (rf.rva_UnwindData != 0) 600 { 601 if (PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf)) 602 { 603 bfd_vma altent = PEX64_GET_UNWINDDATA_UNIFIED_RVA (&rf); 604 bfd_vma pdata_vma = bfd_get_section_vma (abfd, pdata_section); 605 struct pex64_runtime_function arf; 606 607 fprintf (file, "\t shares information with "); 608 altent += imagebase; 609 610 if (altent >= pdata_vma 611 && (altent + PDATA_ROW_SIZE <= pdata_vma 612 + pei_section_data (abfd, pdata_section)->virt_size)) 613 { 614 pex64_get_runtime_function 615 (abfd, &arf, &pdata[altent - pdata_vma]); 616 fprintf (file, "pdata element at 0x"); 617 fprintf_vma (file, arf.rva_UnwindData); 618 } 619 else 620 fprintf (file, "unknown pdata element"); 621 fprintf (file, ".\n"); 622 } 623 else 624 { 625 bfd_vma *p; 626 627 /* Search for the current entry in the sorted array. */ 628 p = (bfd_vma *) 629 bsearch (&rf.rva_UnwindData, xdata_arr, 630 (size_t) xdata_arr_cnt, sizeof (bfd_vma), 631 sort_xdata_arr); 632 633 /* Advance to the next pointer into the xdata section. We may 634 have shared xdata entries, which will result in a string of 635 identical pointers in the array; advance past all of them. */ 636 while (p[0] <= rf.rva_UnwindData) 637 ++p; 638 if (p[0] == ~((bfd_vma) 0)) 639 p = NULL; 640 641 pex64_dump_xdata (file, abfd, xdata_section, xdata, p, &rf); 642 } 643 } 644 } 645 646 done: 647 free (pdata); 648 free (xdata_arr); 649 free (xdata); 650 651 return TRUE; 652 } 653 654 #define bfd_pe_print_pdata pex64_bfd_print_pdata 655 656 #include "coff-x86_64.c" 657
