X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Famd64-windows-tdep.c;h=e1e777c4355e74a617527fcebee594fcf182f778;hb=6a053cb1ff643cec3349d7f2f47ae5573f82d613;hp=4e750a10bffa1e0484fc0c085f59872c1292f093;hpb=9058cc3a1bbf4c43a484120290e4245622782bb0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c index 4e750a10bf..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,8 +18,7 @@ #include "defs.h" #include "osabi.h" #include "amd64-tdep.h" -#include "solib.h" -#include "solib-target.h" +#include "gdbsupport/x86-xstate.h" #include "gdbtypes.h" #include "gdbcore.h" #include "regcache.h" @@ -31,53 +30,260 @@ #include "coff/i386.h" #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[] = { AMD64_RCX_REGNUM, /* %rcx */ AMD64_RDX_REGNUM, /* %rdx */ - 8, /* %r8 */ - 9 /* %r9 */ + AMD64_R8_REGNUM, /* %r8 */ + AMD64_R9_REGNUM /* %r9 */ }; -/* Implement the "classify" method in the gdbarch_tdep structure - for amd64-windows. */ +/* Return nonzero if an argument of type TYPE should be passed + via one of the integer registers. */ -static void -amd64_windows_classify (struct type *type, enum amd64_reg_class class[2]) +static int +amd64_windows_passed_by_integer_register (struct type *type) { switch (TYPE_CODE (type)) { - case TYPE_CODE_ARRAY: - /* Arrays are always passed by memory. */ - class[0] = class[1] = AMD64_MEMORY; - break; - + case TYPE_CODE_INT: + case TYPE_CODE_ENUM: + case TYPE_CODE_BOOL: + case TYPE_CODE_RANGE: + 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: - /* Struct/Union types whose size is 1, 2, 4, or 8 bytes - are passed as if they were integers of the same size. - Types of different sizes are passed by memory. */ - if (TYPE_LENGTH (type) == 1 - || TYPE_LENGTH (type) == 2 - || TYPE_LENGTH (type) == 4 - || TYPE_LENGTH (type) == 8) - { - class[0] = AMD64_INTEGER; - class[1] = AMD64_NO_CLASS; - } - else - class[0] = class[1] = AMD64_MEMORY; - break; + return (TYPE_LENGTH (type) == 1 + || TYPE_LENGTH (type) == 2 + || TYPE_LENGTH (type) == 4 + || TYPE_LENGTH (type) == 8); default: - /* For all the other types, the conventions are the same as - with the System V ABI. */ - amd64_classify (type, class); + return 0; } } +/* Return nonzero if an argument of type TYPE should be passed + via one of the XMM registers. */ + +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 non-zero iff an argument of the given TYPE should be passed + by pointer. */ + +static int +amd64_windows_passed_by_pointer (struct type *type) +{ + if (amd64_windows_passed_by_integer_register (type)) + return 0; + + if (amd64_windows_passed_by_xmm_register (type)) + return 0; + + return 1; +} + +/* For each argument that should be passed by pointer, reserve some + stack space, store a copy of the argument on the stack, and replace + the argument by its address. Return the new Stack Pointer value. + + NARGS is the number of arguments. ARGS is the array containing + the value of each argument. SP is value of the Stack Pointer. */ + +static CORE_ADDR +amd64_windows_adjust_args_passed_by_pointer (struct value **args, + int nargs, CORE_ADDR sp) +{ + int i; + + for (i = 0; i < nargs; i++) + 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); + + /* Store a copy of that argument on the stack, aligned to + a 16 bytes boundary, and then use the copy's address as + the argument. */ + + sp -= len; + sp &= ~0xf; + write_memory (sp, valbuf, len); + + args[i] + = value_addr (value_from_contents_and_address (type, valbuf, sp)); + } + + return sp; +} + +/* Store the value of ARG in register REGNO (right-justified). + REGCACHE is the register cache. */ + +static void +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); + gdb_byte buf[8]; + + gdb_assert (TYPE_LENGTH (type) <= 8); + memset (buf, 0, sizeof 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 + the updated value of the SP (Stack Pointer). + + All arguments are identical to the arguments used in + amd64_windows_push_dummy_call. */ + +static CORE_ADDR +amd64_windows_push_arguments (struct regcache *regcache, int nargs, + struct value **args, CORE_ADDR sp, + function_call_return_method return_method) +{ + int reg_idx = 0; + int i; + struct value **stack_args = XALLOCAVEC (struct value *, nargs); + int num_stack_args = 0; + int num_elements = 0; + int element = 0; + + /* First, handle the arguments passed by pointer. + + These arguments are replaced by pointers to a copy we are making + in inferior memory. So use a copy of the ARGS table, to avoid + modifying the original one. */ + { + 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); + args = args1; + } + + /* Reserve a register for the "hidden" argument. */ + 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 on_stack_p = 1; + + if (reg_idx < ARRAY_SIZE (amd64_windows_dummy_call_integer_regs)) + { + if (amd64_windows_passed_by_integer_register (type)) + { + amd64_windows_store_arg_in_reg + (regcache, args[i], + amd64_windows_dummy_call_integer_regs[reg_idx]); + on_stack_p = 0; + reg_idx++; + } + else if (amd64_windows_passed_by_xmm_register (type)) + { + amd64_windows_store_arg_in_reg + (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 + (regcache, args[i], + amd64_windows_dummy_call_integer_regs[reg_idx]); + on_stack_p = 0; + reg_idx++; + } + } + + if (on_stack_p) + { + num_elements += ((len + 7) / 8); + stack_args[num_stack_args++] = args[i]; + } + } + + /* Allocate space for the arguments on the stack, keeping it + aligned on a 16 byte boundary. */ + sp -= num_elements * 8; + sp &= ~0xf; + + /* Write out the arguments to the stack. */ + 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]); + + write_memory (sp + element * 8, valbuf, TYPE_LENGTH (type)); + element += ((TYPE_LENGTH (type) + 7) / 8); + } + + return sp; +} + +/* Implement the "push_dummy_call" gdbarch method. */ + +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, + 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, + return_method); + + /* Pass "hidden" argument". */ + 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 (arg_regnum, buf); + } + + /* Reserve some memory on the stack for the integer-parameter + registers, as required by the ABI. */ + sp -= ARRAY_SIZE (amd64_windows_dummy_call_integer_regs) * 8; + + /* Store return address. */ + sp -= 8; + store_unsigned_integer (buf, 8, byte_order, bp_addr); + write_memory (sp, buf, 8); + + /* Update the stack pointer... */ + store_unsigned_integer (buf, 8, byte_order, sp); + regcache->cooked_write (AMD64_RSP_REGNUM, buf); + + /* ...and fake a frame pointer. */ + regcache->cooked_write (AMD64_RBP_REGNUM, buf); + + return sp + 16; +} + /* Implement the "return_value" gdbarch method for amd64-windows. */ static enum return_value_convention @@ -123,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; } } @@ -152,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; } } @@ -213,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 @@ -285,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; @@ -391,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; @@ -418,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. + */ + + 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; - for (j = 0; ; j++) + 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. */ @@ -429,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, @@ -446,15 +688,17 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, ex_ui.CountOfCodes, ex_ui.FrameRegisterOffset); /* Check version. */ - if (PEX64_UWI_VERSION (ex_ui.Version_Flags) != 1) + 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. */ @@ -493,23 +737,38 @@ amd64_windows_frame_decode_insns (struct frame_info *this_frame, return; end_insns = &insns[codes_count * 2]; - for (p = insns; p < end_insns; p += 2) + p = insns; + + /* Skip opcodes 6 of version 2. This opcode is not documented. */ + if (PEX64_UWI_VERSION (ex_ui.Version_Flags) == 2) { - int reg; + for (; p < end_insns; p += 2) + if (PEX64_UNWCODE_CODE (p[1]) != 6) + break; + } - if (frame_debug) - fprintf_unfiltered - (gdb_stdlog, " op #%u: off=0x%02x, insn=0x%02x\n", - (unsigned) (p - insns), p[0], p[1]); + for (; p < end_insns; p += 2) + { + int reg; - /* 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: @@ -537,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])] = @@ -573,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. */ @@ -604,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. */ @@ -668,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. @@ -717,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; } @@ -749,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; @@ -798,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) @@ -847,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); @@ -889,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 @@ -901,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; @@ -930,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); } @@ -955,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 @@ -970,36 +1225,26 @@ 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); /* On Windows, "long"s are only 32bit. */ set_gdbarch_long_bit (gdbarch, 32); /* Function calls. */ - tdep->call_dummy_num_integer_regs = - ARRAY_SIZE (amd64_windows_dummy_call_integer_regs); - tdep->call_dummy_integer_regs = amd64_windows_dummy_call_integer_regs; - tdep->classify = amd64_windows_classify; - tdep->memory_args_by_pointer = 1; - tdep->integer_param_regs_saved_in_caller_frame = 1; + set_gdbarch_push_dummy_call (gdbarch, amd64_windows_push_dummy_call); set_gdbarch_return_value (gdbarch, amd64_windows_return_value); set_gdbarch_skip_main_prologue (gdbarch, amd64_skip_main_prologue); set_gdbarch_skip_trampoline_code (gdbarch, amd64_windows_skip_trampoline_code); - set_gdbarch_iterate_over_objfiles_in_search_order - (gdbarch, windows_iterate_over_objfiles_in_search_order); - set_gdbarch_skip_prologue (gdbarch, amd64_windows_skip_prologue); set_gdbarch_auto_wide_charset (gdbarch, amd64_windows_auto_wide_charset); - - set_solib_ops (gdbarch, &solib_target_so_ops); } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_amd64_windows_tdep; - void _initialize_amd64_windows_tdep (void) {