X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fi386-linux-tdep.c;h=21f403a9a2a2c88bceb6c4d8cc3a27cc4316d22e;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=8847ad3e301f37de7cdadeb73c8aa336163ad777;hpb=72aded8673d6cb2d0e33696e010a778e9bbfa817;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c index 8847ad3e30..21f403a9a2 100644 --- a/gdb/i386-linux-tdep.c +++ b/gdb/i386-linux-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for GNU/Linux i386. - Copyright (C) 2000-2015 Free Software Foundation, Inc. + Copyright (C) 2000-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -18,6 +18,7 @@ along with this program. If not, see . */ #include "defs.h" +#include "displaced-stepping.h" #include "gdbcore.h" #include "frame.h" #include "value.h" @@ -26,29 +27,29 @@ #include "inferior.h" #include "osabi.h" #include "reggroups.h" -#include "dwarf2-frame.h" +#include "dwarf2/frame.h" #include "i386-tdep.h" #include "i386-linux-tdep.h" #include "linux-tdep.h" +#include "utils.h" #include "glibc-tdep.h" #include "solib-svr4.h" #include "symtab.h" #include "arch-utils.h" #include "xml-syscall.h" +#include "infrun.h" #include "i387-tdep.h" -#include "x86-xstate.h" +#include "gdbsupport/x86-xstate.h" /* The syscall's XML filename for i386. */ #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml" #include "record-full.h" #include "linux-record.h" -#include "features/i386/i386-linux.c" -#include "features/i386/i386-mmx-linux.c" -#include "features/i386/i386-mpx-linux.c" -#include "features/i386/i386-avx-linux.c" -#include "features/i386/i386-avx512-linux.c" + +#include "arch/i386.h" +#include "target-descriptions.h" /* Return non-zero, when the register is in the corresponding register group. Put the LINUX_ORIG_EAX register in the system group. */ @@ -384,6 +385,66 @@ i386_canonicalize_syscall (int syscall) return gdb_sys_no_syscall; } +/* Value of the sigcode in case of a boundary fault. */ + +#define SIG_CODE_BONDARY_FAULT 3 + +/* i386 GNU/Linux implementation of the handle_segmentation_fault + gdbarch hook. Displays information related to MPX bound + violations. */ +void +i386_linux_handle_segmentation_fault (struct gdbarch *gdbarch, + struct ui_out *uiout) +{ + /* -Wmaybe-uninitialized */ + CORE_ADDR lower_bound = 0, upper_bound = 0, access = 0; + int is_upper; + long sig_code = 0; + + if (!i386_mpx_enabled ()) + return; + + try + { + /* Sigcode evaluates if the actual segfault is a boundary violation. */ + sig_code = parse_and_eval_long ("$_siginfo.si_code\n"); + + lower_bound + = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._lower"); + upper_bound + = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._upper"); + access + = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr"); + } + catch (const gdb_exception &exception) + { + return; + } + + /* If this is not a boundary violation just return. */ + if (sig_code != SIG_CODE_BONDARY_FAULT) + return; + + is_upper = (access > upper_bound ? 1 : 0); + + uiout->text ("\n"); + if (is_upper) + uiout->field_string ("sigcode-meaning", _("Upper bound violation")); + else + uiout->field_string ("sigcode-meaning", _("Lower bound violation")); + + uiout->text (_(" while accessing address ")); + uiout->field_core_addr ("bound-access", gdbarch, access); + + uiout->text (_("\nBounds: [lower = ")); + uiout->field_core_addr ("lower-bound", gdbarch, lower_bound); + + uiout->text (_(", upper = ")); + uiout->field_core_addr ("upper-bound", gdbarch, upper_bound); + + uiout->text (_("]")); +} + /* Parse the arguments of current system call instruction and record the values of the registers and memory that will be changed into "record_arch_list". This instruction is "int 0x80" (Linux @@ -477,7 +538,7 @@ i386_linux_record_signal (struct gdbarch *gdbarch, static LONGEST i386_linux_get_syscall_number_from_regcache (struct regcache *regcache) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); /* The content of a register. */ gdb_byte buf[4]; @@ -487,7 +548,7 @@ i386_linux_get_syscall_number_from_regcache (struct regcache *regcache) /* Getting the system call number from the register. When dealing with x86 architecture, this information is stored at %eax register. */ - regcache_cooked_read (regcache, I386_LINUX_ORIG_EAX_REGNUM, buf); + regcache->cooked_read (I386_LINUX_ORIG_EAX_REGNUM, buf); ret = extract_signed_integer (buf, 4, byte_order); @@ -499,9 +560,9 @@ i386_linux_get_syscall_number_from_regcache (struct regcache *regcache) static LONGEST i386_linux_get_syscall_number (struct gdbarch *gdbarch, - ptid_t ptid) + thread_info *thread) { - struct regcache *regcache = get_thread_regcache (ptid); + struct regcache *regcache = get_thread_regcache (thread); return i386_linux_get_syscall_number_from_regcache (regcache); } @@ -549,6 +610,7 @@ int i386_linux_gregset_reg_offset[] = -1, -1, /* MPX registers BNDCFGU, BNDSTATUS. */ -1, -1, -1, -1, -1, -1, -1, -1, /* k0 ... k7 (AVX512) */ -1, -1, -1, -1, -1, -1, -1, -1, /* zmm0 ... zmm7 (AVX512) */ + -1, /* PKRU register */ 11 * 4, /* "orig_eax" */ }; @@ -586,7 +648,7 @@ i386_linux_core_read_xcr0 (bfd *abfd) if (xstate) { - size_t size = bfd_section_size (abfd, xstate); + size_t size = bfd_section_size (xstate); /* Check extended state size. */ if (size < X86_XSTATE_AVX_SIZE) @@ -613,6 +675,31 @@ i386_linux_core_read_xcr0 (bfd *abfd) return xcr0; } +/* See i386-linux-tdep.h. */ + +const struct target_desc * +i386_linux_read_description (uint64_t xcr0) +{ + if (xcr0 == 0) + return NULL; + + static struct target_desc *i386_linux_tdescs \ + [2/*X87*/][2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {}; + struct target_desc **tdesc; + + tdesc = &i386_linux_tdescs[(xcr0 & X86_XSTATE_X87) ? 1 : 0] + [(xcr0 & X86_XSTATE_SSE) ? 1 : 0] + [(xcr0 & X86_XSTATE_AVX) ? 1 : 0] + [(xcr0 & X86_XSTATE_MPX) ? 1 : 0] + [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0] + [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]; + + if (*tdesc == NULL) + *tdesc = i386_create_target_description (xcr0, true, false); + + return *tdesc; +} + /* Get Linux/x86 target description from core dump. */ static const struct target_desc * @@ -622,28 +709,15 @@ i386_linux_core_read_description (struct gdbarch *gdbarch, { /* Linux/i386. */ uint64_t xcr0 = i386_linux_core_read_xcr0 (abfd); + const struct target_desc *tdesc = i386_linux_read_description (xcr0); - switch ((xcr0 & X86_XSTATE_ALL_MASK)) - { - case X86_XSTATE_MPX_AVX512_MASK: - case X86_XSTATE_AVX512_MASK: - return tdesc_i386_avx512_linux; - case X86_XSTATE_MPX_MASK: - return tdesc_i386_mpx_linux; - case X86_XSTATE_AVX_MASK: - return tdesc_i386_avx_linux; - case X86_XSTATE_SSE_MASK: - return tdesc_i386_linux; - case X86_XSTATE_X87_MASK: - return tdesc_i386_mmx_linux; - default: - break; - } + if (tdesc != NULL) + return tdesc; if (bfd_get_section_by_name (abfd, ".reg-xfp") != NULL) - return tdesc_i386_linux; + return i386_linux_read_description (X86_XSTATE_SSE_MASK); else - return tdesc_i386_mmx_linux; + return i386_linux_read_description (X86_XSTATE_X87_MASK); } /* Similar to i386_supply_fpregset, but use XSAVE extended state. */ @@ -656,6 +730,12 @@ i386_linux_supply_xstateregset (const struct regset *regset, i387_supply_xsave (regcache, regnum, xstateregs); } +struct type * +x86_linux_get_siginfo_type (struct gdbarch *gdbarch) +{ + return linux_get_siginfo_type_with_fields (gdbarch, LINUX_SIGINFO_FIELD_ADDR_BND); +} + /* Similar to i386_collect_fpregset, but use XSAVE extended state. */ static void @@ -685,16 +765,17 @@ i386_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - cb (".reg", 68, &i386_gregset, NULL, cb_data); + cb (".reg", 68, 68, &i386_gregset, NULL, cb_data); if (tdep->xcr0 & X86_XSTATE_AVX) cb (".reg-xstate", X86_XSTATE_SIZE (tdep->xcr0), - &i386_linux_xstateregset, "XSAVE extended state", cb_data); + X86_XSTATE_SIZE (tdep->xcr0), &i386_linux_xstateregset, + "XSAVE extended state", cb_data); else if (tdep->xcr0 & X86_XSTATE_SSE) - cb (".reg-xfp", 512, &i386_fpregset, "extended floating-point", + cb (".reg-xfp", 512, 512, &i386_fpregset, "extended floating-point", cb_data); else - cb (".reg2", 108, &i386_fpregset, NULL, cb_data); + cb (".reg2", 108, 108, &i386_fpregset, NULL, cb_data); } /* Linux kernel shows PC value after the 'int $0x80' instruction even if @@ -709,35 +790,49 @@ i386_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, 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 + It is not fully correct as the bytes in struct displaced_step_copy_insn_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 + displaced_step_copy_insn_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 * +static displaced_step_copy_insn_closure_up 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); + displaced_step_copy_insn_closure_up 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; + /* The closure returned by i386_displaced_step_copy_insn is simply a + buffer with a copy of the instruction. */ + i386_displaced_step_copy_insn_closure *closure + = (i386_displaced_step_copy_insn_closure *) closure_.get (); /* Fake nop. */ - insn[0] = 0x90; + closure->buf[0] = 0x90; } - return closure; + return closure_; +} + +static displaced_step_prepare_status +i386_displaced_step_prepare (gdbarch *arch, thread_info *thread) +{ + gdb_assert (false); + return DISPLACED_STEP_PREPARE_STATUS_OK; +} + +static displaced_step_finish_status +i386_displaced_step_finish (gdbarch *arch, thread_info *thread, gdb_signal sig) +{ + gdb_assert (false); + return DISPLACED_STEP_FINISH_STATUS_OK; } static void @@ -745,8 +840,7 @@ 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 - = (struct tdesc_arch_data *) info.tdep_info; + struct tdesc_arch_data *tdesc_data = info.tdesc_data; const struct tdesc_feature *feature; int valid_p; @@ -761,7 +855,7 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS); if (! tdesc_has_registers (tdesc)) - tdesc = tdesc_i386_linux; + tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK); tdep->tdesc = tdesc; feature = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.linux"); @@ -869,6 +963,7 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) i386_linux_record_tdep.size_hayes_esp_config = 12; i386_linux_record_tdep.size_size_t = 4; i386_linux_record_tdep.size_iovec = 8; + i386_linux_record_tdep.size_time_t = 4; /* These values are the second argument of system call "sys_ioctl". They are obtained from Linux Kernel source. */ @@ -956,7 +1051,7 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 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 + /* N_FUN symbols in shared libraries have 0 for their values and need to be relocated. */ set_gdbarch_sofun_address_maybe_missing (gdbarch, 1); @@ -984,30 +1079,23 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_displaced_step_copy_insn (gdbarch, 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); - set_gdbarch_displaced_step_location (gdbarch, - linux_displaced_step_location); + set_gdbarch_displaced_step_prepare (gdbarch, i386_displaced_step_prepare); + set_gdbarch_displaced_step_finish (gdbarch, i386_displaced_step_finish); /* Functions for 'catch syscall'. */ set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_I386); set_gdbarch_get_syscall_number (gdbarch, i386_linux_get_syscall_number); -} -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern void _initialize_i386_linux_tdep (void); + set_gdbarch_get_siginfo_type (gdbarch, x86_linux_get_siginfo_type); + set_gdbarch_handle_segmentation_fault (gdbarch, + i386_linux_handle_segmentation_fault); +} +void _initialize_i386_linux_tdep (); void -_initialize_i386_linux_tdep (void) +_initialize_i386_linux_tdep () { 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 (); - initialize_tdesc_i386_mpx_linux (); - initialize_tdesc_i386_avx512_linux (); }