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/>. */
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 case TYPE_CODE_COMPLEX
:
129 return (type
->length () == 1
130 || type
->length () == 2
131 || type
->length () == 4
132 || type
->length () == 8);
139 /* Return nonzero if an argument of type TYPE should be passed
140 via one of the XMM registers. */
143 amd64_windows_passed_by_xmm_register (struct type
*type
)
145 return ((type
->code () == TYPE_CODE_FLT
146 || type
->code () == TYPE_CODE_DECFLOAT
)
147 && (type
->length () == 4 || type
->length () == 8));
150 /* Return non-zero iff an argument of the given TYPE should be passed
154 amd64_windows_passed_by_pointer (struct type
*type
)
156 if (amd64_windows_passed_by_integer_register (type
))
159 if (amd64_windows_passed_by_xmm_register (type
))
165 /* For each argument that should be passed by pointer, reserve some
166 stack space, store a copy of the argument on the stack, and replace
167 the argument by its address. Return the new Stack Pointer value.
169 NARGS is the number of arguments. ARGS is the array containing
170 the value of each argument. SP is value of the Stack Pointer. */
173 amd64_windows_adjust_args_passed_by_pointer (struct value
**args
,
174 int nargs
, CORE_ADDR sp
)
178 for (i
= 0; i
< nargs
; i
++)
179 if (amd64_windows_passed_by_pointer (args
[i
]->type ()))
181 struct type
*type
= args
[i
]->type ();
182 const gdb_byte
*valbuf
= args
[i
]->contents ().data ();
183 const int len
= type
->length ();
185 /* Store a copy of that argument on the stack, aligned to
186 a 16 bytes boundary, and then use the copy's address as
191 write_memory (sp
, valbuf
, len
);
194 = value_addr (value_from_contents_and_address (type
, valbuf
, sp
));
200 /* Store the value of ARG in register REGNO (right-justified).
201 REGCACHE is the register cache. */
204 amd64_windows_store_arg_in_reg (struct regcache
*regcache
,
205 struct value
*arg
, int regno
)
207 struct type
*type
= arg
->type ();
208 const gdb_byte
*valbuf
= arg
->contents ().data ();
211 gdb_assert (type
->length () <= 8);
212 memset (buf
, 0, sizeof buf
);
213 memcpy (buf
, valbuf
, std::min (type
->length (), (ULONGEST
) 8));
214 regcache
->cooked_write (regno
, buf
);
217 /* Push the arguments for an inferior function call, and return
218 the updated value of the SP (Stack Pointer).
220 All arguments are identical to the arguments used in
221 amd64_windows_push_dummy_call. */
224 amd64_windows_push_arguments (struct regcache
*regcache
, int nargs
,
225 struct value
**args
, CORE_ADDR sp
,
226 function_call_return_method return_method
)
230 struct value
**stack_args
= XALLOCAVEC (struct value
*, nargs
);
231 int num_stack_args
= 0;
232 int num_elements
= 0;
235 /* First, handle the arguments passed by pointer.
237 These arguments are replaced by pointers to a copy we are making
238 in inferior memory. So use a copy of the ARGS table, to avoid
239 modifying the original one. */
241 struct value
**args1
= XALLOCAVEC (struct value
*, nargs
);
243 memcpy (args1
, args
, nargs
* sizeof (struct value
*));
244 sp
= amd64_windows_adjust_args_passed_by_pointer (args1
, nargs
, sp
);
248 /* Reserve a register for the "hidden" argument. */
249 if (return_method
== return_method_struct
)
252 for (i
= 0; i
< nargs
; i
++)
254 struct type
*type
= args
[i
]->type ();
255 int len
= type
->length ();
258 if (reg_idx
< ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
))
260 if (amd64_windows_passed_by_integer_register (type
))
262 amd64_windows_store_arg_in_reg
264 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
268 else if (amd64_windows_passed_by_xmm_register (type
))
270 amd64_windows_store_arg_in_reg
271 (regcache
, args
[i
], AMD64_XMM0_REGNUM
+ reg_idx
);
272 /* In case of varargs, these parameters must also be
273 passed via the integer registers. */
274 amd64_windows_store_arg_in_reg
276 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
284 num_elements
+= ((len
+ 7) / 8);
285 stack_args
[num_stack_args
++] = args
[i
];
289 /* Allocate space for the arguments on the stack, keeping it
290 aligned on a 16 byte boundary. */
291 sp
-= num_elements
* 8;
294 /* Write out the arguments to the stack. */
295 for (i
= 0; i
< num_stack_args
; i
++)
297 struct type
*type
= stack_args
[i
]->type ();
298 const gdb_byte
*valbuf
= stack_args
[i
]->contents ().data ();
300 write_memory (sp
+ element
* 8, valbuf
, type
->length ());
301 element
+= ((type
->length () + 7) / 8);
307 /* Implement the "push_dummy_call" gdbarch method. */
310 amd64_windows_push_dummy_call
311 (struct gdbarch
*gdbarch
, struct value
*function
,
312 struct regcache
*regcache
, CORE_ADDR bp_addr
,
313 int nargs
, struct value
**args
, CORE_ADDR sp
,
314 function_call_return_method return_method
, CORE_ADDR struct_addr
)
316 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
319 /* Pass arguments. */
320 sp
= amd64_windows_push_arguments (regcache
, nargs
, args
, sp
,
323 /* Pass "hidden" argument". */
324 if (return_method
== return_method_struct
)
326 /* The "hidden" argument is passed throught the first argument
328 const int arg_regnum
= amd64_windows_dummy_call_integer_regs
[0];
330 store_unsigned_integer (buf
, 8, byte_order
, struct_addr
);
331 regcache
->cooked_write (arg_regnum
, buf
);
334 /* Reserve some memory on the stack for the integer-parameter
335 registers, as required by the ABI. */
336 sp
-= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
) * 8;
338 /* Store return address. */
340 store_unsigned_integer (buf
, 8, byte_order
, bp_addr
);
341 write_memory (sp
, buf
, 8);
343 /* Update the stack pointer... */
344 store_unsigned_integer (buf
, 8, byte_order
, sp
);
345 regcache
->cooked_write (AMD64_RSP_REGNUM
, buf
);
347 /* ...and fake a frame pointer. */
348 regcache
->cooked_write (AMD64_RBP_REGNUM
, buf
);
353 /* Implement the "return_value" gdbarch method for amd64-windows. */
355 static enum return_value_convention
356 amd64_windows_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
357 struct type
*type
, struct regcache
*regcache
,
358 struct value
**read_value
, const gdb_byte
*writebuf
)
360 int len
= type
->length ();
363 /* See if our value is returned through a register. If it is, then
364 store the associated register number in REGNUM. */
365 switch (type
->code ())
368 /* floats, and doubles are returned via XMM0. */
369 if (len
== 4 || len
== 8)
370 regnum
= AMD64_XMM0_REGNUM
;
372 case TYPE_CODE_ARRAY
:
373 /* __m128, __m128i and __m128d are returned via XMM0. */
374 if (type
->is_vector () && len
== 16)
376 enum type_code code
= type
->target_type ()->code ();
377 if (code
== TYPE_CODE_INT
|| code
== TYPE_CODE_FLT
)
379 regnum
= AMD64_XMM0_REGNUM
;
385 /* All other values that are 1, 2, 4 or 8 bytes long are returned
387 if (len
== 1 || len
== 2 || len
== 4 || len
== 8)
388 regnum
= AMD64_RAX_REGNUM
;
389 else if (len
== 16 && type
->code () == TYPE_CODE_INT
)
390 regnum
= AMD64_XMM0_REGNUM
;
396 /* RAX contains the address where the return value has been stored. */
397 if (read_value
!= nullptr)
401 regcache_raw_read_unsigned (regcache
, AMD64_RAX_REGNUM
, &addr
);
402 *read_value
= value_at_non_lval (type
, addr
);
404 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
408 /* Extract the return value from the register where it was stored. */
409 if (read_value
!= nullptr)
411 *read_value
= value::allocate (type
);
412 regcache
->raw_read_part (regnum
, 0, len
,
413 (*read_value
)->contents_raw ().data ());
416 regcache
->raw_write_part (regnum
, 0, len
, writebuf
);
417 return RETURN_VALUE_REGISTER_CONVENTION
;
421 /* Check that the code pointed to by PC corresponds to a call to
422 __main, skip it if so. Return PC otherwise. */
425 amd64_skip_main_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
427 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
430 target_read_memory (pc
, &op
, 1);
435 if (target_read_memory (pc
+ 1, buf
, sizeof buf
) == 0)
437 struct bound_minimal_symbol s
;
440 call_dest
= pc
+ 5 + extract_signed_integer (buf
, 4, byte_order
);
441 s
= lookup_minimal_symbol_by_pc (call_dest
);
443 && s
.minsym
->linkage_name () != NULL
444 && strcmp (s
.minsym
->linkage_name (), "__main") == 0)
452 struct amd64_windows_frame_cache
454 /* ImageBase for the module. */
455 CORE_ADDR image_base
;
457 /* Function start and end rva. */
461 /* Next instruction to be executed. */
467 /* Address of saved integer and xmm registers. */
468 CORE_ADDR prev_reg_addr
[16];
469 CORE_ADDR prev_xmm_addr
[16];
471 /* These two next fields are set only for machine info frames. */
473 /* Likewise for RIP. */
474 CORE_ADDR prev_rip_addr
;
476 /* Likewise for RSP. */
477 CORE_ADDR prev_rsp_addr
;
479 /* Address of the previous frame. */
483 /* Convert a Windows register number to gdb. */
484 static const enum amd64_regnum amd64_windows_w2gdb_regnum
[] =
504 /* Return TRUE iff PC is the range of the function corresponding to
508 pc_in_range (CORE_ADDR pc
, const struct amd64_windows_frame_cache
*cache
)
510 return (pc
>= cache
->image_base
+ cache
->start_rva
511 && pc
< cache
->image_base
+ cache
->end_rva
);
514 /* Try to recognize and decode an epilogue sequence.
516 Return -1 if we fail to read the instructions for any reason.
517 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
520 amd64_windows_frame_decode_epilogue (const frame_info_ptr
&this_frame
,
521 struct amd64_windows_frame_cache
*cache
)
523 /* According to MSDN an epilogue "must consist of either an add RSP,constant
524 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
525 register pops and a return or a jmp".
527 Furthermore, according to RtlVirtualUnwind, the complete list of
532 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
533 - jmp qword ptr imm32 - not handled
534 - rex.w jmp reg [4X ff eY]
537 CORE_ADDR pc
= cache
->pc
;
538 CORE_ADDR cur_sp
= cache
->sp
;
539 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
540 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
544 /* We don't care about the instruction deallocating the frame:
545 if it hasn't been executed, the pc is still in the body,
546 if it has been executed, the following epilog decoding will work. */
549 - pop reg [41 58-5f] or [58-5f]. */
554 if (target_read_memory (pc
, &op
, 1) != 0)
557 if (op
>= 0x40 && op
<= 0x4f)
563 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
569 if (op
>= 0x58 && op
<= 0x5f)
572 gdb_byte reg
= (op
& 0x0f) | ((rex
& 1) << 3);
574 cache
->prev_reg_addr
[amd64_windows_w2gdb_regnum
[reg
]] = cur_sp
;
581 /* Allow the user to break this loop. This shouldn't happen as the
582 number of consecutive pop should be small. */
586 /* Then decode the marker. */
589 if (target_read_memory (pc
, &op
, 1) != 0)
596 cache
->prev_rip_addr
= cur_sp
;
597 cache
->prev_sp
= cur_sp
+ 8;
606 if (target_read_memory (pc
+ 1, &rel8
, 1) != 0)
608 npc
= pc
+ 2 + (signed char) rel8
;
610 /* If the jump is within the function, then this is not a marker,
611 otherwise this is a tail-call. */
612 return !pc_in_range (npc
, cache
);
621 if (target_read_memory (pc
+ 1, rel32
, 4) != 0)
623 npc
= pc
+ 5 + extract_signed_integer (rel32
, 4, byte_order
);
625 /* If the jump is within the function, then this is not a marker,
626 otherwise this is a tail-call. */
627 return !pc_in_range (npc
, cache
);
635 if (target_read_memory (pc
+ 1, imm16
, 2) != 0)
637 cache
->prev_rip_addr
= cur_sp
;
638 cache
->prev_sp
= cur_sp
639 + extract_unsigned_integer (imm16
, 4, byte_order
);
648 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
653 cache
->prev_rip_addr
= cur_sp
;
654 cache
->prev_sp
= cur_sp
+ 8;
674 /* Got a REX prefix, read next byte. */
676 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
684 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
686 return (op1
& 0xf8) == 0xe0;
692 /* Not REX, so unknown. */
697 /* Decode and execute unwind insns at UNWIND_INFO. */
700 amd64_windows_frame_decode_insns (const frame_info_ptr
&this_frame
,
701 struct amd64_windows_frame_cache
*cache
,
702 CORE_ADDR unwind_info
)
704 CORE_ADDR save_addr
= 0;
705 CORE_ADDR cur_sp
= cache
->sp
;
706 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
707 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
710 /* There are at least 3 possibilities to share an unwind info entry:
711 1. Two different runtime_function entries (in .pdata) can point to the
712 same unwind info entry. There is no such indication while unwinding,
713 so we don't really care about that case. We suppose this scheme is
714 used to save memory when the unwind entries are exactly the same.
715 2. Chained unwind_info entries, with no unwind codes (no prologue).
716 There is a major difference with the previous case: the pc range for
717 the function is different (in case 1, the pc range comes from the
718 runtime_function entry; in case 2, the pc range for the chained entry
719 comes from the first unwind entry). Case 1 cannot be used instead as
720 the pc is not in the prologue. This case is officially documented.
721 (There might be unwind code in the first unwind entry to handle
722 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
724 3. Undocumented unwind info redirection. Hard to know the exact purpose,
725 so it is considered as a memory optimization of case 2.
730 /* Unofficially documented unwind info redirection, when UNWIND_INFO
731 address is odd (http://www.codemachine.com/article_x64deepdive.html).
733 struct external_pex64_runtime_function d
;
735 if (target_read_memory (cache
->image_base
+ (unwind_info
& ~1),
736 (gdb_byte
*) &d
, sizeof (d
)) != 0)
740 = extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
742 = extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
744 = extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
749 struct external_pex64_unwind_info ex_ui
;
750 /* There are at most 256 16-bit unwind insns. */
751 gdb_byte insns
[2 * 256];
754 unsigned char codes_count
;
755 unsigned char frame_reg
;
758 /* Read and decode header. */
759 if (target_read_memory (cache
->image_base
+ unwind_info
,
760 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) != 0)
763 frame_debug_printf ("%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x",
764 paddress (gdbarch
, unwind_info
),
765 ex_ui
.Version_Flags
, ex_ui
.SizeOfPrologue
,
766 ex_ui
.CountOfCodes
, ex_ui
.FrameRegisterOffset
);
769 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 1
770 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 2)
773 start
= cache
->image_base
+ cache
->start_rva
;
775 && !(cache
->pc
>= start
&& cache
->pc
< start
+ ex_ui
.SizeOfPrologue
))
777 /* We want to detect if the PC points to an epilogue. This needs
778 to be checked only once, and an epilogue can be anywhere but in
779 the prologue. If so, the epilogue detection+decoding function is
780 sufficient. Otherwise, the unwinder will consider that the PC
781 is in the body of the function and will need to decode unwind
783 if (amd64_windows_frame_decode_epilogue (this_frame
, cache
) == 1)
786 /* Not in an epilog. Clear possible side effects. */
787 memset (cache
->prev_reg_addr
, 0, sizeof (cache
->prev_reg_addr
));
790 codes_count
= ex_ui
.CountOfCodes
;
791 frame_reg
= PEX64_UWI_FRAMEREG (ex_ui
.FrameRegisterOffset
);
795 /* According to msdn:
796 If an FP reg is used, then any unwind code taking an offset must
797 only be used after the FP reg is established in the prolog. */
799 int frreg
= amd64_windows_w2gdb_regnum
[frame_reg
];
801 get_frame_register (this_frame
, frreg
, buf
);
802 save_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
804 frame_debug_printf (" frame_reg=%s, val=%s",
805 gdbarch_register_name (gdbarch
, frreg
),
806 paddress (gdbarch
, save_addr
));
811 && target_read_memory (cache
->image_base
+ unwind_info
813 insns
, codes_count
* 2) != 0)
816 end_insns
= &insns
[codes_count
* 2];
819 /* Skip opcodes 6 of version 2. This opcode is not documented. */
820 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 2)
822 for (; p
< end_insns
; p
+= 2)
823 if (PEX64_UNWCODE_CODE (p
[1]) != 6)
827 for (; p
< end_insns
; p
+= 2)
831 /* Virtually execute the operation if the pc is after the
832 corresponding instruction (that does matter in case of break
833 within the prologue). Note that for chained info (!first), the
834 prologue has been fully executed. */
835 if (cache
->pc
>= start
+ p
[0] || cache
->pc
< start
)
837 frame_debug_printf (" op #%u: off=0x%02x, insn=0x%02x",
838 (unsigned) (p
- insns
), p
[0], p
[1]);
840 /* If there is no frame registers defined, the current value of
841 rsp is used instead. */
847 switch (PEX64_UNWCODE_CODE (p
[1]))
849 case UWOP_PUSH_NONVOL
:
850 /* Push pre-decrements RSP. */
851 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
852 cache
->prev_reg_addr
[reg
] = cur_sp
;
855 case UWOP_ALLOC_LARGE
:
856 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
858 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
859 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
860 cur_sp
+= extract_unsigned_integer (p
+ 2, 4, byte_order
);
864 case UWOP_ALLOC_SMALL
:
865 cur_sp
+= 8 + 8 * PEX64_UNWCODE_INFO (p
[1]);
869 - PEX64_UWI_FRAMEOFF (ex_ui
.FrameRegisterOffset
) * 16;
871 case UWOP_SAVE_NONVOL
:
872 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
873 cache
->prev_reg_addr
[reg
] = save_addr
874 + 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
876 case UWOP_SAVE_NONVOL_FAR
:
877 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
878 cache
->prev_reg_addr
[reg
] = save_addr
879 + 8 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
881 case UWOP_SAVE_XMM128
:
882 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
884 - 16 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
886 case UWOP_SAVE_XMM128_FAR
:
887 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
889 - 16 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
891 case UWOP_PUSH_MACHFRAME
:
892 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
894 cache
->prev_rip_addr
= cur_sp
+ 0;
895 cache
->prev_rsp_addr
= cur_sp
+ 24;
898 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
900 cache
->prev_rip_addr
= cur_sp
+ 8;
901 cache
->prev_rsp_addr
= cur_sp
+ 32;
911 /* Display address where the register was saved. */
913 frame_debug_printf (" [reg %s at %s]",
914 gdbarch_register_name (gdbarch
, reg
),
916 cache
->prev_reg_addr
[reg
]));
919 /* Adjust with the length of the opcode. */
920 switch (PEX64_UNWCODE_CODE (p
[1]))
922 case UWOP_PUSH_NONVOL
:
923 case UWOP_ALLOC_SMALL
:
925 case UWOP_PUSH_MACHFRAME
:
927 case UWOP_ALLOC_LARGE
:
928 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
930 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
935 case UWOP_SAVE_NONVOL
:
936 case UWOP_SAVE_XMM128
:
939 case UWOP_SAVE_NONVOL_FAR
:
940 case UWOP_SAVE_XMM128_FAR
:
947 if (PEX64_UWI_FLAGS (ex_ui
.Version_Flags
) != UNW_FLAG_CHAININFO
)
949 /* End of unwind info. */
954 /* Read the chained unwind info. */
955 struct external_pex64_runtime_function d
;
958 /* Not anymore the first entry. */
961 /* Stay aligned on word boundary. */
962 chain_vma
= cache
->image_base
+ unwind_info
963 + sizeof (ex_ui
) + ((codes_count
+ 1) & ~1) * 2;
965 if (target_read_memory (chain_vma
, (gdb_byte
*) &d
, sizeof (d
)) != 0)
968 /* Decode begin/end. This may be different from .pdata index, as
969 an unwind info may be shared by several functions (in particular
970 if many functions have the same prolog and handler. */
972 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
974 extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
976 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
978 frame_debug_printf ("next in chain: unwind_data=%s, start_rva=%s, "
980 paddress (gdbarch
, unwind_info
),
981 paddress (gdbarch
, cache
->start_rva
),
982 paddress (gdbarch
, cache
->end_rva
));
985 /* Allow the user to break this loop. */
988 /* PC is saved by the call. */
989 if (cache
->prev_rip_addr
== 0)
990 cache
->prev_rip_addr
= cur_sp
;
991 cache
->prev_sp
= cur_sp
+ 8;
993 frame_debug_printf (" prev_sp: %s, prev_pc @%s",
994 paddress (gdbarch
, cache
->prev_sp
),
995 paddress (gdbarch
, cache
->prev_rip_addr
));
998 /* Find SEH unwind info for PC, returning 0 on success.
1000 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
1001 to the base address of the corresponding image, and START_RVA
1002 to the rva of the function containing PC. */
1005 amd64_windows_find_unwind_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1006 CORE_ADDR
*unwind_info
,
1007 CORE_ADDR
*image_base
,
1008 CORE_ADDR
*start_rva
,
1011 struct obj_section
*sec
;
1013 IMAGE_DATA_DIRECTORY
*dir
;
1014 struct objfile
*objfile
;
1015 unsigned long lo
, hi
;
1017 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1019 /* Get the corresponding exception directory. */
1020 sec
= find_pc_section (pc
);
1023 objfile
= sec
->objfile
;
1024 pe
= pe_data (sec
->objfile
->obfd
);
1025 dir
= &pe
->pe_opthdr
.DataDirectory
[PE_EXCEPTION_TABLE
];
1027 base
= pe
->pe_opthdr
.ImageBase
+ objfile
->text_section_offset ();
1032 Note: This does not handle dynamically added entries (for JIT
1033 engines). For this, we would need to ask the kernel directly,
1034 which means getting some info from the native layer. For the
1035 rest of the code, however, it's probably faster to search
1036 the entry ourselves. */
1038 hi
= dir
->Size
/ sizeof (struct external_pex64_runtime_function
);
1042 unsigned long mid
= lo
+ (hi
- lo
) / 2;
1043 struct external_pex64_runtime_function d
;
1046 if (target_read_memory (base
+ dir
->VirtualAddress
+ mid
* sizeof (d
),
1047 (gdb_byte
*) &d
, sizeof (d
)) != 0)
1050 sa
= extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
1051 ea
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
1054 else if (pc
>= base
+ ea
)
1056 else if (pc
>= base
+ sa
&& pc
< base
+ ea
)
1062 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
1069 frame_debug_printf ("image_base=%s, unwind_data=%s",
1070 paddress (gdbarch
, base
),
1071 paddress (gdbarch
, *unwind_info
));
1076 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1079 static struct amd64_windows_frame_cache
*
1080 amd64_windows_frame_cache (const frame_info_ptr
&this_frame
, void **this_cache
)
1082 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1083 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1084 struct amd64_windows_frame_cache
*cache
;
1087 CORE_ADDR unwind_info
= 0;
1090 return (struct amd64_windows_frame_cache
*) *this_cache
;
1092 cache
= FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache
);
1093 *this_cache
= cache
;
1095 /* Get current PC and SP. */
1096 pc
= get_frame_pc (this_frame
);
1097 get_frame_register (this_frame
, AMD64_RSP_REGNUM
, buf
);
1098 cache
->sp
= extract_unsigned_integer (buf
, 8, byte_order
);
1101 /* If we can't find the unwind info, keep trying as though this is a
1102 leaf function. This situation can happen when PC==0, see
1103 https://sourceware.org/bugzilla/show_bug.cgi?id=30255. */
1104 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1108 || unwind_info
== 0)
1110 /* Assume a leaf function. */
1111 cache
->prev_sp
= cache
->sp
+ 8;
1112 cache
->prev_rip_addr
= cache
->sp
;
1116 /* Decode unwind insns to compute saved addresses. */
1117 amd64_windows_frame_decode_insns (this_frame
, cache
, unwind_info
);
1122 /* Implement the "prev_register" method of struct frame_unwind
1123 using the standard Windows x64 SEH info. */
1125 static struct value
*
1126 amd64_windows_frame_prev_register (const frame_info_ptr
&this_frame
,
1127 void **this_cache
, int regnum
)
1129 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1130 struct amd64_windows_frame_cache
*cache
=
1131 amd64_windows_frame_cache (this_frame
, this_cache
);
1134 frame_debug_printf ("%s for sp=%s",
1135 gdbarch_register_name (gdbarch
, regnum
),
1136 paddress (gdbarch
, cache
->prev_sp
));
1138 if (regnum
>= AMD64_XMM0_REGNUM
&& regnum
<= AMD64_XMM0_REGNUM
+ 15)
1139 prev
= cache
->prev_xmm_addr
[regnum
- AMD64_XMM0_REGNUM
];
1140 else if (regnum
== AMD64_RSP_REGNUM
)
1142 prev
= cache
->prev_rsp_addr
;
1144 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_sp
);
1146 else if (regnum
>= AMD64_RAX_REGNUM
&& regnum
<= AMD64_R15_REGNUM
)
1147 prev
= cache
->prev_reg_addr
[regnum
- AMD64_RAX_REGNUM
];
1148 else if (regnum
== AMD64_RIP_REGNUM
)
1149 prev
= cache
->prev_rip_addr
;
1154 frame_debug_printf (" -> at %s", paddress (gdbarch
, prev
));
1158 /* Register was saved. */
1159 return frame_unwind_got_memory (this_frame
, regnum
, prev
);
1163 /* Register is either volatile or not modified. */
1164 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1168 /* Implement the "this_id" method of struct frame_unwind using
1169 the standard Windows x64 SEH info. */
1172 amd64_windows_frame_this_id (const frame_info_ptr
&this_frame
, void **this_cache
,
1173 struct frame_id
*this_id
)
1175 struct amd64_windows_frame_cache
*cache
=
1176 amd64_windows_frame_cache (this_frame
, this_cache
);
1178 *this_id
= frame_id_build (cache
->prev_sp
,
1179 cache
->image_base
+ cache
->start_rva
);
1182 /* Windows x64 SEH unwinder. */
1184 static const struct frame_unwind amd64_windows_frame_unwind
=
1188 default_frame_unwind_stop_reason
,
1189 &amd64_windows_frame_this_id
,
1190 &amd64_windows_frame_prev_register
,
1192 default_frame_sniffer
1195 /* Implement the "skip_prologue" gdbarch method. */
1198 amd64_windows_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1200 CORE_ADDR func_addr
;
1201 CORE_ADDR unwind_info
= 0;
1202 CORE_ADDR image_base
, start_rva
, end_rva
;
1203 struct external_pex64_unwind_info ex_ui
;
1205 /* Use prologue size from unwind info. */
1206 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1207 &image_base
, &start_rva
, &end_rva
) == 0)
1209 if (unwind_info
== 0)
1211 /* Leaf function. */
1214 else if (target_read_memory (image_base
+ unwind_info
,
1215 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) == 0
1216 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 1)
1217 return std::max (pc
, image_base
+ start_rva
+ ex_ui
.SizeOfPrologue
);
1220 /* See if we can determine the end of the prologue via the symbol
1221 table. If so, then return either the PC, or the PC after
1222 the prologue, whichever is greater. */
1223 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1225 CORE_ADDR post_prologue_pc
1226 = skip_prologue_using_sal (gdbarch
, func_addr
);
1228 if (post_prologue_pc
!= 0)
1229 return std::max (pc
, post_prologue_pc
);
1235 /* Check Win64 DLL jmp trampolines and find jump destination. */
1238 amd64_windows_skip_trampoline_code (const frame_info_ptr
&frame
, CORE_ADDR pc
)
1240 CORE_ADDR destination
= 0;
1241 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1242 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1244 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1245 if (pc
&& read_memory_unsigned_integer (pc
, 2, byte_order
) == 0x25ff)
1247 /* Get opcode offset and see if we can find a reference in our data. */
1249 = read_memory_unsigned_integer (pc
+ 2, 4, byte_order
);
1251 /* Get address of function pointer at end of pc. */
1252 CORE_ADDR indirect_addr
= pc
+ offset
+ 6;
1254 struct minimal_symbol
*indsym
1256 ? lookup_minimal_symbol_by_pc (indirect_addr
).minsym
1258 const char *symname
= indsym
? indsym
->linkage_name () : NULL
;
1262 if (startswith (symname
, "__imp_")
1263 || startswith (symname
, "_imp_"))
1265 = read_memory_unsigned_integer (indirect_addr
, 8, byte_order
);
1272 /* Implement the "auto_wide_charset" gdbarch method. */
1275 amd64_windows_auto_wide_charset (void)
1280 /* Common parts for gdbarch initialization for Windows and Cygwin on AMD64. */
1283 amd64_windows_init_abi_common (gdbarch_info info
, struct gdbarch
*gdbarch
)
1285 i386_gdbarch_tdep
*tdep
= gdbarch_tdep
<i386_gdbarch_tdep
> (gdbarch
);
1287 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1288 preferred over the SEH one. The reasons are:
1289 - binaries without SEH but with dwarf2 debug info are correctly handled
1290 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1292 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1293 handled if the dwarf2 unwinder is used).
1295 The call to amd64_init_abi appends default unwinders, that aren't
1296 compatible with the SEH one.
1298 frame_unwind_append_unwinder (gdbarch
, &amd64_windows_frame_unwind
);
1300 amd64_init_abi (info
, gdbarch
,
1301 amd64_target_description (X86_XSTATE_SSE_MASK
, false));
1303 /* Function calls. */
1304 set_gdbarch_push_dummy_call (gdbarch
, amd64_windows_push_dummy_call
);
1305 set_gdbarch_return_value_as_value (gdbarch
, amd64_windows_return_value
);
1306 set_gdbarch_skip_main_prologue (gdbarch
, amd64_skip_main_prologue
);
1307 set_gdbarch_skip_trampoline_code (gdbarch
,
1308 amd64_windows_skip_trampoline_code
);
1310 set_gdbarch_skip_prologue (gdbarch
, amd64_windows_skip_prologue
);
1312 tdep
->gregset_reg_offset
= amd64_windows_gregset_reg_offset
;
1313 tdep
->gregset_num_regs
= ARRAY_SIZE (amd64_windows_gregset_reg_offset
);
1314 tdep
->sizeof_gregset
= AMD64_WINDOWS_SIZEOF_GREGSET
;
1315 tdep
->sizeof_fpregset
= 0;
1317 /* Core file support. */
1318 set_gdbarch_core_xfer_shared_libraries
1319 (gdbarch
, windows_core_xfer_shared_libraries
);
1320 set_gdbarch_core_pid_to_str (gdbarch
, windows_core_pid_to_str
);
1322 set_gdbarch_auto_wide_charset (gdbarch
, amd64_windows_auto_wide_charset
);
1325 /* gdbarch initialization for Windows on AMD64. */
1328 amd64_windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1330 amd64_windows_init_abi_common (info
, gdbarch
);
1331 windows_init_abi (info
, gdbarch
);
1333 /* On Windows, "long"s are only 32bit. */
1334 set_gdbarch_long_bit (gdbarch
, 32);
1337 /* Sigwrapper unwinder instruction patterns for AMD64. */
1339 static const gdb_byte amd64_sigbe_bytes
[] = {
1340 0x49, 0xc7, 0xc3, 0xf8, 0xff, 0xff, 0xff, /* movq $-8,%r11 */
1341 0x4d, 0x0f, 0xc1, 0x9a, /* xaddq %r11,$tls::stackptr(%r10) */
1342 /* 4 bytes for tls::stackptr operand. */
1345 static const gdb_byte amd64_sigdelayed_bytes
[] = {
1346 0x49, 0xc7, 0xc3, 0xf8, 0xff, 0xff, 0xff, /* movq $-8,%r11 */
1347 0x4d, 0x0f, 0xc1, 0x9c, 0x24, /* xaddq %r11,$tls::stackptr(%r12) */
1348 /* 4 bytes for tls::stackptr operand. */
1351 static const gdb::array_view
<const gdb_byte
> amd64_sig_patterns
[] {
1352 { amd64_sigbe_bytes
},
1353 { amd64_sigdelayed_bytes
},
1356 /* The sigwrapper unwinder on AMD64. */
1358 static const cygwin_sigwrapper_frame_unwind
1359 amd64_cygwin_sigwrapper_frame_unwind (amd64_sig_patterns
);
1361 /* gdbarch initialization for Cygwin on AMD64. */
1364 amd64_cygwin_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1366 frame_unwind_append_unwinder (gdbarch
, &amd64_cygwin_sigwrapper_frame_unwind
);
1368 amd64_windows_init_abi_common (info
, gdbarch
);
1369 cygwin_init_abi (info
, gdbarch
);
1373 amd64_windows_osabi_sniffer (bfd
*abfd
)
1375 const char *target_name
= bfd_get_target (abfd
);
1377 if (!streq (target_name
, "pei-x86-64"))
1378 return GDB_OSABI_UNKNOWN
;
1380 if (is_linked_with_cygwin_dll (abfd
))
1381 return GDB_OSABI_CYGWIN
;
1383 return GDB_OSABI_WINDOWS
;
1386 static enum gdb_osabi
1387 amd64_cygwin_core_osabi_sniffer (bfd
*abfd
)
1389 const char *target_name
= bfd_get_target (abfd
);
1391 /* Cygwin uses elf core dumps. Do not claim all ELF executables,
1392 check whether there is a .reg section of proper size. */
1393 if (strcmp (target_name
, "elf64-x86-64") == 0)
1395 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1396 if (section
!= nullptr
1397 && bfd_section_size (section
) == AMD64_WINDOWS_SIZEOF_GREGSET
)
1398 return GDB_OSABI_CYGWIN
;
1401 return GDB_OSABI_UNKNOWN
;
1404 void _initialize_amd64_windows_tdep ();
1406 _initialize_amd64_windows_tdep ()
1408 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_WINDOWS
,
1409 amd64_windows_init_abi
);
1410 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_CYGWIN
,
1411 amd64_cygwin_init_abi
);
1413 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_coff_flavour
,
1414 amd64_windows_osabi_sniffer
);
1416 /* Cygwin uses elf core dumps. */
1417 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_elf_flavour
,
1418 amd64_cygwin_core_osabi_sniffer
);