2010-04-27 Kai Tietz <kai.tietz@onevision.com>
[external/binutils.git] / bfd / pei-x86_64.c
1 /* BFD back-end for Intel 386 PE IMAGE COFF files.
2    Copyright 2006, 2007, 2009 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_64pei_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_EXACT_MATCH (".data"), \
47   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
48 { COFF_SECTION_NAME_EXACT_MATCH (".rdata"), \
49   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
50 { COFF_SECTION_NAME_EXACT_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 static const char *pex_regs[16] = {
80   "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
81   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
82 };
83
84 static void
85 pex64_get_runtime_function (bfd *abfd, struct pex64_runtime_function *rf,
86                             const void *data)
87 {
88   const struct external_pex64_runtime_function *ex_rf =
89     (const struct external_pex64_runtime_function *) data;
90   rf->rva_BeginAddress = bfd_get_32 (abfd, ex_rf->rva_BeginAddress);
91   rf->rva_EndAddress = bfd_get_32 (abfd, ex_rf->rva_EndAddress);
92   rf->rva_UnwindData =  bfd_get_32 (abfd, ex_rf->rva_UnwindData);
93   rf->isChained = PEX64_IS_RUNTIME_FUNCTION_CHAINED (rf);
94   rf->rva_UnwindData = PEX64_GET_UNWINDDATA_UNIFIED_RVA (rf);
95 }
96
97 static void
98 pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui, void *data)
99 {
100   struct external_pex64_unwind_info *ex_ui =
101     (struct external_pex64_unwind_info *) data;
102   bfd_byte *ex_dta = (bfd_byte *) data;
103
104   memset (ui, 0, sizeof (struct pex64_unwind_info));
105   ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
106   ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
107   ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
108   ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
109   ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
110   ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
111   ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
112   ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
113   ui->rawUnwindCodes = &ex_dta[4];
114   ex_dta += ui->SizeOfBlock;
115   switch (ui->Flags)
116     {
117     case UNW_FLAG_EHANDLER:
118       ui->rva_ExceptionHandler = bfd_get_32 (abfd, ex_dta);
119       break;
120     case UNW_FLAG_UHANDLER:
121       ui->rva_TerminationHandler = bfd_get_32 (abfd, ex_dta);
122       break;
123     case UNW_FLAG_FHANDLER:
124       ui->rva_FrameHandler = bfd_get_32 (abfd, ex_dta);
125       ui->FrameHandlerArgument = bfd_get_32 (abfd, ex_dta + 4);
126       ui->SizeOfBlock += 8;
127       return;
128     case UNW_FLAG_CHAININFO:
129       ui->rva_FunctionEntry = bfd_get_32 (abfd, ex_dta);
130       ui->SizeOfBlock += 4;
131       return;
132     default:
133       return;
134     }
135   ex_dta += 4;
136   ui->SizeOfBlock += 8;
137   ui->CountOfScopes = bfd_get_32 (abfd, ex_dta);
138   ex_dta += 4;
139   ui->rawScopeEntries = ex_dta;
140   ui->SizeOfBlock += (ui->CountOfScopes * PEX64_SCOPE_ENTRY_SIZE);
141 }
142
143 static void
144 pex64_get_scope_entry (bfd *abfd, struct pex64_scope_entry *se,
145                        bfd_vma idx, const bfd_byte *x)
146 {
147   const struct external_pex64_scope_entry *ex_se;
148   x += (idx * PEX64_SCOPE_ENTRY_SIZE);
149   ex_se = (const struct external_pex64_scope_entry *) x;
150   memset (se, 0, sizeof (struct pex64_scope_entry));
151   se->rva_BeginAddress = bfd_get_32 (abfd, ex_se->rva_BeginAddress);
152   se->rva_EndAddress = bfd_get_32 (abfd, ex_se->rva_EndAddress);
153   se->rva_HandlerAddress = bfd_get_32 (abfd, ex_se->rva_HandlerAddress);
154   se->rva_JumpAddress = bfd_get_32 (abfd, ex_se->rva_JumpAddress);
155 }
156
157 static void
158 pex64_xdata_print_uwd_codes (FILE *file, struct pex64_unwind_info *ui,
159                              bfd_vma pc_addr)
160 {
161   bfd_vma i;
162   bfd_vma tmp = 0;
163   const bfd_byte *insns[256];
164   bfd_vma insns_count = 0;
165   const bfd_byte *dta = ui->rawUnwindCodes;
166
167   if (ui->CountOfCodes == 0 || !dta)
168     return;
169
170   /* Sort array ascending. Note: it is stored in reversed order.  */
171   for (i = 0; i < ui->CountOfCodes; i++)
172     {
173       const bfd_byte *t;
174
175       t = insns[insns_count++] = &dta[i * 2];
176       switch (PEX64_UNWCODE_CODE (t[1]))
177         {
178         case UWOP_PUSH_NONVOL:
179         case UWOP_ALLOC_SMALL:
180         case UWOP_SET_FPREG:
181         case UWOP_PUSH_MACHFRAME:
182           break;
183         case UWOP_ALLOC_LARGE:
184           if (PEX64_UNWCODE_INFO (t[1]) == 0)
185             {
186               i += 1;
187               break;
188             }
189           else if (PEX64_UNWCODE_INFO (t[1]) == 1)
190             {
191               i += 2;
192               break;
193             }
194           /* fall through.  */
195         default:
196           fprintf (file, "\t contains unknown code (%u).\n",
197                    (unsigned int) PEX64_UNWCODE_CODE (t[1]));
198           return;
199         case UWOP_SAVE_NONVOL:
200         case UWOP_SAVE_XMM:
201         case UWOP_SAVE_XMM128:
202           i++;
203           break;
204         case UWOP_SAVE_NONVOL_FAR:
205         case UWOP_SAVE_XMM_FAR:
206         case UWOP_SAVE_XMM128_FAR:
207           i += 2;
208           break;
209         }
210     }
211   fprintf (file, "\t At pc 0x");
212   fprintf_vma (file, pc_addr);
213   fprintf (file, " there are the following saves (in logical order).\n");
214   for (i = insns_count; i > 0;)
215     {
216       --i;
217       dta = insns[i];
218       fprintf (file, "\t  insn ends at pc+0x%02x: ", (unsigned int) dta[0]);
219       switch (PEX64_UNWCODE_CODE (dta[1]))
220         {
221         case UWOP_PUSH_NONVOL:
222           fprintf (file, "push %s.\n", pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
223           break;
224         case UWOP_ALLOC_LARGE:
225           if (PEX64_UNWCODE_INFO (dta[1]) == 0)
226             {
227               tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
228               tmp *= 8;
229             }
230           else
231             tmp = (bfd_vma) (*((unsigned int *)&dta[2]));
232           fprintf (file, "save stack region of size 0x");
233           fprintf_vma (file, tmp);
234           fprintf (file,".\n");
235           break;
236         case UWOP_ALLOC_SMALL:
237           tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
238           tmp += 1;
239           tmp *= 8;
240           fprintf (file, "save stack region of size 0x");
241           fprintf_vma (file, tmp);
242           fprintf (file,".\n");
243           break;
244         case UWOP_SET_FPREG:
245           tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
246           tmp *= 16;
247           fprintf (file, "FPReg = (FrameReg) + 0x");
248           fprintf_vma (file, tmp);
249           fprintf (file, ".\n");
250           break;
251         case UWOP_SAVE_NONVOL:
252           fprintf (file, "mov %s at 0x",
253                    pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
254           tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
255           tmp *= 8;
256           fprintf_vma (file, tmp);
257           fprintf (file, ".\n");
258           break;
259         case UWOP_SAVE_NONVOL_FAR:
260           fprintf (file, "mov %s at 0x",
261                    pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
262           tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
263           fprintf_vma (file, tmp);
264           fprintf (file, ".\n");
265           break;
266         case UWOP_SAVE_XMM:
267           tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
268           tmp *= 8;
269           fprintf (file, "mov mm%u at 0x",
270                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
271           fprintf_vma (file, tmp);
272           fprintf (file, ".\n");
273           break;
274         case UWOP_SAVE_XMM_FAR:
275           tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
276           fprintf (file, "mov mm%u at 0x",
277                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
278           fprintf_vma (file, tmp);
279           fprintf (file, ".\n");
280           break;
281         case UWOP_SAVE_XMM128:
282           tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
283           tmp *= 16;
284           fprintf (file, "mov xmm%u at 0x",
285                    (unsigned int) PEX64_UNWCODE_INFO ( dta[1]));
286           fprintf_vma (file, tmp);
287           fprintf (file, ".\n");
288           break;
289         case UWOP_SAVE_XMM128_FAR:
290           tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
291           fprintf (file, "mov xmm%u at 0x",
292                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
293           fprintf_vma (file, tmp);
294           fprintf (file, ".\n");
295           break;
296         case UWOP_PUSH_MACHFRAME:
297           fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
298           if (PEX64_UNWCODE_INFO (dta[1]) == 0)
299             {
300               fprintf (file, ")");
301             }
302           else if (PEX64_UNWCODE_INFO (dta[1]) == 1)
303             {
304               fprintf (file, ",ErrorCode)");
305             }
306           else
307             fprintf (file, ", unknown(%u))",
308                      (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
309           fprintf (file,".\n");
310           break;
311         default:
312           fprintf (file, "unknown code %u.\n",
313                    (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
314           break;
315       }
316     }
317 }
318
319 static asection *
320 pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
321 {
322   asection *section = bfd_get_section_by_name (abfd, sec_name);
323   bfd_vma vsize;
324   bfd_size_type datasize = 0;
325
326   if (section == NULL
327       || coff_section_data (abfd, section) == NULL
328       || pei_section_data (abfd, section) == NULL)
329     return NULL;
330   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
331   datasize = section->size;
332   if (!datasize || vsize > addr || (vsize + datasize) < addr)
333     return NULL;
334   return section;
335 }
336
337 static void
338 pex64_dump_xdata (FILE *file, bfd *abfd, bfd_vma addr, bfd_vma pc_addr)
339 {
340   asection *section = pex64_get_section_by_rva (abfd, addr, ".rdata");
341   bfd_vma vsize;
342   bfd_byte *data = NULL;
343   bfd_vma i;
344
345   if (!section)
346     section = pex64_get_section_by_rva (abfd, addr, ".data");
347   if (!section)
348     section = pex64_get_section_by_rva (abfd, addr, ".xdata");
349   if (!section)
350     {
351       section = pex64_get_section_by_rva (abfd, addr, ".pdata");
352       if (section)
353         {
354           fprintf (file, "\t Shares information with pdata element at 0x");
355           fprintf_vma (file, addr + pe_data (abfd)->pe_opthdr.ImageBase);
356           fprintf (file, ".\n");
357         }
358     }
359   if (!section)
360     return;
361   vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
362   addr -= vsize;
363   if (bfd_malloc_and_get_section (abfd, section, &data))
364     {
365       struct pex64_unwind_info ui;
366
367       if (!data)
368         return;
369
370       pex64_get_unwind_info (abfd, &ui, &data[addr]);
371
372       if (ui.Version != 1)
373         {
374           fprintf (file, "\tVersion %u (unknown).\n", (unsigned int) ui.Version);
375           return;
376         }
377
378       fprintf (file, "\tFlags: ");
379       switch (ui.Flags)
380         {
381         case UNW_FLAG_NHANDLER:
382           fprintf (file, "UNW_FLAG_NHANDLER");
383           break;
384         case UNW_FLAG_EHANDLER:
385           fprintf (file, "UNW_FLAG_EHANDLER");
386           break;
387         case UNW_FLAG_UHANDLER:
388           fprintf (file, "UNW_FLAG_UHANDLER");
389           break;
390         case UNW_FLAG_FHANDLER:
391           fprintf (file, "UNW_FLAG_FHANDLER = (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER)");
392           break;
393         case UNW_FLAG_CHAININFO:
394           fprintf (file, "UNW_FLAG_CHAININFO");
395           break;
396         default:
397           fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
398           break;
399         }
400       fprintf (file, ".\n");
401       if (ui.CountOfCodes != 0)
402         fprintf (file, "\tEntry has %u codes.", (unsigned int) ui.CountOfCodes);
403       fprintf (file, "\tPrologue size: %u, Frame offset = 0x%x.\n",
404                (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
405       fprintf (file, "\tFrame register is %s.\n",
406         ui.FrameRegister == 0 ? "CFA"
407                               : pex_regs[(unsigned int) ui.FrameRegister]);
408
409       pex64_xdata_print_uwd_codes (file, &ui, pc_addr);
410       
411       switch (ui.Flags)
412         {
413         case UNW_FLAG_NHANDLER:
414           return;
415         case UNW_FLAG_EHANDLER:
416           fprintf (file, "\texception_handler at 0x%x.\n", (unsigned int) ui.rva_ExceptionHandler);
417           break;
418         case UNW_FLAG_UHANDLER:
419           fprintf (file, "\ttermination_handler at 0x%x.\n", (unsigned int) ui.rva_TerminationHandler);
420         case UNW_FLAG_FHANDLER:
421           fprintf (file, "\tframe_handler at 0x%x.\n", (unsigned int) ui.rva_FrameHandler);
422           fprintf (file, "\t Argument for FrameHandler: 0x%x.\n",
423                    (unsigned int) ui.FrameHandlerArgument);
424           return;
425         case UNW_FLAG_CHAININFO:
426           fprintf (file, "\t Function Entry: 0x%x\n", (unsigned int) ui.rva_FunctionEntry);
427           return;
428         default:
429           fprintf (file, "\t Unknown flag value of 0x%x\n", (unsigned int) ui.Flags);
430           return;
431         }
432       fprintf (file, "\t 0x%x # of scope(s)\n", (unsigned int) ui.CountOfScopes);
433       for (i = 0; i < ui.CountOfScopes; i++)
434         {
435           struct pex64_scope_entry se;
436           pex64_get_scope_entry (abfd, &se, i, ui.rawScopeEntries);
437           fprintf (file, "\t scope #%u: BeginAddress: 0x%x, EndAddress: 0x%x,"
438                    "\n\t\tHandlerAddress:0x%x, JumpTarget:0x%x\n",
439                    (unsigned int) (i + 1),
440                    (unsigned int) se.rva_BeginAddress,
441                    (unsigned int) se.rva_EndAddress,
442                    (unsigned int) se.rva_HandlerAddress,
443                    (unsigned int) se.rva_JumpAddress);
444         }
445     }
446   if (data != NULL)
447     free (data);
448 }
449
450 static bfd_boolean
451 pex64_bfd_print_pdata (bfd *abfd, void *vfile)
452 {
453   FILE *file = (FILE *) vfile;
454   bfd_byte *data = NULL;
455   asection *section = bfd_get_section_by_name (abfd, ".pdata");
456   bfd_size_type datasize = 0;
457   bfd_size_type i;
458   bfd_size_type start, stop;
459   int onaline = PDATA_ROW_SIZE;
460
461   if (section == NULL
462       || coff_section_data (abfd, section) == NULL
463       || pei_section_data (abfd, section) == NULL)
464     return TRUE;
465
466   stop = pei_section_data (abfd, 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   fprintf (file,
473            _("\nThe Function Table (interpreted .pdata section contents)\n"));
474
475   fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
476
477   datasize = section->size;
478   if (datasize == 0)
479     return TRUE;
480
481   if (!bfd_malloc_and_get_section (abfd, section, &data))
482     {
483       if (data != NULL)
484         free (data);
485       return FALSE;
486     }
487
488   start = 0;
489
490   for (i = start; i < stop; i += onaline)
491     {
492       struct pex64_runtime_function rf;
493
494       if (i + PDATA_ROW_SIZE > stop)
495         break;
496       pex64_get_runtime_function (abfd, &rf, &data[i]);
497
498       if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
499           && rf.rva_UnwindData == 0)
500         /* We are probably into the padding of the section now.  */
501         break;
502
503       fputc (' ', file);
504       fprintf_vma (file, i + section->vma);
505       fprintf (file, ":\t");
506       rf.rva_BeginAddress += pe_data (abfd)->pe_opthdr.ImageBase;
507       fprintf_vma (file, rf.rva_BeginAddress);
508       fputc (' ', file);
509       rf.rva_EndAddress += pe_data (abfd)->pe_opthdr.ImageBase;
510       fprintf_vma (file, rf.rva_EndAddress);
511       fputc (' ', file);
512       fprintf_vma (file, rf.rva_UnwindData);
513       fprintf (file, "\n");
514
515       if (rf.rva_UnwindData != 0)
516         {
517           if (rf.isChained)
518             {
519               fprintf (file, "\t shares information with pdata element at 0x");
520               fprintf_vma (file, rf.rva_UnwindData + pe_data (abfd)->pe_opthdr.ImageBase);
521               fprintf (file, ".\n");
522             }
523           else
524             pex64_dump_xdata (file, abfd, rf.rva_UnwindData, rf.rva_BeginAddress);
525         }
526     }
527
528   free (data);
529
530   return TRUE;
531 }
532
533 #define bfd_pe_print_pdata   pex64_bfd_print_pdata
534
535 #include "coff-x86_64.c"