1 /* Copyright (C) 2009-2018 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 "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 /* 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_RVALUE_REF:
61 case TYPE_CODE_STRUCT:
63 return (TYPE_LENGTH (type) == 1
64 || TYPE_LENGTH (type) == 2
65 || TYPE_LENGTH (type) == 4
66 || TYPE_LENGTH (type) == 8);
73 /* Return nonzero if an argument of type TYPE should be passed
74 via one of the XMM registers. */
77 amd64_windows_passed_by_xmm_register (struct type *type)
79 return ((TYPE_CODE (type) == TYPE_CODE_FLT
80 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
81 && (TYPE_LENGTH (type) == 4 || TYPE_LENGTH (type) == 8));
84 /* Return non-zero iff an argument of the given TYPE should be passed
88 amd64_windows_passed_by_pointer (struct type *type)
90 if (amd64_windows_passed_by_integer_register (type))
93 if (amd64_windows_passed_by_xmm_register (type))
99 /* For each argument that should be passed by pointer, reserve some
100 stack space, store a copy of the argument on the stack, and replace
101 the argument by its address. Return the new Stack Pointer value.
103 NARGS is the number of arguments. ARGS is the array containing
104 the value of each argument. SP is value of the Stack Pointer. */
107 amd64_windows_adjust_args_passed_by_pointer (struct value **args,
108 int nargs, CORE_ADDR sp)
112 for (i = 0; i < nargs; i++)
113 if (amd64_windows_passed_by_pointer (value_type (args[i])))
115 struct type *type = value_type (args[i]);
116 const gdb_byte *valbuf = value_contents (args[i]);
117 const int len = TYPE_LENGTH (type);
119 /* Store a copy of that argument on the stack, aligned to
120 a 16 bytes boundary, and then use the copy's address as
125 write_memory (sp, valbuf, len);
128 = value_addr (value_from_contents_and_address (type, valbuf, sp));
134 /* Store the value of ARG in register REGNO (right-justified).
135 REGCACHE is the register cache. */
138 amd64_windows_store_arg_in_reg (struct regcache *regcache,
139 struct value *arg, int regno)
141 struct type *type = value_type (arg);
142 const gdb_byte *valbuf = value_contents (arg);
145 gdb_assert (TYPE_LENGTH (type) <= 8);
146 memset (buf, 0, sizeof buf);
147 memcpy (buf, valbuf, std::min (TYPE_LENGTH (type), (unsigned int) 8));
148 regcache_cooked_write (regcache, regno, buf);
151 /* Push the arguments for an inferior function call, and return
152 the updated value of the SP (Stack Pointer).
154 All arguments are identical to the arguments used in
155 amd64_windows_push_dummy_call. */
158 amd64_windows_push_arguments (struct regcache *regcache, int nargs,
159 struct value **args, CORE_ADDR sp,
164 struct value **stack_args = XALLOCAVEC (struct value *, nargs);
165 int num_stack_args = 0;
166 int num_elements = 0;
169 /* First, handle the arguments passed by pointer.
171 These arguments are replaced by pointers to a copy we are making
172 in inferior memory. So use a copy of the ARGS table, to avoid
173 modifying the original one. */
175 struct value **args1 = XALLOCAVEC (struct value *, nargs);
177 memcpy (args1, args, nargs * sizeof (struct value *));
178 sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp);
182 /* Reserve a register for the "hidden" argument. */
186 for (i = 0; i < nargs; i++)
188 struct type *type = value_type (args[i]);
189 int len = TYPE_LENGTH (type);
192 if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs))
194 if (amd64_windows_passed_by_integer_register (type))
196 amd64_windows_store_arg_in_reg
198 amd64_windows_dummy_call_integer_regs[reg_idx]);
202 else if (amd64_windows_passed_by_xmm_register (type))
204 amd64_windows_store_arg_in_reg
205 (regcache, args[i], AMD64_XMM0_REGNUM + reg_idx);
206 /* In case of varargs, these parameters must also be
207 passed via the integer registers. */
208 amd64_windows_store_arg_in_reg
210 amd64_windows_dummy_call_integer_regs[reg_idx]);
218 num_elements += ((len + 7) / 8);
219 stack_args[num_stack_args++] = args[i];
223 /* Allocate space for the arguments on the stack, keeping it
224 aligned on a 16 byte boundary. */
225 sp -= num_elements * 8;
228 /* Write out the arguments to the stack. */
229 for (i = 0; i < num_stack_args; i++)
231 struct type *type = value_type (stack_args[i]);
232 const gdb_byte *valbuf = value_contents (stack_args[i]);
234 write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type));
235 element += ((TYPE_LENGTH (type) + 7) / 8);
241 /* Implement the "push_dummy_call" gdbarch method. */
244 amd64_windows_push_dummy_call
245 (struct gdbarch *gdbarch, struct value *function,
246 struct regcache *regcache, CORE_ADDR bp_addr,
247 int nargs, struct value **args,
248 CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
250 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
253 /* Pass arguments. */
254 sp = amd64_windows_push_arguments (regcache, nargs, args, sp,
257 /* Pass "hidden" argument". */
260 /* The "hidden" argument is passed throught the first argument
262 const int arg_regnum = amd64_windows_dummy_call_integer_regs[0];
264 store_unsigned_integer (buf, 8, byte_order, struct_addr);
265 regcache_cooked_write (regcache, arg_regnum, buf);
268 /* Reserve some memory on the stack for the integer-parameter
269 registers, as required by the ABI. */
270 sp -= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs) * 8;
272 /* Store return address. */
274 store_unsigned_integer (buf, 8, byte_order, bp_addr);
275 write_memory (sp, buf, 8);
277 /* Update the stack pointer... */
278 store_unsigned_integer (buf, 8, byte_order, sp);
279 regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf);
281 /* ...and fake a frame pointer. */
282 regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf);
287 /* Implement the "return_value" gdbarch method for amd64-windows. */
289 static enum return_value_convention
290 amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
291 struct type *type, struct regcache *regcache,
292 gdb_byte *readbuf, const gdb_byte *writebuf)
294 int len = TYPE_LENGTH (type);
297 /* See if our value is returned through a register. If it is, then
298 store the associated register number in REGNUM. */
299 switch (TYPE_CODE (type))
302 case TYPE_CODE_DECFLOAT:
303 /* __m128, __m128i, __m128d, floats, and doubles are returned
305 if (len == 4 || len == 8 || len == 16)
306 regnum = AMD64_XMM0_REGNUM;
309 /* All other values that are 1, 2, 4 or 8 bytes long are returned
311 if (len == 1 || len == 2 || len == 4 || len == 8)
312 regnum = AMD64_RAX_REGNUM;
318 /* RAX contains the address where the return value has been stored. */
323 regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr);
324 read_memory (addr, readbuf, TYPE_LENGTH (type));
326 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
330 /* Extract the return value from the register where it was stored. */
332 regcache->raw_read_part (regnum, 0, len, readbuf);
334 regcache_raw_write_part (regcache, regnum, 0, len, writebuf);
335 return RETURN_VALUE_REGISTER_CONVENTION;
339 /* Check that the code pointed to by PC corresponds to a call to
340 __main, skip it if so. Return PC otherwise. */
343 amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
345 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
348 target_read_memory (pc, &op, 1);
353 if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
355 struct bound_minimal_symbol s;
358 call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
359 s = lookup_minimal_symbol_by_pc (call_dest);
361 && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
362 && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
370 struct amd64_windows_frame_cache
372 /* ImageBase for the module. */
373 CORE_ADDR image_base;
375 /* Function start and end rva. */
379 /* Next instruction to be executed. */
385 /* Address of saved integer and xmm registers. */
386 CORE_ADDR prev_reg_addr[16];
387 CORE_ADDR prev_xmm_addr[16];
389 /* These two next fields are set only for machine info frames. */
391 /* Likewise for RIP. */
392 CORE_ADDR prev_rip_addr;
394 /* Likewise for RSP. */
395 CORE_ADDR prev_rsp_addr;
397 /* Address of the previous frame. */
401 /* Convert a Windows register number to gdb. */
402 static const enum amd64_regnum amd64_windows_w2gdb_regnum[] =
422 /* Return TRUE iff PC is the the range of the function corresponding to
426 pc_in_range (CORE_ADDR pc, const struct amd64_windows_frame_cache *cache)
428 return (pc >= cache->image_base + cache->start_rva
429 && pc < cache->image_base + cache->end_rva);
432 /* Try to recognize and decode an epilogue sequence.
434 Return -1 if we fail to read the instructions for any reason.
435 Return 1 if an epilogue sequence was recognized, 0 otherwise. */
438 amd64_windows_frame_decode_epilogue (struct frame_info *this_frame,
439 struct amd64_windows_frame_cache *cache)
441 /* According to MSDN an epilogue "must consist of either an add RSP,constant
442 or lea RSP,constant[FPReg], followed by a series of zero or more 8-byte
443 register pops and a return or a jmp".
445 Furthermore, according to RtlVirtualUnwind, the complete list of
450 - jmp imm8 | imm32 [eb rel8] or [e9 rel32]
451 - jmp qword ptr imm32 - not handled
452 - rex.w jmp reg [4X ff eY]
455 CORE_ADDR pc = cache->pc;
456 CORE_ADDR cur_sp = cache->sp;
457 struct gdbarch *gdbarch = get_frame_arch (this_frame);
458 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
462 /* We don't care about the instruction deallocating the frame:
463 if it hasn't been executed, the pc is still in the body,
464 if it has been executed, the following epilog decoding will work. */
467 - pop reg [41 58-5f] or [58-5f]. */
472 if (target_read_memory (pc, &op, 1) != 0)
475 if (op >= 0x40 && op <= 0x4f)
481 if (target_read_memory (pc + 1, &op, 1) != 0)
487 if (op >= 0x58 && op <= 0x5f)
490 gdb_byte reg = (op & 0x0f) | ((rex & 1) << 3);
492 cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp;
499 /* Allow the user to break this loop. This shouldn't happen as the
500 number of consecutive pop should be small. */
504 /* Then decode the marker. */
507 if (target_read_memory (pc, &op, 1) != 0)
514 cache->prev_rip_addr = cur_sp;
515 cache->prev_sp = cur_sp + 8;
524 if (target_read_memory (pc + 1, &rel8, 1) != 0)
526 npc = pc + 2 + (signed char) rel8;
528 /* If the jump is within the function, then this is not a marker,
529 otherwise this is a tail-call. */
530 return !pc_in_range (npc, cache);
539 if (target_read_memory (pc + 1, rel32, 4) != 0)
541 npc = pc + 5 + extract_signed_integer (rel32, 4, byte_order);
543 /* If the jump is within the function, then this is not a marker,
544 otherwise this is a tail-call. */
545 return !pc_in_range (npc, cache);
553 if (target_read_memory (pc + 1, imm16, 2) != 0)
555 cache->prev_rip_addr = cur_sp;
556 cache->prev_sp = cur_sp
557 + extract_unsigned_integer (imm16, 4, byte_order);
566 if (target_read_memory (pc + 2, &op1, 1) != 0)
571 cache->prev_rip_addr = cur_sp;
572 cache->prev_sp = cur_sp + 8;
592 /* Got a REX prefix, read next byte. */
594 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);
628 /* There are at least 3 possibilities to share an unwind info entry:
629 1. Two different runtime_function entries (in .pdata) can point to the
630 same unwind info entry. There is no such indication while unwinding,
631 so we don't really care about that case. We suppose this scheme is
632 used to save memory when the unwind entries are exactly the same.
633 2. Chained unwind_info entries, with no unwind codes (no prologue).
634 There is a major difference with the previous case: the pc range for
635 the function is different (in case 1, the pc range comes from the
636 runtime_function entry; in case 2, the pc range for the chained entry
637 comes from the first unwind entry). Case 1 cannot be used instead as
638 the pc is not in the prologue. This case is officially documented.
639 (There might be unwind code in the first unwind entry to handle
640 additional unwinding). GCC (at least until gcc 5.0) doesn't chain
642 3. Undocumented unwind info redirection. Hard to know the exact purpose,
643 so it is considered as a memory optimization of case 2.
648 /* Unofficially documented unwind info redirection, when UNWIND_INFO
649 address is odd (http://www.codemachine.com/article_x64deepdive.html).
651 struct external_pex64_runtime_function d;
653 if (target_read_memory (cache->image_base + (unwind_info & ~1),
654 (gdb_byte *) &d, sizeof (d)) != 0)
658 = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
660 = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
662 = extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
667 struct external_pex64_unwind_info ex_ui;
668 /* There are at most 256 16-bit unwind insns. */
669 gdb_byte insns[2 * 256];
672 unsigned char codes_count;
673 unsigned char frame_reg;
676 /* Read and decode header. */
677 if (target_read_memory (cache->image_base + unwind_info,
678 (gdb_byte *) &ex_ui, sizeof (ex_ui)) != 0)
684 "amd64_windows_frame_decodes_insn: "
685 "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n",
686 paddress (gdbarch, unwind_info),
687 ex_ui.Version_Flags, ex_ui.SizeOfPrologue,
688 ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset);
691 if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1
692 && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2)
695 start = cache->image_base + cache->start_rva;
697 && !(cache->pc >= start && cache->pc < start + ex_ui.SizeOfPrologue))
699 /* We want to detect if the PC points to an epilogue. This needs
700 to be checked only once, and an epilogue can be anywhere but in
701 the prologue. If so, the epilogue detection+decoding function is
702 sufficient. Otherwise, the unwinder will consider that the PC
703 is in the body of the function and will need to decode unwind
705 if (amd64_windows_frame_decode_epilogue (this_frame, cache) == 1)
708 /* Not in an epilog. Clear possible side effects. */
709 memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr));
712 codes_count = ex_ui.CountOfCodes;
713 frame_reg = PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset);
717 /* According to msdn:
718 If an FP reg is used, then any unwind code taking an offset must
719 only be used after the FP reg is established in the prolog. */
721 int frreg = amd64_windows_w2gdb_regnum[frame_reg];
723 get_frame_register (this_frame, frreg, buf);
724 save_addr = extract_unsigned_integer (buf, 8, byte_order);
727 fprintf_unfiltered (gdb_stdlog, " frame_reg=%s, val=%s\n",
728 gdbarch_register_name (gdbarch, frreg),
729 paddress (gdbarch, save_addr));
734 && target_read_memory (cache->image_base + unwind_info
736 insns, codes_count * 2) != 0)
739 end_insns = &insns[codes_count * 2];
742 /* Skip opcodes 6 of version 2. This opcode is not documented. */
743 if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2)
745 for (; p < end_insns; p += 2)
746 if (PEX64_UNWCODE_CODE (p[1]) != 6)
750 for (; p < end_insns; p += 2)
754 /* Virtually execute the operation if the pc is after the
755 corresponding instruction (that does matter in case of break
756 within the prologue). Note that for chained info (!first), the
757 prologue has been fully executed. */
758 if (cache->pc >= start + p[0] || cache->pc < start)
762 (gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n",
763 (unsigned) (p - insns), p[0], p[1]);
765 /* If there is no frame registers defined, the current value of
766 rsp is used instead. */
772 switch (PEX64_UNWCODE_CODE (p[1]))
774 case UWOP_PUSH_NONVOL:
775 /* Push pre-decrements RSP. */
776 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
777 cache->prev_reg_addr[reg] = cur_sp;
780 case UWOP_ALLOC_LARGE:
781 if (PEX64_UNWCODE_INFO (p[1]) == 0)
783 8 * extract_unsigned_integer (p + 2, 2, byte_order);
784 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
785 cur_sp += extract_unsigned_integer (p + 2, 4, byte_order);
789 case UWOP_ALLOC_SMALL:
790 cur_sp += 8 + 8 * PEX64_UNWCODE_INFO (p[1]);
794 - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16;
796 case UWOP_SAVE_NONVOL:
797 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
798 cache->prev_reg_addr[reg] = save_addr
799 + 8 * extract_unsigned_integer (p + 2, 2, byte_order);
801 case UWOP_SAVE_NONVOL_FAR:
802 reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])];
803 cache->prev_reg_addr[reg] = save_addr
804 + 8 * extract_unsigned_integer (p + 2, 4, byte_order);
806 case UWOP_SAVE_XMM128:
807 cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
809 - 16 * extract_unsigned_integer (p + 2, 2, byte_order);
811 case UWOP_SAVE_XMM128_FAR:
812 cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =
814 - 16 * extract_unsigned_integer (p + 2, 4, byte_order);
816 case UWOP_PUSH_MACHFRAME:
817 if (PEX64_UNWCODE_INFO (p[1]) == 0)
819 cache->prev_rip_addr = cur_sp + 0;
820 cache->prev_rsp_addr = cur_sp + 24;
823 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
825 cache->prev_rip_addr = cur_sp + 8;
826 cache->prev_rsp_addr = cur_sp + 32;
836 /* Display address where the register was saved. */
837 if (frame_debug && reg >= 0)
839 (gdb_stdlog, " [reg %s at %s]\n",
840 gdbarch_register_name (gdbarch, reg),
841 paddress (gdbarch, cache->prev_reg_addr[reg]));
844 /* Adjust with the length of the opcode. */
845 switch (PEX64_UNWCODE_CODE (p[1]))
847 case UWOP_PUSH_NONVOL:
848 case UWOP_ALLOC_SMALL:
850 case UWOP_PUSH_MACHFRAME:
852 case UWOP_ALLOC_LARGE:
853 if (PEX64_UNWCODE_INFO (p[1]) == 0)
855 else if (PEX64_UNWCODE_INFO (p[1]) == 1)
860 case UWOP_SAVE_NONVOL:
861 case UWOP_SAVE_XMM128:
864 case UWOP_SAVE_NONVOL_FAR:
865 case UWOP_SAVE_XMM128_FAR:
872 if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO)
874 /* End of unwind info. */
879 /* Read the chained unwind info. */
880 struct external_pex64_runtime_function d;
883 /* Not anymore the first entry. */
886 /* Stay aligned on word boundary. */
887 chain_vma = cache->image_base + unwind_info
888 + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2;
890 if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0)
893 /* Decode begin/end. This may be different from .pdata index, as
894 an unwind info may be shared by several functions (in particular
895 if many functions have the same prolog and handler. */
897 extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
899 extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
901 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
906 "amd64_windows_frame_decodes_insn (next in chain):"
907 " unwind_data=%s, start_rva=%s, end_rva=%s\n",
908 paddress (gdbarch, unwind_info),
909 paddress (gdbarch, cache->start_rva),
910 paddress (gdbarch, cache->end_rva));
913 /* Allow the user to break this loop. */
916 /* PC is saved by the call. */
917 if (cache->prev_rip_addr == 0)
918 cache->prev_rip_addr = cur_sp;
919 cache->prev_sp = cur_sp + 8;
922 fprintf_unfiltered (gdb_stdlog, " prev_sp: %s, prev_pc @%s\n",
923 paddress (gdbarch, cache->prev_sp),
924 paddress (gdbarch, cache->prev_rip_addr));
927 /* Find SEH unwind info for PC, returning 0 on success.
929 UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE
930 to the base address of the corresponding image, and START_RVA
931 to the rva of the function containing PC. */
934 amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc,
935 CORE_ADDR *unwind_info,
936 CORE_ADDR *image_base,
937 CORE_ADDR *start_rva,
940 struct obj_section *sec;
942 IMAGE_DATA_DIRECTORY *dir;
943 struct objfile *objfile;
944 unsigned long lo, hi;
946 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
948 /* Get the corresponding exception directory. */
949 sec = find_pc_section (pc);
952 objfile = sec->objfile;
953 pe = pe_data (sec->objfile->obfd);
954 dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE];
956 base = pe->pe_opthdr.ImageBase
957 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
962 Note: This does not handle dynamically added entries (for JIT
963 engines). For this, we would need to ask the kernel directly,
964 which means getting some info from the native layer. For the
965 rest of the code, however, it's probably faster to search
966 the entry ourselves. */
968 hi = dir->Size / sizeof (struct external_pex64_runtime_function);
972 unsigned long mid = lo + (hi - lo) / 2;
973 struct external_pex64_runtime_function d;
976 if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d),
977 (gdb_byte *) &d, sizeof (d)) != 0)
980 sa = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order);
981 ea = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order);
984 else if (pc >= base + ea)
986 else if (pc >= base + sa && pc < base + ea)
992 extract_unsigned_integer (d.rva_UnwindData, 4, byte_order);
1002 "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n",
1003 paddress (gdbarch, base), paddress (gdbarch, *unwind_info));
1008 /* Fill THIS_CACHE using the native amd64-windows unwinding data
1011 static struct amd64_windows_frame_cache *
1012 amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
1014 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1015 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1016 struct amd64_windows_frame_cache *cache;
1019 CORE_ADDR unwind_info = 0;
1022 return (struct amd64_windows_frame_cache *) *this_cache;
1024 cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
1025 *this_cache = cache;
1027 /* Get current PC and SP. */
1028 pc = get_frame_pc (this_frame);
1029 get_frame_register (this_frame, AMD64_RSP_REGNUM, buf);
1030 cache->sp = extract_unsigned_integer (buf, 8, byte_order);
1033 if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1039 if (unwind_info == 0)
1041 /* Assume a leaf function. */
1042 cache->prev_sp = cache->sp + 8;
1043 cache->prev_rip_addr = cache->sp;
1047 /* Decode unwind insns to compute saved addresses. */
1048 amd64_windows_frame_decode_insns (this_frame, cache, unwind_info);
1053 /* Implement the "prev_register" method of struct frame_unwind
1054 using the standard Windows x64 SEH info. */
1056 static struct value *
1057 amd64_windows_frame_prev_register (struct frame_info *this_frame,
1058 void **this_cache, int regnum)
1060 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1061 struct amd64_windows_frame_cache *cache =
1062 amd64_windows_frame_cache (this_frame, this_cache);
1066 fprintf_unfiltered (gdb_stdlog,
1067 "amd64_windows_frame_prev_register %s for sp=%s\n",
1068 gdbarch_register_name (gdbarch, regnum),
1069 paddress (gdbarch, cache->prev_sp));
1071 if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
1072 prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM];
1073 else if (regnum == AMD64_RSP_REGNUM)
1075 prev = cache->prev_rsp_addr;
1077 return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp);
1079 else if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_R15_REGNUM)
1080 prev = cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM];
1081 else if (regnum == AMD64_RIP_REGNUM)
1082 prev = cache->prev_rip_addr;
1086 if (prev && frame_debug)
1087 fprintf_unfiltered (gdb_stdlog, " -> at %s\n", paddress (gdbarch, prev));
1091 /* Register was saved. */
1092 return frame_unwind_got_memory (this_frame, regnum, prev);
1096 /* Register is either volatile or not modified. */
1097 return frame_unwind_got_register (this_frame, regnum, regnum);
1101 /* Implement the "this_id" method of struct frame_unwind using
1102 the standard Windows x64 SEH info. */
1105 amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache,
1106 struct frame_id *this_id)
1108 struct amd64_windows_frame_cache *cache =
1109 amd64_windows_frame_cache (this_frame, this_cache);
1111 *this_id = frame_id_build (cache->prev_sp,
1112 cache->image_base + cache->start_rva);
1115 /* Windows x64 SEH unwinder. */
1117 static const struct frame_unwind amd64_windows_frame_unwind =
1120 default_frame_unwind_stop_reason,
1121 &amd64_windows_frame_this_id,
1122 &amd64_windows_frame_prev_register,
1124 default_frame_sniffer
1127 /* Implement the "skip_prologue" gdbarch method. */
1130 amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1132 CORE_ADDR func_addr;
1133 CORE_ADDR unwind_info = 0;
1134 CORE_ADDR image_base, start_rva, end_rva;
1135 struct external_pex64_unwind_info ex_ui;
1137 /* Use prologue size from unwind info. */
1138 if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info,
1139 &image_base, &start_rva, &end_rva) == 0)
1141 if (unwind_info == 0)
1143 /* Leaf function. */
1146 else if (target_read_memory (image_base + unwind_info,
1147 (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0
1148 && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1)
1149 return std::max (pc, image_base + start_rva + ex_ui.SizeOfPrologue);
1152 /* See if we can determine the end of the prologue via the symbol
1153 table. If so, then return either the PC, or the PC after
1154 the prologue, whichever is greater. */
1155 if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1157 CORE_ADDR post_prologue_pc
1158 = skip_prologue_using_sal (gdbarch, func_addr);
1160 if (post_prologue_pc != 0)
1161 return std::max (pc, post_prologue_pc);
1167 /* Check Win64 DLL jmp trampolines and find jump destination. */
1170 amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1172 CORE_ADDR destination = 0;
1173 struct gdbarch *gdbarch = get_frame_arch (frame);
1174 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1176 /* Check for jmp *<offset>(%rip) (jump near, absolute indirect (/4)). */
1177 if (pc && read_memory_unsigned_integer (pc, 2, byte_order) == 0x25ff)
1179 /* Get opcode offset and see if we can find a reference in our data. */
1181 = read_memory_unsigned_integer (pc + 2, 4, byte_order);
1183 /* Get address of function pointer at end of pc. */
1184 CORE_ADDR indirect_addr = pc + offset + 6;
1186 struct minimal_symbol *indsym
1188 ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
1190 const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;
1194 if (startswith (symname, "__imp_")
1195 || startswith (symname, "_imp_"))
1197 = read_memory_unsigned_integer (indirect_addr, 8, byte_order);
1204 /* Implement the "auto_wide_charset" gdbarch method. */
1207 amd64_windows_auto_wide_charset (void)
1213 amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1215 /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is
1216 preferred over the SEH one. The reasons are:
1217 - binaries without SEH but with dwarf2 debug info are correcly handled
1218 (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH
1220 - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be
1221 handled if the dwarf2 unwinder is used).
1223 The call to amd64_init_abi appends default unwinders, that aren't
1224 compatible with the SEH one.
1226 frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind);
1228 amd64_init_abi (info, gdbarch,
1229 amd64_target_description (X86_XSTATE_SSE_MASK));
1231 windows_init_abi (info, gdbarch);
1233 /* On Windows, "long"s are only 32bit. */
1234 set_gdbarch_long_bit (gdbarch, 32);
1236 /* Function calls. */
1237 set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call);
1238 set_gdbarch_return_value (gdbarch, amd64_windows_return_value);
1239 set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue);
1240 set_gdbarch_skip_trampoline_code (gdbarch,
1241 amd64_windows_skip_trampoline_code);
1243 set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue);
1245 set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset);
1249 _initialize_amd64_windows_tdep (void)
1251 gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN,
1252 amd64_windows_init_abi);