X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fi386-linux-tdep.c;h=7b69aab3a161a024389cd11a56e0883e63603213;hb=403cb6b138c38faf72f7abc034db3505b9bdb82f;hp=78fe88e2d05191a3f646a491d1353ddeec1c634f;hpb=a96d9b2e9a79e6cc7a9da9b4e5bab6fcc35f1eb4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c index 78fe88e2d0..7b69aab3a1 100644 --- a/gdb/i386-linux-tdep.c +++ b/gdb/i386-linux-tdep.c @@ -1,7 +1,6 @@ /* Target-dependent code for GNU/Linux i386. - Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 - Free Software Foundation, Inc. + Copyright (C) 2000-2013 Free Software Foundation, Inc. This file is part of GDB. @@ -23,6 +22,7 @@ #include "frame.h" #include "value.h" #include "regcache.h" +#include "regset.h" #include "inferior.h" #include "osabi.h" #include "reggroups.h" @@ -36,36 +36,43 @@ #include "solib-svr4.h" #include "symtab.h" #include "arch-utils.h" -#include "regset.h" #include "xml-syscall.h" +#include "i387-tdep.h" +#include "i386-xstate.h" + /* The syscall's XML filename for i386. */ #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml" -#include "record.h" +#include "record-full.h" #include "linux-record.h" #include +#include "features/i386/i386-linux.c" +#include "features/i386/i386-mmx-linux.c" +#include "features/i386/i386-avx-linux.c" + /* Supported register note sections. */ static struct core_regset_section i386_linux_regset_sections[] = { - { ".reg", 144 }, - { ".reg2", 108 }, - { ".reg-xfp", 512 }, + { ".reg", 68, "general-purpose" }, + { ".reg2", 108, "floating-point" }, { NULL, 0 } }; -/* Return the name of register REG. */ - -static const char * -i386_linux_register_name (struct gdbarch *gdbarch, int reg) +static struct core_regset_section i386_linux_sse_regset_sections[] = { - /* Deal with the extra "orig_eax" pseudo register. */ - if (reg == I386_LINUX_ORIG_EAX_REGNUM) - return "orig_eax"; + { ".reg", 68, "general-purpose" }, + { ".reg-xfp", 512, "extended floating-point" }, + { NULL, 0 } +}; - return i386_register_name (gdbarch, reg); -} +static struct core_regset_section i386_linux_avx_regset_sections[] = +{ + { ".reg", 68, "general-purpose" }, + { ".reg-xstate", I386_XSTATE_MAX_SIZE, "XSAVE extended state" }, + { NULL, 0 } +}; /* Return non-zero, when the register is in the corresponding register group. Put the LINUX_ORIG_EAX register in the system group. */ @@ -247,7 +254,7 @@ static int i386_linux_sigtramp_p (struct frame_info *this_frame) { CORE_ADDR pc = get_frame_pc (this_frame); - char *name; + const char *name; find_pc_partial_function (pc, &name, NULL, NULL); @@ -272,7 +279,7 @@ i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch, struct frame_info *this_frame) { CORE_ADDR pc = get_frame_pc (this_frame); - char *name; + const char *name; find_pc_partial_function (pc, &name, NULL, NULL); @@ -358,7 +365,32 @@ i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) regcache_cooked_write_unsigned (regcache, I386_LINUX_ORIG_EAX_REGNUM, -1); } -static struct linux_record_tdep i386_linux_record_tdep; +/* Record all registers but IP register for process-record. */ + +static int +i386_all_but_ip_registers_record (struct regcache *regcache) +{ + if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_ECX_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_EDX_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_EBX_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_ESP_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_EBP_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_ESI_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_EDI_REGNUM)) + return -1; + if (record_full_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM)) + return -1; + + return 0; +} /* i386_canonicalize_syscall maps from the native i386 Linux set of syscall ids into a canonical set of syscall ids used by @@ -383,8 +415,10 @@ i386_canonicalize_syscall (int syscall) Return -1 if something wrong. */ +static struct linux_record_tdep i386_linux_record_tdep; + static int -i386_linux_intx80_sysenter_record (struct regcache *regcache) +i386_linux_intx80_sysenter_syscall_record (struct regcache *regcache) { int ret; LONGEST syscall_native; @@ -402,24 +436,72 @@ i386_linux_intx80_sysenter_record (struct regcache *regcache) return -1; } + if (syscall_gdb == gdb_sys_sigreturn + || syscall_gdb == gdb_sys_rt_sigreturn) + { + if (i386_all_but_ip_registers_record (regcache)) + return -1; + return 0; + } + ret = record_linux_system_call (syscall_gdb, regcache, &i386_linux_record_tdep); if (ret) return ret; /* Record the return value of the system call. */ - if (record_arch_list_add_reg (regcache, I386_EAX_REGNUM)) + if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM)) + return -1; + + return 0; +} + +#define I386_LINUX_xstate 270 +#define I386_LINUX_frame_size 732 + +static int +i386_linux_record_signal (struct gdbarch *gdbarch, + struct regcache *regcache, + enum gdb_signal signal) +{ + ULONGEST esp; + + if (i386_all_but_ip_registers_record (regcache)) + return -1; + + if (record_full_arch_list_add_reg (regcache, I386_EIP_REGNUM)) + return -1; + + /* Record the change in the stack. */ + regcache_raw_read_unsigned (regcache, I386_ESP_REGNUM, &esp); + /* This is for xstate. + sp -= sizeof (struct _fpstate); */ + esp -= I386_LINUX_xstate; + /* This is for frame_size. + sp -= sizeof (struct rt_sigframe); */ + esp -= I386_LINUX_frame_size; + if (record_full_arch_list_add_mem (esp, + I386_LINUX_xstate + I386_LINUX_frame_size)) + return -1; + + if (record_full_arch_list_add_end ()) return -1; return 0; } +/* Core of the implementation for gdbarch get_syscall_number. Get pending + syscall number from REGCACHE. If there is no pending syscall -1 will be + returned. Pending syscall means ptrace has stepped into the syscall but + another ptrace call will step out. PC is right after the int $0x80 + / syscall / sysenter instruction in both cases, PC does not change during + the second ptrace step. */ + static LONGEST -i386_linux_get_syscall_number (struct gdbarch *gdbarch, - ptid_t ptid) +i386_linux_get_syscall_number_from_regcache (struct regcache *regcache) { - struct regcache *regcache = get_thread_regcache (ptid); + struct gdbarch *gdbarch = get_regcache_arch (regcache); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); /* The content of a register. */ gdb_byte buf[4]; @@ -436,6 +518,18 @@ i386_linux_get_syscall_number (struct gdbarch *gdbarch, return ret; } +/* Wrapper for i386_linux_get_syscall_number_from_regcache to make it + compatible with gdbarch get_syscall_number method prototype. */ + +static LONGEST +i386_linux_get_syscall_number (struct gdbarch *gdbarch, + ptid_t ptid) +{ + struct regcache *regcache = get_thread_regcache (ptid); + + return i386_linux_get_syscall_number_from_regcache (regcache); +} + /* The register sets used in GNU/Linux ELF core-dumps are identical to the register sets in `struct user' that are used for a.out core-dumps. These are also used by ptrace(2). The corresponding @@ -452,7 +546,7 @@ i386_linux_get_syscall_number (struct gdbarch *gdbarch, format and GDB's register cache layout. */ /* From . */ -static int i386_linux_gregset_reg_offset[] = +int i386_linux_gregset_reg_offset[] = { 6 * 4, /* %eax */ 1 * 4, /* %ecx */ @@ -474,6 +568,7 @@ static int i386_linux_gregset_reg_offset[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 11 * 4 /* "orig_eax" */ }; @@ -501,21 +596,150 @@ static int i386_linux_sc_reg_offset[] = 0 * 4 /* %gs */ }; +/* Get XSAVE extended state xcr0 from core dump. */ + +uint64_t +i386_linux_core_read_xcr0 (bfd *abfd) +{ + asection *xstate = bfd_get_section_by_name (abfd, ".reg-xstate"); + uint64_t xcr0; + + if (xstate) + { + size_t size = bfd_section_size (abfd, xstate); + + /* Check extended state size. */ + if (size < I386_XSTATE_AVX_SIZE) + xcr0 = I386_XSTATE_SSE_MASK; + else + { + char contents[8]; + + if (! bfd_get_section_contents (abfd, xstate, contents, + I386_LINUX_XSAVE_XCR0_OFFSET, + 8)) + { + warning (_("Couldn't read `xcr0' bytes from " + "`.reg-xstate' section in core file.")); + return 0; + } + + xcr0 = bfd_get_64 (abfd, contents); + } + } + else + xcr0 = 0; + + return xcr0; +} + +/* Get Linux/x86 target description from core dump. */ + +static const struct target_desc * +i386_linux_core_read_description (struct gdbarch *gdbarch, + struct target_ops *target, + bfd *abfd) +{ + /* Linux/i386. */ + uint64_t xcr0 = i386_linux_core_read_xcr0 (abfd); + switch ((xcr0 & I386_XSTATE_AVX_MASK)) + { + case I386_XSTATE_AVX_MASK: + return tdesc_i386_avx_linux; + case I386_XSTATE_SSE_MASK: + return tdesc_i386_linux; + case I386_XSTATE_X87_MASK: + return tdesc_i386_mmx_linux; + default: + break; + } + + if (bfd_get_section_by_name (abfd, ".reg-xfp") != NULL) + return tdesc_i386_linux; + else + return tdesc_i386_mmx_linux; +} + +/* Linux kernel shows PC value after the 'int $0x80' instruction even if + inferior is still inside the syscall. On next PTRACE_SINGLESTEP it will + finish the syscall but PC will not change. + + Some vDSOs contain 'int $0x80; ret' and during stepping out of the syscall + i386_displaced_step_fixup would keep PC at the displaced pad location. + As PC is pointing to the 'ret' instruction before the step + i386_displaced_step_fixup would expect inferior has just executed that 'ret' + and PC should not be adjusted. In reality it finished syscall instead and + PC should get relocated back to its vDSO address. Hide the 'ret' + instruction by 'nop' so that i386_displaced_step_fixup is not confused. + + It is not fully correct as the bytes in struct displaced_step_closure will + not match the inferior code. But we would need some new flag in + displaced_step_closure otherwise to keep the state that syscall is finishing + for the later i386_displaced_step_fixup execution as the syscall execution + is already no longer detectable there. The new flag field would mean + i386-linux-tdep.c needs to wrap all the displacement methods of i386-tdep.c + which does not seem worth it. The same effect is achieved by patching that + 'nop' instruction there instead. */ + +static struct displaced_step_closure * +i386_linux_displaced_step_copy_insn (struct gdbarch *gdbarch, + CORE_ADDR from, CORE_ADDR to, + struct regcache *regs) +{ + struct displaced_step_closure *closure; + + closure = i386_displaced_step_copy_insn (gdbarch, from, to, regs); + + if (i386_linux_get_syscall_number_from_regcache (regs) != -1) + { + /* Since we use simple_displaced_step_copy_insn, our closure is a + copy of the instruction. */ + gdb_byte *insn = (gdb_byte *) closure; + + /* Fake nop. */ + insn[0] = 0x90; + } + + return closure; +} + static void i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + const struct target_desc *tdesc = info.target_desc; + struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info; + const struct tdesc_feature *feature; + int valid_p; + + gdb_assert (tdesc_data); + + linux_init_abi (info, gdbarch); /* GNU/Linux uses ELF. */ i386_elf_init_abi (info, gdbarch); - /* Since we have the extra "orig_eax" register on GNU/Linux, we have - to adjust a few things. */ + /* Reserve a number for orig_eax. */ + set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS); + + if (! tdesc_has_registers (tdesc)) + tdesc = tdesc_i386_linux; + tdep->tdesc = tdesc; + + feature = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.linux"); + if (feature == NULL) + return; + + valid_p = tdesc_numbered_register (feature, tdesc_data, + I386_LINUX_ORIG_EAX_REGNUM, + "orig_eax"); + if (!valid_p) + return; + /* Add the %orig_eax register used for syscall restarting. */ set_gdbarch_write_pc (gdbarch, i386_linux_write_pc); - set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS); - set_gdbarch_register_name (gdbarch, i386_linux_register_name); - set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p); + + tdep->register_reggroup_p = i386_linux_register_reggroup_p; tdep->gregset_reg_offset = i386_linux_gregset_reg_offset; tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset); @@ -528,7 +752,10 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) tdep->sc_reg_offset = i386_linux_sc_reg_offset; tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset); + tdep->xsave_xcr0_offset = I386_LINUX_XSAVE_XCR0_OFFSET; + set_gdbarch_process_record (gdbarch, i386_process_record); + set_gdbarch_process_record_signal (gdbarch, i386_linux_record_signal); /* Initialize the i386_linux_record_tdep. */ /* These values are the size of the type that will be used in a system @@ -689,11 +916,12 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) i386_linux_record_tdep.arg5 = I386_EDI_REGNUM; i386_linux_record_tdep.arg6 = I386_EBP_REGNUM; - tdep->i386_intx80_record = i386_linux_intx80_sysenter_record; - tdep->i386_sysenter_record = i386_linux_intx80_sysenter_record; + tdep->i386_intx80_record = i386_linux_intx80_sysenter_syscall_record; + tdep->i386_sysenter_record = i386_linux_intx80_sysenter_syscall_record; + tdep->i386_syscall_record = i386_linux_intx80_sysenter_syscall_record; /* N_FUN symbols in shared libaries have 0 for their values and need - to be relocated. */ + to be relocated. */ set_gdbarch_sofun_address_maybe_missing (gdbarch, 1); /* GNU/Linux uses SVR4-style shared libraries. */ @@ -711,11 +939,19 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) svr4_fetch_objfile_link_map); /* Install supported register note sections. */ - set_gdbarch_core_regset_sections (gdbarch, i386_linux_regset_sections); + if (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx")) + set_gdbarch_core_regset_sections (gdbarch, i386_linux_avx_regset_sections); + else if (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.sse")) + set_gdbarch_core_regset_sections (gdbarch, i386_linux_sse_regset_sections); + else + set_gdbarch_core_regset_sections (gdbarch, i386_linux_regset_sections); + + set_gdbarch_core_read_description (gdbarch, + i386_linux_core_read_description); /* Displaced stepping. */ set_gdbarch_displaced_step_copy_insn (gdbarch, - simple_displaced_step_copy_insn); + i386_linux_displaced_step_copy_insn); set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup); set_gdbarch_displaced_step_free_closure (gdbarch, simple_displaced_step_free_closure); @@ -738,4 +974,9 @@ _initialize_i386_linux_tdep (void) { gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX, i386_linux_init_abi); + + /* Initialize the Linux target description. */ + initialize_tdesc_i386_linux (); + initialize_tdesc_i386_mmx_linux (); + initialize_tdesc_i386_avx_linux (); }