1 /* Copyright (C) 2009-2020 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"
21 #include "gdbsupport/x86-xstate.h"
25 #include "windows-tdep.h"
28 #include "frame-unwind.h"
29 #include "coff/internal.h"
30 #include "coff/i386.h"
36 /* The registers used to pass integer arguments during a function call. */
37 static int amd64_windows_dummy_call_integer_regs
[] =
39 AMD64_RCX_REGNUM
, /* %rcx */
40 AMD64_RDX_REGNUM
, /* %rdx */
41 AMD64_R8_REGNUM
, /* %r8 */
42 AMD64_R9_REGNUM
/* %r9 */
45 /* This vector maps GDB's idea of a register's number into an offset into
46 the Windows API CONTEXT structure. */
47 static int amd64_windows_gregset_reg_offset
[] =
73 288, /* FloatSave.FloatRegisters[0] */
74 304, /* FloatSave.FloatRegisters[1] */
75 320, /* FloatSave.FloatRegisters[2] */
76 336, /* FloatSave.FloatRegisters[3] */
77 352, /* FloatSave.FloatRegisters[4] */
78 368, /* FloatSave.FloatRegisters[5] */
79 384, /* FloatSave.FloatRegisters[6] */
80 400, /* FloatSave.FloatRegisters[7] */
81 256, /* FloatSave.ControlWord */
82 258, /* FloatSave.StatusWord */
83 260, /* FloatSave.TagWord */
84 268, /* FloatSave.ErrorSelector */
85 264, /* FloatSave.ErrorOffset */
86 276, /* FloatSave.DataSelector */
87 272, /* FloatSave.DataOffset */
88 268, /* FloatSave.ErrorSelector */
105 280, /* FloatSave.MxCsr */
108 #define AMD64_WINDOWS_SIZEOF_GREGSET 1232
110 /* Return nonzero if an argument of type TYPE should be passed
111 via one of the integer registers. */
114 amd64_windows_passed_by_integer_register (struct type
*type
)
116 switch (type
->code ())
121 case TYPE_CODE_RANGE
:
125 case TYPE_CODE_RVALUE_REF
:
126 case TYPE_CODE_STRUCT
:
127 case TYPE_CODE_UNION
:
128 return (TYPE_LENGTH (type
) == 1
129 || TYPE_LENGTH (type
) == 2
130 || TYPE_LENGTH (type
) == 4
131 || TYPE_LENGTH (type
) == 8);
138 /* Return nonzero if an argument of type TYPE should be passed
139 via one of the XMM registers. */
142 amd64_windows_passed_by_xmm_register (struct type
*type
)
144 return ((type
->code () == TYPE_CODE_FLT
145 || type
->code () == TYPE_CODE_DECFLOAT
)
146 && (TYPE_LENGTH (type
) == 4 || TYPE_LENGTH (type
) == 8));
149 /* Return non-zero iff an argument of the given TYPE should be passed
153 amd64_windows_passed_by_pointer (struct type
*type
)
155 if (amd64_windows_passed_by_integer_register (type
))
158 if (amd64_windows_passed_by_xmm_register (type
))
164 /* For each argument that should be passed by pointer, reserve some
165 stack space, store a copy of the argument on the stack, and replace
166 the argument by its address. Return the new Stack Pointer value.
168 NARGS is the number of arguments. ARGS is the array containing
169 the value of each argument. SP is value of the Stack Pointer. */
172 amd64_windows_adjust_args_passed_by_pointer (struct value
**args
,
173 int nargs
, CORE_ADDR sp
)
177 for (i
= 0; i
< nargs
; i
++)
178 if (amd64_windows_passed_by_pointer (value_type (args
[i
])))
180 struct type
*type
= value_type (args
[i
]);
181 const gdb_byte
*valbuf
= value_contents (args
[i
]);
182 const int len
= TYPE_LENGTH (type
);
184 /* Store a copy of that argument on the stack, aligned to
185 a 16 bytes boundary, and then use the copy's address as
190 write_memory (sp
, valbuf
, len
);
193 = value_addr (value_from_contents_and_address (type
, valbuf
, sp
));
199 /* Store the value of ARG in register REGNO (right-justified).
200 REGCACHE is the register cache. */
203 amd64_windows_store_arg_in_reg (struct regcache
*regcache
,
204 struct value
*arg
, int regno
)
206 struct type
*type
= value_type (arg
);
207 const gdb_byte
*valbuf
= value_contents (arg
);
210 gdb_assert (TYPE_LENGTH (type
) <= 8);
211 memset (buf
, 0, sizeof buf
);
212 memcpy (buf
, valbuf
, std::min (TYPE_LENGTH (type
), (ULONGEST
) 8));
213 regcache
->cooked_write (regno
, buf
);
216 /* Push the arguments for an inferior function call, and return
217 the updated value of the SP (Stack Pointer).
219 All arguments are identical to the arguments used in
220 amd64_windows_push_dummy_call. */
223 amd64_windows_push_arguments (struct regcache
*regcache
, int nargs
,
224 struct value
**args
, CORE_ADDR sp
,
225 function_call_return_method return_method
)
229 struct value
**stack_args
= XALLOCAVEC (struct value
*, nargs
);
230 int num_stack_args
= 0;
231 int num_elements
= 0;
234 /* First, handle the arguments passed by pointer.
236 These arguments are replaced by pointers to a copy we are making
237 in inferior memory. So use a copy of the ARGS table, to avoid
238 modifying the original one. */
240 struct value
**args1
= XALLOCAVEC (struct value
*, nargs
);
242 memcpy (args1
, args
, nargs
* sizeof (struct value
*));
243 sp
= amd64_windows_adjust_args_passed_by_pointer (args1
, nargs
, sp
);
247 /* Reserve a register for the "hidden" argument. */
248 if (return_method
== return_method_struct
)
251 for (i
= 0; i
< nargs
; i
++)
253 struct type
*type
= value_type (args
[i
]);
254 int len
= TYPE_LENGTH (type
);
257 if (reg_idx
< ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
))
259 if (amd64_windows_passed_by_integer_register (type
))
261 amd64_windows_store_arg_in_reg
263 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
267 else if (amd64_windows_passed_by_xmm_register (type
))
269 amd64_windows_store_arg_in_reg
270 (regcache
, args
[i
], AMD64_XMM0_REGNUM
+ reg_idx
);
271 /* In case of varargs, these parameters must also be
272 passed via the integer registers. */
273 amd64_windows_store_arg_in_reg
275 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
283 num_elements
+= ((len
+ 7) / 8);
284 stack_args
[num_stack_args
++] = args
[i
];
288 /* Allocate space for the arguments on the stack, keeping it
289 aligned on a 16 byte boundary. */
290 sp
-= num_elements
* 8;
293 /* Write out the arguments to the stack. */
294 for (i
= 0; i
< num_stack_args
; i
++)
296 struct type
*type
= value_type (stack_args
[i
]);
297 const gdb_byte
*valbuf
= value_contents (stack_args
[i
]);
299 write_memory (sp
+ element
* 8, valbuf
, TYPE_LENGTH (type
));
300 element
+= ((TYPE_LENGTH (type
) + 7) / 8);
306 /* Implement the "push_dummy_call" gdbarch method. */
309 amd64_windows_push_dummy_call
310 (struct gdbarch
*gdbarch
, struct value
*function
,
311 struct regcache
*regcache
, CORE_ADDR bp_addr
,
312 int nargs
, struct value
**args
, CORE_ADDR sp
,
313 function_call_return_method return_method
, CORE_ADDR struct_addr
)
315 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
318 /* Pass arguments. */
319 sp
= amd64_windows_push_arguments (regcache
, nargs
, args
, sp
,
322 /* Pass "hidden" argument". */
323 if (return_method
== return_method_struct
)
325 /* The "hidden" argument is passed throught the first argument
327 const int arg_regnum
= amd64_windows_dummy_call_integer_regs
[0];
329 store_unsigned_integer (buf
, 8, byte_order
, struct_addr
);
330 regcache
->cooked_write (arg_regnum
, buf
);
333 /* Reserve some memory on the stack for the integer-parameter
334 registers, as required by the ABI. */
335 sp
-= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
) * 8;
337 /* Store return address. */
339 store_unsigned_integer (buf
, 8, byte_order
, bp_addr
);
340 write_memory (sp
, buf
, 8);
342 /* Update the stack pointer... */
343 store_unsigned_integer (buf
, 8, byte_order
, sp
);
344 regcache
->cooked_write (AMD64_RSP_REGNUM
, buf
);
346 /* ...and fake a frame pointer. */
347 regcache
->cooked_write (AMD64_RBP_REGNUM
, buf
);
352 /* Implement the "return_value" gdbarch method for amd64-windows. */
354 static enum return_value_convention
355 amd64_windows_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
356 struct type
*type
, struct regcache
*regcache
,
357 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
359 int len
= TYPE_LENGTH (type
);
362 /* See if our value is returned through a register. If it is, then
363 store the associated register number in REGNUM. */
364 switch (type
->code ())
367 case TYPE_CODE_DECFLOAT
:
368 /* __m128, __m128i, __m128d, floats, and doubles are returned
370 if (len
== 4 || len
== 8 || len
== 16)
371 regnum
= AMD64_XMM0_REGNUM
;
374 /* All other values that are 1, 2, 4 or 8 bytes long are returned
376 if (len
== 1 || len
== 2 || len
== 4 || len
== 8)
377 regnum
= AMD64_RAX_REGNUM
;
383 /* RAX contains the address where the return value has been stored. */
388 regcache_raw_read_unsigned (regcache
, AMD64_RAX_REGNUM
, &addr
);
389 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
391 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
395 /* Extract the return value from the register where it was stored. */
397 regcache
->raw_read_part (regnum
, 0, len
, readbuf
);
399 regcache
->raw_write_part (regnum
, 0, len
, writebuf
);
400 return RETURN_VALUE_REGISTER_CONVENTION
;
404 /* Check that the code pointed to by PC corresponds to a call to
405 __main, skip it if so. Return PC otherwise. */
408 amd64_skip_main_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
413 target_read_memory (pc
, &op
, 1);
418 if (target_read_memory (pc
+ 1, buf
, sizeof buf
) == 0)
420 struct bound_minimal_symbol s
;
423 call_dest
= pc
+ 5 + extract_signed_integer (buf
, 4, byte_order
);
424 s
= lookup_minimal_symbol_by_pc (call_dest
);
426 && s
.minsym
->linkage_name () != NULL
427 && strcmp (s
.minsym
->linkage_name (), "__main") == 0)
435 struct amd64_windows_frame_cache
437 /* ImageBase for the module. */
438 CORE_ADDR image_base
;
440 /* Function start and end rva. */
444 /* Next instruction to be executed. */
450 /* Address of saved integer and xmm registers. */
451 CORE_ADDR prev_reg_addr
[16];
452 CORE_ADDR prev_xmm_addr
[16];
454 /* These two next fields are set only for machine info frames. */
456 /* Likewise for RIP. */
457 CORE_ADDR prev_rip_addr
;
459 /* Likewise for RSP. */
460 CORE_ADDR prev_rsp_addr
;
462 /* Address of the previous frame. */
466 /* Convert a Windows register number to gdb. */
467 static const enum amd64_regnum amd64_windows_w2gdb_regnum
[] =
487 /* Return TRUE iff PC is the range of the function corresponding to
491 pc_in_range (CORE_ADDR pc
, const struct amd64_windows_frame_cache
*cache
)
493 return (pc
>= cache
->image_base
+ cache
->start_rva
494 && pc
< cache
->image_base
+ cache
->end_rva
);
497 /* Try to recognize and decode an epilogue sequence.
499 Return -1 if we fail to read the instructions for any reason.
500 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
503 amd64_windows_frame_decode_epilogue (struct frame_info
*this_frame
,
504 struct amd64_windows_frame_cache
*cache
)
506 /* According to MSDN an epilogue "must consist of either an add RSP,constant
507 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
508 register pops and a return or a jmp".
510 Furthermore, according to RtlVirtualUnwind, the complete list of
515 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
516 - jmp qword ptr imm32 - not handled
517 - rex.w jmp reg [4X ff eY]
520 CORE_ADDR pc
= cache
->pc
;
521 CORE_ADDR cur_sp
= cache
->sp
;
522 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
523 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
527 /* We don't care about the instruction deallocating the frame:
528 if it hasn't been executed, the pc is still in the body,
529 if it has been executed, the following epilog decoding will work. */
532 - pop reg [41 58-5f] or [58-5f]. */
537 if (target_read_memory (pc
, &op
, 1) != 0)
540 if (op
>= 0x40 && op
<= 0x4f)
546 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
552 if (op
>= 0x58 && op
<= 0x5f)
555 gdb_byte reg
= (op
& 0x0f) | ((rex
& 1) << 3);
557 cache
->prev_reg_addr
[amd64_windows_w2gdb_regnum
[reg
]] = cur_sp
;
564 /* Allow the user to break this loop. This shouldn't happen as the
565 number of consecutive pop should be small. */
569 /* Then decode the marker. */
572 if (target_read_memory (pc
, &op
, 1) != 0)
579 cache
->prev_rip_addr
= cur_sp
;
580 cache
->prev_sp
= cur_sp
+ 8;
589 if (target_read_memory (pc
+ 1, &rel8
, 1) != 0)
591 npc
= pc
+ 2 + (signed char) rel8
;
593 /* If the jump is within the function, then this is not a marker,
594 otherwise this is a tail-call. */
595 return !pc_in_range (npc
, cache
);
604 if (target_read_memory (pc
+ 1, rel32
, 4) != 0)
606 npc
= pc
+ 5 + extract_signed_integer (rel32
, 4, byte_order
);
608 /* If the jump is within the function, then this is not a marker,
609 otherwise this is a tail-call. */
610 return !pc_in_range (npc
, cache
);
618 if (target_read_memory (pc
+ 1, imm16
, 2) != 0)
620 cache
->prev_rip_addr
= cur_sp
;
621 cache
->prev_sp
= cur_sp
622 + extract_unsigned_integer (imm16
, 4, byte_order
);
631 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
636 cache
->prev_rip_addr
= cur_sp
;
637 cache
->prev_sp
= cur_sp
+ 8;
657 /* Got a REX prefix, read next byte. */
659 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
667 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
669 return (op1
& 0xf8) == 0xe0;
675 /* Not REX, so unknown. */
680 /* Decode and execute unwind insns at UNWIND_INFO. */
683 amd64_windows_frame_decode_insns (struct frame_info
*this_frame
,
684 struct amd64_windows_frame_cache
*cache
,
685 CORE_ADDR unwind_info
)
687 CORE_ADDR save_addr
= 0;
688 CORE_ADDR cur_sp
= cache
->sp
;
689 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
690 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
693 /* There are at least 3 possibilities to share an unwind info entry:
694 1. Two different runtime_function entries (in .pdata) can point to the
695 same unwind info entry. There is no such indication while unwinding,
696 so we don't really care about that case. We suppose this scheme is
697 used to save memory when the unwind entries are exactly the same.
698 2. Chained unwind_info entries, with no unwind codes (no prologue).
699 There is a major difference with the previous case: the pc range for
700 the function is different (in case 1, the pc range comes from the
701 runtime_function entry; in case 2, the pc range for the chained entry
702 comes from the first unwind entry). Case 1 cannot be used instead as
703 the pc is not in the prologue. This case is officially documented.
704 (There might be unwind code in the first unwind entry to handle
705 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
707 3. Undocumented unwind info redirection. Hard to know the exact purpose,
708 so it is considered as a memory optimization of case 2.
713 /* Unofficially documented unwind info redirection, when UNWIND_INFO
714 address is odd (http://www.codemachine.com/article_x64deepdive.html).
716 struct external_pex64_runtime_function d
;
718 if (target_read_memory (cache
->image_base
+ (unwind_info
& ~1),
719 (gdb_byte
*) &d
, sizeof (d
)) != 0)
723 = extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
725 = extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
727 = extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
732 struct external_pex64_unwind_info ex_ui
;
733 /* There are at most 256 16-bit unwind insns. */
734 gdb_byte insns
[2 * 256];
737 unsigned char codes_count
;
738 unsigned char frame_reg
;
741 /* Read and decode header. */
742 if (target_read_memory (cache
->image_base
+ unwind_info
,
743 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) != 0)
749 "amd64_windows_frame_decodes_insn: "
750 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
751 paddress (gdbarch
, unwind_info
),
752 ex_ui
.Version_Flags
, ex_ui
.SizeOfPrologue
,
753 ex_ui
.CountOfCodes
, ex_ui
.FrameRegisterOffset
);
756 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 1
757 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 2)
760 start
= cache
->image_base
+ cache
->start_rva
;
762 && !(cache
->pc
>= start
&& cache
->pc
< start
+ ex_ui
.SizeOfPrologue
))
764 /* We want to detect if the PC points to an epilogue. This needs
765 to be checked only once, and an epilogue can be anywhere but in
766 the prologue. If so, the epilogue detection+decoding function is
767 sufficient. Otherwise, the unwinder will consider that the PC
768 is in the body of the function and will need to decode unwind
770 if (amd64_windows_frame_decode_epilogue (this_frame
, cache
) == 1)
773 /* Not in an epilog. Clear possible side effects. */
774 memset (cache
->prev_reg_addr
, 0, sizeof (cache
->prev_reg_addr
));
777 codes_count
= ex_ui
.CountOfCodes
;
778 frame_reg
= PEX64_UWI_FRAMEREG (ex_ui
.FrameRegisterOffset
);
782 /* According to msdn:
783 If an FP reg is used, then any unwind code taking an offset must
784 only be used after the FP reg is established in the prolog. */
786 int frreg
= amd64_windows_w2gdb_regnum
[frame_reg
];
788 get_frame_register (this_frame
, frreg
, buf
);
789 save_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
792 fprintf_unfiltered (gdb_stdlog
, " frame_reg=%s, val=%s\n",
793 gdbarch_register_name (gdbarch
, frreg
),
794 paddress (gdbarch
, save_addr
));
799 && target_read_memory (cache
->image_base
+ unwind_info
801 insns
, codes_count
* 2) != 0)
804 end_insns
= &insns
[codes_count
* 2];
807 /* Skip opcodes 6 of version 2. This opcode is not documented. */
808 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 2)
810 for (; p
< end_insns
; p
+= 2)
811 if (PEX64_UNWCODE_CODE (p
[1]) != 6)
815 for (; p
< end_insns
; p
+= 2)
819 /* Virtually execute the operation if the pc is after the
820 corresponding instruction (that does matter in case of break
821 within the prologue). Note that for chained info (!first), the
822 prologue has been fully executed. */
823 if (cache
->pc
>= start
+ p
[0] || cache
->pc
< start
)
827 (gdb_stdlog
, " op #%u: off=0x%02x, insn=0x%02x\n",
828 (unsigned) (p
- insns
), p
[0], p
[1]);
830 /* If there is no frame registers defined, the current value of
831 rsp is used instead. */
837 switch (PEX64_UNWCODE_CODE (p
[1]))
839 case UWOP_PUSH_NONVOL
:
840 /* Push pre-decrements RSP. */
841 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
842 cache
->prev_reg_addr
[reg
] = cur_sp
;
845 case UWOP_ALLOC_LARGE
:
846 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
848 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
849 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
850 cur_sp
+= extract_unsigned_integer (p
+ 2, 4, byte_order
);
854 case UWOP_ALLOC_SMALL
:
855 cur_sp
+= 8 + 8 * PEX64_UNWCODE_INFO (p
[1]);
859 - PEX64_UWI_FRAMEOFF (ex_ui
.FrameRegisterOffset
) * 16;
861 case UWOP_SAVE_NONVOL
:
862 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
863 cache
->prev_reg_addr
[reg
] = save_addr
864 + 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
866 case UWOP_SAVE_NONVOL_FAR
:
867 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
868 cache
->prev_reg_addr
[reg
] = save_addr
869 + 8 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
871 case UWOP_SAVE_XMM128
:
872 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
874 - 16 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
876 case UWOP_SAVE_XMM128_FAR
:
877 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
879 - 16 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
881 case UWOP_PUSH_MACHFRAME
:
882 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
884 cache
->prev_rip_addr
= cur_sp
+ 0;
885 cache
->prev_rsp_addr
= cur_sp
+ 24;
888 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
890 cache
->prev_rip_addr
= cur_sp
+ 8;
891 cache
->prev_rsp_addr
= cur_sp
+ 32;
901 /* Display address where the register was saved. */
902 if (frame_debug
&& reg
>= 0)
904 (gdb_stdlog
, " [reg %s at %s]\n",
905 gdbarch_register_name (gdbarch
, reg
),
906 paddress (gdbarch
, cache
->prev_reg_addr
[reg
]));
909 /* Adjust with the length of the opcode. */
910 switch (PEX64_UNWCODE_CODE (p
[1]))
912 case UWOP_PUSH_NONVOL
:
913 case UWOP_ALLOC_SMALL
:
915 case UWOP_PUSH_MACHFRAME
:
917 case UWOP_ALLOC_LARGE
:
918 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
920 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
925 case UWOP_SAVE_NONVOL
:
926 case UWOP_SAVE_XMM128
:
929 case UWOP_SAVE_NONVOL_FAR
:
930 case UWOP_SAVE_XMM128_FAR
:
937 if (PEX64_UWI_FLAGS (ex_ui
.Version_Flags
) != UNW_FLAG_CHAININFO
)
939 /* End of unwind info. */
944 /* Read the chained unwind info. */
945 struct external_pex64_runtime_function d
;
948 /* Not anymore the first entry. */
951 /* Stay aligned on word boundary. */
952 chain_vma
= cache
->image_base
+ unwind_info
953 + sizeof (ex_ui
) + ((codes_count
+ 1) & ~1) * 2;
955 if (target_read_memory (chain_vma
, (gdb_byte
*) &d
, sizeof (d
)) != 0)
958 /* Decode begin/end. This may be different from .pdata index, as
959 an unwind info may be shared by several functions (in particular
960 if many functions have the same prolog and handler. */
962 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
964 extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
966 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
971 "amd64_windows_frame_decodes_insn (next in chain):"
972 " unwind_data=%s, start_rva=%s, end_rva=%s\n",
973 paddress (gdbarch
, unwind_info
),
974 paddress (gdbarch
, cache
->start_rva
),
975 paddress (gdbarch
, cache
->end_rva
));
978 /* Allow the user to break this loop. */
981 /* PC is saved by the call. */
982 if (cache
->prev_rip_addr
== 0)
983 cache
->prev_rip_addr
= cur_sp
;
984 cache
->prev_sp
= cur_sp
+ 8;
987 fprintf_unfiltered (gdb_stdlog
, " prev_sp: %s, prev_pc @%s\n",
988 paddress (gdbarch
, cache
->prev_sp
),
989 paddress (gdbarch
, cache
->prev_rip_addr
));
992 /* Find SEH unwind info for PC, returning 0 on success.
994 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
995 to the base address of the corresponding image, and START_RVA
996 to the rva of the function containing PC. */
999 amd64_windows_find_unwind_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1000 CORE_ADDR
*unwind_info
,
1001 CORE_ADDR
*image_base
,
1002 CORE_ADDR
*start_rva
,
1005 struct obj_section
*sec
;
1007 IMAGE_DATA_DIRECTORY
*dir
;
1008 struct objfile
*objfile
;
1009 unsigned long lo
, hi
;
1011 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1013 /* Get the corresponding exception directory. */
1014 sec
= find_pc_section (pc
);
1017 objfile
= sec
->objfile
;
1018 pe
= pe_data (sec
->objfile
->obfd
);
1019 dir
= &pe
->pe_opthdr
.DataDirectory
[PE_EXCEPTION_TABLE
];
1021 base
= pe
->pe_opthdr
.ImageBase
+ objfile
->text_section_offset ();
1026 Note: This does not handle dynamically added entries (for JIT
1027 engines). For this, we would need to ask the kernel directly,
1028 which means getting some info from the native layer. For the
1029 rest of the code, however, it's probably faster to search
1030 the entry ourselves. */
1032 hi
= dir
->Size
/ sizeof (struct external_pex64_runtime_function
);
1036 unsigned long mid
= lo
+ (hi
- lo
) / 2;
1037 struct external_pex64_runtime_function d
;
1040 if (target_read_memory (base
+ dir
->VirtualAddress
+ mid
* sizeof (d
),
1041 (gdb_byte
*) &d
, sizeof (d
)) != 0)
1044 sa
= extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
1045 ea
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
1048 else if (pc
>= base
+ ea
)
1050 else if (pc
>= base
+ sa
&& pc
< base
+ ea
)
1056 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
1066 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
1067 paddress (gdbarch
, base
), paddress (gdbarch
, *unwind_info
));
1072 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1075 static struct amd64_windows_frame_cache
*
1076 amd64_windows_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
1078 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1079 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1080 struct amd64_windows_frame_cache
*cache
;
1083 CORE_ADDR unwind_info
= 0;
1086 return (struct amd64_windows_frame_cache
*) *this_cache
;
1088 cache
= FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache
);
1089 *this_cache
= cache
;
1091 /* Get current PC and SP. */
1092 pc
= get_frame_pc (this_frame
);
1093 get_frame_register (this_frame
, AMD64_RSP_REGNUM
, buf
);
1094 cache
->sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1097 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1103 if (unwind_info
== 0)
1105 /* Assume a leaf function. */
1106 cache
->prev_sp
= cache
->sp
+ 8;
1107 cache
->prev_rip_addr
= cache
->sp
;
1111 /* Decode unwind insns to compute saved addresses. */
1112 amd64_windows_frame_decode_insns (this_frame
, cache
, unwind_info
);
1117 /* Implement the "prev_register" method of struct frame_unwind
1118 using the standard Windows x64 SEH info. */
1120 static struct value
*
1121 amd64_windows_frame_prev_register (struct frame_info
*this_frame
,
1122 void **this_cache
, int regnum
)
1124 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1125 struct amd64_windows_frame_cache
*cache
=
1126 amd64_windows_frame_cache (this_frame
, this_cache
);
1130 fprintf_unfiltered (gdb_stdlog
,
1131 "amd64_windows_frame_prev_register %s for sp=%s\n",
1132 gdbarch_register_name (gdbarch
, regnum
),
1133 paddress (gdbarch
, cache
->prev_sp
));
1135 if (regnum
>= AMD64_XMM0_REGNUM
&& regnum
<= AMD64_XMM0_REGNUM
+ 15)
1136 prev
= cache
->prev_xmm_addr
[regnum
- AMD64_XMM0_REGNUM
];
1137 else if (regnum
== AMD64_RSP_REGNUM
)
1139 prev
= cache
->prev_rsp_addr
;
1141 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_sp
);
1143 else if (regnum
>= AMD64_RAX_REGNUM
&& regnum
<= AMD64_R15_REGNUM
)
1144 prev
= cache
->prev_reg_addr
[regnum
- AMD64_RAX_REGNUM
];
1145 else if (regnum
== AMD64_RIP_REGNUM
)
1146 prev
= cache
->prev_rip_addr
;
1150 if (prev
&& frame_debug
)
1151 fprintf_unfiltered (gdb_stdlog
, " -> at %s\n", paddress (gdbarch
, prev
));
1155 /* Register was saved. */
1156 return frame_unwind_got_memory (this_frame
, regnum
, prev
);
1160 /* Register is either volatile or not modified. */
1161 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1165 /* Implement the "this_id" method of struct frame_unwind using
1166 the standard Windows x64 SEH info. */
1169 amd64_windows_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1170 struct frame_id
*this_id
)
1172 struct amd64_windows_frame_cache
*cache
=
1173 amd64_windows_frame_cache (this_frame
, this_cache
);
1175 *this_id
= frame_id_build (cache
->prev_sp
,
1176 cache
->image_base
+ cache
->start_rva
);
1179 /* Windows x64 SEH unwinder. */
1181 static const struct frame_unwind amd64_windows_frame_unwind
=
1184 default_frame_unwind_stop_reason
,
1185 &amd64_windows_frame_this_id
,
1186 &amd64_windows_frame_prev_register
,
1188 default_frame_sniffer
1191 /* Implement the "skip_prologue" gdbarch method. */
1194 amd64_windows_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1196 CORE_ADDR func_addr
;
1197 CORE_ADDR unwind_info
= 0;
1198 CORE_ADDR image_base
, start_rva
, end_rva
;
1199 struct external_pex64_unwind_info ex_ui
;
1201 /* Use prologue size from unwind info. */
1202 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1203 &image_base
, &start_rva
, &end_rva
) == 0)
1205 if (unwind_info
== 0)
1207 /* Leaf function. */
1210 else if (target_read_memory (image_base
+ unwind_info
,
1211 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) == 0
1212 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 1)
1213 return std::max (pc
, image_base
+ start_rva
+ ex_ui
.SizeOfPrologue
);
1216 /* See if we can determine the end of the prologue via the symbol
1217 table. If so, then return either the PC, or the PC after
1218 the prologue, whichever is greater. */
1219 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1221 CORE_ADDR post_prologue_pc
1222 = skip_prologue_using_sal (gdbarch
, func_addr
);
1224 if (post_prologue_pc
!= 0)
1225 return std::max (pc
, post_prologue_pc
);
1231 /* Check Win64 DLL jmp trampolines and find jump destination. */
1234 amd64_windows_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1236 CORE_ADDR destination
= 0;
1237 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1238 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1240 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1241 if (pc
&& read_memory_unsigned_integer (pc
, 2, byte_order
) == 0x25ff)
1243 /* Get opcode offset and see if we can find a reference in our data. */
1245 = read_memory_unsigned_integer (pc
+ 2, 4, byte_order
);
1247 /* Get address of function pointer at end of pc. */
1248 CORE_ADDR indirect_addr
= pc
+ offset
+ 6;
1250 struct minimal_symbol
*indsym
1252 ? lookup_minimal_symbol_by_pc (indirect_addr
).minsym
1254 const char *symname
= indsym
? indsym
->linkage_name () : NULL
;
1258 if (startswith (symname
, "__imp_")
1259 || startswith (symname
, "_imp_"))
1261 = read_memory_unsigned_integer (indirect_addr
, 8, byte_order
);
1268 /* Implement the "auto_wide_charset" gdbarch method. */
1271 amd64_windows_auto_wide_charset (void)
1276 /* Common parts for gdbarch initialization for Windows and Cygwin on AMD64. */
1279 amd64_windows_init_abi_common (gdbarch_info info
, struct gdbarch
*gdbarch
)
1281 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1283 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1284 preferred over the SEH one. The reasons are:
1285 - binaries without SEH but with dwarf2 debug info are correctly handled
1286 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1288 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1289 handled if the dwarf2 unwinder is used).
1291 The call to amd64_init_abi appends default unwinders, that aren't
1292 compatible with the SEH one.
1294 frame_unwind_append_unwinder (gdbarch
, &amd64_windows_frame_unwind
);
1296 amd64_init_abi (info
, gdbarch
,
1297 amd64_target_description (X86_XSTATE_SSE_MASK
, false));
1299 /* Function calls. */
1300 set_gdbarch_push_dummy_call (gdbarch
, amd64_windows_push_dummy_call
);
1301 set_gdbarch_return_value (gdbarch
, amd64_windows_return_value
);
1302 set_gdbarch_skip_main_prologue (gdbarch
, amd64_skip_main_prologue
);
1303 set_gdbarch_skip_trampoline_code (gdbarch
,
1304 amd64_windows_skip_trampoline_code
);
1306 set_gdbarch_skip_prologue (gdbarch
, amd64_windows_skip_prologue
);
1308 tdep
->gregset_reg_offset
= amd64_windows_gregset_reg_offset
;
1309 tdep
->gregset_num_regs
= ARRAY_SIZE (amd64_windows_gregset_reg_offset
);
1310 tdep
->sizeof_gregset
= AMD64_WINDOWS_SIZEOF_GREGSET
;
1311 tdep
->sizeof_fpregset
= 0;
1313 /* Core file support. */
1314 set_gdbarch_core_xfer_shared_libraries
1315 (gdbarch
, windows_core_xfer_shared_libraries
);
1316 set_gdbarch_core_pid_to_str (gdbarch
, windows_core_pid_to_str
);
1318 set_gdbarch_auto_wide_charset (gdbarch
, amd64_windows_auto_wide_charset
);
1321 /* gdbarch initialization for Windows on AMD64. */
1324 amd64_windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1326 amd64_windows_init_abi_common (info
, gdbarch
);
1327 windows_init_abi (info
, gdbarch
);
1329 /* On Windows, "long"s are only 32bit. */
1330 set_gdbarch_long_bit (gdbarch
, 32);
1333 /* gdbarch initialization for Cygwin on AMD64. */
1336 amd64_cygwin_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1338 amd64_windows_init_abi_common (info
, gdbarch
);
1339 cygwin_init_abi (info
, gdbarch
);
1343 amd64_windows_osabi_sniffer (bfd
*abfd
)
1345 const char *target_name
= bfd_get_target (abfd
);
1347 if (!streq (target_name
, "pei-x86-64"))
1348 return GDB_OSABI_UNKNOWN
;
1350 if (is_linked_with_cygwin_dll (abfd
))
1351 return GDB_OSABI_CYGWIN
;
1353 return GDB_OSABI_WINDOWS
;
1356 static enum gdb_osabi
1357 amd64_cygwin_core_osabi_sniffer (bfd
*abfd
)
1359 const char *target_name
= bfd_get_target (abfd
);
1361 /* Cygwin uses elf core dumps. Do not claim all ELF executables,
1362 check whether there is a .reg section of proper size. */
1363 if (strcmp (target_name
, "elf64-x86-64") == 0)
1365 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1366 if (section
!= nullptr
1367 && bfd_section_size (section
) == AMD64_WINDOWS_SIZEOF_GREGSET
)
1368 return GDB_OSABI_CYGWIN
;
1371 return GDB_OSABI_UNKNOWN
;
1374 void _initialize_amd64_windows_tdep ();
1376 _initialize_amd64_windows_tdep ()
1378 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_WINDOWS
,
1379 amd64_windows_init_abi
);
1380 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_CYGWIN
,
1381 amd64_cygwin_init_abi
);
1383 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_coff_flavour
,
1384 amd64_windows_osabi_sniffer
);
1386 /* Cygwin uses elf core dumps. */
1387 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_elf_flavour
,
1388 amd64_cygwin_core_osabi_sniffer
);