1 /* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
4 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
5 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "linux-nat.h"
30 #include "nat/linux-ptrace.h"
33 #include "s390-linux-tdep.h"
34 #include "elf/common.h"
36 #include <asm/ptrace.h>
37 #include "nat/gdb_ptrace.h"
38 #include <asm/types.h>
39 #include <sys/procfs.h>
40 #include <sys/ucontext.h>
43 #include "inf-ptrace.h"
45 /* Per-thread arch-specific data. */
49 /* Non-zero if the thread's PER info must be re-written. */
53 static int have_regset_last_break = 0;
54 static int have_regset_system_call = 0;
55 static int have_regset_tdb = 0;
56 static int have_regset_vxrs = 0;
58 /* Register map for 32-bit executables running under a 64-bit
62 static const struct regcache_map_entry s390_64_regmap_gregset[] =
64 /* Skip PSWM and PSWA, since they must be handled specially. */
65 { 2, REGCACHE_MAP_SKIP, 8 },
66 { 1, S390_R0_UPPER_REGNUM, 4 }, { 1, S390_R0_REGNUM, 4 },
67 { 1, S390_R1_UPPER_REGNUM, 4 }, { 1, S390_R1_REGNUM, 4 },
68 { 1, S390_R2_UPPER_REGNUM, 4 }, { 1, S390_R2_REGNUM, 4 },
69 { 1, S390_R3_UPPER_REGNUM, 4 }, { 1, S390_R3_REGNUM, 4 },
70 { 1, S390_R4_UPPER_REGNUM, 4 }, { 1, S390_R4_REGNUM, 4 },
71 { 1, S390_R5_UPPER_REGNUM, 4 }, { 1, S390_R5_REGNUM, 4 },
72 { 1, S390_R6_UPPER_REGNUM, 4 }, { 1, S390_R6_REGNUM, 4 },
73 { 1, S390_R7_UPPER_REGNUM, 4 }, { 1, S390_R7_REGNUM, 4 },
74 { 1, S390_R8_UPPER_REGNUM, 4 }, { 1, S390_R8_REGNUM, 4 },
75 { 1, S390_R9_UPPER_REGNUM, 4 }, { 1, S390_R9_REGNUM, 4 },
76 { 1, S390_R10_UPPER_REGNUM, 4 }, { 1, S390_R10_REGNUM, 4 },
77 { 1, S390_R11_UPPER_REGNUM, 4 }, { 1, S390_R11_REGNUM, 4 },
78 { 1, S390_R12_UPPER_REGNUM, 4 }, { 1, S390_R12_REGNUM, 4 },
79 { 1, S390_R13_UPPER_REGNUM, 4 }, { 1, S390_R13_REGNUM, 4 },
80 { 1, S390_R14_UPPER_REGNUM, 4 }, { 1, S390_R14_REGNUM, 4 },
81 { 1, S390_R15_UPPER_REGNUM, 4 }, { 1, S390_R15_REGNUM, 4 },
82 { 16, S390_A0_REGNUM, 4 },
83 { 1, REGCACHE_MAP_SKIP, 4 }, { 1, S390_ORIG_R2_REGNUM, 4 },
87 static const struct regset s390_64_gregset =
89 s390_64_regmap_gregset,
90 regcache_supply_regset,
91 regcache_collect_regset
94 #define S390_PSWM_OFFSET 0
95 #define S390_PSWA_OFFSET 8
98 /* PER-event mask bits and PER control bits (CR9). */
100 #define PER_BIT(n) (1UL << (63 - (n)))
101 #define PER_EVENT_BRANCH PER_BIT (32)
102 #define PER_EVENT_IFETCH PER_BIT (33)
103 #define PER_EVENT_STORE PER_BIT (34)
104 #define PER_EVENT_NULLIFICATION PER_BIT (39)
105 #define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40)
106 #define PER_CONTROL_SUSPENSION PER_BIT (41)
107 #define PER_CONTROL_ALTERATION PER_BIT (42)
110 /* Fill GDB's register array with the general-purpose register values
113 When debugging a 32-bit executable running under a 64-bit kernel,
114 we have to fix up the 64-bit registers we get from the kernel to
115 make them look like 32-bit registers. */
118 supply_gregset (struct regcache *regcache, const gregset_t *regp)
121 struct gdbarch *gdbarch = get_regcache_arch (regcache);
122 if (gdbarch_ptr_bit (gdbarch) == 32)
124 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
128 regcache_supply_regset (&s390_64_gregset, regcache, -1,
129 regp, sizeof (gregset_t));
130 pswm = extract_unsigned_integer ((const gdb_byte *) regp
131 + S390_PSWM_OFFSET, 8, byte_order);
132 pswa = extract_unsigned_integer ((const gdb_byte *) regp
133 + S390_PSWA_OFFSET, 8, byte_order);
134 store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000);
135 regcache_raw_supply (regcache, S390_PSWM_REGNUM, buf);
136 store_unsigned_integer (buf, 4, byte_order,
137 (pswa & 0x7fffffff) | (pswm & 0x80000000));
138 regcache_raw_supply (regcache, S390_PSWA_REGNUM, buf);
143 regcache_supply_regset (&s390_gregset, regcache, -1, regp,
147 /* Fill register REGNO (if it is a general-purpose register) in
148 *REGP with the value in GDB's register array. If REGNO is -1,
149 do this for all registers. */
152 fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno)
155 struct gdbarch *gdbarch = get_regcache_arch (regcache);
156 if (gdbarch_ptr_bit (gdbarch) == 32)
158 regcache_collect_regset (&s390_64_gregset, regcache, regno,
159 regp, sizeof (gregset_t));
162 || regno == S390_PSWM_REGNUM || regno == S390_PSWA_REGNUM)
164 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
167 gdb_byte *pswm_p = (gdb_byte *) regp + S390_PSWM_OFFSET;
168 gdb_byte *pswa_p = (gdb_byte *) regp + S390_PSWA_OFFSET;
170 pswm = extract_unsigned_integer (pswm_p, 8, byte_order);
172 if (regno == -1 || regno == S390_PSWM_REGNUM)
175 regcache_raw_collect (regcache, S390_PSWM_REGNUM, buf);
176 pswm |= (extract_unsigned_integer (buf, 4, byte_order)
180 if (regno == -1 || regno == S390_PSWA_REGNUM)
182 regcache_raw_collect (regcache, S390_PSWA_REGNUM, buf);
183 pswa = extract_unsigned_integer (buf, 4, byte_order);
184 pswm ^= (pswm ^ pswa) & 0x80000000;
186 store_unsigned_integer (pswa_p, 8, byte_order, pswa);
189 store_unsigned_integer (pswm_p, 8, byte_order, pswm);
195 regcache_collect_regset (&s390_gregset, regcache, regno, regp,
199 /* Fill GDB's register array with the floating-point register values
202 supply_fpregset (struct regcache *regcache, const fpregset_t *regp)
204 regcache_supply_regset (&s390_fpregset, regcache, -1, regp,
205 sizeof (fpregset_t));
208 /* Fill register REGNO (if it is a general-purpose register) in
209 *REGP with the value in GDB's register array. If REGNO is -1,
210 do this for all registers. */
212 fill_fpregset (const struct regcache *regcache, fpregset_t *regp, int regno)
214 regcache_collect_regset (&s390_fpregset, regcache, regno, regp,
215 sizeof (fpregset_t));
218 /* Find the TID for the current inferior thread to use with ptrace. */
220 s390_inferior_tid (void)
222 /* GNU/Linux LWP ID's are process ID's. */
223 int tid = ptid_get_lwp (inferior_ptid);
225 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
230 /* Fetch all general-purpose registers from process/thread TID and
231 store their values in GDB's register cache. */
233 fetch_regs (struct regcache *regcache, int tid)
238 parea.len = sizeof (regs);
239 parea.process_addr = (addr_t) ®s;
240 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
241 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
242 perror_with_name (_("Couldn't get registers"));
244 supply_gregset (regcache, (const gregset_t *) ®s);
247 /* Store all valid general-purpose registers in GDB's register cache
248 into the process/thread specified by TID. */
250 store_regs (const struct regcache *regcache, int tid, int regnum)
255 parea.len = sizeof (regs);
256 parea.process_addr = (addr_t) ®s;
257 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
258 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
259 perror_with_name (_("Couldn't get registers"));
261 fill_gregset (regcache, ®s, regnum);
263 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
264 perror_with_name (_("Couldn't write registers"));
267 /* Fetch all floating-point registers from process/thread TID and store
268 their values in GDB's register cache. */
270 fetch_fpregs (struct regcache *regcache, int tid)
275 parea.len = sizeof (fpregs);
276 parea.process_addr = (addr_t) &fpregs;
277 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
278 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
279 perror_with_name (_("Couldn't get floating point status"));
281 supply_fpregset (regcache, (const fpregset_t *) &fpregs);
284 /* Store all valid floating-point registers in GDB's register cache
285 into the process/thread specified by TID. */
287 store_fpregs (const struct regcache *regcache, int tid, int regnum)
292 parea.len = sizeof (fpregs);
293 parea.process_addr = (addr_t) &fpregs;
294 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
295 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
296 perror_with_name (_("Couldn't get floating point status"));
298 fill_fpregset (regcache, &fpregs, regnum);
300 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
301 perror_with_name (_("Couldn't write floating point status"));
304 /* Fetch all registers in the kernel's register set whose number is
305 REGSET_ID, whose size is REGSIZE, and whose layout is described by
306 REGSET, from process/thread TID and store their values in GDB's
309 fetch_regset (struct regcache *regcache, int tid,
310 int regset_id, int regsize, const struct regset *regset)
312 void *buf = alloca (regsize);
316 iov.iov_len = regsize;
318 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
320 if (errno == ENODATA)
321 regcache_supply_regset (regset, regcache, -1, NULL, regsize);
323 perror_with_name (_("Couldn't get register set"));
326 regcache_supply_regset (regset, regcache, -1, buf, regsize);
329 /* Store all registers in the kernel's register set whose number is
330 REGSET_ID, whose size is REGSIZE, and whose layout is described by
331 REGSET, from GDB's register cache back to process/thread TID. */
333 store_regset (struct regcache *regcache, int tid,
334 int regset_id, int regsize, const struct regset *regset)
336 void *buf = alloca (regsize);
340 iov.iov_len = regsize;
342 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
343 perror_with_name (_("Couldn't get register set"));
345 regcache_collect_regset (regset, regcache, -1, buf, regsize);
347 if (ptrace (PTRACE_SETREGSET, tid, (long) regset_id, (long) &iov) < 0)
348 perror_with_name (_("Couldn't set register set"));
351 /* Check whether the kernel provides a register set with number REGSET
352 of size REGSIZE for process/thread TID. */
354 check_regset (int tid, int regset, int regsize)
356 void *buf = alloca (regsize);
360 iov.iov_len = regsize;
362 if (ptrace (PTRACE_GETREGSET, tid, (long) regset, (long) &iov) >= 0
368 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
369 this for all registers. */
371 s390_linux_fetch_inferior_registers (struct target_ops *ops,
372 struct regcache *regcache, int regnum)
374 pid_t tid = get_ptrace_pid (regcache_get_ptid (regcache));
376 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
377 fetch_regs (regcache, tid);
379 if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum))
380 fetch_fpregs (regcache, tid);
382 if (have_regset_last_break)
383 if (regnum == -1 || regnum == S390_LAST_BREAK_REGNUM)
384 fetch_regset (regcache, tid, NT_S390_LAST_BREAK, 8,
385 (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32
386 ? &s390_last_break_regset : &s390x_last_break_regset));
388 if (have_regset_system_call)
389 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
390 fetch_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
391 &s390_system_call_regset);
394 if (regnum == -1 || S390_IS_TDBREGSET_REGNUM (regnum))
395 fetch_regset (regcache, tid, NT_S390_TDB, s390_sizeof_tdbregset,
398 if (have_regset_vxrs)
400 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
401 && regnum <= S390_V15_LOWER_REGNUM))
402 fetch_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
403 &s390_vxrs_low_regset);
404 if (regnum == -1 || (regnum >= S390_V16_REGNUM
405 && regnum <= S390_V31_REGNUM))
406 fetch_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
407 &s390_vxrs_high_regset);
411 /* Store register REGNUM back into the child process. If REGNUM is
412 -1, do this for all registers. */
414 s390_linux_store_inferior_registers (struct target_ops *ops,
415 struct regcache *regcache, int regnum)
417 pid_t tid = get_ptrace_pid (regcache_get_ptid (regcache));
419 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
420 store_regs (regcache, tid, regnum);
422 if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum))
423 store_fpregs (regcache, tid, regnum);
425 /* S390_LAST_BREAK_REGNUM is read-only. */
427 if (have_regset_system_call)
428 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
429 store_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
430 &s390_system_call_regset);
432 if (have_regset_vxrs)
434 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
435 && regnum <= S390_V15_LOWER_REGNUM))
436 store_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
437 &s390_vxrs_low_regset);
438 if (regnum == -1 || (regnum >= S390_V16_REGNUM
439 && regnum <= S390_V31_REGNUM))
440 store_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
441 &s390_vxrs_high_regset);
446 /* Hardware-assisted watchpoint handling. */
448 /* For each process we maintain a list of all currently active
449 watchpoints, in order to properly handle watchpoint removal.
451 The only thing we actually need is the total address space area
452 spanned by the watchpoints. */
454 typedef struct watch_area
460 DEF_VEC_O (s390_watch_area);
462 /* Hardware debug state. */
464 struct s390_debug_reg_state
466 VEC_s390_watch_area *watch_areas;
467 VEC_s390_watch_area *break_areas;
470 /* Per-process data. */
472 struct s390_process_info
474 struct s390_process_info *next;
476 struct s390_debug_reg_state state;
479 static struct s390_process_info *s390_process_list = NULL;
481 /* Find process data for process PID. */
483 static struct s390_process_info *
484 s390_find_process_pid (pid_t pid)
486 struct s390_process_info *proc;
488 for (proc = s390_process_list; proc; proc = proc->next)
489 if (proc->pid == pid)
495 /* Add process data for process PID. Returns newly allocated info
498 static struct s390_process_info *
499 s390_add_process (pid_t pid)
501 struct s390_process_info *proc = XCNEW (struct s390_process_info);
504 proc->next = s390_process_list;
505 s390_process_list = proc;
510 /* Get data specific info for process PID, creating it if necessary.
511 Never returns NULL. */
513 static struct s390_process_info *
514 s390_process_info_get (pid_t pid)
516 struct s390_process_info *proc;
518 proc = s390_find_process_pid (pid);
520 proc = s390_add_process (pid);
525 /* Get hardware debug state for process PID. */
527 static struct s390_debug_reg_state *
528 s390_get_debug_reg_state (pid_t pid)
530 return &s390_process_info_get (pid)->state;
533 /* Called whenever GDB is no longer debugging process PID. It deletes
534 data structures that keep track of hardware debug state. */
537 s390_forget_process (pid_t pid)
539 struct s390_process_info *proc, **proc_link;
541 proc = s390_process_list;
542 proc_link = &s390_process_list;
546 if (proc->pid == pid)
548 VEC_free (s390_watch_area, proc->state.watch_areas);
549 VEC_free (s390_watch_area, proc->state.break_areas);
550 *proc_link = proc->next;
555 proc_link = &proc->next;
560 /* linux_nat_new_fork hook. */
563 s390_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
566 struct s390_debug_reg_state *parent_state;
567 struct s390_debug_reg_state *child_state;
569 /* NULL means no watchpoint has ever been set in the parent. In
570 that case, there's nothing to do. */
571 if (lwp_arch_private_info (parent) == NULL)
574 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of
575 the parent. So copy the debug state from parent to child. */
577 parent_pid = ptid_get_pid (parent->ptid);
578 parent_state = s390_get_debug_reg_state (parent_pid);
579 child_state = s390_get_debug_reg_state (child_pid);
581 child_state->watch_areas = VEC_copy (s390_watch_area,
582 parent_state->watch_areas);
583 child_state->break_areas = VEC_copy (s390_watch_area,
584 parent_state->break_areas);
587 /* Dump PER state. */
590 s390_show_debug_regs (int tid, const char *where)
595 parea.len = sizeof (per_info);
596 parea.process_addr = (addr_t) &per_info;
597 parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
599 if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea, 0) < 0)
600 perror_with_name (_("Couldn't retrieve debug regs"));
602 debug_printf ("PER (debug) state for %d -- %s\n"
603 " cr9-11: %lx %lx %lx\n"
604 " start, end: %lx %lx\n"
605 " code/ATMID: %x address: %lx PAID: %x\n",
608 per_info.control_regs.words.cr[0],
609 per_info.control_regs.words.cr[1],
610 per_info.control_regs.words.cr[2],
611 per_info.starting_addr,
612 per_info.ending_addr,
613 per_info.lowcore.words.perc_atmid,
614 per_info.lowcore.words.address,
615 per_info.lowcore.words.access_id);
619 s390_stopped_by_watchpoint (struct target_ops *ops)
621 struct s390_debug_reg_state *state
622 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
623 per_lowcore_bits per_lowcore;
628 s390_show_debug_regs (s390_inferior_tid (), "stop");
630 /* Speed up common case. */
631 if (VEC_empty (s390_watch_area, state->watch_areas))
634 parea.len = sizeof (per_lowcore);
635 parea.process_addr = (addr_t) & per_lowcore;
636 parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
637 if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
638 perror_with_name (_("Couldn't retrieve watchpoint status"));
640 result = (per_lowcore.perc_storage_alteration == 1
641 && per_lowcore.perc_store_real_address == 0);
645 /* Do not report this watchpoint again. */
646 memset (&per_lowcore, 0, sizeof (per_lowcore));
647 if (ptrace (PTRACE_POKEUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
648 perror_with_name (_("Couldn't clear watchpoint status"));
654 /* Each time before resuming a thread, update its PER info. */
657 s390_prepare_to_resume (struct lwp_info *lp)
660 pid_t pid = ptid_get_pid (ptid_of_lwp (lp));
665 CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0;
667 s390_watch_area *area;
668 struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp);
669 struct s390_debug_reg_state *state = s390_get_debug_reg_state (pid);
670 int step = lwp_is_stepping (lp);
672 /* Nothing to do if there was never any PER info for this thread. */
676 /* If PER info has changed, update it. When single-stepping, disable
677 hardware breakpoints (if any). Otherwise we're done. */
678 if (!lp_priv->per_info_changed)
680 if (!step || VEC_empty (s390_watch_area, state->break_areas))
684 lp_priv->per_info_changed = 0;
686 tid = ptid_get_lwp (ptid_of_lwp (lp));
690 parea.len = sizeof (per_info);
691 parea.process_addr = (addr_t) & per_info;
692 parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
694 /* Clear PER info, but adjust the single_step field (used by older
696 memset (&per_info, 0, sizeof (per_info));
697 per_info.single_step = (step != 0);
699 if (!VEC_empty (s390_watch_area, state->watch_areas))
702 VEC_iterate (s390_watch_area, state->watch_areas, ix, area);
705 watch_lo_addr = std::min (watch_lo_addr, area->lo_addr);
706 watch_hi_addr = std::max (watch_hi_addr, area->hi_addr);
709 /* Enable storage-alteration events. */
710 per_info.control_regs.words.cr[0] |= (PER_EVENT_STORE
711 | PER_CONTROL_ALTERATION);
714 if (!VEC_empty (s390_watch_area, state->break_areas))
716 /* Don't install hardware breakpoints while single-stepping, since
717 our PER settings (e.g. the nullification bit) might then conflict
718 with the kernel's. But re-install them afterwards. */
720 lp_priv->per_info_changed = 1;
724 VEC_iterate (s390_watch_area, state->break_areas, ix, area);
727 watch_lo_addr = std::min (watch_lo_addr, area->lo_addr);
728 watch_hi_addr = std::max (watch_hi_addr, area->hi_addr);
731 /* If there's just one breakpoint, enable instruction-fetching
732 nullification events for the breakpoint address (fast).
733 Otherwise stop after any instruction within the PER area and
734 after any branch into it (slow). */
735 if (watch_hi_addr == watch_lo_addr)
736 per_info.control_regs.words.cr[0] |= (PER_EVENT_NULLIFICATION
740 /* The PER area must include the instruction before the
741 first breakpoint address. */
742 watch_lo_addr = watch_lo_addr > 6 ? watch_lo_addr - 6 : 0;
743 per_info.control_regs.words.cr[0]
746 | PER_CONTROL_BRANCH_ADDRESS);
750 per_info.starting_addr = watch_lo_addr;
751 per_info.ending_addr = watch_hi_addr;
753 if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea, 0) < 0)
754 perror_with_name (_("Couldn't modify watchpoint status"));
757 s390_show_debug_regs (tid, "resume");
760 /* Mark the PER info as changed, so the next resume will update it. */
763 s390_mark_per_info_changed (struct lwp_info *lp)
765 if (lwp_arch_private_info (lp) == NULL)
766 lwp_set_arch_private_info (lp, XCNEW (struct arch_lwp_info));
768 lwp_arch_private_info (lp)->per_info_changed = 1;
771 /* When attaching to a new thread, mark its PER info as changed. */
774 s390_new_thread (struct lwp_info *lp)
776 s390_mark_per_info_changed (lp);
779 /* Iterator callback for s390_refresh_per_info. */
782 s390_refresh_per_info_cb (struct lwp_info *lp, void *arg)
784 s390_mark_per_info_changed (lp);
786 if (!lwp_is_stopped (lp))
791 /* Make sure that threads are stopped and mark PER info as changed. */
794 s390_refresh_per_info (void)
796 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
798 iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb, NULL);
803 s390_insert_watchpoint (struct target_ops *self,
804 CORE_ADDR addr, int len, enum target_hw_bp_type type,
805 struct expression *cond)
807 s390_watch_area area;
808 struct s390_debug_reg_state *state
809 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
812 area.hi_addr = addr + len - 1;
813 VEC_safe_push (s390_watch_area, state->watch_areas, &area);
815 return s390_refresh_per_info ();
819 s390_remove_watchpoint (struct target_ops *self,
820 CORE_ADDR addr, int len, enum target_hw_bp_type type,
821 struct expression *cond)
824 s390_watch_area *area;
825 struct s390_debug_reg_state *state
826 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
829 VEC_iterate (s390_watch_area, state->watch_areas, ix, area);
832 if (area->lo_addr == addr && area->hi_addr == addr + len - 1)
834 VEC_unordered_remove (s390_watch_area, state->watch_areas, ix);
835 return s390_refresh_per_info ();
839 fprintf_unfiltered (gdb_stderr,
840 "Attempt to remove nonexistent watchpoint.\n");
844 /* Implement the "can_use_hw_breakpoint" target_ops method. */
847 s390_can_use_hw_breakpoint (struct target_ops *self,
848 enum bptype type, int cnt, int othertype)
850 if (type == bp_hardware_watchpoint || type == bp_hardware_breakpoint)
855 /* Implement the "insert_hw_breakpoint" target_ops method. */
858 s390_insert_hw_breakpoint (struct target_ops *self,
859 struct gdbarch *gdbarch,
860 struct bp_target_info *bp_tgt)
862 s390_watch_area area;
863 struct s390_debug_reg_state *state;
865 area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
866 area.hi_addr = area.lo_addr;
867 state = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
868 VEC_safe_push (s390_watch_area, state->break_areas, &area);
870 return s390_refresh_per_info ();
873 /* Implement the "remove_hw_breakpoint" target_ops method. */
876 s390_remove_hw_breakpoint (struct target_ops *self,
877 struct gdbarch *gdbarch,
878 struct bp_target_info *bp_tgt)
881 struct watch_area *area;
882 struct s390_debug_reg_state *state;
884 state = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
886 VEC_iterate (s390_watch_area, state->break_areas, ix, area);
889 if (area->lo_addr == bp_tgt->placed_address)
891 VEC_unordered_remove (s390_watch_area, state->break_areas, ix);
892 return s390_refresh_per_info ();
896 fprintf_unfiltered (gdb_stderr,
897 "Attempt to remove nonexistent breakpoint.\n");
902 s390_region_ok_for_hw_watchpoint (struct target_ops *self,
903 CORE_ADDR addr, int cnt)
909 s390_target_wordsize (void)
913 /* Check for 64-bit inferior process. This is the case when the host is
914 64-bit, and in addition bit 32 of the PSW mask is set. */
919 pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0);
920 if (errno == 0 && (pswm & 0x100000000ul) != 0)
928 s390_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
929 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
931 int sizeof_auxv_field = s390_target_wordsize ();
932 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
933 gdb_byte *ptr = *readptr;
938 if (endptr - ptr < sizeof_auxv_field * 2)
941 *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
942 ptr += sizeof_auxv_field;
943 *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
944 ptr += sizeof_auxv_field;
950 static const struct target_desc *
951 s390_read_description (struct target_ops *ops)
953 int tid = s390_inferior_tid ();
955 have_regset_last_break
956 = check_regset (tid, NT_S390_LAST_BREAK, 8);
957 have_regset_system_call
958 = check_regset (tid, NT_S390_SYSTEM_CALL, 4);
960 /* If GDB itself is compiled as 64-bit, we are running on a machine in
961 z/Architecture mode. If the target is running in 64-bit addressing
962 mode, report s390x architecture. If the target is running in 31-bit
963 addressing mode, but the kernel supports using 64-bit registers in
964 that mode, report s390 architecture with 64-bit GPRs. */
969 target_auxv_search (¤t_target, AT_HWCAP, &hwcap);
970 have_regset_tdb = (hwcap & HWCAP_S390_TE)
971 && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset);
973 have_regset_vxrs = (hwcap & HWCAP_S390_VX)
974 && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8)
975 && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16);
977 if (s390_target_wordsize () == 8)
978 return (have_regset_vxrs ?
979 (have_regset_tdb ? tdesc_s390x_tevx_linux64 :
980 tdesc_s390x_vx_linux64) :
981 have_regset_tdb ? tdesc_s390x_te_linux64 :
982 have_regset_system_call ? tdesc_s390x_linux64v2 :
983 have_regset_last_break ? tdesc_s390x_linux64v1 :
984 tdesc_s390x_linux64);
986 if (hwcap & HWCAP_S390_HIGH_GPRS)
987 return (have_regset_vxrs ?
988 (have_regset_tdb ? tdesc_s390_tevx_linux64 :
989 tdesc_s390_vx_linux64) :
990 have_regset_tdb ? tdesc_s390_te_linux64 :
991 have_regset_system_call ? tdesc_s390_linux64v2 :
992 have_regset_last_break ? tdesc_s390_linux64v1 :
997 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
998 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
999 mode, report s390 architecture with 32-bit GPRs. */
1000 return (have_regset_system_call? tdesc_s390_linux32v2 :
1001 have_regset_last_break? tdesc_s390_linux32v1 :
1002 tdesc_s390_linux32);
1005 void _initialize_s390_nat (void);
1008 _initialize_s390_nat (void)
1010 struct target_ops *t;
1012 /* Fill in the generic GNU/Linux methods. */
1013 t = linux_target ();
1015 /* Add our register access methods. */
1016 t->to_fetch_registers = s390_linux_fetch_inferior_registers;
1017 t->to_store_registers = s390_linux_store_inferior_registers;
1019 /* Add our watchpoint methods. */
1020 t->to_can_use_hw_breakpoint = s390_can_use_hw_breakpoint;
1021 t->to_insert_hw_breakpoint = s390_insert_hw_breakpoint;
1022 t->to_remove_hw_breakpoint = s390_remove_hw_breakpoint;
1023 t->to_region_ok_for_hw_watchpoint = s390_region_ok_for_hw_watchpoint;
1024 t->to_have_continuable_watchpoint = 1;
1025 t->to_stopped_by_watchpoint = s390_stopped_by_watchpoint;
1026 t->to_insert_watchpoint = s390_insert_watchpoint;
1027 t->to_remove_watchpoint = s390_remove_watchpoint;
1029 /* Detect target architecture. */
1030 t->to_read_description = s390_read_description;
1031 t->to_auxv_parse = s390_auxv_parse;
1033 /* Register the target. */
1034 linux_nat_add_target (t);
1035 linux_nat_set_new_thread (t, s390_new_thread);
1036 linux_nat_set_prepare_to_resume (t, s390_prepare_to_resume);
1037 linux_nat_set_forget_process (t, s390_forget_process);
1038 linux_nat_set_new_fork (t, s390_linux_new_fork);
1040 /* A maintenance command to enable showing the PER state. */
1041 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
1042 &show_debug_regs, _("\
1043 Set whether to show the PER (debug) hardware state."), _("\
1044 Show whether to show the PER (debug) hardware state."), _("\
1045 Use \"on\" to enable, \"off\" to disable.\n\
1046 If enabled, the PER state is shown after it is changed by GDB,\n\
1047 and when the inferior triggers a breakpoint or watchpoint."),
1050 &maintenance_set_cmdlist,
1051 &maintenance_show_cmdlist);