projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix PR10373 which is SH relax bug.
[deliverable/binutils-gdb.git] / gdb / amd64-windows-tdep.c
CommitLineData
ecd75fc8 1/* Copyright (C) 2009-2014 Free Software Foundation, Inc.
d0761299
JB		 2
3 This file is part of GDB.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17
18#include "defs.h"
19#include "osabi.h"
20#include "amd64-tdep.h"
ba581dc1 21#include "gdbtypes.h"
cba6fab5
JB		 22#include "gdbcore.h"
23#include "regcache.h"
a8e1bb34 24#include "windows-tdep.h"
84552b16 25#include "frame.h"
9058cc3a
TG		 26#include "objfiles.h"
27#include "frame-unwind.h"
28#include "coff/internal.h"
29#include "coff/i386.h"
30#include "coff/pe.h"
31#include "libcoff.h"
20c2e3e0 32#include "value.h"
ba581dc1
JB		 33
34/* The registers used to pass integer arguments during a function call. */
35static int amd64_windows_dummy_call_integer_regs[] =
36{
37 AMD64_RCX_REGNUM, /* %rcx */
38 AMD64_RDX_REGNUM, /* %rdx */
5b856f36
PM		 39 AMD64_R8_REGNUM, /* %r8 */
40 AMD64_R9_REGNUM /* %r9 */
ba581dc1
JB		 41};
42
20c2e3e0
JB		 43/* Return nonzero if an argument of type TYPE should be passed
44 via one of the integer registers. */
ba581dc1 45
20c2e3e0
JB		 46static int
47amd64_windows_passed_by_integer_register (struct type *type)
ba581dc1
JB		 48{
49 switch (TYPE_CODE (type))
50 {
20c2e3e0
JB		 51 case TYPE_CODE_INT:
52 case TYPE_CODE_ENUM:
53 case TYPE_CODE_BOOL:
54 case TYPE_CODE_RANGE:
55 case TYPE_CODE_CHAR:
56 case TYPE_CODE_PTR:
57 case TYPE_CODE_REF:
ba581dc1
JB		 58 case TYPE_CODE_STRUCT:
59 case TYPE_CODE_UNION:
20c2e3e0
JB		 60 return (TYPE_LENGTH (type) == 1
61 || TYPE_LENGTH (type) == 2
62 || TYPE_LENGTH (type) == 4
63 || TYPE_LENGTH (type) == 8);
ba581dc1
JB		 64
65 default:
20c2e3e0 66 return 0;
ba581dc1
JB		 67 }
68}
d0761299 69
20c2e3e0
JB		 70/* Return nonzero if an argument of type TYPE should be passed
71 via one of the XMM registers. */
72
73static int
74amd64_windows_passed_by_xmm_register (struct type *type)
75{
76 return ((TYPE_CODE (type) == TYPE_CODE_FLT
77 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
78 && (TYPE_LENGTH (type) == 4 || TYPE_LENGTH (type) == 8));
79}
80
81/* Return non-zero iff an argument of the given TYPE should be passed
82 by pointer. */
83
84static int
85amd64_windows_passed_by_pointer (struct type *type)
86{
87 if (amd64_windows_passed_by_integer_register (type))
88 return 0;
89
90 if (amd64_windows_passed_by_xmm_register (type))
91 return 0;
92
93 return 1;
94}
95
96/* For each argument that should be passed by pointer, reserve some
97 stack space, store a copy of the argument on the stack, and replace
98 the argument by its address. Return the new Stack Pointer value.
99
100 NARGS is the number of arguments. ARGS is the array containing
101 the value of each argument. SP is value of the Stack Pointer. */
102
103static CORE_ADDR
104amd64_windows_adjust_args_passed_by_pointer (struct value **args,
105 int nargs, CORE_ADDR sp)
106{
107 int i;
108
109 for (i = 0; i < nargs; i++)
110 if (amd64_windows_passed_by_pointer (value_type (args[i])))
111 {
112 struct type *type = value_type (args[i]);
113 const gdb_byte *valbuf = value_contents (args[i]);
114 const int len = TYPE_LENGTH (type);
115
116 /* Store a copy of that argument on the stack, aligned to
117 a 16 bytes boundary, and then use the copy's address as
118 the argument. */
119
120 sp -= len;
121 sp &= ~0xf;
122 write_memory (sp, valbuf, len);
123
124 args[i]
125 = value_addr (value_from_contents_and_address (type, valbuf, sp));
126 }
127
128 return sp;
129}
130
131/* Store the value of ARG in register REGNO (right-justified).
132 REGCACHE is the register cache. */
133
134static void
135amd64_windows_store_arg_in_reg (struct regcache *regcache,
136 struct value *arg, int regno)
137{
138 struct type *type = value_type (arg);
139 const gdb_byte *valbuf = value_contents (arg);
140 gdb_byte buf[8];
141
142 gdb_assert (TYPE_LENGTH (type) <= 8);
143 memset (buf, 0, sizeof buf);
144 memcpy (buf, valbuf, min (TYPE_LENGTH (type), 8));
145 regcache_cooked_write (regcache, regno, buf);
146}
147
148/* Push the arguments for an inferior function call, and return
149 the updated value of the SP (Stack Pointer).
150
151 All arguments are identical to the arguments used in
152 amd64_windows_push_dummy_call. */
153
154static CORE_ADDR
155amd64_windows_push_arguments (struct regcache *regcache, int nargs,
156 struct value **args, CORE_ADDR sp,
157 int struct_return)
158{
159 int reg_idx = 0;
160 int i;
161 struct value **stack_args = alloca (nargs * sizeof (struct value *));
162 int num_stack_args = 0;
163 int num_elements = 0;
164 int element = 0;
165
166 /* First, handle the arguments passed by pointer.
167
168 These arguments are replaced by pointers to a copy we are making
169 in inferior memory. So use a copy of the ARGS table, to avoid
170 modifying the original one. */
171 {
172 struct value **args1 = alloca (nargs * sizeof (struct value *));
173
174 memcpy (args1, args, nargs * sizeof (struct value *));
175 sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp);
176 args = args1;
177 }
178
179 /* Reserve a register for the "hidden" argument. */
180 if (struct_return)
181 reg_idx++;
182
183 for (i = 0; i < nargs; i++)
184 {
185 struct type *type = value_type (args[i]);
186 int len = TYPE_LENGTH (type);
187 int on_stack_p = 1;
188
189 if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs))
190 {
191 if (amd64_windows_passed_by_integer_register (type))
192 {
193 amd64_windows_store_arg_in_reg
194 (regcache, args[i],
195 amd64_windows_dummy_call_integer_regs[reg_idx]);
196 on_stack_p = 0;
197 reg_idx++;
198 }
199 else if (amd64_windows_passed_by_xmm_register (type))
200 {
201 amd64_windows_store_arg_in_reg
202 (regcache, args[i], AMD64_XMM0_REGNUM + reg_idx);
203 /* In case of varargs, these parameters must also be
204 passed via the integer registers. */
205 amd64_windows_store_arg_in_reg
206 (regcache, args[i],
207 amd64_windows_dummy_call_integer_regs[reg_idx]);
208 on_stack_p = 0;
209 reg_idx++;
210 }
211 }
212
213 if (on_stack_p)
214 {
215 num_elements += ((len + 7) / 8);
216 stack_args[num_stack_args++] = args[i];
217 }
218 }
219
220 /* Allocate space for the arguments on the stack, keeping it
221 aligned on a 16 byte boundary. */
222 sp -= num_elements * 8;
223 sp &= ~0xf;
224
225 /* Write out the arguments to the stack. */
226 for (i = 0; i < num_stack_args; i++)
227 {
228 struct type *type = value_type (stack_args[i]);
229 const gdb_byte *valbuf = value_contents (stack_args[i]);
230
231 write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type));
232 element += ((TYPE_LENGTH (type) + 7) / 8);
233 }
234
235 return sp;
236}
237
238/* Implement the "push_dummy_call" gdbarch method. */
239
240static CORE_ADDR
241amd64_windows_push_dummy_call
242 (struct gdbarch *gdbarch, struct value *function,
243 struct regcache *regcache, CORE_ADDR bp_addr,
244 int nargs, struct value **args,
245 CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
246{
247 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
248 gdb_byte buf[8];
249
250 /* Pass arguments. */
251 sp = amd64_windows_push_arguments (regcache, nargs, args, sp,
252 struct_return);
253
254 /* Pass "hidden" argument". */
255 if (struct_return)
256 {
257 /* The "hidden" argument is passed throught the first argument
258 register. */
259 const int arg_regnum = amd64_windows_dummy_call_integer_regs[0];
260
261 store_unsigned_integer (buf, 8, byte_order, struct_addr);
262 regcache_cooked_write (regcache, arg_regnum, buf);
263 }
264
265 /* Reserve some memory on the stack for the integer-parameter
266 registers, as required by the ABI. */
267 sp -= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs) * 8;
268
269 /* Store return address. */
270 sp -= 8;
271 store_unsigned_integer (buf, 8, byte_order, bp_addr);
272 write_memory (sp, buf, 8);
273
274 /* Update the stack pointer... */
275 store_unsigned_integer (buf, 8, byte_order, sp);
276 regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);
277
278 /* ...and fake a frame pointer. */
279 regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);
280
281 return sp + 16;
282}
283
cba6fab5
JB		 284/* Implement the "return_value" gdbarch method for amd64-windows. */
285
286static enum return_value_convention
6a3a010b 287amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
cba6fab5
JB		 288 struct type *type, struct regcache *regcache,
289 gdb_byte *readbuf, const gdb_byte *writebuf)
290{
291 int len = TYPE_LENGTH (type);
292 int regnum = -1;
293
294 /* See if our value is returned through a register. If it is, then
295 store the associated register number in REGNUM. */
296 switch (TYPE_CODE (type))
297 {
298 case TYPE_CODE_FLT:
299 case TYPE_CODE_DECFLOAT:
300 /* __m128, __m128i, __m128d, floats, and doubles are returned
301 via XMM0. */
302 if (len == 4 || len == 8 || len == 16)
303 regnum = AMD64_XMM0_REGNUM;
304 break;
305 default:
306 /* All other values that are 1, 2, 4 or 8 bytes long are returned
307 via RAX. */
308 if (len == 1 || len == 2 || len == 4 || len == 8)
309 regnum = AMD64_RAX_REGNUM;
310 break;
311 }
312
313 if (regnum < 0)
314 {
315 /* RAX contains the address where the return value has been stored. */
316 if (readbuf)
317 {
318 ULONGEST addr;
319
320 regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr);
321 read_memory (addr, readbuf, TYPE_LENGTH (type));
322 }
323 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
324 }
325 else
326 {
327 /* Extract the return value from the register where it was stored. */
328 if (readbuf)
329 regcache_raw_read_part (regcache, regnum, 0, len, readbuf);
330 if (writebuf)
331 regcache_raw_write_part (regcache, regnum, 0, len, writebuf);
332 return RETURN_VALUE_REGISTER_CONVENTION;
333 }
334}
335
99e24b90
PM		 336/* Check that the code pointed to by PC corresponds to a call to
337 __main, skip it if so. Return PC otherwise. */
338
339static CORE_ADDR
340amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
341{
342 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
343 gdb_byte op;
344
345 target_read_memory (pc, &op, 1);
346 if (op == 0xe8)
347 {
348 gdb_byte buf[4];
349
350 if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
351 {
7cbd4a93 352 struct bound_minimal_symbol s;
99e24b90
PM		 353 CORE_ADDR call_dest;
354
355 call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
356 s = lookup_minimal_symbol_by_pc (call_dest);
7cbd4a93 357 if (s.minsym != NULL
efd66ac6
TT		 358 && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
359 && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
99e24b90
PM		 360 pc += 5;
361 }
362 }
363
364 return pc;
365}
366
9058cc3a
TG		 367struct amd64_windows_frame_cache
368{
369 /* ImageBase for the module. */
370 CORE_ADDR image_base;
371
372 /* Function start and end rva. */
373 CORE_ADDR start_rva;
374 CORE_ADDR end_rva;
375
376 /* Next instruction to be executed. */
377 CORE_ADDR pc;
378
379 /* Current sp. */
380 CORE_ADDR sp;
381
382 /* Address of saved integer and xmm registers. */
383 CORE_ADDR prev_reg_addr[16];
384 CORE_ADDR prev_xmm_addr[16];
385
386 /* These two next fields are set only for machine info frames. */
387
388 /* Likewise for RIP. */
389 CORE_ADDR prev_rip_addr;
390
391 /* Likewise for RSP. */
392 CORE_ADDR prev_rsp_addr;
393
394 /* Address of the previous frame. */
395 CORE_ADDR prev_sp;
396};
397
398/* Convert a Windows register number to gdb. */
399static const enum amd64_regnum amd64_windows_w2gdb_regnum[] =
400{
401 AMD64_RAX_REGNUM,
402 AMD64_RCX_REGNUM,
403 AMD64_RDX_REGNUM,
404 AMD64_RBX_REGNUM,
405 AMD64_RSP_REGNUM,
406 AMD64_RBP_REGNUM,
407 AMD64_RSI_REGNUM,
408 AMD64_RDI_REGNUM,
409 AMD64_R8_REGNUM,
410 AMD64_R9_REGNUM,
411 AMD64_R10_REGNUM,
412 AMD64_R11_REGNUM,
413 AMD64_R12_REGNUM,
414 AMD64_R13_REGNUM,
415 AMD64_R14_REGNUM,
416 AMD64_R15_REGNUM
417};
418
419/* Return TRUE iff PC is the the range of the function corresponding to
420 CACHE. */
421
422static int
423pc_in_range (CORE_ADDR pc, const struct amd64_windows_frame_cache *cache)
424{
425 return (pc >= cache->image_base + cache->start_rva
426 && pc < cache->image_base + cache->end_rva);
427}
428
429/* Try to recognize and decode an epilogue sequence.
430
431 Return -1 if we fail to read the instructions for any reason.
432 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
433
434static int
435amd64_windows_frame_decode_epilogue (struct frame_info *this_frame,
436 struct amd64_windows_frame_cache *cache)
437{
438 /* According to MSDN an epilogue "must consist of either an add RSP,constant
439 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
440 register pops and a return or a jmp".
441
442 Furthermore, according to RtlVirtualUnwind, the complete list of
443 epilog marker is:
444 - ret [c3]
445 - ret n [c2 imm16]
446 - rep ret [f3 c3]
447 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
448 - jmp qword ptr imm32 - not handled
449 - rex.w jmp reg [4X ff eY]
450 */
451
452 CORE_ADDR pc = cache->pc;
453 CORE_ADDR cur_sp = cache->sp;
454 struct gdbarch *gdbarch = get_frame_arch (this_frame);
455 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
456 gdb_byte op;
457 gdb_byte rex;
458
459 /* We don't care about the instruction deallocating the frame:
460 if it hasn't been executed, the pc is still in the body,
461 if it has been executed, the following epilog decoding will work. */
462
463 /* First decode:
464 - pop reg [41 58-5f] or [58-5f]. */
465
466 while (1)
467 {
468 /* Read opcode. */
469 if (target_read_memory (pc, &op, 1) != 0)
470 return -1;
471
472 if (op >= 0x40 && op <= 0x4f)
473 {
474 /* REX prefix. */
475 rex = op;
476
477 /* Read opcode. */
478 if (target_read_memory (pc + 1, &op, 1) != 0)
479 return -1;
480 }
481 else
482 rex = 0;
483
484 if (op >= 0x58 && op <= 0x5f)
485 {
486 /* pop reg */
487 gdb_byte reg = (op & 0x0f) | ((rex & 1) << 3);
488
489 cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp;
490 cur_sp += 8;
491 }
492 else
493 break;
494
495 /* Allow the user to break this loop. This shouldn't happen as the
496 number of consecutive pop should be small. */
497 QUIT;
498 }
499
500 /* Then decode the marker. */
501
502 /* Read opcode. */
503 if (target_read_memory (pc, &op, 1) != 0)
504 return -1;
505
506 switch (op)
507 {
508 case 0xc3:
509 /* Ret. */
510 cache->prev_rip_addr = cur_sp;
511 cache->prev_sp = cur_sp + 8;
512 return 1;
513
514 case 0xeb:
515 {
516 /* jmp rel8 */
517 gdb_byte rel8;
518 CORE_ADDR npc;
519
520 if (target_read_memory (pc + 1, &rel8, 1) != 0)
521 return -1;
522 npc = pc + 2 + (signed char) rel8;
523
524 /* If the jump is within the function, then this is not a marker,
525 otherwise this is a tail-call. */
526 return !pc_in_range (npc, cache);
527 }
528
529 case 0xec:
530 {
531 /* jmp rel32 */
532 gdb_byte rel32[4];
533 CORE_ADDR npc;
534
535 if (target_read_memory (pc + 1, rel32, 4) != 0)
536 return -1;
537 npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);
538
539 /* If the jump is within the function, then this is not a marker,
540 otherwise this is a tail-call. */
541 return !pc_in_range (npc, cache);
542 }
543
544 case 0xc2:
545 {
546 /* ret n */
547 gdb_byte imm16[2];
548
549 if (target_read_memory (pc + 1, imm16, 2) != 0)
550 return -1;
551 cache->prev_rip_addr = cur_sp;
552 cache->prev_sp = cur_sp
553 + extract_unsigned_integer (imm16, 4, byte_order);
554 return 1;
555 }
556
557 case 0xf3:
558 {
559 /* rep; ret */
560 gdb_byte op1;
561
562 if (target_read_memory (pc + 2, &op1, 1) != 0)
563 return -1;
564 if (op1 != 0xc3)
565 return 0;
566
567 cache->prev_rip_addr = cur_sp;
568 cache->prev_sp = cur_sp + 8;
569 return 1;
570 }
571
572 case 0x40:
573 case 0x41:
574 case 0x42:
575 case 0x43:
576 case 0x44:
577 case 0x45:
578 case 0x46:
579 case 0x47:
580 case 0x48:
581 case 0x49:
582 case 0x4a:
583 case 0x4b:
584 case 0x4c:
585 case 0x4d:
586 case 0x4e:
587 case 0x4f:
588 /* Got a REX prefix, read next byte. */
589 rex = op;
590 if (target_read_memory (pc + 1, &op, 1) != 0)
591 return -1;
592
593 if (op == 0xff)
594 {
595 /* rex jmp reg */
596 gdb_byte op1;
597 unsigned int reg;
598 gdb_byte buf[8];
599
600 if (target_read_memory (pc + 2, &op1, 1) != 0)
601 return -1;
602 return (op1 & 0xf8) == 0xe0;
603 }
604 else
605 return 0;
606
607 default:
608 /* Not REX, so unknown. */
609 return 0;
610 }
611}
612
613/* Decode and execute unwind insns at UNWIND_INFO. */
614
615static void
616amd64_windows_frame_decode_insns (struct frame_info *this_frame,
617 struct amd64_windows_frame_cache *cache,
618 CORE_ADDR unwind_info)
619{
620 CORE_ADDR save_addr = 0;
621 CORE_ADDR cur_sp = cache->sp;
622 struct gdbarch *gdbarch = get_frame_arch (this_frame);
623 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
624 int j;
625
626 for (j = 0; ; j++)
627 {
628 struct external_pex64_unwind_info ex_ui;
629 /* There are at most 256 16-bit unwind insns. */
630 gdb_byte insns[2 * 256];
631 gdb_byte *p;
632 gdb_byte *end_insns;
633 unsigned char codes_count;
634 unsigned char frame_reg;
635 unsigned char frame_off;
636
637 /* Read and decode header. */
638 if (target_read_memory (cache->image_base + unwind_info,
639 (gdb_byte *) &ex_ui, sizeof (ex_ui)) != 0)
640 return;
641
642 if (frame_debug)
643 fprintf_unfiltered
644 (gdb_stdlog,
645 "amd64_windows_frame_decodes_insn: "
646 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
647 paddress (gdbarch, unwind_info),
648 ex_ui.Version_Flags, ex_ui.SizeOfPrologue,
649 ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset);
650
651 /* Check version. */
170d82c9
JB		 652 if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
653 && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
9058cc3a
TG		 654 return;
655
656 if (j == 0
657 && (cache->pc >=
658 cache->image_base + cache->start_rva + ex_ui.SizeOfPrologue))
659 {
660 /* Not in the prologue. We want to detect if the PC points to an
661 epilogue. If so, the epilogue detection+decoding function is
662 sufficient. Otherwise, the unwinder will consider that the PC
663 is in the body of the function and will need to decode unwind
664 info. */
665 if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
666 return;
667
668 /* Not in an epilog. Clear possible side effects. */
669 memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
670 }
671
672 codes_count = ex_ui.CountOfCodes;
673 frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
674
675 if (frame_reg != 0)
676 {
677 /* According to msdn:
678 If an FP reg is used, then any unwind code taking an offset must
679 only be used after the FP reg is established in the prolog. */
680 gdb_byte buf[8];
681 int frreg = amd64_windows_w2gdb_regnum[frame_reg];
682
683 get_frame_register (this_frame, frreg, buf);
684 save_addr = extract_unsigned_integer (buf, 8, byte_order);
685
686 if (frame_debug)
687 fprintf_unfiltered (gdb_stdlog, " frame_reg=%s, val=%s\n",
688 gdbarch_register_name (gdbarch, frreg),
689 paddress (gdbarch, save_addr));
690 }
691
692 /* Read opcodes. */
693 if (codes_count != 0
694 && target_read_memory (cache->image_base + unwind_info
695 + sizeof (ex_ui),
696 insns, codes_count * 2) != 0)
697 return;
698
699 end_insns = &insns[codes_count * 2];
170d82c9
JB		 700 p = insns;
701
702 /* Skip opcodes 6 of version 2. This opcode is not documented. */
703 if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2)
704 {
705 for (; p < end_insns; p += 2)
706 if (PEX64_UNWCODE_CODE (p[1]) != 6)
707 break;
708 }
709
710 for (; p < end_insns; p += 2)
9058cc3a
TG		 711 {
712 int reg;
713
714 if (frame_debug)
715 fprintf_unfiltered
716 (gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n",
717 (unsigned) (p - insns), p[0], p[1]);
718
719 /* Virtually execute the operation. */
720 if (cache->pc >= cache->image_base + cache->start_rva + p[0])
721 {
722 /* If there is no frame registers defined, the current value of
723 rsp is used instead. */
724 if (frame_reg == 0)
725 save_addr = cur_sp;
726
727 switch (PEX64_UNWCODE_CODE (p[1]))
728 {
729 case UWOP_PUSH_NONVOL:
730 /* Push pre-decrements RSP. */
731 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
732 cache->prev_reg_addr[reg] = cur_sp;
733 cur_sp += 8;
734 break;
735 case UWOP_ALLOC_LARGE:
736 if (PEX64_UNWCODE_INFO (p[1]) == 0)
737 cur_sp +=
738 8 * extract_unsigned_integer (p + 2, 2, byte_order);
739 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
740 cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
741 else
742 return;
743 break;
744 case UWOP_ALLOC_SMALL:
745 cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
746 break;
747 case UWOP_SET_FPREG:
748 cur_sp = save_addr
749 - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
750 break;
751 case UWOP_SAVE_NONVOL:
752 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
753 cache->prev_reg_addr[reg] = save_addr
754 - 8 * extract_unsigned_integer (p + 2, 2, byte_order);
755 break;
756 case UWOP_SAVE_NONVOL_FAR:
757 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
758 cache->prev_reg_addr[reg] = save_addr
759 - 8 * extract_unsigned_integer (p + 2, 4, byte_order);
760 break;
761 case UWOP_SAVE_XMM128:
762 cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
763 save_addr
764 - 16 * extract_unsigned_integer (p + 2, 2, byte_order);
765 break;
766 case UWOP_SAVE_XMM128_FAR:
767 cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
768 save_addr
769 - 16 * extract_unsigned_integer (p + 2, 4, byte_order);
770 break;
771 case UWOP_PUSH_MACHFRAME:
772 if (PEX64_UNWCODE_INFO (p[1]) == 0)
773 {
774 cache->prev_rip_addr = cur_sp + 0;
775 cache->prev_rsp_addr = cur_sp + 24;
776 cur_sp += 40;
777 }
778 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
779 {
780 cache->prev_rip_addr = cur_sp + 8;
781 cache->prev_rsp_addr = cur_sp + 32;
782 cur_sp += 48;
783 }
784 else
785 return;
786 break;
787 default:
788 return;
789 }
790 }
791
792 /* Adjust with the length of the opcode. */
793 switch (PEX64_UNWCODE_CODE (p[1]))
794 {
795 case UWOP_PUSH_NONVOL:
796 case UWOP_ALLOC_SMALL:
797 case UWOP_SET_FPREG:
798 case UWOP_PUSH_MACHFRAME:
799 break;
800 case UWOP_ALLOC_LARGE:
801 if (PEX64_UNWCODE_INFO (p[1]) == 0)
802 p += 2;
803 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
804 p += 4;
805 else
806 return;
807 break;
808 case UWOP_SAVE_NONVOL:
809 case UWOP_SAVE_XMM128:
810 p += 2;
811 break;
812 case UWOP_SAVE_NONVOL_FAR:
813 case UWOP_SAVE_XMM128_FAR:
814 p += 4;
815 break;
816 default:
817 return;
818 }
819 }
820 if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
821 break;
822 else
823 {
824 /* Read the chained unwind info. */
825 struct external_pex64_runtime_function d;
826 CORE_ADDR chain_vma;
827
828 chain_vma = cache->image_base + unwind_info
829 + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2 + 8;
830
831 if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
832 return;
833
834 cache->start_rva =
835 extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
836 cache->end_rva =
837 extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
838 unwind_info =
839 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
840 }
841
842 /* Allow the user to break this loop. */
843 QUIT;
844 }
845 /* PC is saved by the call. */
846 if (cache->prev_rip_addr == 0)
847 cache->prev_rip_addr = cur_sp;
848 cache->prev_sp = cur_sp + 8;
849
850 if (frame_debug)
851 fprintf_unfiltered (gdb_stdlog, " prev_sp: %s, prev_pc @%s\n",
852 paddress (gdbarch, cache->prev_sp),
853 paddress (gdbarch, cache->prev_rip_addr));
854}
855
856/* Find SEH unwind info for PC, returning 0 on success.
857
858 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
859 to the base address of the corresponding image, and START_RVA
860 to the rva of the function containing PC. */
861
862static int
863amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
864 CORE_ADDR *unwind_info,
865 CORE_ADDR *image_base,
866 CORE_ADDR *start_rva,
867 CORE_ADDR *end_rva)
868{
869 struct obj_section *sec;
870 pe_data_type *pe;
871 IMAGE_DATA_DIRECTORY *dir;
872 struct objfile *objfile;
873 unsigned long lo, hi;
874 CORE_ADDR base;
875 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
876
877 /* Get the corresponding exception directory. */
878 sec = find_pc_section (pc);
879 if (sec == NULL)
880 return -1;
881 objfile = sec->objfile;
882 pe = pe_data (sec->objfile->obfd);
883 dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
884
885 base = pe->pe_opthdr.ImageBase
886 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
887 *image_base = base;
888
889 /* Find the entry.
890
891 Note: This does not handle dynamically added entries (for JIT
892 engines). For this, we would need to ask the kernel directly,
893 which means getting some info from the native layer. For the
894 rest of the code, however, it's probably faster to search
895 the entry ourselves. */
896 lo = 0;
897 hi = dir->Size / sizeof (struct external_pex64_runtime_function);
898 *unwind_info = 0;
899 while (lo <= hi)
900 {
901 unsigned long mid = lo + (hi - lo) / 2;
902 struct external_pex64_runtime_function d;
903 CORE_ADDR sa, ea;
904
905 if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
906 (gdb_byte *) &d, sizeof (d)) != 0)
907 return -1;
908
909 sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
910 ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
911 if (pc < base + sa)
912 hi = mid - 1;
913 else if (pc >= base + ea)
914 lo = mid + 1;
915 else if (pc >= base + sa && pc < base + ea)
916 {
917 /* Got it. */
918 *start_rva = sa;
919 *end_rva = ea;
920 *unwind_info =
921 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
922 break;
923 }
924 else
925 break;
926 }
927
928 if (frame_debug)
929 fprintf_unfiltered
930 (gdb_stdlog,
931 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
932 paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
933
934 if (*unwind_info & 1)
935 {
936 /* Unofficially documented unwind info redirection, when UNWIND_INFO
937 address is odd (http://www.codemachine.com/article_x64deepdive.html).
938 */
939 struct external_pex64_runtime_function d;
940 CORE_ADDR sa, ea;
941
942 if (target_read_memory (base + (*unwind_info & ~1),
943 (gdb_byte *) &d, sizeof (d)) != 0)
944 return -1;
945
946 *start_rva =
947 extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
948 *end_rva = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
949 *unwind_info =
950 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
951
952 }
953 return 0;
954}
955
956/* Fill THIS_CACHE using the native amd64-windows unwinding data
957 for THIS_FRAME. */
958
959static struct amd64_windows_frame_cache *
960amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
961{
962 struct gdbarch *gdbarch = get_frame_arch (this_frame);
963 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
964 struct amd64_windows_frame_cache *cache;
965 gdb_byte buf[8];
966 struct obj_section *sec;
967 pe_data_type *pe;
968 IMAGE_DATA_DIRECTORY *dir;
969 CORE_ADDR image_base;
970 CORE_ADDR pc;
971 struct objfile *objfile;
972 unsigned long lo, hi;
973 CORE_ADDR unwind_info = 0;
974
975 if (*this_cache)
976 return *this_cache;
977
978 cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
979 *this_cache = cache;
980
981 /* Get current PC and SP. */
982 pc = get_frame_pc (this_frame);
983 get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
984 cache->sp = extract_unsigned_integer (buf, 8, byte_order);
985 cache->pc = pc;
986
987 if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
988 &cache->image_base,
989 &cache->start_rva,
990 &cache->end_rva))
991 return cache;
992
993 if (unwind_info == 0)
994 {
995 /* Assume a leaf function. */
996 cache->prev_sp = cache->sp + 8;
997 cache->prev_rip_addr = cache->sp;
998 }
999 else
1000 {
1001 /* Decode unwind insns to compute saved addresses. */
1002 amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
1003 }
1004 return cache;
1005}
1006
1007/* Implement the "prev_register" method of struct frame_unwind
1008 using the standard Windows x64 SEH info. */
1009
1010static struct value *
1011amd64_windows_frame_prev_register (struct frame_info *this_frame,
1012 void **this_cache, int regnum)
1013{
1014 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1015 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1016 struct amd64_windows_frame_cache *cache =
1017 amd64_windows_frame_cache (this_frame, this_cache);
1018 struct value *val;
1019 CORE_ADDR prev;
1020
1021 if (frame_debug)
1022 fprintf_unfiltered (gdb_stdlog,
1023 "amd64_windows_frame_prev_register %s for sp=%s\n",
1024 gdbarch_register_name (gdbarch, regnum),
1025 paddress (gdbarch, cache->prev_sp));
1026
1027 if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1028 prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1029 else if (regnum == AMD64_RSP_REGNUM)
1030 {
1031 prev = cache->prev_rsp_addr;
1032 if (prev == 0)
1033 return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1034 }
1035 else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1036 prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1037 else if (regnum == AMD64_RIP_REGNUM)
1038 prev = cache->prev_rip_addr;
1039 else
1040 prev = 0;
1041
1042 if (prev && frame_debug)
1043 fprintf_unfiltered (gdb_stdlog, " -> at %s\n", paddress (gdbarch, prev));
1044
1045 if (prev)
1046 {
1047 /* Register was saved. */
1048 return frame_unwind_got_memory (this_frame, regnum, prev);
1049 }
1050 else
1051 {
1052 /* Register is either volatile or not modified. */
1053 return frame_unwind_got_register (this_frame, regnum, regnum);
1054 }
1055}
1056
1057/* Implement the "this_id" method of struct frame_unwind using
1058 the standard Windows x64 SEH info. */
1059
1060static void
1061amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1062 struct frame_id *this_id)
1063{
1064 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1065 struct amd64_windows_frame_cache *cache =
1066 amd64_windows_frame_cache (this_frame, this_cache);
1067
1068 *this_id = frame_id_build (cache->prev_sp,
1069 cache->image_base + cache->start_rva);
1070}
1071
1072/* Windows x64 SEH unwinder. */
1073
1074static const struct frame_unwind amd64_windows_frame_unwind =
1075{
1076 NORMAL_FRAME,
1077 default_frame_unwind_stop_reason,
1078 &amd64_windows_frame_this_id,
1079 &amd64_windows_frame_prev_register,
1080 NULL,
1081 default_frame_sniffer
1082};
1083
1084/* Implement the "skip_prologue" gdbarch method. */
1085
1086static CORE_ADDR
1087amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1088{
1089 CORE_ADDR func_addr;
1090 CORE_ADDR unwind_info = 0;
1091 CORE_ADDR image_base, start_rva, end_rva;
1092 struct external_pex64_unwind_info ex_ui;
1093
1094 /* Use prologue size from unwind info. */
1095 if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1096 &image_base, &start_rva, &end_rva) == 0)
1097 {
1098 if (unwind_info == 0)
1099 {
1100 /* Leaf function. */
1101 return pc;
1102 }
1103 else if (target_read_memory (image_base + unwind_info,
1104 (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1105 && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1106 return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1107 }
1108
1109 /* See if we can determine the end of the prologue via the symbol
1110 table. If so, then return either the PC, or the PC after
1111 the prologue, whichever is greater. */
1112 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1113 {
1114 CORE_ADDR post_prologue_pc
1115 = skip_prologue_using_sal (gdbarch, func_addr);
1116
1117 if (post_prologue_pc != 0)
1118 return max (pc, post_prologue_pc);
1119 }
1120
1121 return pc;
1122}
1123
84552b16
PA		 1124/* Check Win64 DLL jmp trampolines and find jump destination. */
1125
1126static CORE_ADDR
1127amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1128{
1129 CORE_ADDR destination = 0;
1130 struct gdbarch *gdbarch = get_frame_arch (frame);
1131 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1132
1133 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1134 if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1135 {
1136 /* Get opcode offset and see if we can find a reference in our data. */
1137 ULONGEST offset
1138 = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1139
1140 /* Get address of function pointer at end of pc. */
1141 CORE_ADDR indirect_addr = pc + offset + 6;
1142
1143 struct minimal_symbol *indsym
7cbd4a93
TT		 1144 = (indirect_addr
1145 ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1146 : NULL);
efd66ac6 1147 const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;
84552b16
PA		 1148
1149 if (symname)
1150 {
1151 if (strncmp (symname, "__imp_", 6) == 0
1152 || strncmp (symname, "_imp_", 5) == 0)
1153 destination
1154 = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1155 }
1156 }
1157
1158 return destination;
1159}
99e24b90 1160
83ab93c6
JB		 1161/* Implement the "auto_wide_charset" gdbarch method. */
1162
1163static const char *
1164amd64_windows_auto_wide_charset (void)
1165{
1166 return "UTF-16";
1167}
1168
d0761299
JB		 1169static void
1170amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1171{
ba581dc1
JB		 1172 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1173
9058cc3a
TG		 1174 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1175 preferred over the SEH one. The reasons are:
1176 - binaries without SEH but with dwarf2 debug info are correcly handled
1177 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1178 info).
1179 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1180 handled if the dwarf2 unwinder is used).
1181
1182 The call to amd64_init_abi appends default unwinders, that aren't
1183 compatible with the SEH one.
1184 */
1185 frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1186
d0761299
JB		 1187 amd64_init_abi (info, gdbarch);
1188
64870a42
YQ		 1189 windows_init_abi (info, gdbarch);
1190
d0761299
JB		 1191 /* On Windows, "long"s are only 32bit. */
1192 set_gdbarch_long_bit (gdbarch, 32);
1193
ba581dc1 1194 /* Function calls. */
20c2e3e0 1195 set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
cba6fab5 1196 set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
99e24b90 1197 set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
84552b16
PA		 1198 set_gdbarch_skip_trampoline_code (gdbarch,
1199 amd64_windows_skip_trampoline_code);
ba581dc1 1200
9058cc3a
TG		 1201 set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1202
83ab93c6 1203 set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
d0761299
JB		 1204}
1205
693be288
JK		 1206/* -Wmissing-prototypes */
1207extern initialize_file_ftype _initialize_amd64_windows_tdep;
1208
d0761299
JB		 1209void
1210_initialize_amd64_windows_tdep (void)
1211{
1212 gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1213 amd64_windows_init_abi);
1214}
GDB Binutils - Deliverables
This page took 0.408375 seconds and 4 git commands to generate.