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