X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fia64-linux-nat.c;h=8f36ea78e762ceeb3a44ceef113ce26ce478c5ed;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=64878ec27791d4ec04a74b2e4223d243d732fa5d;hpb=135340afdf3b333cde11e4429fb16271d5170335;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c index 64878ec277..8f36ea78e7 100644 --- a/gdb/ia64-linux-nat.c +++ b/gdb/ia64-linux-nat.c @@ -1,7 +1,7 @@ /* Functions specific to running gdb native on IA-64 running GNU/Linux. - Copyright (C) 1999-2018 Free Software Foundation, Inc. + Copyright (C) 1999-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -28,7 +28,7 @@ #include #include "nat/gdb_ptrace.h" -#include "gdb_wait.h" +#include "gdbsupport/gdb_wait.h" #ifdef HAVE_SYS_REG_H #include #endif @@ -57,8 +57,6 @@ public: ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override; - const struct target_desc *read_description () override; - /* Override watchpoint routines. */ /* The IA-64 architecture can step over a watch point (without @@ -70,7 +68,7 @@ public: has determined that a hardware watchpoint has indeed been hit. The CPU will then be able to execute one instruction without triggering a watchpoint. */ - bool have_steppable_watchpoint () { return 1; } + bool have_steppable_watchpoint () override { return true; } int can_use_hw_breakpoint (enum bptype, int, int) override; bool stopped_by_watchpoint () override; @@ -82,6 +80,8 @@ public: /* Override linux_nat_target low methods. */ void low_new_thread (struct lwp_info *lp) override; bool low_status_is_event (int status) override; + + void enable_watchpoints_in_psr (ptid_t ptid); }; static ia64_linux_nat_target the_ia64_linux_nat_target; @@ -414,33 +414,32 @@ supply_gregset (struct regcache *regcache, const gregset_t *gregsetp) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++) { - regcache_raw_supply (regcache, regi, regp + (regi - IA64_GR0_REGNUM)); + regcache->raw_supply (regi, regp + (regi - IA64_GR0_REGNUM)); } /* FIXME: NAT collection bits are at index 32; gotta deal with these somehow... */ - regcache_raw_supply (regcache, IA64_PR_REGNUM, regp + 33); + regcache->raw_supply (IA64_PR_REGNUM, regp + 33); for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++) { - regcache_raw_supply (regcache, regi, - regp + 34 + (regi - IA64_BR0_REGNUM)); + regcache->raw_supply (regi, regp + 34 + (regi - IA64_BR0_REGNUM)); } - regcache_raw_supply (regcache, IA64_IP_REGNUM, regp + 42); - regcache_raw_supply (regcache, IA64_CFM_REGNUM, regp + 43); - regcache_raw_supply (regcache, IA64_PSR_REGNUM, regp + 44); - regcache_raw_supply (regcache, IA64_RSC_REGNUM, regp + 45); - regcache_raw_supply (regcache, IA64_BSP_REGNUM, regp + 46); - regcache_raw_supply (regcache, IA64_BSPSTORE_REGNUM, regp + 47); - regcache_raw_supply (regcache, IA64_RNAT_REGNUM, regp + 48); - regcache_raw_supply (regcache, IA64_CCV_REGNUM, regp + 49); - regcache_raw_supply (regcache, IA64_UNAT_REGNUM, regp + 50); - regcache_raw_supply (regcache, IA64_FPSR_REGNUM, regp + 51); - regcache_raw_supply (regcache, IA64_PFS_REGNUM, regp + 52); - regcache_raw_supply (regcache, IA64_LC_REGNUM, regp + 53); - regcache_raw_supply (regcache, IA64_EC_REGNUM, regp + 54); + regcache->raw_supply (IA64_IP_REGNUM, regp + 42); + regcache->raw_supply (IA64_CFM_REGNUM, regp + 43); + regcache->raw_supply (IA64_PSR_REGNUM, regp + 44); + regcache->raw_supply (IA64_RSC_REGNUM, regp + 45); + regcache->raw_supply (IA64_BSP_REGNUM, regp + 46); + regcache->raw_supply (IA64_BSPSTORE_REGNUM, regp + 47); + regcache->raw_supply (IA64_RNAT_REGNUM, regp + 48); + regcache->raw_supply (IA64_CCV_REGNUM, regp + 49); + regcache->raw_supply (IA64_UNAT_REGNUM, regp + 50); + regcache->raw_supply (IA64_FPSR_REGNUM, regp + 51); + regcache->raw_supply (IA64_PFS_REGNUM, regp + 52); + regcache->raw_supply (IA64_LC_REGNUM, regp + 53); + regcache->raw_supply (IA64_EC_REGNUM, regp + 54); } void @@ -451,7 +450,7 @@ fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno) #define COPY_REG(_idx_,_regi_) \ if ((regno == -1) || regno == _regi_) \ - regcache_raw_collect (regcache, _regi_, regp + _idx_) + regcache->raw_collect (_regi_, regp + _idx_) for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++) { @@ -500,14 +499,14 @@ supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp) for fr0/fr1 and always supply their expected values. */ /* fr0 is always read as zero. */ - regcache_raw_supply (regcache, IA64_FR0_REGNUM, f_zero); + regcache->raw_supply (IA64_FR0_REGNUM, f_zero); /* fr1 is always read as one (1.0). */ - regcache_raw_supply (regcache, IA64_FR1_REGNUM, f_one); + regcache->raw_supply (IA64_FR1_REGNUM, f_one); for (regi = IA64_FR2_REGNUM; regi <= IA64_FR127_REGNUM; regi++) { from = (const char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]); - regcache_raw_supply (regcache, regi, from); + regcache->raw_supply (regi, from); } } @@ -525,18 +524,17 @@ fill_fpregset (const struct regcache *regcache, for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++) { if ((regno == -1) || (regno == regi)) - regcache_raw_collect (regcache, regi, - &((*fpregsetp)[regi - IA64_FR0_REGNUM])); + regcache->raw_collect (regi, &((*fpregsetp)[regi - IA64_FR0_REGNUM])); } } #define IA64_PSR_DB (1UL << 24) #define IA64_PSR_DD (1UL << 39) -static void -enable_watchpoints_in_psr (ptid_t ptid) +void +ia64_linux_nat_target::enable_watchpoints_in_psr (ptid_t ptid) { - struct regcache *regcache = get_thread_regcache (ptid); + struct regcache *regcache = get_thread_regcache (this, ptid); ULONGEST psr; regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr); @@ -555,9 +553,9 @@ store_debug_register (ptid_t ptid, int idx, long val) { int tid; - tid = ptid_get_lwp (ptid); + tid = ptid.lwp (); if (tid == 0) - tid = ptid_get_pid (ptid); + tid = ptid.pid (); (void) ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) (PT_DBR + 8 * idx), val); } @@ -674,8 +672,8 @@ ia64_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, return -1; } -static void -ia64_linux_new_thread (struct lwp_info *lp) +void +ia64_linux_nat_target::low_new_thread (struct lwp_info *lp) { int i, any; @@ -721,10 +719,9 @@ ia64_linux_nat_target::stopped_by_watchpoint () return stopped_data_address (&addr); } -static int -ia64_linux_can_use_hw_breakpoint (struct target_ops *self, - enum bptype type, - int cnt, int othertype) +int +ia64_linux_nat_target::can_use_hw_breakpoint (enum bptype type, + int cnt, int othertype) { return 1; } @@ -748,7 +745,7 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum) const gdb_byte zero[8] = { 0 }; gdb_assert (sizeof (zero) == register_size (gdbarch, regnum)); - regcache_raw_supply (regcache, regnum, zero); + regcache->raw_supply (regnum, zero); return; } @@ -758,7 +755,7 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum) const gdb_byte f_zero[16] = { 0 }; gdb_assert (sizeof (f_zero) == register_size (gdbarch, regnum)); - regcache_raw_supply (regcache, regnum, f_zero); + regcache->raw_supply (regnum, f_zero); return; } @@ -769,17 +766,17 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum) { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 }; gdb_assert (sizeof (f_one) == register_size (gdbarch, regnum)); - regcache_raw_supply (regcache, regnum, f_one); + regcache->raw_supply (regnum, f_one); return; } if (ia64_cannot_fetch_register (gdbarch, regnum)) { - regcache_raw_supply (regcache, regnum, NULL); + regcache->raw_supply (regnum, NULL); return; } - pid = get_ptrace_pid (regcache_get_ptid (regcache)); + pid = get_ptrace_pid (regcache->ptid ()); /* This isn't really an address, but ptrace thinks of it as one. */ addr = ia64_register_addr (gdbarch, regnum); @@ -800,7 +797,7 @@ ia64_linux_fetch_register (struct regcache *regcache, int regnum) addr += sizeof (PTRACE_TYPE_RET); } - regcache_raw_supply (regcache, regnum, buf); + regcache->raw_supply (regnum, buf); } /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this @@ -833,7 +830,7 @@ ia64_linux_store_register (const struct regcache *regcache, int regnum) if (ia64_cannot_store_register (gdbarch, regnum)) return; - pid = get_ptrace_pid (regcache_get_ptid (regcache)); + pid = get_ptrace_pid (regcache->ptid ()); /* This isn't really an address, but ptrace thinks of it as one. */ addr = ia64_register_addr (gdbarch, regnum); @@ -843,7 +840,7 @@ ia64_linux_store_register (const struct regcache *regcache, int regnum) buf = (PTRACE_TYPE_RET *) alloca (size); /* Write the register contents into the inferior a chunk at a time. */ - regcache_raw_collect (regcache, regnum, buf); + regcache->raw_collect (regnum, buf); for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) { errno = 0; @@ -926,12 +923,11 @@ ia64_linux_nat_target::low_status_is_event (int status) || WSTOPSIG (status) == SIGILL); } +void _initialize_ia64_linux_nat (); void -_initialize_ia64_linux_nat (void) +_initialize_ia64_linux_nat () { - struct target_ops *t = &the_ia64_linux_nat_target; - /* Register the target. */ linux_target = &the_ia64_linux_nat_target; - add_target (t); + add_inf_child_target (&the_ia64_linux_nat_target); }