X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fs390-linux-nat.c;h=d1634bd3a6aef73632bc36be9274d5f09ff32cb0;hb=c0b0a14290e1909a6cc3febb443560c3e95562c2;hp=bc99855bb09bc80b2387e0d98bd718bc57ad32d9;hpb=f6ac5f3d63e03a81c4ff3749aba234961cc9090e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/s390-linux-nat.c b/gdb/s390-linux-nat.c index bc99855bb0..d1634bd3a6 100644 --- a/gdb/s390-linux-nat.c +++ b/gdb/s390-linux-nat.c @@ -1,5 +1,5 @@ /* S390 native-dependent code for GDB, the GNU debugger. - Copyright (C) 2001-2018 Free Software Foundation, Inc. + Copyright (C) 2001-2020 Free Software Foundation, Inc. Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) for IBM Deutschland Entwicklung GmbH, IBM Corporation. @@ -42,6 +42,8 @@ #include #include #include "inf-ptrace.h" +#include "linux-tdep.h" +#include "gdbarch.h" /* Per-thread arch-specific data. */ @@ -122,9 +124,7 @@ public: int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; - int have_continuable_watchpoint () { return 1; } - int stopped_by_watchpoint () override; - int watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override; + bool stopped_by_watchpoint () override; int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override; int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, @@ -135,6 +135,13 @@ public: int auxv_parse (gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) override; + + /* Override linux_nat_target low methods. */ + void low_new_thread (struct lwp_info *lp) override; + void low_delete_thread (struct arch_lwp_info *lp) override; + void low_prepare_to_resume (struct lwp_info *lp) override; + void low_new_fork (struct lwp_info *parent, pid_t child_pid) override; + void low_forget_process (pid_t pid) override; }; static s390_linux_nat_target the_s390_linux_nat_target; @@ -164,10 +171,10 @@ supply_gregset (struct regcache *regcache, const gregset_t *regp) pswa = extract_unsigned_integer ((const gdb_byte *) regp + S390_PSWA_OFFSET, 8, byte_order); store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000); - regcache_raw_supply (regcache, S390_PSWM_REGNUM, buf); + regcache->raw_supply (S390_PSWM_REGNUM, buf); store_unsigned_integer (buf, 4, byte_order, (pswa & 0x7fffffff) | (pswm & 0x80000000)); - regcache_raw_supply (regcache, S390_PSWA_REGNUM, buf); + regcache->raw_supply (S390_PSWA_REGNUM, buf); return; } #endif @@ -204,14 +211,14 @@ fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno) if (regno == -1 || regno == S390_PSWM_REGNUM) { pswm &= 0x80000000; - regcache_raw_collect (regcache, S390_PSWM_REGNUM, buf); + regcache->raw_collect (S390_PSWM_REGNUM, buf); pswm |= (extract_unsigned_integer (buf, 4, byte_order) & 0xfff7ffff) << 32; } if (regno == -1 || regno == S390_PSWA_REGNUM) { - regcache_raw_collect (regcache, S390_PSWA_REGNUM, buf); + regcache->raw_collect (S390_PSWA_REGNUM, buf); pswa = extract_unsigned_integer (buf, 4, byte_order); pswm ^= (pswm ^ pswa) & 0x80000000; pswa &= 0x7fffffff; @@ -252,9 +259,9 @@ static int s390_inferior_tid (void) { /* GNU/Linux LWP ID's are process ID's. */ - int tid = ptid_get_lwp (inferior_ptid); + int tid = inferior_ptid.lwp (); if (tid == 0) - tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */ + tid = inferior_ptid.pid (); /* Not a threaded program. */ return tid; } @@ -402,7 +409,7 @@ check_regset (int tid, int regset, int regsize) void s390_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum) { - pid_t tid = get_ptrace_pid (regcache_get_ptid (regcache)); + pid_t tid = get_ptrace_pid (regcache->ptid ()); if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum)) fetch_regs (regcache, tid); @@ -456,7 +463,7 @@ s390_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum) void s390_linux_nat_target::store_registers (struct regcache *regcache, int regnum) { - pid_t tid = get_ptrace_pid (regcache_get_ptid (regcache)); + pid_t tid = get_ptrace_pid (regcache->ptid ()); if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum)) store_regs (regcache, tid, regnum); @@ -493,28 +500,26 @@ s390_linux_nat_target::store_registers (struct regcache *regcache, int regnum) The only thing we actually need is the total address space area spanned by the watchpoints. */ -typedef struct watch_area +struct watch_area { CORE_ADDR lo_addr; CORE_ADDR hi_addr; -} s390_watch_area; - -DEF_VEC_O (s390_watch_area); +}; /* Hardware debug state. */ struct s390_debug_reg_state { - VEC_s390_watch_area *watch_areas; - VEC_s390_watch_area *break_areas; + std::vector watch_areas; + std::vector break_areas; }; /* Per-process data. */ struct s390_process_info { - struct s390_process_info *next; - pid_t pid; + struct s390_process_info *next = nullptr; + pid_t pid = 0; struct s390_debug_reg_state state; }; @@ -540,7 +545,7 @@ s390_find_process_pid (pid_t pid) static struct s390_process_info * s390_add_process (pid_t pid) { - struct s390_process_info *proc = XCNEW (struct s390_process_info); + struct s390_process_info *proc = new struct s390_process_info; proc->pid = pid; proc->next = s390_process_list; @@ -575,8 +580,8 @@ s390_get_debug_reg_state (pid_t pid) /* Called whenever GDB is no longer debugging process PID. It deletes data structures that keep track of hardware debug state. */ -static void -s390_forget_process (pid_t pid) +void +s390_linux_nat_target::low_forget_process (pid_t pid) { struct s390_process_info *proc, **proc_link; @@ -587,10 +592,8 @@ s390_forget_process (pid_t pid) { if (proc->pid == pid) { - VEC_free (s390_watch_area, proc->state.watch_areas); - VEC_free (s390_watch_area, proc->state.break_areas); *proc_link = proc->next; - xfree (proc); + delete proc; return; } @@ -601,8 +604,8 @@ s390_forget_process (pid_t pid) /* linux_nat_new_fork hook. */ -static void -s390_linux_new_fork (struct lwp_info *parent, pid_t child_pid) +void +s390_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid) { pid_t parent_pid; struct s390_debug_reg_state *parent_state; @@ -616,14 +619,12 @@ s390_linux_new_fork (struct lwp_info *parent, pid_t child_pid) /* GDB core assumes the child inherits the watchpoints/hw breakpoints of the parent. So copy the debug state from parent to child. */ - parent_pid = ptid_get_pid (parent->ptid); + parent_pid = parent->ptid.pid (); parent_state = s390_get_debug_reg_state (parent_pid); child_state = s390_get_debug_reg_state (child_pid); - child_state->watch_areas = VEC_copy (s390_watch_area, - parent_state->watch_areas); - child_state->break_areas = VEC_copy (s390_watch_area, - parent_state->break_areas); + child_state->watch_areas = parent_state->watch_areas; + child_state->break_areas = parent_state->break_areas; } /* Dump PER state. */ @@ -657,21 +658,20 @@ s390_show_debug_regs (int tid, const char *where) per_info.lowcore.words.access_id); } -int +bool s390_linux_nat_target::stopped_by_watchpoint () { struct s390_debug_reg_state *state - = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid)); + = s390_get_debug_reg_state (inferior_ptid.pid ()); per_lowcore_bits per_lowcore; ptrace_area parea; - int result; if (show_debug_regs) s390_show_debug_regs (s390_inferior_tid (), "stop"); /* Speed up common case. */ - if (VEC_empty (s390_watch_area, state->watch_areas)) - return 0; + if (state->watch_areas.empty ()) + return false; parea.len = sizeof (per_lowcore); parea.process_addr = (addr_t) & per_lowcore; @@ -679,8 +679,8 @@ s390_linux_nat_target::stopped_by_watchpoint () if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0) perror_with_name (_("Couldn't retrieve watchpoint status")); - result = (per_lowcore.perc_storage_alteration == 1 - && per_lowcore.perc_store_real_address == 0); + bool result = (per_lowcore.perc_storage_alteration == 1 + && per_lowcore.perc_store_real_address == 0); if (result) { @@ -695,18 +695,16 @@ s390_linux_nat_target::stopped_by_watchpoint () /* Each time before resuming a thread, update its PER info. */ -static void -s390_prepare_to_resume (struct lwp_info *lp) +void +s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) { int tid; - pid_t pid = ptid_get_pid (ptid_of_lwp (lp)); + pid_t pid = ptid_of_lwp (lp).pid (); per_struct per_info; ptrace_area parea; CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0; - unsigned ix; - s390_watch_area *area; struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp); struct s390_debug_reg_state *state = s390_get_debug_reg_state (pid); int step = lwp_is_stepping (lp); @@ -719,13 +717,13 @@ s390_prepare_to_resume (struct lwp_info *lp) hardware breakpoints (if any). Otherwise we're done. */ if (!lp_priv->per_info_changed) { - if (!step || VEC_empty (s390_watch_area, state->break_areas)) + if (!step || state->break_areas.empty ()) return; } lp_priv->per_info_changed = 0; - tid = ptid_get_lwp (ptid_of_lwp (lp)); + tid = ptid_of_lwp (lp).lwp (); if (tid == 0) tid = pid; @@ -738,14 +736,12 @@ s390_prepare_to_resume (struct lwp_info *lp) memset (&per_info, 0, sizeof (per_info)); per_info.single_step = (step != 0); - if (!VEC_empty (s390_watch_area, state->watch_areas)) + if (!state->watch_areas.empty ()) { - for (ix = 0; - VEC_iterate (s390_watch_area, state->watch_areas, ix, area); - ix++) + for (const auto &area : state->watch_areas) { - watch_lo_addr = std::min (watch_lo_addr, area->lo_addr); - watch_hi_addr = std::max (watch_hi_addr, area->hi_addr); + watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); + watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); } /* Enable storage-alteration events. */ @@ -753,7 +749,7 @@ s390_prepare_to_resume (struct lwp_info *lp) | PER_CONTROL_ALTERATION); } - if (!VEC_empty (s390_watch_area, state->break_areas)) + if (!state->break_areas.empty ()) { /* Don't install hardware breakpoints while single-stepping, since our PER settings (e.g. the nullification bit) might then conflict @@ -762,12 +758,10 @@ s390_prepare_to_resume (struct lwp_info *lp) lp_priv->per_info_changed = 1; else { - for (ix = 0; - VEC_iterate (s390_watch_area, state->break_areas, ix, area); - ix++) + for (const auto &area : state->break_areas) { - watch_lo_addr = std::min (watch_lo_addr, area->lo_addr); - watch_hi_addr = std::max (watch_hi_addr, area->hi_addr); + watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); + watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); } /* If there's just one breakpoint, enable instruction-fetching @@ -812,16 +806,16 @@ s390_mark_per_info_changed (struct lwp_info *lp) /* When attaching to a new thread, mark its PER info as changed. */ -static void -s390_new_thread (struct lwp_info *lp) +void +s390_linux_nat_target::low_new_thread (struct lwp_info *lp) { s390_mark_per_info_changed (lp); } /* Function to call when a thread is being deleted. */ -static void -s390_delete_thread (struct arch_lwp_info *arch_lwp) +void +s390_linux_nat_target::low_delete_thread (struct arch_lwp_info *arch_lwp) { xfree (arch_lwp); } @@ -829,7 +823,7 @@ s390_delete_thread (struct arch_lwp_info *arch_lwp) /* Iterator callback for s390_refresh_per_info. */ static int -s390_refresh_per_info_cb (struct lwp_info *lp, void *arg) +s390_refresh_per_info_cb (struct lwp_info *lp) { s390_mark_per_info_changed (lp); @@ -843,9 +837,9 @@ s390_refresh_per_info_cb (struct lwp_info *lp, void *arg) static int s390_refresh_per_info (void) { - ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ())); + ptid_t pid_ptid = ptid_t (current_lwp_ptid ().pid ()); - iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb, NULL); + iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb); return 0; } @@ -854,13 +848,13 @@ s390_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, enum target_hw_bp_type type, struct expression *cond) { - s390_watch_area area; + watch_area area; struct s390_debug_reg_state *state - = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid)); + = s390_get_debug_reg_state (inferior_ptid.pid ()); area.lo_addr = addr; area.hi_addr = addr + len - 1; - VEC_safe_push (s390_watch_area, state->watch_areas, &area); + state->watch_areas.push_back (area); return s390_refresh_per_info (); } @@ -871,17 +865,15 @@ s390_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, struct expression *cond) { unsigned ix; - s390_watch_area *area; struct s390_debug_reg_state *state - = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid)); + = s390_get_debug_reg_state (inferior_ptid.pid ()); - for (ix = 0; - VEC_iterate (s390_watch_area, state->watch_areas, ix, area); - ix++) + for (ix = 0; ix < state->watch_areas.size (); ix++) { - if (area->lo_addr == addr && area->hi_addr == addr + len - 1) + watch_area &area = state->watch_areas[ix]; + if (area.lo_addr == addr && area.hi_addr == addr + len - 1) { - VEC_unordered_remove (s390_watch_area, state->watch_areas, ix); + unordered_remove (state->watch_areas, ix); return s390_refresh_per_info (); } } @@ -908,13 +900,13 @@ int s390_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { - s390_watch_area area; + watch_area area; struct s390_debug_reg_state *state; area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address; area.hi_addr = area.lo_addr; - state = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid)); - VEC_safe_push (s390_watch_area, state->break_areas, &area); + state = s390_get_debug_reg_state (inferior_ptid.pid ()); + state->break_areas.push_back (area); return s390_refresh_per_info (); } @@ -926,17 +918,15 @@ s390_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { unsigned ix; - struct watch_area *area; struct s390_debug_reg_state *state; - state = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid)); - for (ix = 0; - VEC_iterate (s390_watch_area, state->break_areas, ix, area); - ix++) + state = s390_get_debug_reg_state (inferior_ptid.pid ()); + for (ix = 0; state->break_areas.size (); ix++) { - if (area->lo_addr == bp_tgt->placed_address) + watch_area &area = state->break_areas[ix]; + if (area.lo_addr == bp_tgt->placed_address) { - VEC_unordered_remove (s390_watch_area, state->break_areas, ix); + unordered_remove (state->break_areas, ix); return s390_refresh_per_info (); } } @@ -1012,9 +1002,8 @@ s390_linux_nat_target::read_description () that mode, report s390 architecture with 64-bit GPRs. */ #ifdef __s390x__ { - CORE_ADDR hwcap = 0; + CORE_ADDR hwcap = linux_get_hwcap (current_top_target ()); - target_auxv_search (target_stack, AT_HWCAP, &hwcap); have_regset_tdb = (hwcap & HWCAP_S390_TE) && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset); @@ -1059,16 +1048,9 @@ s390_linux_nat_target::read_description () void _initialize_s390_nat (void) { - struct target_ops *t = &the_s390_linux_nat_target; - /* Register the target. */ linux_target = &the_s390_linux_nat_target; - add_target (t); - linux_nat_set_new_thread (t, s390_new_thread); - linux_nat_set_delete_thread (t, s390_delete_thread); - linux_nat_set_prepare_to_resume (t, s390_prepare_to_resume); - linux_nat_set_forget_process (t, s390_forget_process); - linux_nat_set_new_fork (t, s390_linux_new_fork); + add_inf_child_target (&the_s390_linux_nat_target); /* A maintenance command to enable showing the PER state. */ add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,