X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Famd64-windows-tdep.c;h=e1e777c4355e74a617527fcebee594fcf182f778;hb=452f10a186cdb18091f590315c55488b871812e3;hp=6891e1691866e86794be3f58df50c4feab61876b;hpb=170d82c9517d608476e206425253939af4719273;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index 6891e16918..e1e777c435 100644 --- a/gdb/amd64-windows-tdep.c +++ b/gdb/amd64-windows-tdep.c @@ -1,4 +1,4 @@ -/* Copyright (C) 2009-2013 Free Software Foundation, Inc. +/* Copyright (C) 2009-2020 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[] = @@ -55,6 +57,7 @@ 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 @@ -141,8 +144,8 @@ amd64_windows_store_arg_in_reg (struct regcache *regcache, gdb_assert (TYPE_LENGTH (type) <= 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 (type), (ULONGEST) 8)); + regcache->cooked_write (regno, buf); } /* Push the arguments for an inferior function call, and return @@ -154,11 +157,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 +172,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,7 +180,7 @@ 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++) @@ -241,25 +244,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. */ 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 +276,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; } @@ -326,9 +329,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; } } @@ -355,8 +358,8 @@ amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order); s = lookup_minimal_symbol_by_pc (call_dest); if (s.minsym != NULL - && SYMBOL_LINKAGE_NAME (s.minsym) != NULL - && strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0) + && s.minsym->linkage_name () != NULL + && strcmp (s.minsym->linkage_name (), "__main") == 0) pc += 5; } } @@ -416,7 +419,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 @@ -488,6 +491,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 +598,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; @@ -621,9 +623,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,7 +671,7 @@ 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, @@ -653,12 +692,13 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, && 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. */ @@ -711,19 +751,24 @@ 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) { + if (frame_debug) + fprintf_unfiltered + (gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n", + (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 +796,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 +832,13 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, default: return; } + + /* Display address where the register was saved. */ + if (frame_debug && reg >= 0) + fprintf_unfiltered + (gdb_stdlog, " [reg %s at %s]\n", + gdbarch_register_name (gdbarch, reg), + paddress (gdbarch, cache->prev_reg_addr[reg])); } /* Adjust with the length of the opcode. */ @@ -818,25 +870,44 @@ 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 + 8; + + 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 = extract_unsigned_integer (d.rva_EndAddress, 4, byte_order); 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)); } /* Allow the user to break this loop. */ @@ -882,8 +953,8 @@ 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->section_offsets[SECT_OFF_TEXT (objfile)]); *image_base = base; /* Find the entry. @@ -931,25 +1002,6 @@ amd64_windows_find_unwind_info (struct gdbarch *gdbarch, CORE_ADDR pc, "amd64_windows_find_unwind_data: image_base=%s, unwind_data=%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)) != 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; } @@ -963,17 +1015,11 @@ amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache) 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; @@ -1012,10 +1058,8 @@ amd64_windows_frame_prev_register (struct frame_info *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) @@ -1061,7 +1105,6 @@ static void amd64_windows_frame_this_id (struct frame_info *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); @@ -1103,7 +1146,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 @@ -1115,7 +1158,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; @@ -1144,12 +1187,12 @@ 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 ? SYMBOL_LINKAGE_NAME (indsym) : NULL; + const char *symname = indsym ? indsym->linkage_name () : NULL; if (symname) { - if (strncmp (symname, "__imp_", 6) == 0 - || strncmp (symname, "_imp_", 5) == 0) + if (startswith (symname, "__imp_") + || startswith (symname, "_imp_")) destination = read_memory_unsigned_integer (indirect_addr, 8, byte_order); } @@ -1169,11 +1212,9 @@ amd64_windows_auto_wide_charset (void) static void amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { - struct 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 @@ -1184,7 +1225,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); + amd64_init_abi (info, gdbarch, + amd64_target_description (X86_XSTATE_SSE_MASK, false)); windows_init_abi (info, gdbarch); @@ -1203,9 +1245,6 @@ amd64_windows_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset); } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_amd64_windows_tdep; - void _initialize_amd64_windows_tdep (void) {