1 /* Copyright (C) 2009-2016 Free Software Foundation, Inc.
3 This file is part of GDB.
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.
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.
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/>. */
20 #include "amd64-tdep.h"
24 #include "windows-tdep.h"
27 #include "frame-unwind.h"
28 #include "coff/internal.h"
29 #include "coff/i386.h"
35 /* The registers used to pass integer arguments during a function call. */
36 static int amd64_windows_dummy_call_integer_regs
[] =
38 AMD64_RCX_REGNUM
, /* %rcx */
39 AMD64_RDX_REGNUM
, /* %rdx */
40 AMD64_R8_REGNUM
, /* %r8 */
41 AMD64_R9_REGNUM
/* %r9 */
44 /* Return nonzero if an argument of type TYPE should be passed
45 via one of the integer registers. */
48 amd64_windows_passed_by_integer_register (struct type
*type
)
50 switch (TYPE_CODE (type
))
59 case TYPE_CODE_STRUCT
:
61 return (TYPE_LENGTH (type
) == 1
62 || TYPE_LENGTH (type
) == 2
63 || TYPE_LENGTH (type
) == 4
64 || TYPE_LENGTH (type
) == 8);
71 /* Return nonzero if an argument of type TYPE should be passed
72 via one of the XMM registers. */
75 amd64_windows_passed_by_xmm_register (struct type
*type
)
77 return ((TYPE_CODE (type
) == TYPE_CODE_FLT
78 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
79 && (TYPE_LENGTH (type
) == 4 || TYPE_LENGTH (type
) == 8));
82 /* Return non-zero iff an argument of the given TYPE should be passed
86 amd64_windows_passed_by_pointer (struct type
*type
)
88 if (amd64_windows_passed_by_integer_register (type
))
91 if (amd64_windows_passed_by_xmm_register (type
))
97 /* For each argument that should be passed by pointer, reserve some
98 stack space, store a copy of the argument on the stack, and replace
99 the argument by its address. Return the new Stack Pointer value.
101 NARGS is the number of arguments. ARGS is the array containing
102 the value of each argument. SP is value of the Stack Pointer. */
105 amd64_windows_adjust_args_passed_by_pointer (struct value
**args
,
106 int nargs
, CORE_ADDR sp
)
110 for (i
= 0; i
< nargs
; i
++)
111 if (amd64_windows_passed_by_pointer (value_type (args
[i
])))
113 struct type
*type
= value_type (args
[i
]);
114 const gdb_byte
*valbuf
= value_contents (args
[i
]);
115 const int len
= TYPE_LENGTH (type
);
117 /* Store a copy of that argument on the stack, aligned to
118 a 16 bytes boundary, and then use the copy's address as
123 write_memory (sp
, valbuf
, len
);
126 = value_addr (value_from_contents_and_address (type
, valbuf
, sp
));
132 /* Store the value of ARG in register REGNO (right-justified).
133 REGCACHE is the register cache. */
136 amd64_windows_store_arg_in_reg (struct regcache
*regcache
,
137 struct value
*arg
, int regno
)
139 struct type
*type
= value_type (arg
);
140 const gdb_byte
*valbuf
= value_contents (arg
);
143 gdb_assert (TYPE_LENGTH (type
) <= 8);
144 memset (buf
, 0, sizeof buf
);
145 memcpy (buf
, valbuf
, std::min (TYPE_LENGTH (type
), (unsigned int) 8));
146 regcache_cooked_write (regcache
, regno
, buf
);
149 /* Push the arguments for an inferior function call, and return
150 the updated value of the SP (Stack Pointer).
152 All arguments are identical to the arguments used in
153 amd64_windows_push_dummy_call. */
156 amd64_windows_push_arguments (struct regcache
*regcache
, int nargs
,
157 struct value
**args
, CORE_ADDR sp
,
162 struct value
**stack_args
= XALLOCAVEC (struct value
*, nargs
);
163 int num_stack_args
= 0;
164 int num_elements
= 0;
167 /* First, handle the arguments passed by pointer.
169 These arguments are replaced by pointers to a copy we are making
170 in inferior memory. So use a copy of the ARGS table, to avoid
171 modifying the original one. */
173 struct value
**args1
= XALLOCAVEC (struct value
*, nargs
);
175 memcpy (args1
, args
, nargs
* sizeof (struct value
*));
176 sp
= amd64_windows_adjust_args_passed_by_pointer (args1
, nargs
, sp
);
180 /* Reserve a register for the "hidden" argument. */
184 for (i
= 0; i
< nargs
; i
++)
186 struct type
*type
= value_type (args
[i
]);
187 int len
= TYPE_LENGTH (type
);
190 if (reg_idx
< ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
))
192 if (amd64_windows_passed_by_integer_register (type
))
194 amd64_windows_store_arg_in_reg
196 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
200 else if (amd64_windows_passed_by_xmm_register (type
))
202 amd64_windows_store_arg_in_reg
203 (regcache
, args
[i
], AMD64_XMM0_REGNUM
+ reg_idx
);
204 /* In case of varargs, these parameters must also be
205 passed via the integer registers. */
206 amd64_windows_store_arg_in_reg
208 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
216 num_elements
+= ((len
+ 7) / 8);
217 stack_args
[num_stack_args
++] = args
[i
];
221 /* Allocate space for the arguments on the stack, keeping it
222 aligned on a 16 byte boundary. */
223 sp
-= num_elements
* 8;
226 /* Write out the arguments to the stack. */
227 for (i
= 0; i
< num_stack_args
; i
++)
229 struct type
*type
= value_type (stack_args
[i
]);
230 const gdb_byte
*valbuf
= value_contents (stack_args
[i
]);
232 write_memory (sp
+ element
* 8, valbuf
, TYPE_LENGTH (type
));
233 element
+= ((TYPE_LENGTH (type
) + 7) / 8);
239 /* Implement the "push_dummy_call" gdbarch method. */
242 amd64_windows_push_dummy_call
243 (struct gdbarch
*gdbarch
, struct value
*function
,
244 struct regcache
*regcache
, CORE_ADDR bp_addr
,
245 int nargs
, struct value
**args
,
246 CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
248 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
251 /* Pass arguments. */
252 sp
= amd64_windows_push_arguments (regcache
, nargs
, args
, sp
,
255 /* Pass "hidden" argument". */
258 /* The "hidden" argument is passed throught the first argument
260 const int arg_regnum
= amd64_windows_dummy_call_integer_regs
[0];
262 store_unsigned_integer (buf
, 8, byte_order
, struct_addr
);
263 regcache_cooked_write (regcache
, arg_regnum
, buf
);
266 /* Reserve some memory on the stack for the integer-parameter
267 registers, as required by the ABI. */
268 sp
-= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
) * 8;
270 /* Store return address. */
272 store_unsigned_integer (buf
, 8, byte_order
, bp_addr
);
273 write_memory (sp
, buf
, 8);
275 /* Update the stack pointer... */
276 store_unsigned_integer (buf
, 8, byte_order
, sp
);
277 regcache_cooked_write (regcache
, AMD64_RSP_REGNUM
, buf
);
279 /* ...and fake a frame pointer. */
280 regcache_cooked_write (regcache
, AMD64_RBP_REGNUM
, buf
);
285 /* Implement the "return_value" gdbarch method for amd64-windows. */
287 static enum return_value_convention
288 amd64_windows_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
289 struct type
*type
, struct regcache
*regcache
,
290 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
292 int len
= TYPE_LENGTH (type
);
295 /* See if our value is returned through a register. If it is, then
296 store the associated register number in REGNUM. */
297 switch (TYPE_CODE (type
))
300 case TYPE_CODE_DECFLOAT
:
301 /* __m128, __m128i, __m128d, floats, and doubles are returned
303 if (len
== 4 || len
== 8 || len
== 16)
304 regnum
= AMD64_XMM0_REGNUM
;
307 /* All other values that are 1, 2, 4 or 8 bytes long are returned
309 if (len
== 1 || len
== 2 || len
== 4 || len
== 8)
310 regnum
= AMD64_RAX_REGNUM
;
316 /* RAX contains the address where the return value has been stored. */
321 regcache_raw_read_unsigned (regcache
, AMD64_RAX_REGNUM
, &addr
);
322 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
324 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
328 /* Extract the return value from the register where it was stored. */
330 regcache_raw_read_part (regcache
, regnum
, 0, len
, readbuf
);
332 regcache_raw_write_part (regcache
, regnum
, 0, len
, writebuf
);
333 return RETURN_VALUE_REGISTER_CONVENTION
;
337 /* Check that the code pointed to by PC corresponds to a call to
338 __main, skip it if so. Return PC otherwise. */
341 amd64_skip_main_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
343 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
346 target_read_memory (pc
, &op
, 1);
351 if (target_read_memory (pc
+ 1, buf
, sizeof buf
) == 0)
353 struct bound_minimal_symbol s
;
356 call_dest
= pc
+ 5 + extract_signed_integer (buf
, 4, byte_order
);
357 s
= lookup_minimal_symbol_by_pc (call_dest
);
359 && MSYMBOL_LINKAGE_NAME (s
.minsym
) != NULL
360 && strcmp (MSYMBOL_LINKAGE_NAME (s
.minsym
), "__main") == 0)
368 struct amd64_windows_frame_cache
370 /* ImageBase for the module. */
371 CORE_ADDR image_base
;
373 /* Function start and end rva. */
377 /* Next instruction to be executed. */
383 /* Address of saved integer and xmm registers. */
384 CORE_ADDR prev_reg_addr
[16];
385 CORE_ADDR prev_xmm_addr
[16];
387 /* These two next fields are set only for machine info frames. */
389 /* Likewise for RIP. */
390 CORE_ADDR prev_rip_addr
;
392 /* Likewise for RSP. */
393 CORE_ADDR prev_rsp_addr
;
395 /* Address of the previous frame. */
399 /* Convert a Windows register number to gdb. */
400 static const enum amd64_regnum amd64_windows_w2gdb_regnum
[] =
420 /* Return TRUE iff PC is the the range of the function corresponding to
424 pc_in_range (CORE_ADDR pc
, const struct amd64_windows_frame_cache
*cache
)
426 return (pc
>= cache
->image_base
+ cache
->start_rva
427 && pc
< cache
->image_base
+ cache
->end_rva
);
430 /* Try to recognize and decode an epilogue sequence.
432 Return -1 if we fail to read the instructions for any reason.
433 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
436 amd64_windows_frame_decode_epilogue (struct frame_info
*this_frame
,
437 struct amd64_windows_frame_cache
*cache
)
439 /* According to MSDN an epilogue "must consist of either an add RSP,constant
440 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
441 register pops and a return or a jmp".
443 Furthermore, according to RtlVirtualUnwind, the complete list of
448 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
449 - jmp qword ptr imm32 - not handled
450 - rex.w jmp reg [4X ff eY]
453 CORE_ADDR pc
= cache
->pc
;
454 CORE_ADDR cur_sp
= cache
->sp
;
455 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
456 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
460 /* We don't care about the instruction deallocating the frame:
461 if it hasn't been executed, the pc is still in the body,
462 if it has been executed, the following epilog decoding will work. */
465 - pop reg [41 58-5f] or [58-5f]. */
470 if (target_read_memory (pc
, &op
, 1) != 0)
473 if (op
>= 0x40 && op
<= 0x4f)
479 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
485 if (op
>= 0x58 && op
<= 0x5f)
488 gdb_byte reg
= (op
& 0x0f) | ((rex
& 1) << 3);
490 cache
->prev_reg_addr
[amd64_windows_w2gdb_regnum
[reg
]] = cur_sp
;
497 /* Allow the user to break this loop. This shouldn't happen as the
498 number of consecutive pop should be small. */
502 /* Then decode the marker. */
505 if (target_read_memory (pc
, &op
, 1) != 0)
512 cache
->prev_rip_addr
= cur_sp
;
513 cache
->prev_sp
= cur_sp
+ 8;
522 if (target_read_memory (pc
+ 1, &rel8
, 1) != 0)
524 npc
= pc
+ 2 + (signed char) rel8
;
526 /* If the jump is within the function, then this is not a marker,
527 otherwise this is a tail-call. */
528 return !pc_in_range (npc
, cache
);
537 if (target_read_memory (pc
+ 1, rel32
, 4) != 0)
539 npc
= pc
+ 5 + extract_signed_integer (rel32
, 4, byte_order
);
541 /* If the jump is within the function, then this is not a marker,
542 otherwise this is a tail-call. */
543 return !pc_in_range (npc
, cache
);
551 if (target_read_memory (pc
+ 1, imm16
, 2) != 0)
553 cache
->prev_rip_addr
= cur_sp
;
554 cache
->prev_sp
= cur_sp
555 + extract_unsigned_integer (imm16
, 4, byte_order
);
564 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
569 cache
->prev_rip_addr
= cur_sp
;
570 cache
->prev_sp
= cur_sp
+ 8;
590 /* Got a REX prefix, read next byte. */
592 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
600 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
602 return (op1
& 0xf8) == 0xe0;
608 /* Not REX, so unknown. */
613 /* Decode and execute unwind insns at UNWIND_INFO. */
616 amd64_windows_frame_decode_insns (struct frame_info
*this_frame
,
617 struct amd64_windows_frame_cache
*cache
,
618 CORE_ADDR unwind_info
)
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
);
626 /* There are at least 3 possibilities to share an unwind info entry:
627 1. Two different runtime_function entries (in .pdata) can point to the
628 same unwind info entry. There is no such indication while unwinding,
629 so we don't really care about that case. We suppose this scheme is
630 used to save memory when the unwind entries are exactly the same.
631 2. Chained unwind_info entries, with no unwind codes (no prologue).
632 There is a major difference with the previous case: the pc range for
633 the function is different (in case 1, the pc range comes from the
634 runtime_function entry; in case 2, the pc range for the chained entry
635 comes from the first unwind entry). Case 1 cannot be used instead as
636 the pc is not in the prologue. This case is officially documented.
637 (There might be unwind code in the first unwind entry to handle
638 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
640 3. Undocumented unwind info redirection. Hard to know the exact purpose,
641 so it is considered as a memory optimization of case 2.
646 /* Unofficially documented unwind info redirection, when UNWIND_INFO
647 address is odd (http://www.codemachine.com/article_x64deepdive.html).
649 struct external_pex64_runtime_function d
;
651 if (target_read_memory (cache
->image_base
+ (unwind_info
& ~1),
652 (gdb_byte
*) &d
, sizeof (d
)) != 0)
656 = extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
658 = extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
660 = extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
665 struct external_pex64_unwind_info ex_ui
;
666 /* There are at most 256 16-bit unwind insns. */
667 gdb_byte insns
[2 * 256];
670 unsigned char codes_count
;
671 unsigned char frame_reg
;
674 /* Read and decode header. */
675 if (target_read_memory (cache
->image_base
+ unwind_info
,
676 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) != 0)
682 "amd64_windows_frame_decodes_insn: "
683 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
684 paddress (gdbarch
, unwind_info
),
685 ex_ui
.Version_Flags
, ex_ui
.SizeOfPrologue
,
686 ex_ui
.CountOfCodes
, ex_ui
.FrameRegisterOffset
);
689 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 1
690 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 2)
693 start
= cache
->image_base
+ cache
->start_rva
;
695 && !(cache
->pc
>= start
&& cache
->pc
< start
+ ex_ui
.SizeOfPrologue
))
697 /* We want to detect if the PC points to an epilogue. This needs
698 to be checked only once, and an epilogue can be anywhere but in
699 the prologue. If so, the epilogue detection+decoding function is
700 sufficient. Otherwise, the unwinder will consider that the PC
701 is in the body of the function and will need to decode unwind
703 if (amd64_windows_frame_decode_epilogue (this_frame
, cache
) == 1)
706 /* Not in an epilog. Clear possible side effects. */
707 memset (cache
->prev_reg_addr
, 0, sizeof (cache
->prev_reg_addr
));
710 codes_count
= ex_ui
.CountOfCodes
;
711 frame_reg
= PEX64_UWI_FRAMEREG (ex_ui
.FrameRegisterOffset
);
715 /* According to msdn:
716 If an FP reg is used, then any unwind code taking an offset must
717 only be used after the FP reg is established in the prolog. */
719 int frreg
= amd64_windows_w2gdb_regnum
[frame_reg
];
721 get_frame_register (this_frame
, frreg
, buf
);
722 save_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
725 fprintf_unfiltered (gdb_stdlog
, " frame_reg=%s, val=%s\n",
726 gdbarch_register_name (gdbarch
, frreg
),
727 paddress (gdbarch
, save_addr
));
732 && target_read_memory (cache
->image_base
+ unwind_info
734 insns
, codes_count
* 2) != 0)
737 end_insns
= &insns
[codes_count
* 2];
740 /* Skip opcodes 6 of version 2. This opcode is not documented. */
741 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 2)
743 for (; p
< end_insns
; p
+= 2)
744 if (PEX64_UNWCODE_CODE (p
[1]) != 6)
748 for (; p
< end_insns
; p
+= 2)
752 /* Virtually execute the operation if the pc is after the
753 corresponding instruction (that does matter in case of break
754 within the prologue). Note that for chained info (!first), the
755 prologue has been fully executed. */
756 if (cache
->pc
>= start
+ p
[0] || cache
->pc
< start
)
760 (gdb_stdlog
, " op #%u: off=0x%02x, insn=0x%02x\n",
761 (unsigned) (p
- insns
), p
[0], p
[1]);
763 /* If there is no frame registers defined, the current value of
764 rsp is used instead. */
770 switch (PEX64_UNWCODE_CODE (p
[1]))
772 case UWOP_PUSH_NONVOL
:
773 /* Push pre-decrements RSP. */
774 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
775 cache
->prev_reg_addr
[reg
] = cur_sp
;
778 case UWOP_ALLOC_LARGE
:
779 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
781 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
782 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
783 cur_sp
+= extract_unsigned_integer (p
+ 2, 4, byte_order
);
787 case UWOP_ALLOC_SMALL
:
788 cur_sp
+= 8 + 8 * PEX64_UNWCODE_INFO (p
[1]);
792 - PEX64_UWI_FRAMEOFF (ex_ui
.FrameRegisterOffset
) * 16;
794 case UWOP_SAVE_NONVOL
:
795 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
796 cache
->prev_reg_addr
[reg
] = save_addr
797 + 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
799 case UWOP_SAVE_NONVOL_FAR
:
800 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
801 cache
->prev_reg_addr
[reg
] = save_addr
802 + 8 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
804 case UWOP_SAVE_XMM128
:
805 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
807 - 16 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
809 case UWOP_SAVE_XMM128_FAR
:
810 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
812 - 16 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
814 case UWOP_PUSH_MACHFRAME
:
815 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
817 cache
->prev_rip_addr
= cur_sp
+ 0;
818 cache
->prev_rsp_addr
= cur_sp
+ 24;
821 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
823 cache
->prev_rip_addr
= cur_sp
+ 8;
824 cache
->prev_rsp_addr
= cur_sp
+ 32;
834 /* Display address where the register was saved. */
835 if (frame_debug
&& reg
>= 0)
837 (gdb_stdlog
, " [reg %s at %s]\n",
838 gdbarch_register_name (gdbarch
, reg
),
839 paddress (gdbarch
, cache
->prev_reg_addr
[reg
]));
842 /* Adjust with the length of the opcode. */
843 switch (PEX64_UNWCODE_CODE (p
[1]))
845 case UWOP_PUSH_NONVOL
:
846 case UWOP_ALLOC_SMALL
:
848 case UWOP_PUSH_MACHFRAME
:
850 case UWOP_ALLOC_LARGE
:
851 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
853 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
858 case UWOP_SAVE_NONVOL
:
859 case UWOP_SAVE_XMM128
:
862 case UWOP_SAVE_NONVOL_FAR
:
863 case UWOP_SAVE_XMM128_FAR
:
870 if (PEX64_UWI_FLAGS (ex_ui
.Version_Flags
) != UNW_FLAG_CHAININFO
)
872 /* End of unwind info. */
877 /* Read the chained unwind info. */
878 struct external_pex64_runtime_function d
;
881 /* Not anymore the first entry. */
884 /* Stay aligned on word boundary. */
885 chain_vma
= cache
->image_base
+ unwind_info
886 + sizeof (ex_ui
) + ((codes_count
+ 1) & ~1) * 2;
888 if (target_read_memory (chain_vma
, (gdb_byte
*) &d
, sizeof (d
)) != 0)
891 /* Decode begin/end. This may be different from .pdata index, as
892 an unwind info may be shared by several functions (in particular
893 if many functions have the same prolog and handler. */
895 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
897 extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
899 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
904 "amd64_windows_frame_decodes_insn (next in chain):"
905 " unwind_data=%s, start_rva=%s, end_rva=%s\n",
906 paddress (gdbarch
, unwind_info
),
907 paddress (gdbarch
, cache
->start_rva
),
908 paddress (gdbarch
, cache
->end_rva
));
911 /* Allow the user to break this loop. */
914 /* PC is saved by the call. */
915 if (cache
->prev_rip_addr
== 0)
916 cache
->prev_rip_addr
= cur_sp
;
917 cache
->prev_sp
= cur_sp
+ 8;
920 fprintf_unfiltered (gdb_stdlog
, " prev_sp: %s, prev_pc @%s\n",
921 paddress (gdbarch
, cache
->prev_sp
),
922 paddress (gdbarch
, cache
->prev_rip_addr
));
925 /* Find SEH unwind info for PC, returning 0 on success.
927 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
928 to the base address of the corresponding image, and START_RVA
929 to the rva of the function containing PC. */
932 amd64_windows_find_unwind_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
933 CORE_ADDR
*unwind_info
,
934 CORE_ADDR
*image_base
,
935 CORE_ADDR
*start_rva
,
938 struct obj_section
*sec
;
940 IMAGE_DATA_DIRECTORY
*dir
;
941 struct objfile
*objfile
;
942 unsigned long lo
, hi
;
944 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
946 /* Get the corresponding exception directory. */
947 sec
= find_pc_section (pc
);
950 objfile
= sec
->objfile
;
951 pe
= pe_data (sec
->objfile
->obfd
);
952 dir
= &pe
->pe_opthdr
.DataDirectory
[PE_EXCEPTION_TABLE
];
954 base
= pe
->pe_opthdr
.ImageBase
955 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
960 Note: This does not handle dynamically added entries (for JIT
961 engines). For this, we would need to ask the kernel directly,
962 which means getting some info from the native layer. For the
963 rest of the code, however, it's probably faster to search
964 the entry ourselves. */
966 hi
= dir
->Size
/ sizeof (struct external_pex64_runtime_function
);
970 unsigned long mid
= lo
+ (hi
- lo
) / 2;
971 struct external_pex64_runtime_function d
;
974 if (target_read_memory (base
+ dir
->VirtualAddress
+ mid
* sizeof (d
),
975 (gdb_byte
*) &d
, sizeof (d
)) != 0)
978 sa
= extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
979 ea
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
982 else if (pc
>= base
+ ea
)
984 else if (pc
>= base
+ sa
&& pc
< base
+ ea
)
990 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
1000 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
1001 paddress (gdbarch
, base
), paddress (gdbarch
, *unwind_info
));
1006 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1009 static struct amd64_windows_frame_cache
*
1010 amd64_windows_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1012 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1013 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1014 struct amd64_windows_frame_cache
*cache
;
1017 CORE_ADDR unwind_info
= 0;
1020 return (struct amd64_windows_frame_cache
*) *this_cache
;
1022 cache
= FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache
);
1023 *this_cache
= cache
;
1025 /* Get current PC and SP. */
1026 pc
= get_frame_pc (this_frame
);
1027 get_frame_register (this_frame
, AMD64_RSP_REGNUM
, buf
);
1028 cache
->sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1031 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1037 if (unwind_info
== 0)
1039 /* Assume a leaf function. */
1040 cache
->prev_sp
= cache
->sp
+ 8;
1041 cache
->prev_rip_addr
= cache
->sp
;
1045 /* Decode unwind insns to compute saved addresses. */
1046 amd64_windows_frame_decode_insns (this_frame
, cache
, unwind_info
);
1051 /* Implement the "prev_register" method of struct frame_unwind
1052 using the standard Windows x64 SEH info. */
1054 static struct value
*
1055 amd64_windows_frame_prev_register (struct frame_info
*this_frame
,
1056 void **this_cache
, int regnum
)
1058 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1059 struct amd64_windows_frame_cache
*cache
=
1060 amd64_windows_frame_cache (this_frame
, this_cache
);
1064 fprintf_unfiltered (gdb_stdlog
,
1065 "amd64_windows_frame_prev_register %s for sp=%s\n",
1066 gdbarch_register_name (gdbarch
, regnum
),
1067 paddress (gdbarch
, cache
->prev_sp
));
1069 if (regnum
>= AMD64_XMM0_REGNUM
&& regnum
<= AMD64_XMM0_REGNUM
+ 15)
1070 prev
= cache
->prev_xmm_addr
[regnum
- AMD64_XMM0_REGNUM
];
1071 else if (regnum
== AMD64_RSP_REGNUM
)
1073 prev
= cache
->prev_rsp_addr
;
1075 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_sp
);
1077 else if (regnum
>= AMD64_RAX_REGNUM
&& regnum
<= AMD64_R15_REGNUM
)
1078 prev
= cache
->prev_reg_addr
[regnum
- AMD64_RAX_REGNUM
];
1079 else if (regnum
== AMD64_RIP_REGNUM
)
1080 prev
= cache
->prev_rip_addr
;
1084 if (prev
&& frame_debug
)
1085 fprintf_unfiltered (gdb_stdlog
, " -> at %s\n", paddress (gdbarch
, prev
));
1089 /* Register was saved. */
1090 return frame_unwind_got_memory (this_frame
, regnum
, prev
);
1094 /* Register is either volatile or not modified. */
1095 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1099 /* Implement the "this_id" method of struct frame_unwind using
1100 the standard Windows x64 SEH info. */
1103 amd64_windows_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1104 struct frame_id
*this_id
)
1106 struct amd64_windows_frame_cache
*cache
=
1107 amd64_windows_frame_cache (this_frame
, this_cache
);
1109 *this_id
= frame_id_build (cache
->prev_sp
,
1110 cache
->image_base
+ cache
->start_rva
);
1113 /* Windows x64 SEH unwinder. */
1115 static const struct frame_unwind amd64_windows_frame_unwind
=
1118 default_frame_unwind_stop_reason
,
1119 &amd64_windows_frame_this_id
,
1120 &amd64_windows_frame_prev_register
,
1122 default_frame_sniffer
1125 /* Implement the "skip_prologue" gdbarch method. */
1128 amd64_windows_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1130 CORE_ADDR func_addr
;
1131 CORE_ADDR unwind_info
= 0;
1132 CORE_ADDR image_base
, start_rva
, end_rva
;
1133 struct external_pex64_unwind_info ex_ui
;
1135 /* Use prologue size from unwind info. */
1136 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1137 &image_base
, &start_rva
, &end_rva
) == 0)
1139 if (unwind_info
== 0)
1141 /* Leaf function. */
1144 else if (target_read_memory (image_base
+ unwind_info
,
1145 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) == 0
1146 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 1)
1147 return std::max (pc
, image_base
+ start_rva
+ ex_ui
.SizeOfPrologue
);
1150 /* See if we can determine the end of the prologue via the symbol
1151 table. If so, then return either the PC, or the PC after
1152 the prologue, whichever is greater. */
1153 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1155 CORE_ADDR post_prologue_pc
1156 = skip_prologue_using_sal (gdbarch
, func_addr
);
1158 if (post_prologue_pc
!= 0)
1159 return std::max (pc
, post_prologue_pc
);
1165 /* Check Win64 DLL jmp trampolines and find jump destination. */
1168 amd64_windows_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1170 CORE_ADDR destination
= 0;
1171 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1172 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1174 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1175 if (pc
&& read_memory_unsigned_integer (pc
, 2, byte_order
) == 0x25ff)
1177 /* Get opcode offset and see if we can find a reference in our data. */
1179 = read_memory_unsigned_integer (pc
+ 2, 4, byte_order
);
1181 /* Get address of function pointer at end of pc. */
1182 CORE_ADDR indirect_addr
= pc
+ offset
+ 6;
1184 struct minimal_symbol
*indsym
1186 ? lookup_minimal_symbol_by_pc (indirect_addr
).minsym
1188 const char *symname
= indsym
? MSYMBOL_LINKAGE_NAME (indsym
) : NULL
;
1192 if (startswith (symname
, "__imp_")
1193 || startswith (symname
, "_imp_"))
1195 = read_memory_unsigned_integer (indirect_addr
, 8, byte_order
);
1202 /* Implement the "auto_wide_charset" gdbarch method. */
1205 amd64_windows_auto_wide_charset (void)
1211 amd64_windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1213 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1214 preferred over the SEH one. The reasons are:
1215 - binaries without SEH but with dwarf2 debug info are correcly handled
1216 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1218 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1219 handled if the dwarf2 unwinder is used).
1221 The call to amd64_init_abi appends default unwinders, that aren't
1222 compatible with the SEH one.
1224 frame_unwind_append_unwinder (gdbarch
, &amd64_windows_frame_unwind
);
1226 amd64_init_abi (info
, gdbarch
);
1228 windows_init_abi (info
, gdbarch
);
1230 /* On Windows, "long"s are only 32bit. */
1231 set_gdbarch_long_bit (gdbarch
, 32);
1233 /* Function calls. */
1234 set_gdbarch_push_dummy_call (gdbarch
, amd64_windows_push_dummy_call
);
1235 set_gdbarch_return_value (gdbarch
, amd64_windows_return_value
);
1236 set_gdbarch_skip_main_prologue (gdbarch
, amd64_skip_main_prologue
);
1237 set_gdbarch_skip_trampoline_code (gdbarch
,
1238 amd64_windows_skip_trampoline_code
);
1240 set_gdbarch_skip_prologue (gdbarch
, amd64_windows_skip_prologue
);
1242 set_gdbarch_auto_wide_charset (gdbarch
, amd64_windows_auto_wide_charset
);
1245 /* -Wmissing-prototypes */
1246 extern initialize_file_ftype _initialize_amd64_windows_tdep
;
1249 _initialize_amd64_windows_tdep (void)
1251 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_CYGWIN
,
1252 amd64_windows_init_abi
);