X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmips-linux-nat.c;h=38ff461a35b3955780e6ce49c69b0e05c4b27136;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=d8781fc6543bdeaa0c9872e2a6b0a84fd8c7a946;hpb=7bb99c53837248382434ccf26f50b42e69d0b874;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mips-linux-nat.c b/gdb/mips-linux-nat.c index d8781fc654..38ff461a35 100644 --- a/gdb/mips-linux-nat.c +++ b/gdb/mips-linux-nat.c @@ -1,6 +1,6 @@ /* Native-dependent code for GNU/Linux on MIPS processors. - Copyright (C) 2001-2014 Free Software Foundation, Inc. + Copyright (C) 2001-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -20,12 +20,11 @@ #include "defs.h" #include "command.h" #include "gdbcmd.h" -#include "gdb_assert.h" #include "inferior.h" #include "mips-tdep.h" #include "target.h" #include "regcache.h" -#include "linux-nat.h" +#include "linux-nat-trad.h" #include "mips-linux-tdep.h" #include "target-descriptions.h" @@ -33,37 +32,62 @@ #include "gregset.h" #include -#include +#include "nat/gdb_ptrace.h" #include +#include "inf-ptrace.h" -#include "mips-linux-watch.h" - -#include "features/mips-linux.c" -#include "features/mips-dsp-linux.c" -#include "features/mips64-linux.c" -#include "features/mips64-dsp-linux.c" +#include "nat/mips-linux-watch.h" #ifndef PTRACE_GET_THREAD_AREA #define PTRACE_GET_THREAD_AREA 25 #endif -/* Assume that we have PTRACE_GETREGS et al. support. If we do not, - we'll clear this and use PTRACE_PEEKUSER instead. */ -static int have_ptrace_regsets = 1; +class mips_linux_nat_target final : public linux_nat_trad_target +{ +public: + /* Add our register access methods. */ + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + void close () override; + + int can_use_hw_breakpoint (enum bptype, int, int) override; -/* Whether or not to print the mirrored debug registers. */ + int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, + struct expression *) override; -static int maint_show_dr; + int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, + struct expression *) override; -/* Saved function pointers to fetch and store a single register using - PTRACE_PEEKUSER and PTRACE_POKEUSER. */ + bool stopped_by_watchpoint () override; -static void (*super_fetch_registers) (struct target_ops *, - struct regcache *, int); -static void (*super_store_registers) (struct target_ops *, - struct regcache *, int); + bool stopped_data_address (CORE_ADDR *) override; -static void (*super_close) (void); + int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; + + const struct target_desc *read_description () override; + +protected: + /* Override linux_nat_trad_target methods. */ + CORE_ADDR register_u_offset (struct gdbarch *gdbarch, + int regno, int store_p) override; + + /* Override linux_nat_target low methods. */ + void low_new_thread (struct lwp_info *lp) override; + +private: + /* Helpers. See definitions. */ + void mips64_regsets_store_registers (struct regcache *regcache, + int regno); + void mips64_regsets_fetch_registers (struct regcache *regcache, + int regno); +}; + +static mips_linux_nat_target the_mips_linux_nat_target; + +/* Assume that we have PTRACE_GETREGS et al. support. If we do not, + we'll clear this and use PTRACE_PEEKUSER instead. */ +static int have_ptrace_regsets = 1; /* Map gdb internal register number to ptrace ``address''. These ``addresses'' are normally defined in . @@ -121,6 +145,11 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store) if (regno < 0 || regno >= gdbarch_num_regs (gdbarch)) error (_("Bogon register number %d."), regno); + /* On n32 we can't access 64-bit registers via PTRACE_PEEKUSR + or PTRACE_POKEUSR. */ + if (register_size (gdbarch, regno) > sizeof (PTRACE_TYPE_RET)) + return (CORE_ADDR) -1; + if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32) regaddr = regno; else if ((regno >= mips_regnum (gdbarch)->fp0) @@ -157,7 +186,7 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store) /* Fetch the thread-local storage pointer for libthread_db. */ ps_err_e -ps_get_thread_area (const struct ps_prochandle *ph, +ps_get_thread_area (struct ps_prochandle *ph, lwpid_t lwpid, int idx, void **base) { if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0) @@ -176,7 +205,7 @@ ps_get_thread_area (const struct ps_prochandle *ph, void supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) { - if (mips_isa_regsize (get_regcache_arch (regcache)) == 4) + if (mips_isa_regsize (regcache->arch ()) == 4) mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp); else mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp); @@ -186,7 +215,7 @@ void fill_gregset (const struct regcache *regcache, gdb_gregset_t *gregsetp, int regno) { - if (mips_isa_regsize (get_regcache_arch (regcache)) == 4) + if (mips_isa_regsize (regcache->arch ()) == 4) mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno); else mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno); @@ -195,33 +224,25 @@ fill_gregset (const struct regcache *regcache, void supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp) { - if (mips_isa_regsize (get_regcache_arch (regcache)) == 4) - mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp); - else - mips64_supply_fpregset (regcache, - (const mips64_elf_fpregset_t *) fpregsetp); + mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *) fpregsetp); } void fill_fpregset (const struct regcache *regcache, gdb_fpregset_t *fpregsetp, int regno) { - if (mips_isa_regsize (get_regcache_arch (regcache)) == 4) - mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno); - else - mips64_fill_fpregset (regcache, - (mips64_elf_fpregset_t *) fpregsetp, regno); + mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *) fpregsetp, regno); } /* Fetch REGNO (or all registers if REGNO == -1) from the target using PTRACE_GETREGS et al. */ -static void -mips64_linux_regsets_fetch_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +mips_linux_nat_target::mips64_regsets_fetch_registers + (struct regcache *regcache, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); int is_fp, is_dsp; int have_dsp; int regi; @@ -249,9 +270,7 @@ mips64_linux_regsets_fetch_registers (struct target_ops *ops, else is_dsp = 0; - tid = ptid_get_lwp (inferior_ptid); - if (tid == 0) - tid = ptid_get_pid (inferior_ptid); + tid = get_ptrace_pid (regcache->ptid ()); if (regno == -1 || (!is_fp && !is_dsp)) { @@ -291,25 +310,26 @@ mips64_linux_regsets_fetch_registers (struct target_ops *ops, } if (is_dsp) - super_fetch_registers (ops, regcache, regno); + linux_nat_trad_target::fetch_registers (regcache, regno); else if (regno == -1 && have_dsp) { for (regi = mips_regnum (gdbarch)->dspacc; regi < mips_regnum (gdbarch)->dspacc + 6; regi++) - super_fetch_registers (ops, regcache, regi); - super_fetch_registers (ops, regcache, mips_regnum (gdbarch)->dspctl); + linux_nat_trad_target::fetch_registers (regcache, regi); + linux_nat_trad_target::fetch_registers (regcache, + mips_regnum (gdbarch)->dspctl); } } /* Store REGNO (or all registers if REGNO == -1) to the target using PTRACE_SETREGS et al. */ -static void -mips64_linux_regsets_store_registers (struct target_ops *ops, - struct regcache *regcache, int regno) +void +mips_linux_nat_target::mips64_regsets_store_registers + (struct regcache *regcache, int regno) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); int is_fp, is_dsp; int have_dsp; int regi; @@ -337,9 +357,7 @@ mips64_linux_regsets_store_registers (struct target_ops *ops, else is_dsp = 0; - tid = ptid_get_lwp (inferior_ptid); - if (tid == 0) - tid = ptid_get_pid (inferior_ptid); + tid = get_ptrace_pid (regcache->ptid ()); if (regno == -1 || (!is_fp && !is_dsp)) { @@ -370,56 +388,62 @@ mips64_linux_regsets_store_registers (struct target_ops *ops, } if (is_dsp) - super_store_registers (ops, regcache, regno); + linux_nat_trad_target::store_registers (regcache, regno); else if (regno == -1 && have_dsp) { for (regi = mips_regnum (gdbarch)->dspacc; regi < mips_regnum (gdbarch)->dspacc + 6; regi++) - super_store_registers (ops, regcache, regi); - super_store_registers (ops, regcache, mips_regnum (gdbarch)->dspctl); + linux_nat_trad_target::store_registers (regcache, regi); + linux_nat_trad_target::store_registers (regcache, + mips_regnum (gdbarch)->dspctl); } } /* Fetch REGNO (or all registers if REGNO == -1) from the target using any working method. */ -static void -mips64_linux_fetch_registers (struct target_ops *ops, - struct regcache *regcache, int regnum) +void +mips_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum) { /* Unless we already know that PTRACE_GETREGS does not work, try it. */ if (have_ptrace_regsets) - mips64_linux_regsets_fetch_registers (ops, regcache, regnum); + mips64_regsets_fetch_registers (regcache, regnum); /* If we know, or just found out, that PTRACE_GETREGS does not work, fall back to PTRACE_PEEKUSER. */ if (!have_ptrace_regsets) - super_fetch_registers (ops, regcache, regnum); + { + linux_nat_trad_target::fetch_registers (regcache, regnum); + + /* Fill the inaccessible zero register with zero. */ + if (regnum == MIPS_ZERO_REGNUM || regnum == -1) + regcache->raw_supply_zeroed (MIPS_ZERO_REGNUM); + } } /* Store REGNO (or all registers if REGNO == -1) to the target using any working method. */ -static void -mips64_linux_store_registers (struct target_ops *ops, - struct regcache *regcache, int regnum) +void +mips_linux_nat_target::store_registers (struct regcache *regcache, int regnum) { /* Unless we already know that PTRACE_GETREGS does not work, try it. */ if (have_ptrace_regsets) - mips64_linux_regsets_store_registers (ops, regcache, regnum); + mips64_regsets_store_registers (regcache, regnum); /* If we know, or just found out, that PTRACE_GETREGS does not work, fall back to PTRACE_PEEKUSER. */ if (!have_ptrace_regsets) - super_store_registers (ops, regcache, regnum); + linux_nat_trad_target::store_registers (regcache, regnum); } /* Return the address in the core dump or inferior of register REGNO. */ -static CORE_ADDR -mips_linux_register_u_offset (struct gdbarch *gdbarch, int regno, int store_p) +CORE_ADDR +mips_linux_nat_target::register_u_offset (struct gdbarch *gdbarch, + int regno, int store_p) { if (mips_abi_regsize (gdbarch) == 8) return mips64_linux_register_addr (gdbarch, regno, store_p); @@ -427,19 +451,16 @@ mips_linux_register_u_offset (struct gdbarch *gdbarch, int regno, int store_p) return mips_linux_register_addr (gdbarch, regno, store_p); } -static const struct target_desc * -mips_linux_read_description (struct target_ops *ops) +const struct target_desc * +mips_linux_nat_target::read_description () { static int have_dsp = -1; if (have_dsp < 0) { - int tid; - - tid = ptid_get_lwp (inferior_ptid); - if (tid == 0) - tid = ptid_get_pid (inferior_ptid); + int tid = get_ptrace_pid (inferior_ptid); + errno = 0; ptrace (PTRACE_PEEKUSER, tid, DSP_CONTROL, 0); switch (errno) { @@ -511,14 +532,14 @@ mips_show_dr (const char *func, CORE_ADDR addr, /* Target to_can_use_hw_breakpoint implementation. Return 1 if we can handle the specified watch type. */ -static int -mips_linux_can_use_hw_breakpoint (struct target_ops *self, - int type, int cnt, int ot) +int +mips_linux_nat_target::can_use_hw_breakpoint (enum bptype type, + int cnt, int ot) { int i; uint32_t wanted_mask, irw_mask; - if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid), + if (!mips_linux_read_watch_registers (inferior_ptid.lwp (), &watch_readback, &watch_readback_valid, 0)) return 0; @@ -553,48 +574,48 @@ mips_linux_can_use_hw_breakpoint (struct target_ops *self, stopped by watchpoint. The watchhi R and W bits indicate the watch register triggered. */ -static int -mips_linux_stopped_by_watchpoint (struct target_ops *ops) +bool +mips_linux_nat_target::stopped_by_watchpoint () { int n; int num_valid; - if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid), + if (!mips_linux_read_watch_registers (inferior_ptid.lwp (), &watch_readback, &watch_readback_valid, 1)) - return 0; + return false; num_valid = mips_linux_watch_get_num_valid (&watch_readback); for (n = 0; n < MAX_DEBUG_REGISTER && n < num_valid; n++) if (mips_linux_watch_get_watchhi (&watch_readback, n) & (R_MASK | W_MASK)) - return 1; + return true; - return 0; + return false; } /* Target to_stopped_data_address implementation. Set the address where the watch triggered (if known). Return 1 if the address was known. */ -static int -mips_linux_stopped_data_address (struct target_ops *t, CORE_ADDR *paddr) +bool +mips_linux_nat_target::stopped_data_address (CORE_ADDR *paddr) { /* On mips we don't know the low order 3 bits of the data address, so we must return false. */ - return 0; + return false; } /* Target to_region_ok_for_hw_watchpoint implementation. Return 1 if the specified region can be covered by the watch registers. */ -static int -mips_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) +int +mips_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) { struct pt_watch_regs dummy_regs; int i; - if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid), + if (!mips_linux_read_watch_registers (inferior_ptid.lwp (), &watch_readback, &watch_readback_valid, 0)) return 0; @@ -616,47 +637,45 @@ write_watchpoint_regs (void) ALL_LWPS (lp) { - tid = ptid_get_lwp (lp->ptid); - if (ptrace (PTRACE_SET_WATCH_REGS, tid, &watch_mirror) == -1) + tid = lp->ptid.lwp (); + if (ptrace (PTRACE_SET_WATCH_REGS, tid, &watch_mirror, NULL) == -1) perror_with_name (_("Couldn't write debug register")); } return 0; } -/* linux_nat new_thread implementation. Write the mirrored watch - register values for the new thread. */ +/* linux_nat_target::low_new_thread implementation. Write the + mirrored watch register values for the new thread. */ -static void -mips_linux_new_thread (struct lwp_info *lp) +void +mips_linux_nat_target::low_new_thread (struct lwp_info *lp) { - int tid; + long tid = lp->ptid.lwp (); - if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid), + if (!mips_linux_read_watch_registers (tid, &watch_readback, &watch_readback_valid, 0)) return; - tid = ptid_get_lwp (lp->ptid); - if (ptrace (PTRACE_SET_WATCH_REGS, tid, &watch_mirror) == -1) + if (ptrace (PTRACE_SET_WATCH_REGS, tid, &watch_mirror, NULL) == -1) perror_with_name (_("Couldn't write debug register")); } /* Target to_insert_watchpoint implementation. Try to insert a new watch. Return zero on success. */ -static int -mips_linux_insert_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, - struct expression *cond) +int +mips_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond) { struct pt_watch_regs regs; struct mips_watchpoint *new_watch; struct mips_watchpoint **pw; - int i; int retval; - if (!mips_linux_read_watch_registers (ptid_get_lwp (inferior_ptid), + if (!mips_linux_read_watch_registers (inferior_ptid.lwp (), &watch_readback, &watch_readback_valid, 0)) return -1; @@ -674,8 +693,7 @@ mips_linux_insert_watchpoint (struct target_ops *self, return -1; /* It fit. Stick it on the end of the list. */ - new_watch = (struct mips_watchpoint *) - xmalloc (sizeof (struct mips_watchpoint)); + new_watch = XNEW (struct mips_watchpoint); new_watch->addr = addr; new_watch->len = len; new_watch->type = type; @@ -689,7 +707,7 @@ mips_linux_insert_watchpoint (struct target_ops *self, watch_mirror = regs; retval = write_watchpoint_regs (); - if (maint_show_dr) + if (show_debug_regs) mips_show_dr ("insert_watchpoint", addr, len, type); return retval; @@ -698,10 +716,10 @@ mips_linux_insert_watchpoint (struct target_ops *self, /* Target to_remove_watchpoint implementation. Try to remove a watch. Return zero on success. */ -static int -mips_linux_remove_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, - struct expression *cond) +int +mips_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond) { int retval; int deleted_one; @@ -737,7 +755,7 @@ mips_linux_remove_watchpoint (struct target_ops *self, retval = write_watchpoint_regs (); - if (maint_show_dr) + if (show_debug_regs) mips_show_dr ("remove_watchpoint", addr, len, type); return retval; @@ -746,8 +764,8 @@ mips_linux_remove_watchpoint (struct target_ops *self, /* Target to_close implementation. Free any watches and call the super implementation. */ -static void -mips_linux_close (struct target_ops *self) +void +mips_linux_nat_target::close () { struct mips_watchpoint *w; struct mips_watchpoint *nw; @@ -762,19 +780,15 @@ mips_linux_close (struct target_ops *self) } current_watches = NULL; - if (super_close) - super_close (); + linux_nat_trad_target::close (); } -void _initialize_mips_linux_nat (void); - +void _initialize_mips_linux_nat (); void -_initialize_mips_linux_nat (void) +_initialize_mips_linux_nat () { - struct target_ops *t; - add_setshow_boolean_cmd ("show-debug-regs", class_maintenance, - &maint_show_dr, _("\ + &show_debug_regs, _("\ Set whether to show variables that mirror the mips debug registers."), _("\ Show whether to show variables that mirror the mips debug registers."), _("\ Use \"on\" to enable, \"off\" to disable.\n\ @@ -786,32 +800,6 @@ triggers a breakpoint or watchpoint."), &maintenance_set_cmdlist, &maintenance_show_cmdlist); - t = linux_trad_target (mips_linux_register_u_offset); - - super_close = t->to_close; - t->to_close = mips_linux_close; - - super_fetch_registers = t->to_fetch_registers; - super_store_registers = t->to_store_registers; - - t->to_fetch_registers = mips64_linux_fetch_registers; - t->to_store_registers = mips64_linux_store_registers; - - t->to_can_use_hw_breakpoint = mips_linux_can_use_hw_breakpoint; - t->to_remove_watchpoint = mips_linux_remove_watchpoint; - t->to_insert_watchpoint = mips_linux_insert_watchpoint; - t->to_stopped_by_watchpoint = mips_linux_stopped_by_watchpoint; - t->to_stopped_data_address = mips_linux_stopped_data_address; - t->to_region_ok_for_hw_watchpoint = mips_linux_region_ok_for_hw_watchpoint; - - t->to_read_description = mips_linux_read_description; - - linux_nat_add_target (t); - linux_nat_set_new_thread (t, mips_linux_new_thread); - - /* Initialize the standard target descriptions. */ - initialize_tdesc_mips_linux (); - initialize_tdesc_mips_dsp_linux (); - initialize_tdesc_mips64_linux (); - initialize_tdesc_mips64_dsp_linux (); + linux_target = &the_mips_linux_nat_target; + add_inf_child_target (&the_mips_linux_nat_target); }