1 /* Copyright (C) 2009-2024 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/>. */
19 #include "amd64-tdep.h"
20 #include "gdbsupport/x86-xstate.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 /* This vector maps GDB's idea of a register's number into an offset into
45 the Windows API CONTEXT structure. */
46 static int amd64_windows_gregset_reg_offset
[] =
72 288, /* FloatSave.FloatRegisters[0] */
73 304, /* FloatSave.FloatRegisters[1] */
74 320, /* FloatSave.FloatRegisters[2] */
75 336, /* FloatSave.FloatRegisters[3] */
76 352, /* FloatSave.FloatRegisters[4] */
77 368, /* FloatSave.FloatRegisters[5] */
78 384, /* FloatSave.FloatRegisters[6] */
79 400, /* FloatSave.FloatRegisters[7] */
80 256, /* FloatSave.ControlWord */
81 258, /* FloatSave.StatusWord */
82 260, /* FloatSave.TagWord */
83 268, /* FloatSave.ErrorSelector */
84 264, /* FloatSave.ErrorOffset */
85 276, /* FloatSave.DataSelector */
86 272, /* FloatSave.DataOffset */
87 268, /* FloatSave.ErrorSelector */
104 280, /* FloatSave.MxCsr */
107 #define AMD64_WINDOWS_SIZEOF_GREGSET 1232
109 /* Return nonzero if an argument of type TYPE should be passed
110 via one of the integer registers. */
113 amd64_windows_passed_by_integer_register (struct type
*type
)
115 switch (type
->code ())
120 case TYPE_CODE_RANGE
:
124 case TYPE_CODE_RVALUE_REF
:
125 case TYPE_CODE_STRUCT
:
126 case TYPE_CODE_UNION
:
127 case TYPE_CODE_COMPLEX
:
128 return (type
->length () == 1
129 || type
->length () == 2
130 || type
->length () == 4
131 || type
->length () == 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 () == 4 || type
->length () == 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 (args
[i
]->type ()))
180 struct type
*type
= args
[i
]->type ();
181 const gdb_byte
*valbuf
= args
[i
]->contents ().data ();
182 const int len
= type
->length ();
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
= arg
->type ();
207 const gdb_byte
*valbuf
= arg
->contents ().data ();
210 gdb_assert (type
->length () <= 8);
211 memset (buf
, 0, sizeof buf
);
212 memcpy (buf
, valbuf
, std::min (type
->length (), (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
= args
[i
]->type ();
254 int len
= type
->length ();
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
= stack_args
[i
]->type ();
297 const gdb_byte
*valbuf
= stack_args
[i
]->contents ().data ();
299 write_memory (sp
+ element
* 8, valbuf
, type
->length ());
300 element
+= ((type
->length () + 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 struct value
**read_value
, const gdb_byte
*writebuf
)
359 int len
= type
->length ();
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 /* floats, and doubles are returned via XMM0. */
368 if (len
== 4 || len
== 8)
369 regnum
= AMD64_XMM0_REGNUM
;
371 case TYPE_CODE_ARRAY
:
372 /* __m128, __m128i and __m128d are returned via XMM0. */
373 if (type
->is_vector () && len
== 16)
375 enum type_code code
= type
->target_type ()->code ();
376 if (code
== TYPE_CODE_INT
|| code
== TYPE_CODE_FLT
)
378 regnum
= AMD64_XMM0_REGNUM
;
384 /* All other values that are 1, 2, 4 or 8 bytes long are returned
386 if (len
== 1 || len
== 2 || len
== 4 || len
== 8)
387 regnum
= AMD64_RAX_REGNUM
;
388 else if (len
== 16 && type
->code () == TYPE_CODE_INT
)
389 regnum
= AMD64_XMM0_REGNUM
;
395 /* RAX contains the address where the return value has been stored. */
396 if (read_value
!= nullptr)
400 regcache_raw_read_unsigned (regcache
, AMD64_RAX_REGNUM
, &addr
);
401 *read_value
= value_at_non_lval (type
, addr
);
403 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
407 /* Extract the return value from the register where it was stored. */
408 if (read_value
!= nullptr)
410 *read_value
= value::allocate (type
);
411 regcache
->raw_read_part (regnum
, 0, len
,
412 (*read_value
)->contents_raw ().data ());
415 regcache
->raw_write_part (regnum
, 0, len
, writebuf
);
416 return RETURN_VALUE_REGISTER_CONVENTION
;
420 /* Check that the code pointed to by PC corresponds to a call to
421 __main, skip it if so. Return PC otherwise. */
424 amd64_skip_main_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
426 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
429 target_read_memory (pc
, &op
, 1);
434 if (target_read_memory (pc
+ 1, buf
, sizeof buf
) == 0)
436 struct bound_minimal_symbol s
;
439 call_dest
= pc
+ 5 + extract_signed_integer (buf
, 4, byte_order
);
440 s
= lookup_minimal_symbol_by_pc (call_dest
);
442 && s
.minsym
->linkage_name () != NULL
443 && strcmp (s
.minsym
->linkage_name (), "__main") == 0)
451 struct amd64_windows_frame_cache
453 /* ImageBase for the module. */
454 CORE_ADDR image_base
;
456 /* Function start and end rva. */
460 /* Next instruction to be executed. */
466 /* Address of saved integer and xmm registers. */
467 CORE_ADDR prev_reg_addr
[16];
468 CORE_ADDR prev_xmm_addr
[16];
470 /* These two next fields are set only for machine info frames. */
472 /* Likewise for RIP. */
473 CORE_ADDR prev_rip_addr
;
475 /* Likewise for RSP. */
476 CORE_ADDR prev_rsp_addr
;
478 /* Address of the previous frame. */
482 /* Convert a Windows register number to gdb. */
483 static const enum amd64_regnum amd64_windows_w2gdb_regnum
[] =
503 /* Return TRUE iff PC is the range of the function corresponding to
507 pc_in_range (CORE_ADDR pc
, const struct amd64_windows_frame_cache
*cache
)
509 return (pc
>= cache
->image_base
+ cache
->start_rva
510 && pc
< cache
->image_base
+ cache
->end_rva
);
513 /* Try to recognize and decode an epilogue sequence.
515 Return -1 if we fail to read the instructions for any reason.
516 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
519 amd64_windows_frame_decode_epilogue (const frame_info_ptr
&this_frame
,
520 struct amd64_windows_frame_cache
*cache
)
522 /* According to MSDN an epilogue "must consist of either an add RSP,constant
523 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
524 register pops and a return or a jmp".
526 Furthermore, according to RtlVirtualUnwind, the complete list of
531 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
532 - jmp qword ptr imm32 - not handled
533 - rex.w jmp reg [4X ff eY]
536 CORE_ADDR pc
= cache
->pc
;
537 CORE_ADDR cur_sp
= cache
->sp
;
538 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
539 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
543 /* We don't care about the instruction deallocating the frame:
544 if it hasn't been executed, the pc is still in the body,
545 if it has been executed, the following epilog decoding will work. */
548 - pop reg [41 58-5f] or [58-5f]. */
553 if (target_read_memory (pc
, &op
, 1) != 0)
556 if (op
>= 0x40 && op
<= 0x4f)
562 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
568 if (op
>= 0x58 && op
<= 0x5f)
571 gdb_byte reg
= (op
& 0x0f) | ((rex
& 1) << 3);
573 cache
->prev_reg_addr
[amd64_windows_w2gdb_regnum
[reg
]] = cur_sp
;
580 /* Allow the user to break this loop. This shouldn't happen as the
581 number of consecutive pop should be small. */
585 /* Then decode the marker. */
588 if (target_read_memory (pc
, &op
, 1) != 0)
595 cache
->prev_rip_addr
= cur_sp
;
596 cache
->prev_sp
= cur_sp
+ 8;
605 if (target_read_memory (pc
+ 1, &rel8
, 1) != 0)
607 npc
= pc
+ 2 + (signed char) rel8
;
609 /* If the jump is within the function, then this is not a marker,
610 otherwise this is a tail-call. */
611 return !pc_in_range (npc
, cache
);
620 if (target_read_memory (pc
+ 1, rel32
, 4) != 0)
622 npc
= pc
+ 5 + extract_signed_integer (rel32
, 4, byte_order
);
624 /* If the jump is within the function, then this is not a marker,
625 otherwise this is a tail-call. */
626 return !pc_in_range (npc
, cache
);
634 if (target_read_memory (pc
+ 1, imm16
, 2) != 0)
636 cache
->prev_rip_addr
= cur_sp
;
637 cache
->prev_sp
= cur_sp
638 + extract_unsigned_integer (imm16
, 4, byte_order
);
647 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
652 cache
->prev_rip_addr
= cur_sp
;
653 cache
->prev_sp
= cur_sp
+ 8;
673 /* Got a REX prefix, read next byte. */
675 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
683 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
685 return (op1
& 0xf8) == 0xe0;
691 /* Not REX, so unknown. */
696 /* Decode and execute unwind insns at UNWIND_INFO. */
699 amd64_windows_frame_decode_insns (const frame_info_ptr
&this_frame
,
700 struct amd64_windows_frame_cache
*cache
,
701 CORE_ADDR unwind_info
)
703 CORE_ADDR save_addr
= 0;
704 CORE_ADDR cur_sp
= cache
->sp
;
705 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
706 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
709 /* There are at least 3 possibilities to share an unwind info entry:
710 1. Two different runtime_function entries (in .pdata) can point to the
711 same unwind info entry. There is no such indication while unwinding,
712 so we don't really care about that case. We suppose this scheme is
713 used to save memory when the unwind entries are exactly the same.
714 2. Chained unwind_info entries, with no unwind codes (no prologue).
715 There is a major difference with the previous case: the pc range for
716 the function is different (in case 1, the pc range comes from the
717 runtime_function entry; in case 2, the pc range for the chained entry
718 comes from the first unwind entry). Case 1 cannot be used instead as
719 the pc is not in the prologue. This case is officially documented.
720 (There might be unwind code in the first unwind entry to handle
721 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
723 3. Undocumented unwind info redirection. Hard to know the exact purpose,
724 so it is considered as a memory optimization of case 2.
729 /* Unofficially documented unwind info redirection, when UNWIND_INFO
730 address is odd (http://www.codemachine.com/article_x64deepdive.html).
732 struct external_pex64_runtime_function d
;
734 if (target_read_memory (cache
->image_base
+ (unwind_info
& ~1),
735 (gdb_byte
*) &d
, sizeof (d
)) != 0)
739 = extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
741 = extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
743 = extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
748 struct external_pex64_unwind_info ex_ui
;
749 /* There are at most 256 16-bit unwind insns. */
750 gdb_byte insns
[2 * 256];
753 unsigned char codes_count
;
754 unsigned char frame_reg
;
757 /* Read and decode header. */
758 if (target_read_memory (cache
->image_base
+ unwind_info
,
759 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) != 0)
762 frame_debug_printf ("%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x",
763 paddress (gdbarch
, unwind_info
),
764 ex_ui
.Version_Flags
, ex_ui
.SizeOfPrologue
,
765 ex_ui
.CountOfCodes
, ex_ui
.FrameRegisterOffset
);
768 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 1
769 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 2)
772 start
= cache
->image_base
+ cache
->start_rva
;
774 && !(cache
->pc
>= start
&& cache
->pc
< start
+ ex_ui
.SizeOfPrologue
))
776 /* We want to detect if the PC points to an epilogue. This needs
777 to be checked only once, and an epilogue can be anywhere but in
778 the prologue. If so, the epilogue detection+decoding function is
779 sufficient. Otherwise, the unwinder will consider that the PC
780 is in the body of the function and will need to decode unwind
782 if (amd64_windows_frame_decode_epilogue (this_frame
, cache
) == 1)
785 /* Not in an epilog. Clear possible side effects. */
786 memset (cache
->prev_reg_addr
, 0, sizeof (cache
->prev_reg_addr
));
789 codes_count
= ex_ui
.CountOfCodes
;
790 frame_reg
= PEX64_UWI_FRAMEREG (ex_ui
.FrameRegisterOffset
);
794 /* According to msdn:
795 If an FP reg is used, then any unwind code taking an offset must
796 only be used after the FP reg is established in the prolog. */
798 int frreg
= amd64_windows_w2gdb_regnum
[frame_reg
];
800 get_frame_register (this_frame
, frreg
, buf
);
801 save_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
803 frame_debug_printf (" frame_reg=%s, val=%s",
804 gdbarch_register_name (gdbarch
, frreg
),
805 paddress (gdbarch
, save_addr
));
810 && target_read_memory (cache
->image_base
+ unwind_info
812 insns
, codes_count
* 2) != 0)
815 end_insns
= &insns
[codes_count
* 2];
818 /* Skip opcodes 6 of version 2. This opcode is not documented. */
819 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 2)
821 for (; p
< end_insns
; p
+= 2)
822 if (PEX64_UNWCODE_CODE (p
[1]) != 6)
826 for (; p
< end_insns
; p
+= 2)
830 /* Virtually execute the operation if the pc is after the
831 corresponding instruction (that does matter in case of break
832 within the prologue). Note that for chained info (!first), the
833 prologue has been fully executed. */
834 if (cache
->pc
>= start
+ p
[0] || cache
->pc
< start
)
836 frame_debug_printf (" op #%u: off=0x%02x, insn=0x%02x",
837 (unsigned) (p
- insns
), p
[0], p
[1]);
839 /* If there is no frame registers defined, the current value of
840 rsp is used instead. */
846 switch (PEX64_UNWCODE_CODE (p
[1]))
848 case UWOP_PUSH_NONVOL
:
849 /* Push pre-decrements RSP. */
850 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
851 cache
->prev_reg_addr
[reg
] = cur_sp
;
854 case UWOP_ALLOC_LARGE
:
855 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
857 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
858 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
859 cur_sp
+= extract_unsigned_integer (p
+ 2, 4, byte_order
);
863 case UWOP_ALLOC_SMALL
:
864 cur_sp
+= 8 + 8 * PEX64_UNWCODE_INFO (p
[1]);
868 - PEX64_UWI_FRAMEOFF (ex_ui
.FrameRegisterOffset
) * 16;
870 case UWOP_SAVE_NONVOL
:
871 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
872 cache
->prev_reg_addr
[reg
] = save_addr
873 + 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
875 case UWOP_SAVE_NONVOL_FAR
:
876 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
877 cache
->prev_reg_addr
[reg
] = save_addr
878 + 8 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
880 case UWOP_SAVE_XMM128
:
881 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
883 - 16 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
885 case UWOP_SAVE_XMM128_FAR
:
886 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
888 - 16 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
890 case UWOP_PUSH_MACHFRAME
:
891 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
893 cache
->prev_rip_addr
= cur_sp
+ 0;
894 cache
->prev_rsp_addr
= cur_sp
+ 24;
897 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
899 cache
->prev_rip_addr
= cur_sp
+ 8;
900 cache
->prev_rsp_addr
= cur_sp
+ 32;
910 /* Display address where the register was saved. */
912 frame_debug_printf (" [reg %s at %s]",
913 gdbarch_register_name (gdbarch
, reg
),
915 cache
->prev_reg_addr
[reg
]));
918 /* Adjust with the length of the opcode. */
919 switch (PEX64_UNWCODE_CODE (p
[1]))
921 case UWOP_PUSH_NONVOL
:
922 case UWOP_ALLOC_SMALL
:
924 case UWOP_PUSH_MACHFRAME
:
926 case UWOP_ALLOC_LARGE
:
927 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
929 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
934 case UWOP_SAVE_NONVOL
:
935 case UWOP_SAVE_XMM128
:
938 case UWOP_SAVE_NONVOL_FAR
:
939 case UWOP_SAVE_XMM128_FAR
:
946 if (PEX64_UWI_FLAGS (ex_ui
.Version_Flags
) != UNW_FLAG_CHAININFO
)
948 /* End of unwind info. */
953 /* Read the chained unwind info. */
954 struct external_pex64_runtime_function d
;
957 /* Not anymore the first entry. */
960 /* Stay aligned on word boundary. */
961 chain_vma
= cache
->image_base
+ unwind_info
962 + sizeof (ex_ui
) + ((codes_count
+ 1) & ~1) * 2;
964 if (target_read_memory (chain_vma
, (gdb_byte
*) &d
, sizeof (d
)) != 0)
967 /* Decode begin/end. This may be different from .pdata index, as
968 an unwind info may be shared by several functions (in particular
969 if many functions have the same prolog and handler. */
971 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
973 extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
975 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
977 frame_debug_printf ("next in chain: unwind_data=%s, start_rva=%s, "
979 paddress (gdbarch
, unwind_info
),
980 paddress (gdbarch
, cache
->start_rva
),
981 paddress (gdbarch
, cache
->end_rva
));
984 /* Allow the user to break this loop. */
987 /* PC is saved by the call. */
988 if (cache
->prev_rip_addr
== 0)
989 cache
->prev_rip_addr
= cur_sp
;
990 cache
->prev_sp
= cur_sp
+ 8;
992 frame_debug_printf (" prev_sp: %s, prev_pc @%s",
993 paddress (gdbarch
, cache
->prev_sp
),
994 paddress (gdbarch
, cache
->prev_rip_addr
));
997 /* Find SEH unwind info for PC, returning 0 on success.
999 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
1000 to the base address of the corresponding image, and START_RVA
1001 to the rva of the function containing PC. */
1004 amd64_windows_find_unwind_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1005 CORE_ADDR
*unwind_info
,
1006 CORE_ADDR
*image_base
,
1007 CORE_ADDR
*start_rva
,
1010 struct obj_section
*sec
;
1012 IMAGE_DATA_DIRECTORY
*dir
;
1013 struct objfile
*objfile
;
1014 unsigned long lo
, hi
;
1016 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1018 /* Get the corresponding exception directory. */
1019 sec
= find_pc_section (pc
);
1022 objfile
= sec
->objfile
;
1023 pe
= pe_data (sec
->objfile
->obfd
);
1024 dir
= &pe
->pe_opthdr
.DataDirectory
[PE_EXCEPTION_TABLE
];
1026 base
= pe
->pe_opthdr
.ImageBase
+ objfile
->text_section_offset ();
1031 Note: This does not handle dynamically added entries (for JIT
1032 engines). For this, we would need to ask the kernel directly,
1033 which means getting some info from the native layer. For the
1034 rest of the code, however, it's probably faster to search
1035 the entry ourselves. */
1037 hi
= dir
->Size
/ sizeof (struct external_pex64_runtime_function
);
1041 unsigned long mid
= lo
+ (hi
- lo
) / 2;
1042 struct external_pex64_runtime_function d
;
1045 if (target_read_memory (base
+ dir
->VirtualAddress
+ mid
* sizeof (d
),
1046 (gdb_byte
*) &d
, sizeof (d
)) != 0)
1049 sa
= extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
1050 ea
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
1053 else if (pc
>= base
+ ea
)
1055 else if (pc
>= base
+ sa
&& pc
< base
+ ea
)
1061 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
1068 frame_debug_printf ("image_base=%s, unwind_data=%s",
1069 paddress (gdbarch
, base
),
1070 paddress (gdbarch
, *unwind_info
));
1075 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1078 static struct amd64_windows_frame_cache
*
1079 amd64_windows_frame_cache (const frame_info_ptr
&this_frame
, void **this_cache
)
1081 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1082 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1083 struct amd64_windows_frame_cache
*cache
;
1086 CORE_ADDR unwind_info
= 0;
1089 return (struct amd64_windows_frame_cache
*) *this_cache
;
1091 cache
= FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache
);
1092 *this_cache
= cache
;
1094 /* Get current PC and SP. */
1095 pc
= get_frame_pc (this_frame
);
1096 get_frame_register (this_frame
, AMD64_RSP_REGNUM
, buf
);
1097 cache
->sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1100 /* If we can't find the unwind info, keep trying as though this is a
1101 leaf function. This situation can happen when PC==0, see
1102 https://sourceware.org/bugzilla/show_bug.cgi?id=30255. */
1103 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1107 || unwind_info
== 0)
1109 /* Assume a leaf function. */
1110 cache
->prev_sp
= cache
->sp
+ 8;
1111 cache
->prev_rip_addr
= cache
->sp
;
1115 /* Decode unwind insns to compute saved addresses. */
1116 amd64_windows_frame_decode_insns (this_frame
, cache
, unwind_info
);
1121 /* Implement the "prev_register" method of struct frame_unwind
1122 using the standard Windows x64 SEH info. */
1124 static struct value
*
1125 amd64_windows_frame_prev_register (const frame_info_ptr
&this_frame
,
1126 void **this_cache
, int regnum
)
1128 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1129 struct amd64_windows_frame_cache
*cache
=
1130 amd64_windows_frame_cache (this_frame
, this_cache
);
1133 frame_debug_printf ("%s for sp=%s",
1134 gdbarch_register_name (gdbarch
, regnum
),
1135 paddress (gdbarch
, cache
->prev_sp
));
1137 if (regnum
>= AMD64_XMM0_REGNUM
&& regnum
<= AMD64_XMM0_REGNUM
+ 15)
1138 prev
= cache
->prev_xmm_addr
[regnum
- AMD64_XMM0_REGNUM
];
1139 else if (regnum
== AMD64_RSP_REGNUM
)
1141 prev
= cache
->prev_rsp_addr
;
1143 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_sp
);
1145 else if (regnum
>= AMD64_RAX_REGNUM
&& regnum
<= AMD64_R15_REGNUM
)
1146 prev
= cache
->prev_reg_addr
[regnum
- AMD64_RAX_REGNUM
];
1147 else if (regnum
== AMD64_RIP_REGNUM
)
1148 prev
= cache
->prev_rip_addr
;
1153 frame_debug_printf (" -> at %s", paddress (gdbarch
, prev
));
1157 /* Register was saved. */
1158 return frame_unwind_got_memory (this_frame
, regnum
, prev
);
1162 /* Register is either volatile or not modified. */
1163 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1167 /* Implement the "this_id" method of struct frame_unwind using
1168 the standard Windows x64 SEH info. */
1171 amd64_windows_frame_this_id (const frame_info_ptr
&this_frame
, void **this_cache
,
1172 struct frame_id
*this_id
)
1174 struct amd64_windows_frame_cache
*cache
=
1175 amd64_windows_frame_cache (this_frame
, this_cache
);
1177 *this_id
= frame_id_build (cache
->prev_sp
,
1178 cache
->image_base
+ cache
->start_rva
);
1181 /* Windows x64 SEH unwinder. */
1183 static const struct frame_unwind amd64_windows_frame_unwind
=
1187 default_frame_unwind_stop_reason
,
1188 &amd64_windows_frame_this_id
,
1189 &amd64_windows_frame_prev_register
,
1191 default_frame_sniffer
1194 /* Implement the "skip_prologue" gdbarch method. */
1197 amd64_windows_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1199 CORE_ADDR func_addr
;
1200 CORE_ADDR unwind_info
= 0;
1201 CORE_ADDR image_base
, start_rva
, end_rva
;
1202 struct external_pex64_unwind_info ex_ui
;
1204 /* Use prologue size from unwind info. */
1205 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1206 &image_base
, &start_rva
, &end_rva
) == 0)
1208 if (unwind_info
== 0)
1210 /* Leaf function. */
1213 else if (target_read_memory (image_base
+ unwind_info
,
1214 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) == 0
1215 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 1)
1216 return std::max (pc
, image_base
+ start_rva
+ ex_ui
.SizeOfPrologue
);
1219 /* See if we can determine the end of the prologue via the symbol
1220 table. If so, then return either the PC, or the PC after
1221 the prologue, whichever is greater. */
1222 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1224 CORE_ADDR post_prologue_pc
1225 = skip_prologue_using_sal (gdbarch
, func_addr
);
1227 if (post_prologue_pc
!= 0)
1228 return std::max (pc
, post_prologue_pc
);
1234 /* Check Win64 DLL jmp trampolines and find jump destination. */
1237 amd64_windows_skip_trampoline_code (const frame_info_ptr
&frame
, CORE_ADDR pc
)
1239 CORE_ADDR destination
= 0;
1240 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1241 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1243 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1244 if (pc
&& read_memory_unsigned_integer (pc
, 2, byte_order
) == 0x25ff)
1246 /* Get opcode offset and see if we can find a reference in our data. */
1248 = read_memory_unsigned_integer (pc
+ 2, 4, byte_order
);
1250 /* Get address of function pointer at end of pc. */
1251 CORE_ADDR indirect_addr
= pc
+ offset
+ 6;
1253 struct minimal_symbol
*indsym
1255 ? lookup_minimal_symbol_by_pc (indirect_addr
).minsym
1257 const char *symname
= indsym
? indsym
->linkage_name () : NULL
;
1261 if (startswith (symname
, "__imp_")
1262 || startswith (symname
, "_imp_"))
1264 = read_memory_unsigned_integer (indirect_addr
, 8, byte_order
);
1271 /* Implement the "auto_wide_charset" gdbarch method. */
1274 amd64_windows_auto_wide_charset (void)
1279 /* Common parts for gdbarch initialization for Windows and Cygwin on AMD64. */
1282 amd64_windows_init_abi_common (gdbarch_info info
, struct gdbarch
*gdbarch
)
1284 i386_gdbarch_tdep
*tdep
= gdbarch_tdep
<i386_gdbarch_tdep
> (gdbarch
);
1286 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1287 preferred over the SEH one. The reasons are:
1288 - binaries without SEH but with dwarf2 debug info are correctly handled
1289 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1291 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1292 handled if the dwarf2 unwinder is used).
1294 The call to amd64_init_abi appends default unwinders, that aren't
1295 compatible with the SEH one.
1297 frame_unwind_append_unwinder (gdbarch
, &amd64_windows_frame_unwind
);
1299 amd64_init_abi (info
, gdbarch
,
1300 amd64_target_description (X86_XSTATE_SSE_MASK
, false));
1302 /* Function calls. */
1303 set_gdbarch_push_dummy_call (gdbarch
, amd64_windows_push_dummy_call
);
1304 set_gdbarch_return_value_as_value (gdbarch
, amd64_windows_return_value
);
1305 set_gdbarch_skip_main_prologue (gdbarch
, amd64_skip_main_prologue
);
1306 set_gdbarch_skip_trampoline_code (gdbarch
,
1307 amd64_windows_skip_trampoline_code
);
1309 set_gdbarch_skip_prologue (gdbarch
, amd64_windows_skip_prologue
);
1311 tdep
->gregset_reg_offset
= amd64_windows_gregset_reg_offset
;
1312 tdep
->gregset_num_regs
= ARRAY_SIZE (amd64_windows_gregset_reg_offset
);
1313 tdep
->sizeof_gregset
= AMD64_WINDOWS_SIZEOF_GREGSET
;
1314 tdep
->sizeof_fpregset
= 0;
1316 /* Core file support. */
1317 set_gdbarch_core_xfer_shared_libraries
1318 (gdbarch
, windows_core_xfer_shared_libraries
);
1319 set_gdbarch_core_pid_to_str (gdbarch
, windows_core_pid_to_str
);
1321 set_gdbarch_auto_wide_charset (gdbarch
, amd64_windows_auto_wide_charset
);
1324 /* gdbarch initialization for Windows on AMD64. */
1327 amd64_windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1329 amd64_windows_init_abi_common (info
, gdbarch
);
1330 windows_init_abi (info
, gdbarch
);
1332 /* On Windows, "long"s are only 32bit. */
1333 set_gdbarch_long_bit (gdbarch
, 32);
1336 /* Sigwrapper unwinder instruction patterns for AMD64. */
1338 static const gdb_byte amd64_sigbe_bytes
[] = {
1339 0x49, 0xc7, 0xc3, 0xf8, 0xff, 0xff, 0xff, /* movq $-8,%r11 */
1340 0x4d, 0x0f, 0xc1, 0x9a, /* xaddq %r11,$tls::stackptr(%r10) */
1341 /* 4 bytes for tls::stackptr operand. */
1344 static const gdb_byte amd64_sigdelayed_bytes
[] = {
1345 0x49, 0xc7, 0xc3, 0xf8, 0xff, 0xff, 0xff, /* movq $-8,%r11 */
1346 0x4d, 0x0f, 0xc1, 0x9c, 0x24, /* xaddq %r11,$tls::stackptr(%r12) */
1347 /* 4 bytes for tls::stackptr operand. */
1350 static const gdb::array_view
<const gdb_byte
> amd64_sig_patterns
[] {
1351 { amd64_sigbe_bytes
},
1352 { amd64_sigdelayed_bytes
},
1355 /* The sigwrapper unwinder on AMD64. */
1357 static const cygwin_sigwrapper_frame_unwind
1358 amd64_cygwin_sigwrapper_frame_unwind (amd64_sig_patterns
);
1360 /* gdbarch initialization for Cygwin on AMD64. */
1363 amd64_cygwin_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1365 frame_unwind_append_unwinder (gdbarch
, &amd64_cygwin_sigwrapper_frame_unwind
);
1367 amd64_windows_init_abi_common (info
, gdbarch
);
1368 cygwin_init_abi (info
, gdbarch
);
1372 amd64_windows_osabi_sniffer (bfd
*abfd
)
1374 const char *target_name
= bfd_get_target (abfd
);
1376 if (!streq (target_name
, "pei-x86-64"))
1377 return GDB_OSABI_UNKNOWN
;
1379 if (is_linked_with_cygwin_dll (abfd
))
1380 return GDB_OSABI_CYGWIN
;
1382 return GDB_OSABI_WINDOWS
;
1385 static enum gdb_osabi
1386 amd64_cygwin_core_osabi_sniffer (bfd
*abfd
)
1388 const char *target_name
= bfd_get_target (abfd
);
1390 /* Cygwin uses elf core dumps. Do not claim all ELF executables,
1391 check whether there is a .reg section of proper size. */
1392 if (strcmp (target_name
, "elf64-x86-64") == 0)
1394 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1395 if (section
!= nullptr
1396 && bfd_section_size (section
) == AMD64_WINDOWS_SIZEOF_GREGSET
)
1397 return GDB_OSABI_CYGWIN
;
1400 return GDB_OSABI_UNKNOWN
;
1403 void _initialize_amd64_windows_tdep ();
1405 _initialize_amd64_windows_tdep ()
1407 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_WINDOWS
,
1408 amd64_windows_init_abi
);
1409 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_CYGWIN
,
1410 amd64_cygwin_init_abi
);
1412 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_coff_flavour
,
1413 amd64_windows_osabi_sniffer
);
1415 /* Cygwin uses elf core dumps. */
1416 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_elf_flavour
,
1417 amd64_cygwin_core_osabi_sniffer
);