1 /* Copyright (C) 2009-2013 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"
22 #include "solib-target.h"
26 #include "windows-tdep.h"
29 #include "frame-unwind.h"
30 #include "coff/internal.h"
31 #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 /* Return nonzero if an argument of type TYPE should be passed
46 via one of the integer registers. */
49 amd64_windows_passed_by_integer_register (struct type
*type
)
51 switch (TYPE_CODE (type
))
60 case TYPE_CODE_STRUCT
:
62 return (TYPE_LENGTH (type
) == 1
63 || TYPE_LENGTH (type
) == 2
64 || TYPE_LENGTH (type
) == 4
65 || TYPE_LENGTH (type
) == 8);
72 /* Return nonzero if an argument of type TYPE should be passed
73 via one of the XMM registers. */
76 amd64_windows_passed_by_xmm_register (struct type
*type
)
78 return ((TYPE_CODE (type
) == TYPE_CODE_FLT
79 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
80 && (TYPE_LENGTH (type
) == 4 || TYPE_LENGTH (type
) == 8));
83 /* Return non-zero iff an argument of the given TYPE should be passed
87 amd64_windows_passed_by_pointer (struct type
*type
)
89 if (amd64_windows_passed_by_integer_register (type
))
92 if (amd64_windows_passed_by_xmm_register (type
))
98 /* For each argument that should be passed by pointer, reserve some
99 stack space, store a copy of the argument on the stack, and replace
100 the argument by its address. Return the new Stack Pointer value.
102 NARGS is the number of arguments. ARGS is the array containing
103 the value of each argument. SP is value of the Stack Pointer. */
106 amd64_windows_adjust_args_passed_by_pointer (struct value
**args
,
107 int nargs
, CORE_ADDR sp
)
111 for (i
= 0; i
< nargs
; i
++)
112 if (amd64_windows_passed_by_pointer (value_type (args
[i
])))
114 struct type
*type
= value_type (args
[i
]);
115 const gdb_byte
*valbuf
= value_contents (args
[i
]);
116 const int len
= TYPE_LENGTH (type
);
118 /* Store a copy of that argument on the stack, aligned to
119 a 16 bytes boundary, and then use the copy's address as
124 write_memory (sp
, valbuf
, len
);
127 = value_addr (value_from_contents_and_address (type
, valbuf
, sp
));
133 /* Store the value of ARG in register REGNO (right-justified).
134 REGCACHE is the register cache. */
137 amd64_windows_store_arg_in_reg (struct regcache
*regcache
,
138 struct value
*arg
, int regno
)
140 struct type
*type
= value_type (arg
);
141 const gdb_byte
*valbuf
= value_contents (arg
);
144 gdb_assert (TYPE_LENGTH (type
) <= 8);
145 memset (buf
, 0, sizeof buf
);
146 memcpy (buf
, valbuf
, min (TYPE_LENGTH (type
), 8));
147 regcache_cooked_write (regcache
, regno
, buf
);
150 /* Push the arguments for an inferior function call, and return
151 the updated value of the SP (Stack Pointer).
153 All arguments are identical to the arguments used in
154 amd64_windows_push_dummy_call. */
157 amd64_windows_push_arguments (struct regcache
*regcache
, int nargs
,
158 struct value
**args
, CORE_ADDR sp
,
163 struct value
**stack_args
= alloca (nargs
* sizeof (struct value
*));
164 int num_stack_args
= 0;
165 int num_elements
= 0;
168 /* First, handle the arguments passed by pointer.
170 These arguments are replaced by pointers to a copy we are making
171 in inferior memory. So use a copy of the ARGS table, to avoid
172 modifying the original one. */
174 struct value
**args1
= alloca (nargs
* sizeof (struct value
*));
176 memcpy (args1
, args
, nargs
* sizeof (struct value
*));
177 sp
= amd64_windows_adjust_args_passed_by_pointer (args1
, nargs
, sp
);
181 /* Reserve a register for the "hidden" argument. */
185 for (i
= 0; i
< nargs
; i
++)
187 struct type
*type
= value_type (args
[i
]);
188 int len
= TYPE_LENGTH (type
);
191 if (reg_idx
< ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
))
193 if (amd64_windows_passed_by_integer_register (type
))
195 amd64_windows_store_arg_in_reg
197 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
201 else if (amd64_windows_passed_by_xmm_register (type
))
203 amd64_windows_store_arg_in_reg
204 (regcache
, args
[i
], AMD64_XMM0_REGNUM
+ reg_idx
);
205 /* In case of varargs, these parameters must also be
206 passed via the integer registers. */
207 amd64_windows_store_arg_in_reg
209 amd64_windows_dummy_call_integer_regs
[reg_idx
]);
217 num_elements
+= ((len
+ 7) / 8);
218 stack_args
[num_stack_args
++] = args
[i
];
222 /* Allocate space for the arguments on the stack, keeping it
223 aligned on a 16 byte boundary. */
224 sp
-= num_elements
* 8;
227 /* Write out the arguments to the stack. */
228 for (i
= 0; i
< num_stack_args
; i
++)
230 struct type
*type
= value_type (stack_args
[i
]);
231 const gdb_byte
*valbuf
= value_contents (stack_args
[i
]);
233 write_memory (sp
+ element
* 8, valbuf
, TYPE_LENGTH (type
));
234 element
+= ((TYPE_LENGTH (type
) + 7) / 8);
240 /* Implement the "push_dummy_call" gdbarch method. */
243 amd64_windows_push_dummy_call
244 (struct gdbarch
*gdbarch
, struct value
*function
,
245 struct regcache
*regcache
, CORE_ADDR bp_addr
,
246 int nargs
, struct value
**args
,
247 CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
249 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
252 /* Pass arguments. */
253 sp
= amd64_windows_push_arguments (regcache
, nargs
, args
, sp
,
256 /* Pass "hidden" argument". */
259 /* The "hidden" argument is passed throught the first argument
261 const int arg_regnum
= amd64_windows_dummy_call_integer_regs
[0];
263 store_unsigned_integer (buf
, 8, byte_order
, struct_addr
);
264 regcache_cooked_write (regcache
, arg_regnum
, buf
);
267 /* Reserve some memory on the stack for the integer-parameter
268 registers, as required by the ABI. */
269 sp
-= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs
) * 8;
271 /* Store return address. */
273 store_unsigned_integer (buf
, 8, byte_order
, bp_addr
);
274 write_memory (sp
, buf
, 8);
276 /* Update the stack pointer... */
277 store_unsigned_integer (buf
, 8, byte_order
, sp
);
278 regcache_cooked_write (regcache
, AMD64_RSP_REGNUM
, buf
);
280 /* ...and fake a frame pointer. */
281 regcache_cooked_write (regcache
, AMD64_RBP_REGNUM
, buf
);
286 /* Implement the "return_value" gdbarch method for amd64-windows. */
288 static enum return_value_convention
289 amd64_windows_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
290 struct type
*type
, struct regcache
*regcache
,
291 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
293 int len
= TYPE_LENGTH (type
);
296 /* See if our value is returned through a register. If it is, then
297 store the associated register number in REGNUM. */
298 switch (TYPE_CODE (type
))
301 case TYPE_CODE_DECFLOAT
:
302 /* __m128, __m128i, __m128d, floats, and doubles are returned
304 if (len
== 4 || len
== 8 || len
== 16)
305 regnum
= AMD64_XMM0_REGNUM
;
308 /* All other values that are 1, 2, 4 or 8 bytes long are returned
310 if (len
== 1 || len
== 2 || len
== 4 || len
== 8)
311 regnum
= AMD64_RAX_REGNUM
;
317 /* RAX contains the address where the return value has been stored. */
322 regcache_raw_read_unsigned (regcache
, AMD64_RAX_REGNUM
, &addr
);
323 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
325 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
329 /* Extract the return value from the register where it was stored. */
331 regcache_raw_read_part (regcache
, regnum
, 0, len
, readbuf
);
333 regcache_raw_write_part (regcache
, regnum
, 0, len
, writebuf
);
334 return RETURN_VALUE_REGISTER_CONVENTION
;
338 /* Check that the code pointed to by PC corresponds to a call to
339 __main, skip it if so. Return PC otherwise. */
342 amd64_skip_main_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
344 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
347 target_read_memory (pc
, &op
, 1);
352 if (target_read_memory (pc
+ 1, buf
, sizeof buf
) == 0)
354 struct bound_minimal_symbol s
;
357 call_dest
= pc
+ 5 + extract_signed_integer (buf
, 4, byte_order
);
358 s
= lookup_minimal_symbol_by_pc (call_dest
);
360 && SYMBOL_LINKAGE_NAME (s
.minsym
) != NULL
361 && strcmp (SYMBOL_LINKAGE_NAME (s
.minsym
), "__main") == 0)
369 struct amd64_windows_frame_cache
371 /* ImageBase for the module. */
372 CORE_ADDR image_base
;
374 /* Function start and end rva. */
378 /* Next instruction to be executed. */
384 /* Address of saved integer and xmm registers. */
385 CORE_ADDR prev_reg_addr
[16];
386 CORE_ADDR prev_xmm_addr
[16];
388 /* These two next fields are set only for machine info frames. */
390 /* Likewise for RIP. */
391 CORE_ADDR prev_rip_addr
;
393 /* Likewise for RSP. */
394 CORE_ADDR prev_rsp_addr
;
396 /* Address of the previous frame. */
400 /* Convert a Windows register number to gdb. */
401 static const enum amd64_regnum amd64_windows_w2gdb_regnum
[] =
421 /* Return TRUE iff PC is the the range of the function corresponding to
425 pc_in_range (CORE_ADDR pc
, const struct amd64_windows_frame_cache
*cache
)
427 return (pc
>= cache
->image_base
+ cache
->start_rva
428 && pc
< cache
->image_base
+ cache
->end_rva
);
431 /* Try to recognize and decode an epilogue sequence.
433 Return -1 if we fail to read the instructions for any reason.
434 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
437 amd64_windows_frame_decode_epilogue (struct frame_info
*this_frame
,
438 struct amd64_windows_frame_cache
*cache
)
440 /* According to MSDN an epilogue "must consist of either an add RSP,constant
441 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
442 register pops and a return or a jmp".
444 Furthermore, according to RtlVirtualUnwind, the complete list of
449 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
450 - jmp qword ptr imm32 - not handled
451 - rex.w jmp reg [4X ff eY]
454 CORE_ADDR pc
= cache
->pc
;
455 CORE_ADDR cur_sp
= cache
->sp
;
456 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
457 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
461 /* We don't care about the instruction deallocating the frame:
462 if it hasn't been executed, the pc is still in the body,
463 if it has been executed, the following epilog decoding will work. */
466 - pop reg [41 58-5f] or [58-5f]. */
471 if (target_read_memory (pc
, &op
, 1) != 0)
474 if (op
>= 0x40 && op
<= 0x4f)
480 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
486 if (op
>= 0x58 && op
<= 0x5f)
489 gdb_byte reg
= (op
& 0x0f) | ((rex
& 1) << 3);
491 cache
->prev_reg_addr
[amd64_windows_w2gdb_regnum
[reg
]] = cur_sp
;
497 /* Allow the user to break this loop. This shouldn't happen as the
498 number of consecutive pop should be small. */
502 /* Then decode the marker. */
505 if (target_read_memory (pc
, &op
, 1) != 0)
512 cache
->prev_rip_addr
= cur_sp
;
513 cache
->prev_sp
= cur_sp
+ 8;
522 if (target_read_memory (pc
+ 1, &rel8
, 1) != 0)
524 npc
= pc
+ 2 + (signed char) rel8
;
526 /* If the jump is within the function, then this is not a marker,
527 otherwise this is a tail-call. */
528 return !pc_in_range (npc
, cache
);
537 if (target_read_memory (pc
+ 1, rel32
, 4) != 0)
539 npc
= pc
+ 5 + extract_signed_integer (rel32
, 4, byte_order
);
541 /* If the jump is within the function, then this is not a marker,
542 otherwise this is a tail-call. */
543 return !pc_in_range (npc
, cache
);
551 if (target_read_memory (pc
+ 1, imm16
, 2) != 0)
553 cache
->prev_rip_addr
= cur_sp
;
554 cache
->prev_sp
= cur_sp
555 + extract_unsigned_integer (imm16
, 4, byte_order
);
564 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
569 cache
->prev_rip_addr
= cur_sp
;
570 cache
->prev_sp
= cur_sp
+ 8;
590 /* Got a REX prefix, read next byte. */
592 if (target_read_memory (pc
+ 1, &op
, 1) != 0)
602 if (target_read_memory (pc
+ 2, &op1
, 1) != 0)
604 return (op1
& 0xf8) == 0xe0;
610 /* Not REX, so unknown. */
615 /* Decode and execute unwind insns at UNWIND_INFO. */
618 amd64_windows_frame_decode_insns (struct frame_info
*this_frame
,
619 struct amd64_windows_frame_cache
*cache
,
620 CORE_ADDR unwind_info
)
622 CORE_ADDR save_addr
= 0;
623 CORE_ADDR cur_sp
= cache
->sp
;
624 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
625 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
630 struct external_pex64_unwind_info ex_ui
;
631 /* There are at most 256 16-bit unwind insns. */
632 gdb_byte insns
[2 * 256];
635 unsigned char codes_count
;
636 unsigned char frame_reg
;
637 unsigned char frame_off
;
639 /* Read and decode header. */
640 if (target_read_memory (cache
->image_base
+ unwind_info
,
641 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) != 0)
647 "amd64_windows_frame_decodes_insn: "
648 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
649 paddress (gdbarch
, unwind_info
),
650 ex_ui
.Version_Flags
, ex_ui
.SizeOfPrologue
,
651 ex_ui
.CountOfCodes
, ex_ui
.FrameRegisterOffset
);
654 if (PEX64_UWI_VERSION (ex_ui
.Version_Flags
) != 1)
659 cache
->image_base
+ cache
->start_rva
+ ex_ui
.SizeOfPrologue
))
661 /* Not in the prologue. We want to detect if the PC points to an
662 epilogue. If so, the epilogue detection+decoding function is
663 sufficient. Otherwise, the unwinder will consider that the PC
664 is in the body of the function and will need to decode unwind
666 if (amd64_windows_frame_decode_epilogue (this_frame
, cache
) == 1)
669 /* Not in an epilog. Clear possible side effects. */
670 memset (cache
->prev_reg_addr
, 0, sizeof (cache
->prev_reg_addr
));
673 codes_count
= ex_ui
.CountOfCodes
;
674 frame_reg
= PEX64_UWI_FRAMEREG (ex_ui
.FrameRegisterOffset
);
678 /* According to msdn:
679 If an FP reg is used, then any unwind code taking an offset must
680 only be used after the FP reg is established in the prolog. */
682 int frreg
= amd64_windows_w2gdb_regnum
[frame_reg
];
684 get_frame_register (this_frame
, frreg
, buf
);
685 save_addr
= extract_unsigned_integer (buf
, 8, byte_order
);
688 fprintf_unfiltered (gdb_stdlog
, " frame_reg=%s, val=%s\n",
689 gdbarch_register_name (gdbarch
, frreg
),
690 paddress (gdbarch
, save_addr
));
695 && target_read_memory (cache
->image_base
+ unwind_info
697 insns
, codes_count
* 2) != 0)
700 end_insns
= &insns
[codes_count
* 2];
701 for (p
= insns
; p
< end_insns
; p
+= 2)
707 (gdb_stdlog
, " op #%u: off=0x%02x, insn=0x%02x\n",
708 (unsigned) (p
- insns
), p
[0], p
[1]);
710 /* Virtually execute the operation. */
711 if (cache
->pc
>= cache
->image_base
+ cache
->start_rva
+ p
[0])
713 /* If there is no frame registers defined, the current value of
714 rsp is used instead. */
718 switch (PEX64_UNWCODE_CODE (p
[1]))
720 case UWOP_PUSH_NONVOL
:
721 /* Push pre-decrements RSP. */
722 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
723 cache
->prev_reg_addr
[reg
] = cur_sp
;
726 case UWOP_ALLOC_LARGE
:
727 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
729 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
730 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
731 cur_sp
+= extract_unsigned_integer (p
+ 2, 4, byte_order
);
735 case UWOP_ALLOC_SMALL
:
736 cur_sp
+= 8 + 8 * PEX64_UNWCODE_INFO (p
[1]);
740 - PEX64_UWI_FRAMEOFF (ex_ui
.FrameRegisterOffset
) * 16;
742 case UWOP_SAVE_NONVOL
:
743 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
744 cache
->prev_reg_addr
[reg
] = save_addr
745 - 8 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
747 case UWOP_SAVE_NONVOL_FAR
:
748 reg
= amd64_windows_w2gdb_regnum
[PEX64_UNWCODE_INFO (p
[1])];
749 cache
->prev_reg_addr
[reg
] = save_addr
750 - 8 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
752 case UWOP_SAVE_XMM128
:
753 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
755 - 16 * extract_unsigned_integer (p
+ 2, 2, byte_order
);
757 case UWOP_SAVE_XMM128_FAR
:
758 cache
->prev_xmm_addr
[PEX64_UNWCODE_INFO (p
[1])] =
760 - 16 * extract_unsigned_integer (p
+ 2, 4, byte_order
);
762 case UWOP_PUSH_MACHFRAME
:
763 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
765 cache
->prev_rip_addr
= cur_sp
+ 0;
766 cache
->prev_rsp_addr
= cur_sp
+ 24;
769 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
771 cache
->prev_rip_addr
= cur_sp
+ 8;
772 cache
->prev_rsp_addr
= cur_sp
+ 32;
783 /* Adjust with the length of the opcode. */
784 switch (PEX64_UNWCODE_CODE (p
[1]))
786 case UWOP_PUSH_NONVOL
:
787 case UWOP_ALLOC_SMALL
:
789 case UWOP_PUSH_MACHFRAME
:
791 case UWOP_ALLOC_LARGE
:
792 if (PEX64_UNWCODE_INFO (p
[1]) == 0)
794 else if (PEX64_UNWCODE_INFO (p
[1]) == 1)
799 case UWOP_SAVE_NONVOL
:
800 case UWOP_SAVE_XMM128
:
803 case UWOP_SAVE_NONVOL_FAR
:
804 case UWOP_SAVE_XMM128_FAR
:
811 if (PEX64_UWI_FLAGS (ex_ui
.Version_Flags
) != UNW_FLAG_CHAININFO
)
815 /* Read the chained unwind info. */
816 struct external_pex64_runtime_function d
;
819 chain_vma
= cache
->image_base
+ unwind_info
820 + sizeof (ex_ui
) + ((codes_count
+ 1) & ~1) * 2 + 8;
822 if (target_read_memory (chain_vma
, (gdb_byte
*) &d
, sizeof (d
)) != 0)
826 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
828 extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
830 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
833 /* Allow the user to break this loop. */
836 /* PC is saved by the call. */
837 if (cache
->prev_rip_addr
== 0)
838 cache
->prev_rip_addr
= cur_sp
;
839 cache
->prev_sp
= cur_sp
+ 8;
842 fprintf_unfiltered (gdb_stdlog
, " prev_sp: %s, prev_pc @%s\n",
843 paddress (gdbarch
, cache
->prev_sp
),
844 paddress (gdbarch
, cache
->prev_rip_addr
));
847 /* Find SEH unwind info for PC, returning 0 on success.
849 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
850 to the base address of the corresponding image, and START_RVA
851 to the rva of the function containing PC. */
854 amd64_windows_find_unwind_info (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
855 CORE_ADDR
*unwind_info
,
856 CORE_ADDR
*image_base
,
857 CORE_ADDR
*start_rva
,
860 struct obj_section
*sec
;
862 IMAGE_DATA_DIRECTORY
*dir
;
863 struct objfile
*objfile
;
864 unsigned long lo
, hi
;
866 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
868 /* Get the corresponding exception directory. */
869 sec
= find_pc_section (pc
);
872 objfile
= sec
->objfile
;
873 pe
= pe_data (sec
->objfile
->obfd
);
874 dir
= &pe
->pe_opthdr
.DataDirectory
[PE_EXCEPTION_TABLE
];
876 base
= pe
->pe_opthdr
.ImageBase
877 + ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
882 Note: This does not handle dynamically added entries (for JIT
883 engines). For this, we would need to ask the kernel directly,
884 which means getting some info from the native layer. For the
885 rest of the code, however, it's probably faster to search
886 the entry ourselves. */
888 hi
= dir
->Size
/ sizeof (struct external_pex64_runtime_function
);
892 unsigned long mid
= lo
+ (hi
- lo
) / 2;
893 struct external_pex64_runtime_function d
;
896 if (target_read_memory (base
+ dir
->VirtualAddress
+ mid
* sizeof (d
),
897 (gdb_byte
*) &d
, sizeof (d
)) != 0)
900 sa
= extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
901 ea
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
904 else if (pc
>= base
+ ea
)
906 else if (pc
>= base
+ sa
&& pc
< base
+ ea
)
912 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
922 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
923 paddress (gdbarch
, base
), paddress (gdbarch
, *unwind_info
));
925 if (*unwind_info
& 1)
927 /* Unofficially documented unwind info redirection, when UNWIND_INFO
928 address is odd (http://www.codemachine.com/article_x64deepdive.html).
930 struct external_pex64_runtime_function d
;
933 if (target_read_memory (base
+ (*unwind_info
& ~1),
934 (gdb_byte
*) &d
, sizeof (d
)) != 0)
938 extract_unsigned_integer (d
.rva_BeginAddress
, 4, byte_order
);
939 *end_rva
= extract_unsigned_integer (d
.rva_EndAddress
, 4, byte_order
);
941 extract_unsigned_integer (d
.rva_UnwindData
, 4, byte_order
);
947 /* Fill THIS_CACHE using the native amd64-windows unwinding data
950 static struct amd64_windows_frame_cache
*
951 amd64_windows_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
953 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
954 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
955 struct amd64_windows_frame_cache
*cache
;
957 struct obj_section
*sec
;
959 IMAGE_DATA_DIRECTORY
*dir
;
960 CORE_ADDR image_base
;
962 struct objfile
*objfile
;
963 unsigned long lo
, hi
;
964 CORE_ADDR unwind_info
= 0;
969 cache
= FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache
);
972 /* Get current PC and SP. */
973 pc
= get_frame_pc (this_frame
);
974 get_frame_register (this_frame
, AMD64_RSP_REGNUM
, buf
);
975 cache
->sp
= extract_unsigned_integer (buf
, 8, byte_order
);
978 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
984 if (unwind_info
== 0)
986 /* Assume a leaf function. */
987 cache
->prev_sp
= cache
->sp
+ 8;
988 cache
->prev_rip_addr
= cache
->sp
;
992 /* Decode unwind insns to compute saved addresses. */
993 amd64_windows_frame_decode_insns (this_frame
, cache
, unwind_info
);
998 /* Implement the "prev_register" method of struct frame_unwind
999 using the standard Windows x64 SEH info. */
1001 static struct value
*
1002 amd64_windows_frame_prev_register (struct frame_info
*this_frame
,
1003 void **this_cache
, int regnum
)
1005 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1006 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1007 struct amd64_windows_frame_cache
*cache
=
1008 amd64_windows_frame_cache (this_frame
, this_cache
);
1013 fprintf_unfiltered (gdb_stdlog
,
1014 "amd64_windows_frame_prev_register %s for sp=%s\n",
1015 gdbarch_register_name (gdbarch
, regnum
),
1016 paddress (gdbarch
, cache
->prev_sp
));
1018 if (regnum
>= AMD64_XMM0_REGNUM
&& regnum
<= AMD64_XMM0_REGNUM
+ 15)
1019 prev
= cache
->prev_xmm_addr
[regnum
- AMD64_XMM0_REGNUM
];
1020 else if (regnum
== AMD64_RSP_REGNUM
)
1022 prev
= cache
->prev_rsp_addr
;
1024 return frame_unwind_got_constant (this_frame
, regnum
, cache
->prev_sp
);
1026 else if (regnum
>= AMD64_RAX_REGNUM
&& regnum
<= AMD64_R15_REGNUM
)
1027 prev
= cache
->prev_reg_addr
[regnum
- AMD64_RAX_REGNUM
];
1028 else if (regnum
== AMD64_RIP_REGNUM
)
1029 prev
= cache
->prev_rip_addr
;
1033 if (prev
&& frame_debug
)
1034 fprintf_unfiltered (gdb_stdlog
, " -> at %s\n", paddress (gdbarch
, prev
));
1038 /* Register was saved. */
1039 return frame_unwind_got_memory (this_frame
, regnum
, prev
);
1043 /* Register is either volatile or not modified. */
1044 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
1048 /* Implement the "this_id" method of struct frame_unwind using
1049 the standard Windows x64 SEH info. */
1052 amd64_windows_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
1053 struct frame_id
*this_id
)
1055 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1056 struct amd64_windows_frame_cache
*cache
=
1057 amd64_windows_frame_cache (this_frame
, this_cache
);
1059 *this_id
= frame_id_build (cache
->prev_sp
,
1060 cache
->image_base
+ cache
->start_rva
);
1063 /* Windows x64 SEH unwinder. */
1065 static const struct frame_unwind amd64_windows_frame_unwind
=
1068 default_frame_unwind_stop_reason
,
1069 &amd64_windows_frame_this_id
,
1070 &amd64_windows_frame_prev_register
,
1072 default_frame_sniffer
1075 /* Implement the "skip_prologue" gdbarch method. */
1078 amd64_windows_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
1080 CORE_ADDR func_addr
;
1081 CORE_ADDR unwind_info
= 0;
1082 CORE_ADDR image_base
, start_rva
, end_rva
;
1083 struct external_pex64_unwind_info ex_ui
;
1085 /* Use prologue size from unwind info. */
1086 if (amd64_windows_find_unwind_info (gdbarch
, pc
, &unwind_info
,
1087 &image_base
, &start_rva
, &end_rva
) == 0)
1089 if (unwind_info
== 0)
1091 /* Leaf function. */
1094 else if (target_read_memory (image_base
+ unwind_info
,
1095 (gdb_byte
*) &ex_ui
, sizeof (ex_ui
)) == 0
1096 && PEX64_UWI_VERSION (ex_ui
.Version_Flags
) == 1)
1097 return max (pc
, image_base
+ start_rva
+ ex_ui
.SizeOfPrologue
);
1100 /* See if we can determine the end of the prologue via the symbol
1101 table. If so, then return either the PC, or the PC after
1102 the prologue, whichever is greater. */
1103 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
))
1105 CORE_ADDR post_prologue_pc
1106 = skip_prologue_using_sal (gdbarch
, func_addr
);
1108 if (post_prologue_pc
!= 0)
1109 return max (pc
, post_prologue_pc
);
1115 /* Check Win64 DLL jmp trampolines and find jump destination. */
1118 amd64_windows_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1120 CORE_ADDR destination
= 0;
1121 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1122 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1124 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1125 if (pc
&& read_memory_unsigned_integer (pc
, 2, byte_order
) == 0x25ff)
1127 /* Get opcode offset and see if we can find a reference in our data. */
1129 = read_memory_unsigned_integer (pc
+ 2, 4, byte_order
);
1131 /* Get address of function pointer at end of pc. */
1132 CORE_ADDR indirect_addr
= pc
+ offset
+ 6;
1134 struct minimal_symbol
*indsym
1136 ? lookup_minimal_symbol_by_pc (indirect_addr
).minsym
1138 const char *symname
= indsym
? SYMBOL_LINKAGE_NAME (indsym
) : NULL
;
1142 if (strncmp (symname
, "__imp_", 6) == 0
1143 || strncmp (symname
, "_imp_", 5) == 0)
1145 = read_memory_unsigned_integer (indirect_addr
, 8, byte_order
);
1152 /* Implement the "auto_wide_charset" gdbarch method. */
1155 amd64_windows_auto_wide_charset (void)
1161 amd64_windows_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1163 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1165 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1166 preferred over the SEH one. The reasons are:
1167 - binaries without SEH but with dwarf2 debug info are correcly handled
1168 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1170 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1171 handled if the dwarf2 unwinder is used).
1173 The call to amd64_init_abi appends default unwinders, that aren't
1174 compatible with the SEH one.
1176 frame_unwind_append_unwinder (gdbarch
, &amd64_windows_frame_unwind
);
1178 amd64_init_abi (info
, gdbarch
);
1180 /* On Windows, "long"s are only 32bit. */
1181 set_gdbarch_long_bit (gdbarch
, 32);
1183 /* Function calls. */
1184 set_gdbarch_push_dummy_call (gdbarch
, amd64_windows_push_dummy_call
);
1185 set_gdbarch_return_value (gdbarch
, amd64_windows_return_value
);
1186 set_gdbarch_skip_main_prologue (gdbarch
, amd64_skip_main_prologue
);
1187 set_gdbarch_skip_trampoline_code (gdbarch
,
1188 amd64_windows_skip_trampoline_code
);
1190 set_gdbarch_iterate_over_objfiles_in_search_order
1191 (gdbarch
, windows_iterate_over_objfiles_in_search_order
);
1193 set_gdbarch_skip_prologue (gdbarch
, amd64_windows_skip_prologue
);
1195 set_gdbarch_auto_wide_charset (gdbarch
, amd64_windows_auto_wide_charset
);
1197 set_solib_ops (gdbarch
, &solib_target_so_ops
);
1200 /* -Wmissing-prototypes */
1201 extern initialize_file_ftype _initialize_amd64_windows_tdep
;
1204 _initialize_amd64_windows_tdep (void)
1206 gdbarch_register_osabi (bfd_arch_i386
, bfd_mach_x86_64
, GDB_OSABI_CYGWIN
,
1207 amd64_windows_init_abi
);