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