From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 11730 invoked by alias); 22 Aug 2013 09:33:16 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 11717 invoked by uid 89); 22 Aug 2013 09:33:16 -0000 X-Spam-SWARE-Status: No, score=-2.7 required=5.0 tests=AWL,BAYES_00,KHOP_THREADED autolearn=ham version=3.3.2 Received: from mel.act-europe.fr (HELO smtp.eu.adacore.com) (194.98.77.210) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Thu, 22 Aug 2013 09:33:10 +0000 Received: from localhost (localhost [127.0.0.1]) by filtered-smtp.eu.adacore.com (Postfix) with ESMTP id CC50F265D673; Thu, 22 Aug 2013 11:33:07 +0200 (CEST) Received: from smtp.eu.adacore.com ([127.0.0.1]) by localhost (smtp.eu.adacore.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id NM1VlJVU2J-P; Thu, 22 Aug 2013 11:33:07 +0200 (CEST) Received: from ulanbator.act-europe.fr (ulanbator.act-europe.fr [10.10.1.67]) (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by smtp.eu.adacore.com (Postfix) with ESMTPSA id B73A8265BA87; Thu, 22 Aug 2013 11:33:07 +0200 (CEST) Content-Type: text/plain; charset=iso-8859-1 Mime-Version: 1.0 (Mac OS X Mail 6.5 \(1508\)) Subject: [PATCH v3] Windows x64 SEH unwinder From: Tristan Gingold In-Reply-To: <51F29440.3030808@redhat.com> Date: Thu, 22 Aug 2013 09:33:00 -0000 Cc: Joel Brobecker , Roland Schwingel , Pedro Alves Content-Transfer-Encoding: quoted-printable Message-Id: <6F12353E-D32C-40F0-87BF-AA77FC15BE03@adacore.com> References: <1357728781-15073-1-git-send-email-brobecker@adacore.com> <1357728781-15073-3-git-send-email-brobecker@adacore.com> <50ED9221.1050504@redhat.com> <9E84DF2D-7AF8-4AA1-A5DF-171EF189A6E7@adacore.com> <50EDA48E.2030406@redhat.com> <66611BA9-4536-42B2-A65C-4EA5DA219E22@adacore.com> <50EEEB3C.9050202@redhat.com> <5BE11EDB-7832-4489-8CB1-6382F5D1D34E@adacore.com> <51F29440.3030808@redhat.com> To: "gdb-patches@sourceware.org ml" X-SW-Source: 2013-08/txt/msg00621.txt.bz2 Hello, after discussion with Roland Schwingel, I have found that the patch doesn't handle well dwarf3 DW_OP_call_frame_cfa, because the SEH unwinder is before the dwarf2 one. So I propose this new patch. The only change is the position of the SEH unwinder: it is appended after the dwarf2 one. As a consequence, old binaries should work too. I have also added the NEWS chunk. Ok for the trunk ? Tristan. 2013-07-08 Tristan Gingold * NEWS: Add entry mentioning support for native Windows x64 SEH data.=20 * amd64-windows-tdep.c: #include "objfiles.h", "frame-unwind.h", "coff/internal.h", "coff/i386.h", "coff/pe.h" and "libcoff.h". (struct amd64_windows_frame_cache): New struct. (amd64_windows_w2gdb_regnum): New global. (pc_in_range, amd64_windows_frame_decode_epilogue) (amd64_windows_frame_decode_insns, amd64_windows_find_unwind_info) (amd64_windows_frame_cache, amd64_windows_frame_prev_register) (amd64_windows_frame_this_id): New functions. (amd64_windows_frame_unwind): New static global. (amd64_windows_skip_prologue): New function. (amd64_windows_init_abi): Call frame_unwind_prepend_unwinder with amd64_windows_frame_unwind. Call set_gdbarch_skip_prologue with amd64_windows_skip_prologue. diff --git a/gdb/NEWS b/gdb/NEWS index 6ee82f7..d9588ff 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -134,6 +134,8 @@ qXfer:libraries-svr4:read's annex * New 'z' formatter for printing and examining memory, this displays the value as hexadecimal zero padded on the left to the size of the type. =20 +* GDB can now use Windows x64 unwinding data. + *** Changes in GDB 7.6 =20 * Target record has been renamed to record-full. diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index a0fd074..4e750a1 100644 --- a/gdb/amd64-windows-tdep.c +++ b/gdb/amd64-windows-tdep.c @@ -25,6 +25,12 @@ #include "regcache.h" #include "windows-tdep.h" #include "frame.h" +#include "objfiles.h" +#include "frame-unwind.h" +#include "coff/internal.h" +#include "coff/i386.h" +#include "coff/pe.h" +#include "libcoff.h" =20 /* The registers used to pass integer arguments during a function call. */ static int amd64_windows_dummy_call_integer_regs[] =3D @@ -155,6 +161,752 @@ amd64_skip_main_prologue (struct gdbarch *gdbarch, CO= RE_ADDR pc) return pc; } =20 +struct amd64_windows_frame_cache +{ + /* ImageBase for the module. */ + CORE_ADDR image_base; + + /* Function start and end rva. */ + CORE_ADDR start_rva; + CORE_ADDR end_rva; + + /* Next instruction to be executed. */ + CORE_ADDR pc; + + /* Current sp. */ + CORE_ADDR sp; + + /* Address of saved integer and xmm registers. */ + CORE_ADDR prev_reg_addr[16]; + CORE_ADDR prev_xmm_addr[16]; + + /* These two next fields are set only for machine info frames. */ + + /* Likewise for RIP. */ + CORE_ADDR prev_rip_addr; + + /* Likewise for RSP. */ + CORE_ADDR prev_rsp_addr; + + /* Address of the previous frame. */ + CORE_ADDR prev_sp; +}; + +/* Convert a Windows register number to gdb. */ +static const enum amd64_regnum amd64_windows_w2gdb_regnum[] =3D +{ + AMD64_RAX_REGNUM, + AMD64_RCX_REGNUM, + AMD64_RDX_REGNUM, + AMD64_RBX_REGNUM, + AMD64_RSP_REGNUM, + AMD64_RBP_REGNUM, + AMD64_RSI_REGNUM, + AMD64_RDI_REGNUM, + AMD64_R8_REGNUM, + AMD64_R9_REGNUM, + AMD64_R10_REGNUM, + AMD64_R11_REGNUM, + AMD64_R12_REGNUM, + AMD64_R13_REGNUM, + AMD64_R14_REGNUM, + AMD64_R15_REGNUM +}; + +/* Return TRUE iff PC is the the range of the function corresponding to + CACHE. */ + +static int +pc_in_range (CORE_ADDR pc, const struct amd64_windows_frame_cache *cache) +{ + return (pc >=3D cache->image_base + cache->start_rva + && pc < cache->image_base + cache->end_rva); +} + +/* Try to recognize and decode an epilogue sequence. + + Return -1 if we fail to read the instructions for any reason. + Return 1 if an epilogue sequence was recognized, 0 otherwise. */ + +static int +amd64_windows_frame_decode_epilogue (struct frame_info *this_frame, + struct amd64_windows_frame_cache *cache) +{ + /* According to MSDN an epilogue "must consist of either an add RSP,cons= tant + or lea RSP,constant[FPReg], followed by a series of zero or more 8-by= te + register pops and a return or a jmp". + + Furthermore, according to RtlVirtualUnwind, the complete list of + epilog marker is: + - ret [c3] + - ret n [c2 imm16] + - rep ret [f3 c3] + - jmp imm8 | imm32 [eb rel8] or [e9 rel32] + - jmp qword ptr imm32 - not handled + - rex.w jmp reg [4X ff eY] + */ + + CORE_ADDR pc =3D cache->pc; + CORE_ADDR cur_sp =3D cache->sp; + struct gdbarch *gdbarch =3D get_frame_arch (this_frame); + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + gdb_byte op; + gdb_byte rex; + + /* We don't care about the instruction deallocating the frame: + if it hasn't been executed, the pc is still in the body, + if it has been executed, the following epilog decoding will work. */ + + /* First decode: + - pop reg [41 58-5f] or [58-5f]. */ + + while (1) + { + /* Read opcode. */ + if (target_read_memory (pc, &op, 1) !=3D 0) + return -1; + + if (op >=3D 0x40 && op <=3D 0x4f) + { + /* REX prefix. */ + rex =3D op; + + /* Read opcode. */ + if (target_read_memory (pc + 1, &op, 1) !=3D 0) + return -1; + } + else + rex =3D 0; + + if (op >=3D 0x58 && op <=3D 0x5f) + { + /* pop reg */ + gdb_byte reg =3D (op & 0x0f) | ((rex & 1) << 3); + + cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] =3D cur_sp; + cur_sp +=3D 8; + } + else + break; + + /* Allow the user to break this loop. This shouldn't happen as the + number of consecutive pop should be small. */ + QUIT; + } + + /* Then decode the marker. */ + + /* Read opcode. */ + if (target_read_memory (pc, &op, 1) !=3D 0) + return -1; + + switch (op) + { + case 0xc3: + /* Ret. */ + cache->prev_rip_addr =3D cur_sp; + cache->prev_sp =3D cur_sp + 8; + return 1; + + case 0xeb: + { + /* jmp rel8 */ + gdb_byte rel8; + CORE_ADDR npc; + + if (target_read_memory (pc + 1, &rel8, 1) !=3D 0) + return -1; + npc =3D pc + 2 + (signed char) rel8; + + /* If the jump is within the function, then this is not a marker, + otherwise this is a tail-call. */ + return !pc_in_range (npc, cache); + } + + case 0xec: + { + /* jmp rel32 */ + gdb_byte rel32[4]; + CORE_ADDR npc; + + if (target_read_memory (pc + 1, rel32, 4) !=3D 0) + return -1; + npc =3D pc + 5 + extract_signed_integer (rel32, 4, byte_order); + + /* If the jump is within the function, then this is not a marker, + otherwise this is a tail-call. */ + return !pc_in_range (npc, cache); + } + + case 0xc2: + { + /* ret n */ + gdb_byte imm16[2]; + + if (target_read_memory (pc + 1, imm16, 2) !=3D 0) + return -1; + cache->prev_rip_addr =3D cur_sp; + cache->prev_sp =3D cur_sp + + extract_unsigned_integer (imm16, 4, byte_order); + return 1; + } + + case 0xf3: + { + /* rep; ret */ + gdb_byte op1; + + if (target_read_memory (pc + 2, &op1, 1) !=3D 0) + return -1; + if (op1 !=3D 0xc3) + return 0; + + cache->prev_rip_addr =3D cur_sp; + cache->prev_sp =3D cur_sp + 8; + return 1; + } + + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4a: + case 0x4b: + case 0x4c: + case 0x4d: + case 0x4e: + case 0x4f: + /* Got a REX prefix, read next byte. */ + rex =3D op; + if (target_read_memory (pc + 1, &op, 1) !=3D 0) + return -1; + + if (op =3D=3D 0xff) + { + /* rex jmp reg */ + gdb_byte op1; + unsigned int reg; + gdb_byte buf[8]; + + if (target_read_memory (pc + 2, &op1, 1) !=3D 0) + return -1; + return (op1 & 0xf8) =3D=3D 0xe0; + } + else + return 0; + + default: + /* Not REX, so unknown. */ + return 0; + } +} + +/* Decode and execute unwind insns at UNWIND_INFO. */ + +static void +amd64_windows_frame_decode_insns (struct frame_info *this_frame, + struct amd64_windows_frame_cache *cache, + CORE_ADDR unwind_info) +{ + CORE_ADDR save_addr =3D 0; + CORE_ADDR cur_sp =3D cache->sp; + struct gdbarch *gdbarch =3D get_frame_arch (this_frame); + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + int j; + + for (j =3D 0; ; j++) + { + struct external_pex64_unwind_info ex_ui; + /* There are at most 256 16-bit unwind insns. */ + gdb_byte insns[2 * 256]; + gdb_byte *p; + gdb_byte *end_insns; + unsigned char codes_count; + unsigned char frame_reg; + unsigned char frame_off; + + /* Read and decode header. */ + if (target_read_memory (cache->image_base + unwind_info, + (gdb_byte *) &ex_ui, sizeof (ex_ui)) !=3D 0) + return; + + if (frame_debug) + fprintf_unfiltered + (gdb_stdlog, + "amd64_windows_frame_decodes_insn: " + "%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x\n", + paddress (gdbarch, unwind_info), + ex_ui.Version_Flags, ex_ui.SizeOfPrologue, + ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset); + + /* Check version. */ + if (PEX64_UWI_VERSION (ex_ui.Version_Flags) !=3D 1) + return; + + if (j =3D=3D 0 + && (cache->pc >=3D + cache->image_base + cache->start_rva + ex_ui.SizeOfPrologue)) + { + /* Not in the prologue. We want to detect if the PC points to an + epilogue. If so, the epilogue detection+decoding function is + sufficient. Otherwise, the unwinder will consider that the PC + is in the body of the function and will need to decode unwind + info. */ + if (amd64_windows_frame_decode_epilogue (this_frame, cache) =3D=3D 1) + return; + + /* Not in an epilog. Clear possible side effects. */ + memset (cache->prev_reg_addr, 0, sizeof (cache->prev_reg_addr)); + } + + codes_count =3D ex_ui.CountOfCodes; + frame_reg =3D PEX64_UWI_FRAMEREG (ex_ui.FrameRegisterOffset); + + if (frame_reg !=3D 0) + { + /* According to msdn: + If an FP reg is used, then any unwind code taking an offset must + only be used after the FP reg is established in the prolog. */ + gdb_byte buf[8]; + int frreg =3D amd64_windows_w2gdb_regnum[frame_reg]; + + get_frame_register (this_frame, frreg, buf); + save_addr =3D extract_unsigned_integer (buf, 8, byte_order); + + if (frame_debug) + fprintf_unfiltered (gdb_stdlog, " frame_reg=3D%s, val=3D%s\n", + gdbarch_register_name (gdbarch, frreg), + paddress (gdbarch, save_addr)); + } + + /* Read opcodes. */ + if (codes_count !=3D 0 + && target_read_memory (cache->image_base + unwind_info + + sizeof (ex_ui), + insns, codes_count * 2) !=3D 0) + return; + + end_insns =3D &insns[codes_count * 2]; + for (p =3D insns; p < end_insns; p +=3D 2) + { + int reg; + + if (frame_debug) + fprintf_unfiltered + (gdb_stdlog, " op #%u: off=3D0x%02x, insn=3D0x%02x\n", + (unsigned) (p - insns), p[0], p[1]); + + /* Virtually execute the operation. */ + if (cache->pc >=3D cache->image_base + cache->start_rva + p[0]) + { + /* If there is no frame registers defined, the current value of + rsp is used instead. */ + if (frame_reg =3D=3D 0) + save_addr =3D cur_sp; + + switch (PEX64_UNWCODE_CODE (p[1])) + { + case UWOP_PUSH_NONVOL: + /* Push pre-decrements RSP. */ + reg =3D amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])]; + cache->prev_reg_addr[reg] =3D cur_sp; + cur_sp +=3D 8; + break; + case UWOP_ALLOC_LARGE: + if (PEX64_UNWCODE_INFO (p[1]) =3D=3D 0) + cur_sp +=3D + 8 * extract_unsigned_integer (p + 2, 2, byte_order); + else if (PEX64_UNWCODE_INFO (p[1]) =3D=3D 1) + cur_sp +=3D extract_unsigned_integer (p + 2, 4, byte_order); + else + return; + break; + case UWOP_ALLOC_SMALL: + cur_sp +=3D 8 + 8 * PEX64_UNWCODE_INFO (p[1]); + break; + case UWOP_SET_FPREG: + cur_sp =3D save_addr + - PEX64_UWI_FRAMEOFF (ex_ui.FrameRegisterOffset) * 16; + break; + case UWOP_SAVE_NONVOL: + reg =3D amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])]; + cache->prev_reg_addr[reg] =3D save_addr + - 8 * extract_unsigned_integer (p + 2, 2, byte_order); + break; + case UWOP_SAVE_NONVOL_FAR: + reg =3D amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])]; + cache->prev_reg_addr[reg] =3D save_addr + - 8 * extract_unsigned_integer (p + 2, 4, byte_order); + break; + case UWOP_SAVE_XMM128: + cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =3D + save_addr + - 16 * extract_unsigned_integer (p + 2, 2, byte_order); + break; + case UWOP_SAVE_XMM128_FAR: + cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] =3D + save_addr + - 16 * extract_unsigned_integer (p + 2, 4, byte_order); + break; + case UWOP_PUSH_MACHFRAME: + if (PEX64_UNWCODE_INFO (p[1]) =3D=3D 0) + { + cache->prev_rip_addr =3D cur_sp + 0; + cache->prev_rsp_addr =3D cur_sp + 24; + cur_sp +=3D 40; + } + else if (PEX64_UNWCODE_INFO (p[1]) =3D=3D 1) + { + cache->prev_rip_addr =3D cur_sp + 8; + cache->prev_rsp_addr =3D cur_sp + 32; + cur_sp +=3D 48; + } + else + return; + break; + default: + return; + } + } + + /* Adjust with the length of the opcode. */ + switch (PEX64_UNWCODE_CODE (p[1])) + { + case UWOP_PUSH_NONVOL: + case UWOP_ALLOC_SMALL: + case UWOP_SET_FPREG: + case UWOP_PUSH_MACHFRAME: + break; + case UWOP_ALLOC_LARGE: + if (PEX64_UNWCODE_INFO (p[1]) =3D=3D 0) + p +=3D 2; + else if (PEX64_UNWCODE_INFO (p[1]) =3D=3D 1) + p +=3D 4; + else + return; + break; + case UWOP_SAVE_NONVOL: + case UWOP_SAVE_XMM128: + p +=3D 2; + break; + case UWOP_SAVE_NONVOL_FAR: + case UWOP_SAVE_XMM128_FAR: + p +=3D 4; + break; + default: + return; + } + } + if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) !=3D UNW_FLAG_CHAININFO) + break; + else + { + /* Read the chained unwind info. */ + struct external_pex64_runtime_function d; + CORE_ADDR chain_vma; + + chain_vma =3D cache->image_base + unwind_info + + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2 + 8; + + if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) !=3D 0) + return; + + cache->start_rva =3D + extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order); + cache->end_rva =3D + extract_unsigned_integer (d.rva_EndAddress, 4, byte_order); + unwind_info =3D + extract_unsigned_integer (d.rva_UnwindData, 4, byte_order); + } + + /* Allow the user to break this loop. */ + QUIT; + } + /* PC is saved by the call. */ + if (cache->prev_rip_addr =3D=3D 0) + cache->prev_rip_addr =3D cur_sp; + cache->prev_sp =3D cur_sp + 8; + + if (frame_debug) + fprintf_unfiltered (gdb_stdlog, " prev_sp: %s, prev_pc @%s\n", + paddress (gdbarch, cache->prev_sp), + paddress (gdbarch, cache->prev_rip_addr)); +} + +/* Find SEH unwind info for PC, returning 0 on success. + + UNWIND_INFO is set to the rva of unwind info address, IMAGE_BASE + to the base address of the corresponding image, and START_RVA + to the rva of the function containing PC. */ + +static int +amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc, + CORE_ADDR *unwind_info, + CORE_ADDR *image_base, + CORE_ADDR *start_rva, + CORE_ADDR *end_rva) +{ + struct obj_section *sec; + pe_data_type *pe; + IMAGE_DATA_DIRECTORY *dir; + struct objfile *objfile; + unsigned long lo, hi; + CORE_ADDR base; + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + + /* Get the corresponding exception directory. */ + sec =3D find_pc_section (pc); + if (sec =3D=3D NULL) + return -1; + objfile =3D sec->objfile; + pe =3D pe_data (sec->objfile->obfd); + dir =3D &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE]; + + base =3D pe->pe_opthdr.ImageBase + + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + *image_base =3D base; + + /* Find the entry. + + Note: This does not handle dynamically added entries (for JIT + engines). For this, we would need to ask the kernel directly, + which means getting some info from the native layer. For the + rest of the code, however, it's probably faster to search + the entry ourselves. */ + lo =3D 0; + hi =3D dir->Size / sizeof (struct external_pex64_runtime_function); + *unwind_info =3D 0; + while (lo <=3D hi) + { + unsigned long mid =3D lo + (hi - lo) / 2; + struct external_pex64_runtime_function d; + CORE_ADDR sa, ea; + + if (target_read_memory (base + dir->VirtualAddress + mid * sizeof (d= ), + (gdb_byte *) &d, sizeof (d)) !=3D 0) + return -1; + + sa =3D extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order); + ea =3D extract_unsigned_integer (d.rva_EndAddress, 4, byte_order); + if (pc < base + sa) + hi =3D mid - 1; + else if (pc >=3D base + ea) + lo =3D mid + 1; + else if (pc >=3D base + sa && pc < base + ea) + { + /* Got it. */ + *start_rva =3D sa; + *end_rva =3D ea; + *unwind_info =3D + extract_unsigned_integer (d.rva_UnwindData, 4, byte_order); + break; + } + else + break; + } + + if (frame_debug) + fprintf_unfiltered + (gdb_stdlog, + "amd64_windows_find_unwind_data: image_base=3D%s, unwind_data=3D%s= \n", + paddress (gdbarch, base), paddress (gdbarch, *unwind_info)); + + if (*unwind_info & 1) + { + /* Unofficially documented unwind info redirection, when UNWIND_INFO + address is odd (http://www.codemachine.com/article_x64deepdive.html). + */ + struct external_pex64_runtime_function d; + CORE_ADDR sa, ea; + + if (target_read_memory (base + (*unwind_info & ~1), + (gdb_byte *) &d, sizeof (d)) !=3D 0) + return -1; + + *start_rva =3D + extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order); + *end_rva =3D extract_unsigned_integer (d.rva_EndAddress, 4, byte_ord= er); + *unwind_info =3D + extract_unsigned_integer (d.rva_UnwindData, 4, byte_order); + + } + return 0; +} + +/* Fill THIS_CACHE using the native amd64-windows unwinding data + for THIS_FRAME. */ + +static struct amd64_windows_frame_cache * +amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cach= e) +{ + struct gdbarch *gdbarch =3D get_frame_arch (this_frame); + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + struct amd64_windows_frame_cache *cache; + gdb_byte buf[8]; + struct obj_section *sec; + pe_data_type *pe; + IMAGE_DATA_DIRECTORY *dir; + CORE_ADDR image_base; + CORE_ADDR pc; + struct objfile *objfile; + unsigned long lo, hi; + CORE_ADDR unwind_info =3D 0; + + if (*this_cache) + return *this_cache; + + cache =3D FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache); + *this_cache =3D cache; + + /* Get current PC and SP. */ + pc =3D get_frame_pc (this_frame); + get_frame_register (this_frame, AMD64_RSP_REGNUM, buf); + cache->sp =3D extract_unsigned_integer (buf, 8, byte_order); + cache->pc =3D pc; + + if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info, + &cache->image_base, + &cache->start_rva, + &cache->end_rva)) + return cache; + + if (unwind_info =3D=3D 0) + { + /* Assume a leaf function. */ + cache->prev_sp =3D cache->sp + 8; + cache->prev_rip_addr =3D cache->sp; + } + else + { + /* Decode unwind insns to compute saved addresses. */ + amd64_windows_frame_decode_insns (this_frame, cache, unwind_info); + } + return cache; +} + +/* Implement the "prev_register" method of struct frame_unwind + using the standard Windows x64 SEH info. */ + +static struct value * +amd64_windows_frame_prev_register (struct frame_info *this_frame, + void **this_cache, int regnum) +{ + struct gdbarch *gdbarch =3D get_frame_arch (this_frame); + enum bfd_endian byte_order =3D gdbarch_byte_order (gdbarch); + struct amd64_windows_frame_cache *cache =3D + amd64_windows_frame_cache (this_frame, this_cache); + struct value *val; + CORE_ADDR prev; + + if (frame_debug) + fprintf_unfiltered (gdb_stdlog, + "amd64_windows_frame_prev_register %s for sp=3D%s\n", + gdbarch_register_name (gdbarch, regnum), + paddress (gdbarch, cache->prev_sp)); + + if (regnum >=3D AMD64_XMM0_REGNUM && regnum <=3D AMD64_XMM0_REGNUM + 15) + prev =3D cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM]; + else if (regnum =3D=3D AMD64_RSP_REGNUM) + { + prev =3D cache->prev_rsp_addr; + if (prev =3D=3D 0) + return frame_unwind_got_constant (this_frame, regnum, cache->prev_sp); + } + else if (regnum >=3D AMD64_RAX_REGNUM && regnum <=3D AMD64_R15_REGNUM) + prev =3D cache->prev_reg_addr[regnum - AMD64_RAX_REGNUM]; + else if (regnum =3D=3D AMD64_RIP_REGNUM) + prev =3D cache->prev_rip_addr; + else + prev =3D 0; + + if (prev && frame_debug) + fprintf_unfiltered (gdb_stdlog, " -> at %s\n", paddress (gdbarch, pre= v)); + + if (prev) + { + /* Register was saved. */ + return frame_unwind_got_memory (this_frame, regnum, prev); + } + else + { + /* Register is either volatile or not modified. */ + return frame_unwind_got_register (this_frame, regnum, regnum); + } +} + +/* Implement the "this_id" method of struct frame_unwind using + the standard Windows x64 SEH info. */ + +static void +amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_ca= che, + struct frame_id *this_id) +{ + struct gdbarch *gdbarch =3D get_frame_arch (this_frame); + struct amd64_windows_frame_cache *cache =3D + amd64_windows_frame_cache (this_frame, this_cache); + + *this_id =3D frame_id_build (cache->prev_sp, + cache->image_base + cache->start_rva); +} + +/* Windows x64 SEH unwinder. */ + +static const struct frame_unwind amd64_windows_frame_unwind =3D +{ + NORMAL_FRAME, + default_frame_unwind_stop_reason, + &amd64_windows_frame_this_id, + &amd64_windows_frame_prev_register, + NULL, + default_frame_sniffer +}; + +/* Implement the "skip_prologue" gdbarch method. */ + +static CORE_ADDR +amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + CORE_ADDR func_addr; + CORE_ADDR unwind_info =3D 0; + CORE_ADDR image_base, start_rva, end_rva; + struct external_pex64_unwind_info ex_ui; + + /* Use prologue size from unwind info. */ + if (amd64_windows_find_unwind_info (gdbarch, pc, &unwind_info, + &image_base, &start_rva, &end_rva) =3D=3D 0) + { + if (unwind_info =3D=3D 0) + { + /* Leaf function. */ + return pc; + } + else if (target_read_memory (image_base + unwind_info, + (gdb_byte *) &ex_ui, sizeof (ex_ui)) =3D=3D 0 + && PEX64_UWI_VERSION (ex_ui.Version_Flags) =3D=3D 1) + return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue); + } + + /* See if we can determine the end of the prologue via the symbol + table. If so, then return either the PC, or the PC after + the prologue, whichever is greater. */ + if (find_pc_partial_function (pc, NULL, &func_addr, NULL)) + { + CORE_ADDR post_prologue_pc + =3D skip_prologue_using_sal (gdbarch, func_addr); + + if (post_prologue_pc !=3D 0) + return max (pc, post_prologue_pc); + } + + return pc; +} + /* Check Win64 DLL jmp trampolines and find jump destination. */ =20 static CORE_ADDR @@ -205,6 +957,19 @@ amd64_windows_init_abi (struct gdbarch_info info, stru= ct gdbarch *gdbarch) { struct gdbarch_tdep *tdep =3D gdbarch_tdep (gdbarch); =20 + /* The dwarf2 unwinder (appended very early by i386_gdbarch_init) is + preferred over the SEH one. The reasons are: + - binaries without SEH but with dwarf2 debug info are correcly handled + (although they aren't ABI compliant, gcc before 4.7 didn't emit SEH + info). + - dwarf3 DW_OP_call_frame_cfa is correctly handled (it can only be + handled if the dwarf2 unwinder is used). + + The call to amd64_init_abi appends default unwinders, that aren't + compatible with the SEH one. + */ + frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind); + amd64_init_abi (info, gdbarch); =20 /* On Windows, "long"s are only 32bit. */ @@ -225,6 +990,8 @@ amd64_windows_init_abi (struct gdbarch_info info, struc= t gdbarch *gdbarch) set_gdbarch_iterate_over_objfiles_in_search_order (gdbarch, windows_iterate_over_objfiles_in_search_order); =20 + set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue); + set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset); =20 set_solib_ops (gdbarch, &solib_target_so_ops); @@ -239,4 +1006,3 @@ _initialize_amd64_windows_tdep (void) gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN, amd64_windows_init_abi); } -