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"
34 /* The registers used to pass integer arguments during a function call. */
35 static int amd64_windows_dummy_call_integer_regs
[] =
37 AMD64_RCX_REGNUM
, /* %rcx */
38 AMD64_RDX_REGNUM
, /* %rdx */
39 AMD64_R8_REGNUM
, /* %r8 */
40 AMD64_R9_REGNUM
/* %r9 */
43 /* Return nonzero if an argument of type TYPE should be passed
44 via one of the integer registers. */
47 amd64_windows_passed_by_integer_register (struct type
*type
)
49 switch (TYPE_CODE (type
))
58 case TYPE_CODE_STRUCT
:
60 return (TYPE_LENGTH (type
) == 1
61 || TYPE_LENGTH (type
) == 2
62 || TYPE_LENGTH (type
) == 4
63 || TYPE_LENGTH (type
) == 8);
70 /* Return nonzero if an argument of type TYPE should be passed
71 via one of the XMM registers. */
74 amd64_windows_passed_by_xmm_register (struct type
*type
)
76 return ((TYPE_CODE (type
) == TYPE_CODE_FLT
77 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
78 && (TYPE_LENGTH (type
) == 4 || TYPE_LENGTH (type
) == 8));
81 /* Return non-zero iff an argument of the given TYPE should be passed
85 amd64_windows_passed_by_pointer (struct type
*type
)
87 if (amd64_windows_passed_by_integer_register (type
))
90 if (amd64_windows_passed_by_xmm_register (type
))
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.
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. */
104 amd64_windows_adjust_args_passed_by_pointer (struct value
**args
,
105 int nargs
, CORE_ADDR sp
)
109 for (i
= 0; i
< nargs
; i
++)
110 if (amd64_windows_passed_by_pointer (value_type (args
[i
])))
112 struct type
*type
= value_type (args
[i
]);
113 const gdb_byte
*valbuf
= value_contents (args
[i
]);
114 const int len
= TYPE_LENGTH (type
);
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
122 write_memory (sp
, valbuf
, len
);
125 = value_addr (value_from_contents_and_address (type
, valbuf
, sp
));
131 /* Store the value of ARG in register REGNO (right-justified).
132 REGCACHE is the register cache. */
135 amd64_windows_store_arg_in_reg (struct regcache
*regcache
,
136 struct value
*arg
, int regno
)
138 struct type
*type
= value_type (arg
);
139 const gdb_byte
*valbuf
= value_contents (arg
);
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
);
148 /* Push the arguments for an inferior function call, and return
149 the updated value of the SP (Stack Pointer).
151 All arguments are identical to the arguments used in
152 amd64_windows_push_dummy_call. */
155 amd64_windows_push_arguments (struct regcache
*regcache
, int nargs
,
156 struct value
**args
, CORE_ADDR sp
,
161 struct value
**stack_args
= XALLOCAVEC (struct value
*, nargs
);
162 int num_stack_args
= 0;
163 int num_elements
= 0;
166 /* First, handle the arguments passed by pointer.
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. */
172 struct value
**args1
= XALLOCAVEC (struct value
*, nargs
);
174 memcpy (args1
, args
, nargs
* sizeof (struct value
*));
175 sp
= amd64_windows_adjust_args_passed_by_pointer (args1
, nargs
, sp
);
179 /* Reserve a register for the "hidden" argument. */
183 for (i
= 0; i
< nargs
; i
++)
185 struct type
*type
= value_type (args
[i
]);
186 int len
= TYPE_LENGTH (type
);
189 if (reg_idx
< ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
))
191 if (amd64_windows_passed_by_integer_register (type
))
193 amd64_windows_store_arg_in_reg
195 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
199 else if (amd64_windows_passed_by_xmm_register (type
))
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
207 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
215 num_elements
+= ((len
+ 7) / 8);
216 stack_args
[num_stack_args
++] = args
[i
];
220 /* Allocate space for the arguments on the stack, keeping it
221 aligned on a 16 byte boundary. */
222 sp
-= num_elements
* 8;
225 /* Write out the arguments to the stack. */
226 for (i
= 0; i
< num_stack_args
; i
++)
228 struct type
*type
= value_type (stack_args
[i
]);
229 const gdb_byte
*valbuf
= value_contents (stack_args
[i
]);
231 write_memory (sp
+ element
* 8, valbuf
, TYPE_LENGTH (type
));
232 element
+= ((TYPE_LENGTH (type
) + 7) / 8);
238 /* Implement the "push_dummy_call" gdbarch method. */
241 amd64_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
)
247 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
250 /* Pass arguments. */
251 sp
= amd64_windows_push_arguments (regcache
, nargs
, args
, sp
,
254 /* Pass "hidden" argument". */
257 /* The "hidden" argument is passed throught the first argument
259 const int arg_regnum
= amd64_windows_dummy_call_integer_regs
[0];
261 store_unsigned_integer (buf
, 8, byte_order
, struct_addr
);
262 regcache_cooked_write (regcache
, arg_regnum
, buf
);
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;
269 /* Store return address. */
271 store_unsigned_integer (buf
, 8, byte_order
, bp_addr
);
272 write_memory (sp
, buf
, 8);
274 /* Update the stack pointer... */
275 store_unsigned_integer (buf
, 8, byte_order
, sp
);
276 regcache_cooked_write (regcache
, AMD64_RSP_REGNUM
, buf
);
278 /* ...and fake a frame pointer. */
279 regcache_cooked_write (regcache
, AMD64_RBP_REGNUM
, buf
);
284 /* Implement the "return_value" gdbarch method for amd64-windows. */
286 static enum return_value_convention
287 amd64_windows_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
288 struct type
*type
, struct regcache
*regcache
,
289 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
291 int len
= TYPE_LENGTH (type
);
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
))
299 case TYPE_CODE_DECFLOAT
:
300 /* __m128, __m128i, __m128d, floats, and doubles are returned
302 if (len
== 4 || len
== 8 || len
== 16)
303 regnum
= AMD64_XMM0_REGNUM
;
306 /* All other values that are 1, 2, 4 or 8 bytes long are returned
308 if (len
== 1 || len
== 2 || len
== 4 || len
== 8)
309 regnum
= AMD64_RAX_REGNUM
;
315 /* RAX contains the address where the return value has been stored. */
320 regcache_raw_read_unsigned (regcache
, AMD64_RAX_REGNUM
, &addr
);
321 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
323 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
327 /* Extract the return value from the register where it was stored. */
329 regcache_raw_read_part (regcache
, regnum
, 0, len
, readbuf
);
331 regcache_raw_write_part (regcache
, regnum
, 0, len
, writebuf
);
332 return RETURN_VALUE_REGISTER_CONVENTION
;
336 /* Check that the code pointed to by PC corresponds to a call to
337 __main, skip it if so. Return PC otherwise. */
340 amd64_skip_main_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
342 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
345 target_read_memory (pc
, &op
, 1);
350 if (target_read_memory (pc
+ 1, buf
, sizeof buf
) == 0)
352 struct bound_minimal_symbol s
;
355 call_dest
= pc
+ 5 + extract_signed_integer (buf
, 4, byte_order
);
356 s
= lookup_minimal_symbol_by_pc (call_dest
);
358 && MSYMBOL_LINKAGE_NAME (s
.minsym
) != NULL
359 && strcmp (MSYMBOL_LINKAGE_NAME (s
.minsym
), "__main") == 0)
367 struct amd64_windows_frame_cache
369 /* ImageBase for the module. */
370 CORE_ADDR image_base
;
372 /* Function start and end rva. */
376 /* Next instruction to be executed. */
382 /* Address of saved integer and xmm registers. */
383 CORE_ADDR prev_reg_addr
[16];
384 CORE_ADDR prev_xmm_addr
[16];
386 /* These two next fields are set only for machine info frames. */
388 /* Likewise for RIP. */
389 CORE_ADDR prev_rip_addr
;
391 /* Likewise for RSP. */
392 CORE_ADDR prev_rsp_addr
;
394 /* Address of the previous frame. */
398 /* Convert a Windows register number to gdb. */
399 static const enum amd64_regnum amd64_windows_w2gdb_regnum
[] =
419 /* Return TRUE iff PC is the the range of the function corresponding to
423 pc_in_range (CORE_ADDR pc
, const struct amd64_windows_frame_cache
*cache
)
425 return (pc
>= cache
->image_base
+ cache
->start_rva
426 && pc
< cache
->image_base
+ cache
->end_rva
);
429 /* Try to recognize and decode an epilogue sequence.
431 Return -1 if we fail to read the instructions for any reason.
432 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
435 amd64_windows_frame_decode_epilogue (struct frame_info
*this_frame
,
436 struct amd64_windows_frame_cache
*cache
)
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".
442 Furthermore, according to RtlVirtualUnwind, the complete list of
447 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
448 - jmp qword ptr imm32 - not handled
449 - rex.w jmp reg [4X ff eY]
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
);
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. */
464 - pop reg [41 58-5f] or [58-5f]. */
469 if (target_read_memory (pc
, &op
, 1) != 0)
472 if (op
>= 0x40 && op
<= 0x4f)
478 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
484 if (op
>= 0x58 && op
<= 0x5f)
487 gdb_byte reg
= (op
& 0x0f) | ((rex
& 1) << 3);
489 cache
->prev_reg_addr
[amd64_windows_w2gdb_regnum
[reg
]] = cur_sp
;
496 /* Allow the user to break this loop. This shouldn't happen as the
497 number of consecutive pop should be small. */
501 /* Then decode the marker. */
504 if (target_read_memory (pc
, &op
, 1) != 0)
511 cache
->prev_rip_addr
= cur_sp
;
512 cache
->prev_sp
= cur_sp
+ 8;
521 if (target_read_memory (pc
+ 1, &rel8
, 1) != 0)
523 npc
= pc
+ 2 + (signed char) rel8
;
525 /* If the jump is within the function, then this is not a marker,
526 otherwise this is a tail-call. */
527 return !pc_in_range (npc
, cache
);
536 if (target_read_memory (pc
+ 1, rel32
, 4) != 0)
538 npc
= pc
+ 5 + extract_signed_integer (rel32
, 4, byte_order
);
540 /* If the jump is within the function, then this is not a marker,
541 otherwise this is a tail-call. */
542 return !pc_in_range (npc
, cache
);
550 if (target_read_memory (pc
+ 1, imm16
, 2) != 0)
552 cache
->prev_rip_addr
= cur_sp
;
553 cache
->prev_sp
= cur_sp
554 + extract_unsigned_integer (imm16
, 4, byte_order
);
563 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
568 cache
->prev_rip_addr
= cur_sp
;
569 cache
->prev_sp
= cur_sp
+ 8;
589 /* Got a REX prefix, read next byte. */
591 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
599 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
601 return (op1
& 0xf8) == 0xe0;
607 /* Not REX, so unknown. */
612 /* Decode and execute unwind insns at UNWIND_INFO. */
615 amd64_windows_frame_decode_insns (struct frame_info
*this_frame
,
616 struct amd64_windows_frame_cache
*cache
,
617 CORE_ADDR unwind_info
)
619 CORE_ADDR save_addr
= 0;
620 CORE_ADDR cur_sp
= cache
->sp
;
621 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
622 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
625 /* There are at least 3 possibilities to share an unwind info entry:
626 1. Two different runtime_function entries (in .pdata) can point to the
627 same unwind info entry. There is no such indication while unwinding,
628 so we don't really care about that case. We suppose this scheme is
629 used to save memory when the unwind entries are exactly the same.
630 2. Chained unwind_info entries, with no unwind codes (no prologue).
631 There is a major difference with the previous case: the pc range for
632 the function is different (in case 1, the pc range comes from the
633 runtime_function entry; in case 2, the pc range for the chained entry
634 comes from the first unwind entry). Case 1 cannot be used instead as
635 the pc is not in the prologue. This case is officially documented.
636 (There might be unwind code in the first unwind entry to handle
637 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
639 3. Undocumented unwind info redirection. Hard to know the exact purpose,
640 so it is considered as a memory optimization of case 2.
645 /* Unofficially documented unwind info redirection, when UNWIND_INFO
646 address is odd (http://www.codemachine.com/article_x64deepdive.html).
648 struct external_pex64_runtime_function d
;
650 if (target_read_memory (cache
->image_base
+ (unwind_info
& ~1),
651 (gdb_byte
*) &d
, sizeof (d
)) != 0)
655 = extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
657 = extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
659 = extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
664 struct external_pex64_unwind_info ex_ui
;
665 /* There are at most 256 16-bit unwind insns. */
666 gdb_byte insns
[2 * 256];
669 unsigned char codes_count
;
670 unsigned char frame_reg
;
673 /* Read and decode header. */
674 if (target_read_memory (cache
->image_base
+ unwind_info
,
675 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) != 0)
681 "amd64_windows_frame_decodes_insn: "
682 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
683 paddress (gdbarch
, unwind_info
),
684 ex_ui
.Version_Flags
, ex_ui
.SizeOfPrologue
,
685 ex_ui
.CountOfCodes
, ex_ui
.FrameRegisterOffset
);
688 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 1
689 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 2)
692 start
= cache
->image_base
+ cache
->start_rva
;
694 && !(cache
->pc
>= start
&& cache
->pc
< start
+ ex_ui
.SizeOfPrologue
))
696 /* We want to detect if the PC points to an epilogue. This needs
697 to be checked only once, and an epilogue can be anywhere but in
698 the prologue. If so, the epilogue detection+decoding function is
699 sufficient. Otherwise, the unwinder will consider that the PC
700 is in the body of the function and will need to decode unwind
702 if (amd64_windows_frame_decode_epilogue (this_frame
, cache
) == 1)
705 /* Not in an epilog. Clear possible side effects. */
706 memset (cache
->prev_reg_addr
, 0, sizeof (cache
->prev_reg_addr
));
709 codes_count
= ex_ui
.CountOfCodes
;
710 frame_reg
= PEX64_UWI_FRAMEREG (ex_ui
.FrameRegisterOffset
);
714 /* According to msdn:
715 If an FP reg is used, then any unwind code taking an offset must
716 only be used after the FP reg is established in the prolog. */
718 int frreg
= amd64_windows_w2gdb_regnum
[frame_reg
];
720 get_frame_register (this_frame
, frreg
, buf
);
721 save_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
724 fprintf_unfiltered (gdb_stdlog
, " frame_reg=%s, val=%s\n",
725 gdbarch_register_name (gdbarch
, frreg
),
726 paddress (gdbarch
, save_addr
));
731 && target_read_memory (cache
->image_base
+ unwind_info
733 insns
, codes_count
* 2) != 0)
736 end_insns
= &insns
[codes_count
* 2];
739 /* Skip opcodes 6 of version 2. This opcode is not documented. */
740 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 2)
742 for (; p
< end_insns
; p
+= 2)
743 if (PEX64_UNWCODE_CODE (p
[1]) != 6)
747 for (; p
< end_insns
; p
+= 2)
751 /* Virtually execute the operation if the pc is after the
752 corresponding instruction (that does matter in case of break
753 within the prologue). Note that for chained info (!first), the
754 prologue has been fully executed. */
755 if (cache
->pc
>= start
+ p
[0] || cache
->pc
< start
)
759 (gdb_stdlog
, " op #%u: off=0x%02x, insn=0x%02x\n",
760 (unsigned) (p
- insns
), p
[0], p
[1]);
762 /* If there is no frame registers defined, the current value of
763 rsp is used instead. */
769 switch (PEX64_UNWCODE_CODE (p
[1]))
771 case UWOP_PUSH_NONVOL
:
772 /* Push pre-decrements RSP. */
773 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
774 cache
->prev_reg_addr
[reg
] = cur_sp
;
777 case UWOP_ALLOC_LARGE
:
778 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
780 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
781 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
782 cur_sp
+= extract_unsigned_integer (p
+ 2, 4, byte_order
);
786 case UWOP_ALLOC_SMALL
:
787 cur_sp
+= 8 + 8 * PEX64_UNWCODE_INFO (p
[1]);
791 - PEX64_UWI_FRAMEOFF (ex_ui
.FrameRegisterOffset
) * 16;
793 case UWOP_SAVE_NONVOL
:
794 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
795 cache
->prev_reg_addr
[reg
] = save_addr
796 + 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
798 case UWOP_SAVE_NONVOL_FAR
:
799 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
800 cache
->prev_reg_addr
[reg
] = save_addr
801 + 8 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
803 case UWOP_SAVE_XMM128
:
804 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
806 - 16 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
808 case UWOP_SAVE_XMM128_FAR
:
809 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
811 - 16 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
813 case UWOP_PUSH_MACHFRAME
:
814 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
816 cache
->prev_rip_addr
= cur_sp
+ 0;
817 cache
->prev_rsp_addr
= cur_sp
+ 24;
820 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
822 cache
->prev_rip_addr
= cur_sp
+ 8;
823 cache
->prev_rsp_addr
= cur_sp
+ 32;
833 /* Display address where the register was saved. */
834 if (frame_debug
&& reg
>= 0)
836 (gdb_stdlog
, " [reg %s at %s]\n",
837 gdbarch_register_name (gdbarch
, reg
),
838 paddress (gdbarch
, cache
->prev_reg_addr
[reg
]));
841 /* Adjust with the length of the opcode. */
842 switch (PEX64_UNWCODE_CODE (p
[1]))
844 case UWOP_PUSH_NONVOL
:
845 case UWOP_ALLOC_SMALL
:
847 case UWOP_PUSH_MACHFRAME
:
849 case UWOP_ALLOC_LARGE
:
850 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
852 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
857 case UWOP_SAVE_NONVOL
:
858 case UWOP_SAVE_XMM128
:
861 case UWOP_SAVE_NONVOL_FAR
:
862 case UWOP_SAVE_XMM128_FAR
:
869 if (PEX64_UWI_FLAGS (ex_ui
.Version_Flags
) != UNW_FLAG_CHAININFO
)
871 /* End of unwind info. */
876 /* Read the chained unwind info. */
877 struct external_pex64_runtime_function d
;
880 /* Not anymore the first entry. */
883 /* Stay aligned on word boundary. */
884 chain_vma
= cache
->image_base
+ unwind_info
885 + sizeof (ex_ui
) + ((codes_count
+ 1) & ~1) * 2;
887 if (target_read_memory (chain_vma
, (gdb_byte
*) &d
, sizeof (d
)) != 0)
890 /* Decode begin/end. This may be different from .pdata index, as
891 an unwind info may be shared by several functions (in particular
892 if many functions have the same prolog and handler. */
894 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
896 extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
898 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
903 "amd64_windows_frame_decodes_insn (next in chain):"
904 " unwind_data=%s, start_rva=%s, end_rva=%s\n",
905 paddress (gdbarch
, unwind_info
),
906 paddress (gdbarch
, cache
->start_rva
),
907 paddress (gdbarch
, cache
->end_rva
));
910 /* Allow the user to break this loop. */
913 /* PC is saved by the call. */
914 if (cache
->prev_rip_addr
== 0)
915 cache
->prev_rip_addr
= cur_sp
;
916 cache
->prev_sp
= cur_sp
+ 8;
919 fprintf_unfiltered (gdb_stdlog
, " prev_sp: %s, prev_pc @%s\n",
920 paddress (gdbarch
, cache
->prev_sp
),
921 paddress (gdbarch
, cache
->prev_rip_addr
));
924 /* Find SEH unwind info for PC, returning 0 on success.
926 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
927 to the base address of the corresponding image, and START_RVA
928 to the rva of the function containing PC. */
931 amd64_windows_find_unwind_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
932 CORE_ADDR
*unwind_info
,
933 CORE_ADDR
*image_base
,
934 CORE_ADDR
*start_rva
,
937 struct obj_section
*sec
;
939 IMAGE_DATA_DIRECTORY
*dir
;
940 struct objfile
*objfile
;
941 unsigned long lo
, hi
;
943 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
945 /* Get the corresponding exception directory. */
946 sec
= find_pc_section (pc
);
949 objfile
= sec
->objfile
;
950 pe
= pe_data (sec
->objfile
->obfd
);
951 dir
= &pe
->pe_opthdr
.DataDirectory
[PE_EXCEPTION_TABLE
];
953 base
= pe
->pe_opthdr
.ImageBase
954 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
959 Note: This does not handle dynamically added entries (for JIT
960 engines). For this, we would need to ask the kernel directly,
961 which means getting some info from the native layer. For the
962 rest of the code, however, it's probably faster to search
963 the entry ourselves. */
965 hi
= dir
->Size
/ sizeof (struct external_pex64_runtime_function
);
969 unsigned long mid
= lo
+ (hi
- lo
) / 2;
970 struct external_pex64_runtime_function d
;
973 if (target_read_memory (base
+ dir
->VirtualAddress
+ mid
* sizeof (d
),
974 (gdb_byte
*) &d
, sizeof (d
)) != 0)
977 sa
= extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
978 ea
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
981 else if (pc
>= base
+ ea
)
983 else if (pc
>= base
+ sa
&& pc
< base
+ ea
)
989 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
999 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
1000 paddress (gdbarch
, base
), paddress (gdbarch
, *unwind_info
));
1005 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1008 static struct amd64_windows_frame_cache
*
1009 amd64_windows_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1011 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1012 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1013 struct amd64_windows_frame_cache
*cache
;
1016 CORE_ADDR unwind_info
= 0;
1019 return (struct amd64_windows_frame_cache
*) *this_cache
;
1021 cache
= FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache
);
1022 *this_cache
= cache
;
1024 /* Get current PC and SP. */
1025 pc
= get_frame_pc (this_frame
);
1026 get_frame_register (this_frame
, AMD64_RSP_REGNUM
, buf
);
1027 cache
->sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1030 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1036 if (unwind_info
== 0)
1038 /* Assume a leaf function. */
1039 cache
->prev_sp
= cache
->sp
+ 8;
1040 cache
->prev_rip_addr
= cache
->sp
;
1044 /* Decode unwind insns to compute saved addresses. */
1045 amd64_windows_frame_decode_insns (this_frame
, cache
, unwind_info
);
1050 /* Implement the "prev_register" method of struct frame_unwind
1051 using the standard Windows x64 SEH info. */
1053 static struct value
*
1054 amd64_windows_frame_prev_register (struct frame_info
*this_frame
,
1055 void **this_cache
, int regnum
)
1057 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1058 struct amd64_windows_frame_cache
*cache
=
1059 amd64_windows_frame_cache (this_frame
, this_cache
);
1063 fprintf_unfiltered (gdb_stdlog
,
1064 "amd64_windows_frame_prev_register %s for sp=%s\n",
1065 gdbarch_register_name (gdbarch
, regnum
),
1066 paddress (gdbarch
, cache
->prev_sp
));
1068 if (regnum
>= AMD64_XMM0_REGNUM
&& regnum
<= AMD64_XMM0_REGNUM
+ 15)
1069 prev
= cache
->prev_xmm_addr
[regnum
- AMD64_XMM0_REGNUM
];
1070 else if (regnum
== AMD64_RSP_REGNUM
)
1072 prev
= cache
->prev_rsp_addr
;
1074 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_sp
);
1076 else if (regnum
>= AMD64_RAX_REGNUM
&& regnum
<= AMD64_R15_REGNUM
)
1077 prev
= cache
->prev_reg_addr
[regnum
- AMD64_RAX_REGNUM
];
1078 else if (regnum
== AMD64_RIP_REGNUM
)
1079 prev
= cache
->prev_rip_addr
;
1083 if (prev
&& frame_debug
)
1084 fprintf_unfiltered (gdb_stdlog
, " -> at %s\n", paddress (gdbarch
, prev
));
1088 /* Register was saved. */
1089 return frame_unwind_got_memory (this_frame
, regnum
, prev
);
1093 /* Register is either volatile or not modified. */
1094 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1098 /* Implement the "this_id" method of struct frame_unwind using
1099 the standard Windows x64 SEH info. */
1102 amd64_windows_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1103 struct frame_id
*this_id
)
1105 struct amd64_windows_frame_cache
*cache
=
1106 amd64_windows_frame_cache (this_frame
, this_cache
);
1108 *this_id
= frame_id_build (cache
->prev_sp
,
1109 cache
->image_base
+ cache
->start_rva
);
1112 /* Windows x64 SEH unwinder. */
1114 static const struct frame_unwind amd64_windows_frame_unwind
=
1117 default_frame_unwind_stop_reason
,
1118 &amd64_windows_frame_this_id
,
1119 &amd64_windows_frame_prev_register
,
1121 default_frame_sniffer
1124 /* Implement the "skip_prologue" gdbarch method. */
1127 amd64_windows_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1129 CORE_ADDR func_addr
;
1130 CORE_ADDR unwind_info
= 0;
1131 CORE_ADDR image_base
, start_rva
, end_rva
;
1132 struct external_pex64_unwind_info ex_ui
;
1134 /* Use prologue size from unwind info. */
1135 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1136 &image_base
, &start_rva
, &end_rva
) == 0)
1138 if (unwind_info
== 0)
1140 /* Leaf function. */
1143 else if (target_read_memory (image_base
+ unwind_info
,
1144 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) == 0
1145 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 1)
1146 return max (pc
, image_base
+ start_rva
+ ex_ui
.SizeOfPrologue
);
1149 /* See if we can determine the end of the prologue via the symbol
1150 table. If so, then return either the PC, or the PC after
1151 the prologue, whichever is greater. */
1152 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1154 CORE_ADDR post_prologue_pc
1155 = skip_prologue_using_sal (gdbarch
, func_addr
);
1157 if (post_prologue_pc
!= 0)
1158 return max (pc
, post_prologue_pc
);
1164 /* Check Win64 DLL jmp trampolines and find jump destination. */
1167 amd64_windows_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1169 CORE_ADDR destination
= 0;
1170 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1171 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1173 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1174 if (pc
&& read_memory_unsigned_integer (pc
, 2, byte_order
) == 0x25ff)
1176 /* Get opcode offset and see if we can find a reference in our data. */
1178 = read_memory_unsigned_integer (pc
+ 2, 4, byte_order
);
1180 /* Get address of function pointer at end of pc. */
1181 CORE_ADDR indirect_addr
= pc
+ offset
+ 6;
1183 struct minimal_symbol
*indsym
1185 ? lookup_minimal_symbol_by_pc (indirect_addr
).minsym
1187 const char *symname
= indsym
? MSYMBOL_LINKAGE_NAME (indsym
) : NULL
;
1191 if (startswith (symname
, "__imp_")
1192 || startswith (symname
, "_imp_"))
1194 = read_memory_unsigned_integer (indirect_addr
, 8, byte_order
);
1201 /* Implement the "auto_wide_charset" gdbarch method. */
1204 amd64_windows_auto_wide_charset (void)
1210 amd64_windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1212 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1213 preferred over the SEH one. The reasons are:
1214 - binaries without SEH but with dwarf2 debug info are correcly handled
1215 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1217 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1218 handled if the dwarf2 unwinder is used).
1220 The call to amd64_init_abi appends default unwinders, that aren't
1221 compatible with the SEH one.
1223 frame_unwind_append_unwinder (gdbarch
, &amd64_windows_frame_unwind
);
1225 amd64_init_abi (info
, gdbarch
);
1227 windows_init_abi (info
, gdbarch
);
1229 /* On Windows, "long"s are only 32bit. */
1230 set_gdbarch_long_bit (gdbarch
, 32);
1232 /* Function calls. */
1233 set_gdbarch_push_dummy_call (gdbarch
, amd64_windows_push_dummy_call
);
1234 set_gdbarch_return_value (gdbarch
, amd64_windows_return_value
);
1235 set_gdbarch_skip_main_prologue (gdbarch
, amd64_skip_main_prologue
);
1236 set_gdbarch_skip_trampoline_code (gdbarch
,
1237 amd64_windows_skip_trampoline_code
);
1239 set_gdbarch_skip_prologue (gdbarch
, amd64_windows_skip_prologue
);
1241 set_gdbarch_auto_wide_charset (gdbarch
, amd64_windows_auto_wide_charset
);
1244 /* -Wmissing-prototypes */
1245 extern initialize_file_ftype _initialize_amd64_windows_tdep
;
1248 _initialize_amd64_windows_tdep (void)
1250 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_CYGWIN
,
1251 amd64_windows_init_abi
);