1 /* BFD back-end for Intel 386 PE IMAGE COFF files.
2 Copyright (C) 2006-2014 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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,
21 Written by Kai Tietz, OneVision Software GmbH&CoKg. */
26 #define TARGET_SYM x86_64pei_vec
27 #define TARGET_NAME "pei-x86-64"
28 #define COFF_IMAGE_WITH_PE
30 #define COFF_WITH_pex64
31 #define PCRELOFFSET TRUE
32 #if defined (USE_MINGW64_LEADING_UNDERSCORES)
33 #define TARGET_UNDERSCORE '_'
35 #define TARGET_UNDERSCORE 0
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)
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 }
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 */
68 #include "coff/x86_64.h"
69 #include "coff/internal.h"
73 #include "libiberty.h"
76 #define AOUTSZ PEPAOUTSZ
77 #define PEAOUTHDR PEPAOUTHDR
79 /* Name of registers according to SEH conventions. */
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"
86 /* Swap in a runtime function. */
89 pex64_get_runtime_function (bfd *abfd, struct pex64_runtime_function *rf,
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);
99 /* Swap in unwind info header. */
102 pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui, void *data)
104 struct external_pex64_unwind_info *ex_ui =
105 (struct external_pex64_unwind_info *) data;
106 bfd_byte *ex_dta = (bfd_byte *) data;
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;
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;
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;
138 /* Display unwind codes. */
141 pex64_xdata_print_uwd_codes (FILE *file, bfd *abfd,
142 struct pex64_unwind_info *ui,
143 struct pex64_runtime_function *rf)
146 unsigned int tmp; /* At least 32 bits. */
149 if (ui->CountOfCodes == 0 || ui->rawUnwindCodes == NULL)
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... */
161 && PEX64_UNWCODE_CODE (ui->rawUnwindCodes[1]) == UWOP_EPILOG)
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;
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]);
173 for (; i < ui->CountOfCodes; i++)
175 const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
178 if (PEX64_UNWCODE_CODE (dta[1]) != UWOP_EPILOG)
180 off = dta[0] | (PEX64_UNWCODE_INFO (dta[1]) << 8);
182 fprintf (file, " [pad]");
184 fprintf (file, " 0x%x", func_size - off);
189 for (; i < ui->CountOfCodes; i++)
191 const bfd_byte *dta = ui->rawUnwindCodes + 2 * i;
192 unsigned int info = PEX64_UNWCODE_INFO (dta[1]);
193 int unexpected = FALSE;
195 fprintf (file, "\t pc+0x%02x: ", (unsigned int) dta[0]);
196 switch (PEX64_UNWCODE_CODE (dta[1]))
198 case UWOP_PUSH_NONVOL:
199 fprintf (file, "push %s", pex_regs[info]);
201 case UWOP_ALLOC_LARGE:
204 tmp = bfd_get_16 (abfd, &dta[2]) * 8;
209 tmp = bfd_get_32 (abfd, &dta[2]);
212 fprintf (file, "alloc large area: rsp = rsp - 0x%x", tmp);
214 case UWOP_ALLOC_SMALL:
215 fprintf (file, "alloc small area: rsp = rsp - 0x%x", (info + 1) * 8);
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;
225 case UWOP_SAVE_NONVOL:
226 tmp = bfd_get_16 (abfd, &dta[2]) * 8;
228 fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
229 unexpected = !save_allowed;
231 case UWOP_SAVE_NONVOL_FAR:
232 tmp = bfd_get_32 (abfd, &dta[2]);
234 fprintf (file, "save %s at rsp + 0x%x", pex_regs[info], tmp);
235 unexpected = !save_allowed;
238 if (ui->Version == 1)
240 tmp = bfd_get_16 (abfd, &dta[2]) * 8;
242 fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
243 unexpected = !save_allowed;
245 else if (ui->Version == 2)
247 fprintf (file, "epilog %02x %01x", dta[0], info);
251 case UWOP_SAVE_XMM_FAR:
252 tmp = bfd_get_32 (abfd, &dta[2]) * 8;
254 fprintf (file, "save mm%u at rsp + 0x%x", info, tmp);
255 unexpected = !save_allowed;
257 case UWOP_SAVE_XMM128:
258 tmp = bfd_get_16 (abfd, &dta[2]) * 16;
260 fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
261 unexpected = !save_allowed;
263 case UWOP_SAVE_XMM128_FAR:
264 tmp = bfd_get_32 (abfd, &dta[2]) * 16;
266 fprintf (file, "save xmm%u at rsp + 0x%x", info, tmp);
267 unexpected = !save_allowed;
269 case UWOP_PUSH_MACHFRAME:
270 fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
274 fprintf (file, ",ErrorCode)");
276 fprintf (file, ", unknown(%u))", info);
279 /* Already caught by the previous scan. */
283 fprintf (file, " [Unexpected!]");
288 /* Check wether section SEC_NAME contains the xdata at address ADDR. */
291 pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
293 asection *section = bfd_get_section_by_name (abfd, sec_name);
295 bfd_size_type datasize = 0;
298 || coff_section_data (abfd, section) == NULL
299 || pei_section_data (abfd, section) == NULL)
301 vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
302 datasize = section->size;
303 if (!datasize || vsize > addr || (vsize + datasize) < addr)
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). */
313 pex64_dump_xdata (FILE *file, bfd *abfd,
314 asection *xdata_section, bfd_byte *xdata, bfd_vma *endx,
315 struct pex64_runtime_function *rf)
319 bfd_vma addr = rf->rva_UnwindData;
320 struct pex64_unwind_info ui;
322 vaddr = xdata_section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
326 end_addr = endx[0] - vaddr;
328 end_addr = (xdata_section->rawsize != 0 ?
329 xdata_section->rawsize : xdata_section->size);
332 pex64_get_unwind_info (abfd, &ui, &xdata[addr]);
334 if (ui.Version != 1 && ui.Version != 2)
337 fprintf (file, "\tVersion %u (unknown).\n",
338 (unsigned int) ui.Version);
339 for (i = 0; addr < end_addr; addr += 1, i++)
342 fprintf (file, "\t %03x:", i);
343 fprintf (file, " %02x", xdata[addr]);
345 fprintf (file, "\n");
348 fprintf (file, "\n");
352 fprintf (file, "\tVersion: %d, Flags: ", ui.Version);
355 case UNW_FLAG_NHANDLER:
356 fprintf (file, "none");
358 case UNW_FLAG_EHANDLER:
359 fprintf (file, "UNW_FLAG_EHANDLER");
361 case UNW_FLAG_UHANDLER:
362 fprintf (file, "UNW_FLAG_UHANDLER");
364 case UNW_FLAG_FHANDLER:
366 (file, "UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER");
368 case UNW_FLAG_CHAININFO:
369 fprintf (file, "UNW_FLAG_CHAININFO");
372 fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
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]);
383 pex64_xdata_print_uwd_codes (file, abfd, &ui, rf);
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");
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");
406 /* Now we need end of this xdata block. */
407 addr += ui.SizeOfBlock;
411 fprintf (file,"\tUser data:\n");
412 for (i = 0; addr < end_addr; addr += 1, i++)
415 fprintf (file, "\t %03x:", i);
416 fprintf (file, " %02x", xdata[addr]);
418 fprintf (file, "\n");
421 fprintf (file, "\n");
425 /* Helper function to sort xdata. The entries of xdata are sorted to know
426 the size of each entry. */
429 sort_xdata_arr (const void *l, const void *r)
431 const bfd_vma *lp = (const bfd_vma *) l;
432 const bfd_vma *rp = (const bfd_vma *) r;
436 return (*lp < *rp ? -1 : 1);
439 /* Display unwind tables for x86-64. */
442 pex64_bfd_print_pdata (bfd *abfd, void *vfile)
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;
452 bfd_vma prev_beginaddress = 0;
453 bfd_vma prev_unwinddata_rva = 0;
455 int onaline = PDATA_ROW_SIZE;
457 bfd_vma *xdata_arr = NULL;
461 if (pdata_section == NULL
462 || coff_section_data (abfd, pdata_section) == NULL
463 || pei_section_data (abfd, pdata_section) == NULL)
466 stop = pei_section_data (abfd, pdata_section)->virt_size;
467 if ((stop % onaline) != 0)
469 _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
470 (long) stop, onaline);
472 /* Display functions table. */
474 _("\nThe Function Table (interpreted .pdata section contents)\n"));
476 fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t UnwindData\n"));
478 if (!bfd_malloc_and_get_section (abfd, pdata_section, &pdata))
481 /* Table of xdata entries. */
482 xdata_arr = (bfd_vma *) xmalloc (sizeof (bfd_vma) * ((stop / onaline) + 1));
485 imagebase = pe_data (abfd)->pe_opthdr.ImageBase;
487 for (i = 0; i < stop; i += onaline)
489 struct pex64_runtime_function rf;
491 if (i + PDATA_ROW_SIZE > stop)
493 pex64_get_runtime_function (abfd, &rf, &pdata[i]);
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. */
500 fprintf_vma (file, i + pdata_section->vma);
501 fprintf (file, ":\t");
502 fprintf_vma (file, imagebase + rf.rva_BeginAddress);
504 fprintf_vma (file, imagebase + rf.rva_EndAddress);
506 fprintf_vma (file, imagebase + rf.rva_UnwindData);
507 fprintf (file, "\n");
508 if (i != 0 && rf.rva_BeginAddress <= prev_beginaddress)
511 fprintf (file, " has %s begin address as predecessor\n",
512 (rf.rva_BeginAddress < prev_beginaddress ? "smaller" : "same"));
514 prev_beginaddress = rf.rva_BeginAddress;
515 /* Now we check for negative addresses. */
516 if ((prev_beginaddress & 0x80000000) != 0)
519 fprintf (file, " has negative begin address\n");
521 if ((rf.rva_EndAddress & 0x80000000) != 0)
524 fprintf (file, " has negative end address\n");
526 if ((rf.rva_UnwindData & 0x80000000) != 0)
529 fprintf (file, " has negative unwind address\n");
531 if (rf.rva_UnwindData && !PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
532 xdata_arr[xdata_arr_cnt++] = rf.rva_UnwindData;
538 /* Add end of list marker. */
539 xdata_arr[xdata_arr_cnt++] = ~((bfd_vma) 0);
541 /* Sort start RVAs of xdata. */
542 if (xdata_arr_cnt > 1)
543 qsort (xdata_arr, (size_t) xdata_arr_cnt, sizeof (bfd_vma),
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");
551 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".data");
553 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".xdata");
555 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".pdata");
557 xdata_section = pex64_get_section_by_rva (abfd, xdata_base, ".text");
559 || !bfd_malloc_and_get_section (abfd, xdata_section, &xdata))
562 /* Do dump of pdata related xdata. */
563 for (i = 0; i < stop; i += onaline)
565 struct pex64_runtime_function rf;
567 if (i + PDATA_ROW_SIZE > stop)
569 pex64_get_runtime_function (abfd, &rf, &pdata[i]);
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. */
576 fprintf (file, "\nDump of .xdata\n");
579 fprintf_vma (file, rf.rva_UnwindData + imagebase);
581 if (prev_unwinddata_rva == rf.rva_UnwindData)
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);
590 prev_unwinddata_rva = rf.rva_UnwindData;
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);
599 if (rf.rva_UnwindData != 0)
601 if (PEX64_IS_RUNTIME_FUNCTION_CHAINED (&rf))
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;
607 fprintf (file, "\t shares information with ");
610 if (altent >= pdata_vma
611 && (altent + PDATA_ROW_SIZE <= pdata_vma
612 + pei_section_data (abfd, pdata_section)->virt_size))
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);
620 fprintf (file, "unknown pdata element");
621 fprintf (file, ".\n");
627 /* Search for the current entry in the sorted array. */
629 bsearch (&rf.rva_UnwindData, xdata_arr,
630 (size_t) xdata_arr_cnt, sizeof (bfd_vma),
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)
638 if (p[0] == ~((bfd_vma) 0))
641 pex64_dump_xdata (file, abfd, xdata_section, xdata, p, &rf);
654 #define bfd_pe_print_pdata pex64_bfd_print_pdata
656 #include "coff-x86_64.c"