/* Target-dependent code for GNU/Linux i386.
- Copyright (C) 2000-2017 Free Software Foundation, Inc.
+ Copyright (C) 2000-2022 Free Software Foundation, Inc.
This file is part of GDB.
#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 "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/32bit-core.c"
-#include "features/i386/32bit-sse.c"
-#include "features/i386/32bit-linux.c"
-#include "features/i386/32bit-avx.c"
-#include "features/i386/32bit-mpx.c"
-#include "features/i386/32bit-avx512.c"
-#include "features/i386/32bit-pkeys.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. */
PC is not at the start of the instruction sequence, there will be
a few trailing readable bytes on the stack. */
- if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN))
+ if (!safe_frame_unwind_memory (this_frame, pc, buf))
return 0;
if (buf[0] != LINUX_SIGTRAMP_INSN0)
pc -= adjust;
- if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN))
+ if (!safe_frame_unwind_memory (this_frame, pc, buf))
return 0;
}
PC is not at the start of the instruction sequence, there will be
a few trailing readable bytes on the stack. */
- if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_RT_SIGTRAMP_LEN))
+ if (!safe_frame_unwind_memory (this_frame, pc, buf))
return 0;
if (buf[0] != LINUX_RT_SIGTRAMP_INSN0)
pc -= LINUX_RT_SIGTRAMP_OFFSET1;
- if (!safe_frame_unwind_memory (this_frame, pc, buf,
- LINUX_RT_SIGTRAMP_LEN))
+ if (!safe_frame_unwind_memory (this_frame, pc,
+ buf))
return 0;
}
#define SIG_CODE_BONDARY_FAULT 3
-/* i386 GNU/Linux implementation of the handle_segmentation_fault
+/* i386 GNU/Linux implementation of the report_signal_info
gdbarch hook. Displays information related to MPX bound
violations. */
void
-i386_linux_handle_segmentation_fault (struct gdbarch *gdbarch,
- struct ui_out *uiout)
+i386_linux_report_signal_info (struct gdbarch *gdbarch, struct ui_out *uiout,
+ enum gdb_signal siggnal)
{
/* -Wmaybe-uninitialized */
CORE_ADDR lower_bound = 0, upper_bound = 0, access = 0;
int is_upper;
long sig_code = 0;
- if (!i386_mpx_enabled ())
+ if (!i386_mpx_enabled () || siggnal != GDB_SIGNAL_SEGV)
return;
- TRY
+ 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");
+ = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._lower");
upper_bound
- = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._upper");
+ = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._upper");
access
- = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
+ = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
}
- CATCH (exception, RETURN_MASK_ALL)
+ catch (const gdb_exception &exception)
{
return;
}
- END_CATCH
/* If this is not a boundary violation just return. */
if (sig_code != SIG_CODE_BONDARY_FAULT)
uiout->field_string ("sigcode-meaning", _("Lower bound violation"));
uiout->text (_(" while accessing address "));
- uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, access));
+ uiout->field_core_addr ("bound-access", gdbarch, access);
uiout->text (_("\nBounds: [lower = "));
- uiout->field_fmt ("lower-bound", "%s", paddress (gdbarch, lower_bound));
+ uiout->field_core_addr ("lower-bound", gdbarch, lower_bound);
uiout->text (_(", upper = "));
- uiout->field_fmt ("upper-bound", "%s", paddress (gdbarch, upper_bound));
+ uiout->field_core_addr ("upper-bound", gdbarch, upper_bound);
uiout->text (_("]"));
}
if (syscall_gdb < 0)
{
- printf_unfiltered (_("Process record and replay target doesn't "
- "support syscall number %s\n"),
- plongest (syscall_native));
+ fprintf_unfiltered (gdb_stderr,
+ _("Process record and replay target doesn't "
+ "support syscall number %s\n"),
+ plongest (syscall_native));
return -1;
}
static int
i386_linux_record_signal (struct gdbarch *gdbarch,
- struct regcache *regcache,
- enum gdb_signal signal)
+ struct regcache *regcache,
+ enum gdb_signal signal)
{
ULONGEST esp;
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];
/* 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);
+ ret = extract_signed_integer (buf, byte_order);
return ret;
}
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);
}
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)
[(xcr0 & X86_XSTATE_PKRU) ? 1 : 0];
if (*tdesc == NULL)
- {
- *tdesc = allocate_target_description ();
- set_tdesc_architecture (*tdesc, bfd_scan_arch ("i386"));
- set_tdesc_osabi (*tdesc, osabi_from_tdesc_string ("GNU/Linux"));
-
- long regnum = 0;
-
- if (xcr0 & X86_XSTATE_X87)
- regnum = create_feature_i386_32bit_core (*tdesc, regnum);
-
- if (xcr0 & X86_XSTATE_SSE)
- regnum = create_feature_i386_32bit_sse (*tdesc, regnum);
-
- regnum = create_feature_i386_32bit_linux (*tdesc, regnum);
-
- if (xcr0 & X86_XSTATE_AVX)
- regnum = create_feature_i386_32bit_avx (*tdesc, regnum);
-
- if (xcr0 & X86_XSTATE_MPX)
- regnum = create_feature_i386_32bit_mpx (*tdesc, regnum);
-
- if (xcr0 & X86_XSTATE_AVX512)
- regnum = create_feature_i386_32bit_avx512 (*tdesc, regnum);
-
- if (xcr0 & X86_XSTATE_PKRU)
- regnum = create_feature_i386_32bit_pkeys (*tdesc, regnum);
- }
+ *tdesc = i386_create_target_description (xcr0, true, false);
return *tdesc;
}
void *cb_data,
const struct regcache *regcache)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ i386_gdbarch_tdep *tdep = (i386_gdbarch_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
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 *
+ 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_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 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 void
i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ i386_gdbarch_tdep *tdep = (i386_gdbarch_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;
gdb_assert (tdesc_data);
- linux_init_abi (info, gdbarch);
+ linux_init_abi (info, gdbarch, 1);
/* GNU/Linux uses ELF. */
i386_elf_init_abi (info, 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);
/* GNU/Linux uses SVR4-style shared libraries. */
set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
set_solib_svr4_fetch_link_map_offsets
- (gdbarch, svr4_ilp32_fetch_link_map_offsets);
+ (gdbarch, linux_ilp32_fetch_link_map_offsets);
/* GNU/Linux uses the dynamic linker included in the GNU C Library. */
set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
/* Enable TLS support. */
set_gdbarch_fetch_tls_load_module_address (gdbarch,
- svr4_fetch_objfile_link_map);
+ svr4_fetch_objfile_link_map);
/* Core file support. */
set_gdbarch_iterate_over_regset_sections
/* Displaced stepping. */
set_gdbarch_displaced_step_copy_insn (gdbarch,
- i386_linux_displaced_step_copy_insn);
+ i386_linux_displaced_step_copy_insn);
set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup);
- set_gdbarch_displaced_step_location (gdbarch,
- linux_displaced_step_location);
/* 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);
+ i386_linux_get_syscall_number);
set_gdbarch_get_siginfo_type (gdbarch, x86_linux_get_siginfo_type);
- set_gdbarch_handle_segmentation_fault (gdbarch,
- i386_linux_handle_segmentation_fault);
+ set_gdbarch_report_signal_info (gdbarch, i386_linux_report_signal_info);
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern void _initialize_i386_linux_tdep (void);
-
+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);