X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=gdb%2Famd64-windows-tdep.c;h=14477e61fdd47ada989cfecab1fe8922f5816414;hb=213516ef315dc1785e4990ef0fc011abedb38cc0;hp=de5d8c7ccf7c059b7d23a77740a03b53bd528caf;hpb=61012eef8463764ccd9117dc1c9bc43cc452b7cc;p=thirdparty%2Fbinutils-gdb.git diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index de5d8c7ccf7..14477e61fdd 100644 --- a/gdb/amd64-windows-tdep.c +++ b/gdb/amd64-windows-tdep.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2009-2015 Free Software Foundation, Inc. +/* Copyright (C) 2009-2023 Free Software Foundation, Inc. This file is part of GDB. @@ -18,6 +18,7 @@ #include "defs.h" #include "osabi.h" #include "amd64-tdep.h" +#include "gdbsupport/x86-xstate.h" #include "gdbtypes.h" #include "gdbcore.h" #include "regcache.h" @@ -30,6 +31,7 @@ #include "coff/pe.h" #include "libcoff.h" #include "value.h" +#include /* The registers used to pass integer arguments during a function call. */ static int amd64_windows_dummy_call_integer_regs[] = @@ -40,13 +42,78 @@ static int amd64_windows_dummy_call_integer_regs[] = AMD64_R9_REGNUM /* %r9 */ }; +/* This vector maps GDB's idea of a register's number into an offset into + the Windows API CONTEXT structure. */ +static int amd64_windows_gregset_reg_offset[] = +{ + 120, /* Rax */ + 144, /* Rbx */ + 128, /* Rcx */ + 136, /* Rdx */ + 168, /* Rsi */ + 176, /* Rdi */ + 160, /* Rbp */ + 152, /* Rsp */ + 184, /* R8 */ + 192, /* R9 */ + 200, /* R10 */ + 208, /* R11 */ + 216, /* R12 */ + 224, /* R13 */ + 232, /* R14 */ + 240, /* R15 */ + 248, /* Rip */ + 68, /* EFlags */ + 56, /* SegCs */ + 66, /* SegSs */ + 58, /* SegDs */ + 60, /* SegEs */ + 62, /* SegFs */ + 64, /* SegGs */ + 288, /* FloatSave.FloatRegisters[0] */ + 304, /* FloatSave.FloatRegisters[1] */ + 320, /* FloatSave.FloatRegisters[2] */ + 336, /* FloatSave.FloatRegisters[3] */ + 352, /* FloatSave.FloatRegisters[4] */ + 368, /* FloatSave.FloatRegisters[5] */ + 384, /* FloatSave.FloatRegisters[6] */ + 400, /* FloatSave.FloatRegisters[7] */ + 256, /* FloatSave.ControlWord */ + 258, /* FloatSave.StatusWord */ + 260, /* FloatSave.TagWord */ + 268, /* FloatSave.ErrorSelector */ + 264, /* FloatSave.ErrorOffset */ + 276, /* FloatSave.DataSelector */ + 272, /* FloatSave.DataOffset */ + 268, /* FloatSave.ErrorSelector */ + 416, /* Xmm0 */ + 432, /* Xmm1 */ + 448, /* Xmm2 */ + 464, /* Xmm3 */ + 480, /* Xmm4 */ + 496, /* Xmm5 */ + 512, /* Xmm6 */ + 528, /* Xmm7 */ + 544, /* Xmm8 */ + 560, /* Xmm9 */ + 576, /* Xmm10 */ + 592, /* Xmm11 */ + 608, /* Xmm12 */ + 624, /* Xmm13 */ + 640, /* Xmm14 */ + 656, /* Xmm15 */ + 280, /* FloatSave.MxCsr */ +}; + +#define AMD64_WINDOWS_SIZEOF_GREGSET 1232 + /* Return nonzero if an argument of type TYPE should be passed via one of the integer registers. */ static int amd64_windows_passed_by_integer_register (struct type *type) { - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_INT: case TYPE_CODE_ENUM: @@ -55,12 +122,14 @@ amd64_windows_passed_by_integer_register (struct type *type) case TYPE_CODE_CHAR: case TYPE_CODE_PTR: case TYPE_CODE_REF: + case TYPE_CODE_RVALUE_REF: case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: - return (TYPE_LENGTH (type) == 1 - || TYPE_LENGTH (type) == 2 - || TYPE_LENGTH (type) == 4 - || TYPE_LENGTH (type) == 8); + case TYPE_CODE_COMPLEX: + return (type->length () == 1 + || type->length () == 2 + || type->length () == 4 + || type->length () == 8); default: return 0; @@ -73,9 +142,9 @@ amd64_windows_passed_by_integer_register (struct type *type) static int amd64_windows_passed_by_xmm_register (struct type *type) { - return ((TYPE_CODE (type) == TYPE_CODE_FLT - || TYPE_CODE (type) == TYPE_CODE_DECFLOAT) - && (TYPE_LENGTH (type) == 4 || TYPE_LENGTH (type) == 8)); + return ((type->code () == TYPE_CODE_FLT + || type->code () == TYPE_CODE_DECFLOAT) + && (type->length () == 4 || type->length () == 8)); } /* Return non-zero iff an argument of the given TYPE should be passed @@ -110,8 +179,8 @@ amd64_windows_adjust_args_passed_by_pointer (struct value **args, if (amd64_windows_passed_by_pointer (value_type (args[i]))) { struct type *type = value_type (args[i]); - const gdb_byte *valbuf = value_contents (args[i]); - const int len = TYPE_LENGTH (type); + const gdb_byte *valbuf = value_contents (args[i]).data (); + const int len = type->length (); /* Store a copy of that argument on the stack, aligned to a 16 bytes boundary, and then use the copy's address as @@ -136,13 +205,13 @@ amd64_windows_store_arg_in_reg (struct regcache *regcache, struct value *arg, int regno) { struct type *type = value_type (arg); - const gdb_byte *valbuf = value_contents (arg); + const gdb_byte *valbuf = value_contents (arg).data (); gdb_byte buf[8]; - gdb_assert (TYPE_LENGTH (type) <= 8); + gdb_assert (type->length () <= 8); memset (buf, 0, sizeof buf); - memcpy (buf, valbuf, min (TYPE_LENGTH (type), 8)); - regcache_cooked_write (regcache, regno, buf); + memcpy (buf, valbuf, std::min (type->length (), (ULONGEST) 8)); + regcache->cooked_write (regno, buf); } /* Push the arguments for an inferior function call, and return @@ -154,11 +223,11 @@ amd64_windows_store_arg_in_reg (struct regcache *regcache, static CORE_ADDR amd64_windows_push_arguments (struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp, - int struct_return) + function_call_return_method return_method) { int reg_idx = 0; int i; - struct value **stack_args = alloca (nargs * sizeof (struct value *)); + struct value **stack_args = XALLOCAVEC (struct value *, nargs); int num_stack_args = 0; int num_elements = 0; int element = 0; @@ -169,7 +238,7 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs, in inferior memory. So use a copy of the ARGS table, to avoid modifying the original one. */ { - struct value **args1 = alloca (nargs * sizeof (struct value *)); + struct value **args1 = XALLOCAVEC (struct value *, nargs); memcpy (args1, args, nargs * sizeof (struct value *)); sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp); @@ -177,13 +246,13 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs, } /* Reserve a register for the "hidden" argument. */ - if (struct_return) + if (return_method == return_method_struct) reg_idx++; for (i = 0; i < nargs; i++) { struct type *type = value_type (args[i]); - int len = TYPE_LENGTH (type); + int len = type->length (); int on_stack_p = 1; if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs)) @@ -199,7 +268,7 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs, else if (amd64_windows_passed_by_xmm_register (type)) { amd64_windows_store_arg_in_reg - (regcache, args[i], AMD64_XMM0_REGNUM + reg_idx); + (regcache, args[i], AMD64_XMM0_REGNUM + reg_idx); /* In case of varargs, these parameters must also be passed via the integer registers. */ amd64_windows_store_arg_in_reg @@ -226,10 +295,10 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs, for (i = 0; i < num_stack_args; i++) { struct type *type = value_type (stack_args[i]); - const gdb_byte *valbuf = value_contents (stack_args[i]); + const gdb_byte *valbuf = value_contents (stack_args[i]).data (); - write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type)); - element += ((TYPE_LENGTH (type) + 7) / 8); + write_memory (sp + element * 8, valbuf, type->length ()); + element += ((type->length () + 7) / 8); } return sp; @@ -241,25 +310,25 @@ static CORE_ADDR amd64_windows_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, - int nargs, struct value **args, - CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) + int nargs, struct value **args, CORE_ADDR sp, + function_call_return_method return_method, CORE_ADDR struct_addr) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); gdb_byte buf[8]; /* Pass arguments. */ sp = amd64_windows_push_arguments (regcache, nargs, args, sp, - struct_return); + return_method); /* Pass "hidden" argument". */ - if (struct_return) + if (return_method == return_method_struct) { /* The "hidden" argument is passed throught the first argument - register. */ + register. */ const int arg_regnum = amd64_windows_dummy_call_integer_regs[0]; store_unsigned_integer (buf, 8, byte_order, struct_addr); - regcache_cooked_write (regcache, arg_regnum, buf); + regcache->cooked_write (arg_regnum, buf); } /* Reserve some memory on the stack for the integer-parameter @@ -273,10 +342,10 @@ amd64_windows_push_dummy_call /* Update the stack pointer... */ store_unsigned_integer (buf, 8, byte_order, sp); - regcache_cooked_write (regcache, AMD64_RSP_REGNUM, buf); + regcache->cooked_write (AMD64_RSP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, AMD64_RBP_REGNUM, buf); + regcache->cooked_write (AMD64_RBP_REGNUM, buf); return sp + 16; } @@ -288,37 +357,49 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { - int len = TYPE_LENGTH (type); + int len = type->length (); int regnum = -1; /* See if our value is returned through a register. If it is, then store the associated register number in REGNUM. */ - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_FLT: - case TYPE_CODE_DECFLOAT: - /* __m128, __m128i, __m128d, floats, and doubles are returned - via XMM0. */ - if (len == 4 || len == 8 || len == 16) - regnum = AMD64_XMM0_REGNUM; - break; + /* floats, and doubles are returned via XMM0. */ + if (len == 4 || len == 8) + regnum = AMD64_XMM0_REGNUM; + break; + case TYPE_CODE_ARRAY: + /* __m128, __m128i and __m128d are returned via XMM0. */ + if (type->is_vector () && len == 16) + { + enum type_code code = type->target_type ()->code (); + if (code == TYPE_CODE_INT || code == TYPE_CODE_FLT) + { + regnum = AMD64_XMM0_REGNUM; + break; + } + } + /* fall through */ default: - /* All other values that are 1, 2, 4 or 8 bytes long are returned - via RAX. */ - if (len == 1 || len == 2 || len == 4 || len == 8) - regnum = AMD64_RAX_REGNUM; - break; + /* All other values that are 1, 2, 4 or 8 bytes long are returned + via RAX. */ + if (len == 1 || len == 2 || len == 4 || len == 8) + regnum = AMD64_RAX_REGNUM; + else if (len == 16 && type->code () == TYPE_CODE_INT) + regnum = AMD64_XMM0_REGNUM; + break; } if (regnum < 0) { /* RAX contains the address where the return value has been stored. */ if (readbuf) - { + { ULONGEST addr; regcache_raw_read_unsigned (regcache, AMD64_RAX_REGNUM, &addr); - read_memory (addr, readbuf, TYPE_LENGTH (type)); + read_memory (addr, readbuf, type->length ()); } return RETURN_VALUE_ABI_RETURNS_ADDRESS; } @@ -326,9 +407,9 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function, { /* Extract the return value from the register where it was stored. */ if (readbuf) - regcache_raw_read_part (regcache, regnum, 0, len, readbuf); + regcache->raw_read_part (regnum, 0, len, readbuf); if (writebuf) - regcache_raw_write_part (regcache, regnum, 0, len, writebuf); + regcache->raw_write_part (regnum, 0, len, writebuf); return RETURN_VALUE_REGISTER_CONVENTION; } } @@ -348,17 +429,17 @@ amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) gdb_byte buf[4]; if (target_read_memory (pc + 1, buf, sizeof buf) == 0) - { - struct bound_minimal_symbol s; - CORE_ADDR call_dest; + { + struct bound_minimal_symbol s; + CORE_ADDR call_dest; call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order); - s = lookup_minimal_symbol_by_pc (call_dest); - if (s.minsym != NULL - && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL - && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0) - pc += 5; - } + s = lookup_minimal_symbol_by_pc (call_dest); + if (s.minsym != NULL + && s.minsym->linkage_name () != NULL + && strcmp (s.minsym->linkage_name (), "__main") == 0) + pc += 5; + } } return pc; @@ -416,7 +497,7 @@ static const enum amd64_regnum amd64_windows_w2gdb_regnum[] = AMD64_R15_REGNUM }; -/* Return TRUE iff PC is the the range of the function corresponding to +/* Return TRUE iff PC is the range of the function corresponding to CACHE. */ static int @@ -432,7 +513,7 @@ pc_in_range (CORE_ADDR pc, const struct amd64_windows_frame_cache *cache) Return 1 if an epilogue sequence was recognized, 0 otherwise. */ static int -amd64_windows_frame_decode_epilogue (struct frame_info *this_frame, +amd64_windows_frame_decode_epilogue (frame_info_ptr this_frame, struct amd64_windows_frame_cache *cache) { /* According to MSDN an epilogue "must consist of either an add RSP,constant @@ -488,6 +569,7 @@ amd64_windows_frame_decode_epilogue (struct frame_info *this_frame, cache->prev_reg_addr[amd64_windows_w2gdb_regnum[reg]] = cur_sp; cur_sp += 8; + pc += rex ? 2 : 1; } else break; @@ -594,8 +676,6 @@ amd64_windows_frame_decode_epilogue (struct frame_info *this_frame, { /* rex jmp reg */ gdb_byte op1; - unsigned int reg; - gdb_byte buf[8]; if (target_read_memory (pc + 2, &op1, 1) != 0) return -1; @@ -613,7 +693,7 @@ amd64_windows_frame_decode_epilogue (struct frame_info *this_frame, /* Decode and execute unwind insns at UNWIND_INFO. */ static void -amd64_windows_frame_decode_insns (struct frame_info *this_frame, +amd64_windows_frame_decode_insns (frame_info_ptr this_frame, struct amd64_windows_frame_cache *cache, CORE_ADDR unwind_info) { @@ -621,9 +701,46 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, CORE_ADDR cur_sp = cache->sp; struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - int j; + int first = 1; + + /* There are at least 3 possibilities to share an unwind info entry: + 1. Two different runtime_function entries (in .pdata) can point to the + same unwind info entry. There is no such indication while unwinding, + so we don't really care about that case. We suppose this scheme is + used to save memory when the unwind entries are exactly the same. + 2. Chained unwind_info entries, with no unwind codes (no prologue). + There is a major difference with the previous case: the pc range for + the function is different (in case 1, the pc range comes from the + runtime_function entry; in case 2, the pc range for the chained entry + comes from the first unwind entry). Case 1 cannot be used instead as + the pc is not in the prologue. This case is officially documented. + (There might be unwind code in the first unwind entry to handle + additional unwinding). GCC (at least until gcc 5.0) doesn't chain + entries. + 3. Undocumented unwind info redirection. Hard to know the exact purpose, + so it is considered as a memory optimization of case 2. + */ - for (j = 0; ; j++) + 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; + + if (target_read_memory (cache->image_base + (unwind_info & ~1), + (gdb_byte *) &d, sizeof (d)) != 0) + return; + + cache->start_rva + = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order); + cache->end_rva + = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order); + unwind_info + = extract_unsigned_integer (d.rva_UnwindData, 4, byte_order); + } + + while (1) { struct external_pex64_unwind_info ex_ui; /* There are at most 256 16-bit unwind insns. */ @@ -632,33 +749,30 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, gdb_byte *end_insns; unsigned char codes_count; unsigned char frame_reg; - unsigned char frame_off; + CORE_ADDR start; /* Read and decode header. */ if (target_read_memory (cache->image_base + unwind_info, (gdb_byte *) &ex_ui, sizeof (ex_ui)) != 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); + frame_debug_printf ("%s: ver: %02x, plgsz: %02x, cnt: %02x, frame: %02x", + 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) != 1 && PEX64_UWI_VERSION (ex_ui.Version_Flags) != 2) return; - if (j == 0 - && (cache->pc >= - cache->image_base + cache->start_rva + ex_ui.SizeOfPrologue)) + start = cache->image_base + cache->start_rva; + if (first + && !(cache->pc >= start && cache->pc < start + 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 + /* We want to detect if the PC points to an epilogue. This needs + to be checked only once, and an epilogue can be anywhere but in + the prologue. 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. */ @@ -683,10 +797,9 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, get_frame_register (this_frame, frreg, buf); save_addr = extract_unsigned_integer (buf, 8, byte_order); - if (frame_debug) - fprintf_unfiltered (gdb_stdlog, " frame_reg=%s, val=%s\n", - gdbarch_register_name (gdbarch, frreg), - paddress (gdbarch, save_addr)); + frame_debug_printf (" frame_reg=%s, val=%s", + gdbarch_register_name (gdbarch, frreg), + paddress (gdbarch, save_addr)); } /* Read opcodes. */ @@ -711,19 +824,22 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, { int reg; - if (frame_debug) - fprintf_unfiltered - (gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n", - (unsigned) (p - insns), p[0], p[1]); - - /* Virtually execute the operation. */ - if (cache->pc >= cache->image_base + cache->start_rva + p[0]) + /* Virtually execute the operation if the pc is after the + corresponding instruction (that does matter in case of break + within the prologue). Note that for chained info (!first), the + prologue has been fully executed. */ + if (cache->pc >= start + p[0] || cache->pc < start) { + frame_debug_printf (" op #%u: off=0x%02x, insn=0x%02x", + (unsigned) (p - insns), p[0], p[1]); + /* If there is no frame registers defined, the current value of rsp is used instead. */ if (frame_reg == 0) save_addr = cur_sp; + reg = -1; + switch (PEX64_UNWCODE_CODE (p[1])) { case UWOP_PUSH_NONVOL: @@ -751,12 +867,12 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, case UWOP_SAVE_NONVOL: reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])]; cache->prev_reg_addr[reg] = save_addr - - 8 * extract_unsigned_integer (p + 2, 2, byte_order); + + 8 * extract_unsigned_integer (p + 2, 2, byte_order); break; case UWOP_SAVE_NONVOL_FAR: reg = amd64_windows_w2gdb_regnum[PEX64_UNWCODE_INFO (p[1])]; cache->prev_reg_addr[reg] = save_addr - - 8 * extract_unsigned_integer (p + 2, 4, byte_order); + + 8 * extract_unsigned_integer (p + 2, 4, byte_order); break; case UWOP_SAVE_XMM128: cache->prev_xmm_addr[PEX64_UNWCODE_INFO (p[1])] = @@ -787,6 +903,13 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, default: return; } + + /* Display address where the register was saved. */ + if (reg >= 0) + frame_debug_printf (" [reg %s at %s]", + gdbarch_register_name (gdbarch, reg), + paddress (gdbarch, + cache->prev_reg_addr[reg])); } /* Adjust with the length of the opcode. */ @@ -818,19 +941,29 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, } } if (PEX64_UWI_FLAGS (ex_ui.Version_Flags) != UNW_FLAG_CHAININFO) - break; + { + /* End of unwind info. */ + break; + } else { /* Read the chained unwind info. */ struct external_pex64_runtime_function d; CORE_ADDR chain_vma; + /* Not anymore the first entry. */ + first = 0; + + /* Stay aligned on word boundary. */ chain_vma = cache->image_base + unwind_info + sizeof (ex_ui) + ((codes_count + 1) & ~1) * 2; if (target_read_memory (chain_vma, (gdb_byte *) &d, sizeof (d)) != 0) return; + /* Decode begin/end. This may be different from .pdata index, as + an unwind info may be shared by several functions (in particular + if many functions have the same prolog and handler. */ cache->start_rva = extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order); cache->end_rva = @@ -838,14 +971,11 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, unwind_info = extract_unsigned_integer (d.rva_UnwindData, 4, byte_order); - if (frame_debug) - fprintf_unfiltered - (gdb_stdlog, - "amd64_windows_frame_decodes_insn (next in chain):" - " unwind_data=%s, start_rva=%s, end_rva=%s\n", - paddress (gdbarch, unwind_info), - paddress (gdbarch, cache->start_rva), - paddress (gdbarch, cache->end_rva)); + frame_debug_printf ("next in chain: unwind_data=%s, start_rva=%s, " + "end_rva=%s", + paddress (gdbarch, unwind_info), + paddress (gdbarch, cache->start_rva), + paddress (gdbarch, cache->end_rva)); } /* Allow the user to break this loop. */ @@ -856,10 +986,9 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, cache->prev_rip_addr = cur_sp; cache->prev_sp = 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)); + frame_debug_printf (" prev_sp: %s, prev_pc @%s", + paddress (gdbarch, cache->prev_sp), + paddress (gdbarch, cache->prev_rip_addr)); } /* Find SEH unwind info for PC, returning 0 on success. @@ -891,8 +1020,7 @@ amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc, pe = pe_data (sec->objfile->obfd); dir = &pe->pe_opthdr.DataDirectory[PE_EXCEPTION_TABLE]; - base = pe->pe_opthdr.ImageBase - + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + base = pe->pe_opthdr.ImageBase + objfile->text_section_offset (); *image_base = base; /* Find the entry. @@ -934,31 +1062,10 @@ amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc, break; } - if (frame_debug) - fprintf_unfiltered - (gdb_stdlog, - "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%s\n", - paddress (gdbarch, base), paddress (gdbarch, *unwind_info)); + frame_debug_printf ("image_base=%s, unwind_data=%s", + 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)) != 0) - return -1; - - *start_rva = - extract_unsigned_integer (d.rva_BeginAddress, 4, byte_order); - *end_rva = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order); - *unwind_info = - extract_unsigned_integer (d.rva_UnwindData, 4, byte_order); - - } return 0; } @@ -966,23 +1073,17 @@ amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc, for THIS_FRAME. */ static struct amd64_windows_frame_cache * -amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache) +amd64_windows_frame_cache (frame_info_ptr this_frame, void **this_cache) { struct gdbarch *gdbarch = get_frame_arch (this_frame); enum bfd_endian byte_order = 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 = 0; if (*this_cache) - return *this_cache; + return (struct amd64_windows_frame_cache *) *this_cache; cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache); *this_cache = cache; @@ -1017,21 +1118,17 @@ amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache) using the standard Windows x64 SEH info. */ static struct value * -amd64_windows_frame_prev_register (struct frame_info *this_frame, +amd64_windows_frame_prev_register (frame_info_ptr this_frame, void **this_cache, int regnum) { struct gdbarch *gdbarch = get_frame_arch (this_frame); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct amd64_windows_frame_cache *cache = 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=%s\n", - gdbarch_register_name (gdbarch, regnum), - paddress (gdbarch, cache->prev_sp)); + frame_debug_printf ("%s for sp=%s", + gdbarch_register_name (gdbarch, regnum), + paddress (gdbarch, cache->prev_sp)); if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15) prev = cache->prev_xmm_addr[regnum - AMD64_XMM0_REGNUM]; @@ -1048,8 +1145,8 @@ amd64_windows_frame_prev_register (struct frame_info *this_frame, else prev = 0; - if (prev && frame_debug) - fprintf_unfiltered (gdb_stdlog, " -> at %s\n", paddress (gdbarch, prev)); + if (prev != 0) + frame_debug_printf (" -> at %s", paddress (gdbarch, prev)); if (prev) { @@ -1067,10 +1164,9 @@ amd64_windows_frame_prev_register (struct frame_info *this_frame, the standard Windows x64 SEH info. */ static void -amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache, +amd64_windows_frame_this_id (frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id) { - struct gdbarch *gdbarch = get_frame_arch (this_frame); struct amd64_windows_frame_cache *cache = amd64_windows_frame_cache (this_frame, this_cache); @@ -1082,6 +1178,7 @@ amd64_windows_frame_this_id (struct frame_info *this_frame, void **this_cache, static const struct frame_unwind amd64_windows_frame_unwind = { + "amd64 windows", NORMAL_FRAME, default_frame_unwind_stop_reason, &amd64_windows_frame_this_id, @@ -1112,7 +1209,7 @@ amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) else if (target_read_memory (image_base + unwind_info, (gdb_byte *) &ex_ui, sizeof (ex_ui)) == 0 && PEX64_UWI_VERSION (ex_ui.Version_Flags) == 1) - return max (pc, image_base + start_rva + ex_ui.SizeOfPrologue); + return std::max (pc, image_base + start_rva + ex_ui.SizeOfPrologue); } /* See if we can determine the end of the prologue via the symbol @@ -1124,7 +1221,7 @@ amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) = skip_prologue_using_sal (gdbarch, func_addr); if (post_prologue_pc != 0) - return max (pc, post_prologue_pc); + return std::max (pc, post_prologue_pc); } return pc; @@ -1133,7 +1230,7 @@ amd64_windows_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) /* Check Win64 DLL jmp trampolines and find jump destination. */ static CORE_ADDR -amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) +amd64_windows_skip_trampoline_code (frame_info_ptr frame, CORE_ADDR pc) { CORE_ADDR destination = 0; struct gdbarch *gdbarch = get_frame_arch (frame); @@ -1153,7 +1250,7 @@ amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) = (indirect_addr ? lookup_minimal_symbol_by_pc (indirect_addr).minsym : NULL); - const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL; + const char *symname = indsym ? indsym->linkage_name () : NULL; if (symname) { @@ -1175,14 +1272,16 @@ amd64_windows_auto_wide_charset (void) return "UTF-16"; } +/* Common parts for gdbarch initialization for Windows and Cygwin on AMD64. */ + static void -amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +amd64_windows_init_abi_common (gdbarch_info info, struct gdbarch *gdbarch) { - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + i386_gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* 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 + - binaries without SEH but with dwarf2 debug info are correctly 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 @@ -1193,12 +1292,8 @@ amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) */ frame_unwind_append_unwinder (gdbarch, &amd64_windows_frame_unwind); - amd64_init_abi (info, gdbarch); - - windows_init_abi (info, gdbarch); - - /* On Windows, "long"s are only 32bit. */ - set_gdbarch_long_bit (gdbarch, 32); + amd64_init_abi (info, gdbarch, + amd64_target_description (X86_XSTATE_SSE_MASK, false)); /* Function calls. */ set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call); @@ -1209,15 +1304,86 @@ amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue); + tdep->gregset_reg_offset = amd64_windows_gregset_reg_offset; + tdep->gregset_num_regs = ARRAY_SIZE (amd64_windows_gregset_reg_offset); + tdep->sizeof_gregset = AMD64_WINDOWS_SIZEOF_GREGSET; + tdep->sizeof_fpregset = 0; + + /* Core file support. */ + set_gdbarch_core_xfer_shared_libraries + (gdbarch, windows_core_xfer_shared_libraries); + set_gdbarch_core_pid_to_str (gdbarch, windows_core_pid_to_str); + set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset); } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_amd64_windows_tdep; +/* gdbarch initialization for Windows on AMD64. */ +static void +amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + amd64_windows_init_abi_common (info, gdbarch); + windows_init_abi (info, gdbarch); + + /* On Windows, "long"s are only 32bit. */ + set_gdbarch_long_bit (gdbarch, 32); +} + +/* gdbarch initialization for Cygwin on AMD64. */ + +static void +amd64_cygwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + amd64_windows_init_abi_common (info, gdbarch); + cygwin_init_abi (info, gdbarch); +} + +static gdb_osabi +amd64_windows_osabi_sniffer (bfd *abfd) +{ + const char *target_name = bfd_get_target (abfd); + + if (!streq (target_name, "pei-x86-64")) + return GDB_OSABI_UNKNOWN; + + if (is_linked_with_cygwin_dll (abfd)) + return GDB_OSABI_CYGWIN; + + return GDB_OSABI_WINDOWS; +} + +static enum gdb_osabi +amd64_cygwin_core_osabi_sniffer (bfd *abfd) +{ + const char *target_name = bfd_get_target (abfd); + + /* Cygwin uses elf core dumps. Do not claim all ELF executables, + check whether there is a .reg section of proper size. */ + if (strcmp (target_name, "elf64-x86-64") == 0) + { + asection *section = bfd_get_section_by_name (abfd, ".reg"); + if (section != nullptr + && bfd_section_size (section) == AMD64_WINDOWS_SIZEOF_GREGSET) + return GDB_OSABI_CYGWIN; + } + + return GDB_OSABI_UNKNOWN; +} + +void _initialize_amd64_windows_tdep (); void -_initialize_amd64_windows_tdep (void) +_initialize_amd64_windows_tdep () { + gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_WINDOWS, + amd64_windows_init_abi); gdbarch_register_osabi (bfd_arch_i386, bfd_mach_x86_64, GDB_OSABI_CYGWIN, - amd64_windows_init_abi); + amd64_cygwin_init_abi); + + gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour, + amd64_windows_osabi_sniffer); + + /* Cygwin uses elf core dumps. */ + gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_elf_flavour, + amd64_cygwin_core_osabi_sniffer); + }