1 /* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright (C) 2001-2018 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;
57 static int have_regset_gs = 0;
59 /* Register map for 32-bit executables running under a 64-bit
63 static const struct regcache_map_entry s390_64_regmap_gregset[] =
65 /* Skip PSWM and PSWA, since they must be handled specially. */
66 { 2, REGCACHE_MAP_SKIP, 8 },
67 { 1, S390_R0_UPPER_REGNUM, 4 }, { 1, S390_R0_REGNUM, 4 },
68 { 1, S390_R1_UPPER_REGNUM, 4 }, { 1, S390_R1_REGNUM, 4 },
69 { 1, S390_R2_UPPER_REGNUM, 4 }, { 1, S390_R2_REGNUM, 4 },
70 { 1, S390_R3_UPPER_REGNUM, 4 }, { 1, S390_R3_REGNUM, 4 },
71 { 1, S390_R4_UPPER_REGNUM, 4 }, { 1, S390_R4_REGNUM, 4 },
72 { 1, S390_R5_UPPER_REGNUM, 4 }, { 1, S390_R5_REGNUM, 4 },
73 { 1, S390_R6_UPPER_REGNUM, 4 }, { 1, S390_R6_REGNUM, 4 },
74 { 1, S390_R7_UPPER_REGNUM, 4 }, { 1, S390_R7_REGNUM, 4 },
75 { 1, S390_R8_UPPER_REGNUM, 4 }, { 1, S390_R8_REGNUM, 4 },
76 { 1, S390_R9_UPPER_REGNUM, 4 }, { 1, S390_R9_REGNUM, 4 },
77 { 1, S390_R10_UPPER_REGNUM, 4 }, { 1, S390_R10_REGNUM, 4 },
78 { 1, S390_R11_UPPER_REGNUM, 4 }, { 1, S390_R11_REGNUM, 4 },
79 { 1, S390_R12_UPPER_REGNUM, 4 }, { 1, S390_R12_REGNUM, 4 },
80 { 1, S390_R13_UPPER_REGNUM, 4 }, { 1, S390_R13_REGNUM, 4 },
81 { 1, S390_R14_UPPER_REGNUM, 4 }, { 1, S390_R14_REGNUM, 4 },
82 { 1, S390_R15_UPPER_REGNUM, 4 }, { 1, S390_R15_REGNUM, 4 },
83 { 16, S390_A0_REGNUM, 4 },
84 { 1, REGCACHE_MAP_SKIP, 4 }, { 1, S390_ORIG_R2_REGNUM, 4 },
88 static const struct regset s390_64_gregset =
90 s390_64_regmap_gregset,
91 regcache_supply_regset,
92 regcache_collect_regset
95 #define S390_PSWM_OFFSET 0
96 #define S390_PSWA_OFFSET 8
99 /* PER-event mask bits and PER control bits (CR9). */
101 #define PER_BIT(n) (1UL << (63 - (n)))
102 #define PER_EVENT_BRANCH PER_BIT (32)
103 #define PER_EVENT_IFETCH PER_BIT (33)
104 #define PER_EVENT_STORE PER_BIT (34)
105 #define PER_EVENT_NULLIFICATION PER_BIT (39)
106 #define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40)
107 #define PER_CONTROL_SUSPENSION PER_BIT (41)
108 #define PER_CONTROL_ALTERATION PER_BIT (42)
111 /* Fill GDB's register array with the general-purpose register values
114 When debugging a 32-bit executable running under a 64-bit kernel,
115 we have to fix up the 64-bit registers we get from the kernel to
116 make them look like 32-bit registers. */
119 supply_gregset (struct regcache *regcache, const gregset_t *regp)
122 struct gdbarch *gdbarch = regcache->arch ();
123 if (gdbarch_ptr_bit (gdbarch) == 32)
125 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
129 regcache_supply_regset (&s390_64_gregset, regcache, -1,
130 regp, sizeof (gregset_t));
131 pswm = extract_unsigned_integer ((const gdb_byte *) regp
132 + S390_PSWM_OFFSET, 8, byte_order);
133 pswa = extract_unsigned_integer ((const gdb_byte *) regp
134 + S390_PSWA_OFFSET, 8, byte_order);
135 store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000);
136 regcache_raw_supply (regcache, S390_PSWM_REGNUM, buf);
137 store_unsigned_integer (buf, 4, byte_order,
138 (pswa & 0x7fffffff) | (pswm & 0x80000000));
139 regcache_raw_supply (regcache, S390_PSWA_REGNUM, buf);
144 regcache_supply_regset (&s390_gregset, regcache, -1, regp,
148 /* Fill register REGNO (if it is a general-purpose register) in
149 *REGP with the value in GDB's register array. If REGNO is -1,
150 do this for all registers. */
153 fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno)
156 struct gdbarch *gdbarch = regcache->arch ();
157 if (gdbarch_ptr_bit (gdbarch) == 32)
159 regcache_collect_regset (&s390_64_gregset, regcache, regno,
160 regp, sizeof (gregset_t));
163 || regno == S390_PSWM_REGNUM || regno == S390_PSWA_REGNUM)
165 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
168 gdb_byte *pswm_p = (gdb_byte *) regp + S390_PSWM_OFFSET;
169 gdb_byte *pswa_p = (gdb_byte *) regp + S390_PSWA_OFFSET;
171 pswm = extract_unsigned_integer (pswm_p, 8, byte_order);
173 if (regno == -1 || regno == S390_PSWM_REGNUM)
176 regcache_raw_collect (regcache, S390_PSWM_REGNUM, buf);
177 pswm |= (extract_unsigned_integer (buf, 4, byte_order)
181 if (regno == -1 || regno == S390_PSWA_REGNUM)
183 regcache_raw_collect (regcache, S390_PSWA_REGNUM, buf);
184 pswa = extract_unsigned_integer (buf, 4, byte_order);
185 pswm ^= (pswm ^ pswa) & 0x80000000;
187 store_unsigned_integer (pswa_p, 8, byte_order, pswa);
190 store_unsigned_integer (pswm_p, 8, byte_order, pswm);
196 regcache_collect_regset (&s390_gregset, regcache, regno, regp,
200 /* Fill GDB's register array with the floating-point register values
203 supply_fpregset (struct regcache *regcache, const fpregset_t *regp)
205 regcache_supply_regset (&s390_fpregset, regcache, -1, regp,
206 sizeof (fpregset_t));
209 /* Fill register REGNO (if it is a general-purpose register) in
210 *REGP with the value in GDB's register array. If REGNO is -1,
211 do this for all registers. */
213 fill_fpregset (const struct regcache *regcache, fpregset_t *regp, int regno)
215 regcache_collect_regset (&s390_fpregset, regcache, regno, regp,
216 sizeof (fpregset_t));
219 /* Find the TID for the current inferior thread to use with ptrace. */
221 s390_inferior_tid (void)
223 /* GNU/Linux LWP ID's are process ID's. */
224 int tid = ptid_get_lwp (inferior_ptid);
226 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
231 /* Fetch all general-purpose registers from process/thread TID and
232 store their values in GDB's register cache. */
234 fetch_regs (struct regcache *regcache, int tid)
239 parea.len = sizeof (regs);
240 parea.process_addr = (addr_t) ®s;
241 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
242 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
243 perror_with_name (_("Couldn't get registers"));
245 supply_gregset (regcache, (const gregset_t *) ®s);
248 /* Store all valid general-purpose registers in GDB's register cache
249 into the process/thread specified by TID. */
251 store_regs (const struct regcache *regcache, int tid, int regnum)
256 parea.len = sizeof (regs);
257 parea.process_addr = (addr_t) ®s;
258 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
259 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
260 perror_with_name (_("Couldn't get registers"));
262 fill_gregset (regcache, ®s, regnum);
264 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
265 perror_with_name (_("Couldn't write registers"));
268 /* Fetch all floating-point registers from process/thread TID and store
269 their values in GDB's register cache. */
271 fetch_fpregs (struct regcache *regcache, int tid)
276 parea.len = sizeof (fpregs);
277 parea.process_addr = (addr_t) &fpregs;
278 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
279 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
280 perror_with_name (_("Couldn't get floating point status"));
282 supply_fpregset (regcache, (const fpregset_t *) &fpregs);
285 /* Store all valid floating-point registers in GDB's register cache
286 into the process/thread specified by TID. */
288 store_fpregs (const struct regcache *regcache, int tid, int regnum)
293 parea.len = sizeof (fpregs);
294 parea.process_addr = (addr_t) &fpregs;
295 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
296 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
297 perror_with_name (_("Couldn't get floating point status"));
299 fill_fpregset (regcache, &fpregs, regnum);
301 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
302 perror_with_name (_("Couldn't write floating point status"));
305 /* Fetch all registers in the kernel's register set whose number is
306 REGSET_ID, whose size is REGSIZE, and whose layout is described by
307 REGSET, from process/thread TID and store their values in GDB's
310 fetch_regset (struct regcache *regcache, int tid,
311 int regset_id, int regsize, const struct regset *regset)
313 void *buf = alloca (regsize);
317 iov.iov_len = regsize;
319 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
321 if (errno == ENODATA)
322 regcache_supply_regset (regset, regcache, -1, NULL, regsize);
324 perror_with_name (_("Couldn't get register set"));
327 regcache_supply_regset (regset, regcache, -1, buf, regsize);
330 /* Store all registers in the kernel's register set whose number is
331 REGSET_ID, whose size is REGSIZE, and whose layout is described by
332 REGSET, from GDB's register cache back to process/thread TID. */
334 store_regset (struct regcache *regcache, int tid,
335 int regset_id, int regsize, const struct regset *regset)
337 void *buf = alloca (regsize);
341 iov.iov_len = regsize;
343 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
344 perror_with_name (_("Couldn't get register set"));
346 regcache_collect_regset (regset, regcache, -1, buf, regsize);
348 if (ptrace (PTRACE_SETREGSET, tid, (long) regset_id, (long) &iov) < 0)
349 perror_with_name (_("Couldn't set register set"));
352 /* Check whether the kernel provides a register set with number REGSET
353 of size REGSIZE for process/thread TID. */
355 check_regset (int tid, int regset, int regsize)
357 void *buf = alloca (regsize);
361 iov.iov_len = regsize;
363 if (ptrace (PTRACE_GETREGSET, tid, (long) regset, (long) &iov) >= 0
369 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
370 this for all registers. */
372 s390_linux_fetch_inferior_registers (struct target_ops *ops,
373 struct regcache *regcache, int regnum)
375 pid_t tid = get_ptrace_pid (regcache_get_ptid (regcache));
377 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
378 fetch_regs (regcache, tid);
380 if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum))
381 fetch_fpregs (regcache, tid);
383 if (have_regset_last_break)
384 if (regnum == -1 || regnum == S390_LAST_BREAK_REGNUM)
385 fetch_regset (regcache, tid, NT_S390_LAST_BREAK, 8,
386 (gdbarch_ptr_bit (regcache->arch ()) == 32
387 ? &s390_last_break_regset : &s390x_last_break_regset));
389 if (have_regset_system_call)
390 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
391 fetch_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
392 &s390_system_call_regset);
395 if (regnum == -1 || S390_IS_TDBREGSET_REGNUM (regnum))
396 fetch_regset (regcache, tid, NT_S390_TDB, s390_sizeof_tdbregset,
399 if (have_regset_vxrs)
401 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
402 && regnum <= S390_V15_LOWER_REGNUM))
403 fetch_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
404 &s390_vxrs_low_regset);
405 if (regnum == -1 || (regnum >= S390_V16_REGNUM
406 && regnum <= S390_V31_REGNUM))
407 fetch_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
408 &s390_vxrs_high_regset);
413 if (regnum == -1 || (regnum >= S390_GSD_REGNUM
414 && regnum <= S390_GSEPLA_REGNUM))
415 fetch_regset (regcache, tid, NT_S390_GS_CB, 4 * 8,
417 if (regnum == -1 || (regnum >= S390_BC_GSD_REGNUM
418 && regnum <= S390_BC_GSEPLA_REGNUM))
419 fetch_regset (regcache, tid, NT_S390_GS_BC, 4 * 8,
424 /* Store register REGNUM back into the child process. If REGNUM is
425 -1, do this for all registers. */
427 s390_linux_store_inferior_registers (struct target_ops *ops,
428 struct regcache *regcache, int regnum)
430 pid_t tid = get_ptrace_pid (regcache_get_ptid (regcache));
432 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
433 store_regs (regcache, tid, regnum);
435 if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum))
436 store_fpregs (regcache, tid, regnum);
438 /* S390_LAST_BREAK_REGNUM is read-only. */
440 if (have_regset_system_call)
441 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
442 store_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
443 &s390_system_call_regset);
445 if (have_regset_vxrs)
447 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
448 && regnum <= S390_V15_LOWER_REGNUM))
449 store_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
450 &s390_vxrs_low_regset);
451 if (regnum == -1 || (regnum >= S390_V16_REGNUM
452 && regnum <= S390_V31_REGNUM))
453 store_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
454 &s390_vxrs_high_regset);
459 /* Hardware-assisted watchpoint handling. */
461 /* For each process we maintain a list of all currently active
462 watchpoints, in order to properly handle watchpoint removal.
464 The only thing we actually need is the total address space area
465 spanned by the watchpoints. */
467 typedef struct watch_area
473 DEF_VEC_O (s390_watch_area);
475 /* Hardware debug state. */
477 struct s390_debug_reg_state
479 VEC_s390_watch_area *watch_areas;
480 VEC_s390_watch_area *break_areas;
483 /* Per-process data. */
485 struct s390_process_info
487 struct s390_process_info *next;
489 struct s390_debug_reg_state state;
492 static struct s390_process_info *s390_process_list = NULL;
494 /* Find process data for process PID. */
496 static struct s390_process_info *
497 s390_find_process_pid (pid_t pid)
499 struct s390_process_info *proc;
501 for (proc = s390_process_list; proc; proc = proc->next)
502 if (proc->pid == pid)
508 /* Add process data for process PID. Returns newly allocated info
511 static struct s390_process_info *
512 s390_add_process (pid_t pid)
514 struct s390_process_info *proc = XCNEW (struct s390_process_info);
517 proc->next = s390_process_list;
518 s390_process_list = proc;
523 /* Get data specific info for process PID, creating it if necessary.
524 Never returns NULL. */
526 static struct s390_process_info *
527 s390_process_info_get (pid_t pid)
529 struct s390_process_info *proc;
531 proc = s390_find_process_pid (pid);
533 proc = s390_add_process (pid);
538 /* Get hardware debug state for process PID. */
540 static struct s390_debug_reg_state *
541 s390_get_debug_reg_state (pid_t pid)
543 return &s390_process_info_get (pid)->state;
546 /* Called whenever GDB is no longer debugging process PID. It deletes
547 data structures that keep track of hardware debug state. */
550 s390_forget_process (pid_t pid)
552 struct s390_process_info *proc, **proc_link;
554 proc = s390_process_list;
555 proc_link = &s390_process_list;
559 if (proc->pid == pid)
561 VEC_free (s390_watch_area, proc->state.watch_areas);
562 VEC_free (s390_watch_area, proc->state.break_areas);
563 *proc_link = proc->next;
568 proc_link = &proc->next;
573 /* linux_nat_new_fork hook. */
576 s390_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
579 struct s390_debug_reg_state *parent_state;
580 struct s390_debug_reg_state *child_state;
582 /* NULL means no watchpoint has ever been set in the parent. In
583 that case, there's nothing to do. */
584 if (lwp_arch_private_info (parent) == NULL)
587 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of
588 the parent. So copy the debug state from parent to child. */
590 parent_pid = ptid_get_pid (parent->ptid);
591 parent_state = s390_get_debug_reg_state (parent_pid);
592 child_state = s390_get_debug_reg_state (child_pid);
594 child_state->watch_areas = VEC_copy (s390_watch_area,
595 parent_state->watch_areas);
596 child_state->break_areas = VEC_copy (s390_watch_area,
597 parent_state->break_areas);
600 /* Dump PER state. */
603 s390_show_debug_regs (int tid, const char *where)
608 parea.len = sizeof (per_info);
609 parea.process_addr = (addr_t) &per_info;
610 parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
612 if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea, 0) < 0)
613 perror_with_name (_("Couldn't retrieve debug regs"));
615 debug_printf ("PER (debug) state for %d -- %s\n"
616 " cr9-11: %lx %lx %lx\n"
617 " start, end: %lx %lx\n"
618 " code/ATMID: %x address: %lx PAID: %x\n",
621 per_info.control_regs.words.cr[0],
622 per_info.control_regs.words.cr[1],
623 per_info.control_regs.words.cr[2],
624 per_info.starting_addr,
625 per_info.ending_addr,
626 per_info.lowcore.words.perc_atmid,
627 per_info.lowcore.words.address,
628 per_info.lowcore.words.access_id);
632 s390_stopped_by_watchpoint (struct target_ops *ops)
634 struct s390_debug_reg_state *state
635 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
636 per_lowcore_bits per_lowcore;
641 s390_show_debug_regs (s390_inferior_tid (), "stop");
643 /* Speed up common case. */
644 if (VEC_empty (s390_watch_area, state->watch_areas))
647 parea.len = sizeof (per_lowcore);
648 parea.process_addr = (addr_t) & per_lowcore;
649 parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
650 if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
651 perror_with_name (_("Couldn't retrieve watchpoint status"));
653 result = (per_lowcore.perc_storage_alteration == 1
654 && per_lowcore.perc_store_real_address == 0);
658 /* Do not report this watchpoint again. */
659 memset (&per_lowcore, 0, sizeof (per_lowcore));
660 if (ptrace (PTRACE_POKEUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
661 perror_with_name (_("Couldn't clear watchpoint status"));
667 /* Each time before resuming a thread, update its PER info. */
670 s390_prepare_to_resume (struct lwp_info *lp)
673 pid_t pid = ptid_get_pid (ptid_of_lwp (lp));
678 CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0;
680 s390_watch_area *area;
681 struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp);
682 struct s390_debug_reg_state *state = s390_get_debug_reg_state (pid);
683 int step = lwp_is_stepping (lp);
685 /* Nothing to do if there was never any PER info for this thread. */
689 /* If PER info has changed, update it. When single-stepping, disable
690 hardware breakpoints (if any). Otherwise we're done. */
691 if (!lp_priv->per_info_changed)
693 if (!step || VEC_empty (s390_watch_area, state->break_areas))
697 lp_priv->per_info_changed = 0;
699 tid = ptid_get_lwp (ptid_of_lwp (lp));
703 parea.len = sizeof (per_info);
704 parea.process_addr = (addr_t) & per_info;
705 parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
707 /* Clear PER info, but adjust the single_step field (used by older
709 memset (&per_info, 0, sizeof (per_info));
710 per_info.single_step = (step != 0);
712 if (!VEC_empty (s390_watch_area, state->watch_areas))
715 VEC_iterate (s390_watch_area, state->watch_areas, ix, area);
718 watch_lo_addr = std::min (watch_lo_addr, area->lo_addr);
719 watch_hi_addr = std::max (watch_hi_addr, area->hi_addr);
722 /* Enable storage-alteration events. */
723 per_info.control_regs.words.cr[0] |= (PER_EVENT_STORE
724 | PER_CONTROL_ALTERATION);
727 if (!VEC_empty (s390_watch_area, state->break_areas))
729 /* Don't install hardware breakpoints while single-stepping, since
730 our PER settings (e.g. the nullification bit) might then conflict
731 with the kernel's. But re-install them afterwards. */
733 lp_priv->per_info_changed = 1;
737 VEC_iterate (s390_watch_area, state->break_areas, ix, area);
740 watch_lo_addr = std::min (watch_lo_addr, area->lo_addr);
741 watch_hi_addr = std::max (watch_hi_addr, area->hi_addr);
744 /* If there's just one breakpoint, enable instruction-fetching
745 nullification events for the breakpoint address (fast).
746 Otherwise stop after any instruction within the PER area and
747 after any branch into it (slow). */
748 if (watch_hi_addr == watch_lo_addr)
749 per_info.control_regs.words.cr[0] |= (PER_EVENT_NULLIFICATION
753 /* The PER area must include the instruction before the
754 first breakpoint address. */
755 watch_lo_addr = watch_lo_addr > 6 ? watch_lo_addr - 6 : 0;
756 per_info.control_regs.words.cr[0]
759 | PER_CONTROL_BRANCH_ADDRESS);
763 per_info.starting_addr = watch_lo_addr;
764 per_info.ending_addr = watch_hi_addr;
766 if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea, 0) < 0)
767 perror_with_name (_("Couldn't modify watchpoint status"));
770 s390_show_debug_regs (tid, "resume");
773 /* Mark the PER info as changed, so the next resume will update it. */
776 s390_mark_per_info_changed (struct lwp_info *lp)
778 if (lwp_arch_private_info (lp) == NULL)
779 lwp_set_arch_private_info (lp, XCNEW (struct arch_lwp_info));
781 lwp_arch_private_info (lp)->per_info_changed = 1;
784 /* When attaching to a new thread, mark its PER info as changed. */
787 s390_new_thread (struct lwp_info *lp)
789 s390_mark_per_info_changed (lp);
792 /* Function to call when a thread is being deleted. */
795 s390_delete_thread (struct arch_lwp_info *arch_lwp)
800 /* Iterator callback for s390_refresh_per_info. */
803 s390_refresh_per_info_cb (struct lwp_info *lp, void *arg)
805 s390_mark_per_info_changed (lp);
807 if (!lwp_is_stopped (lp))
812 /* Make sure that threads are stopped and mark PER info as changed. */
815 s390_refresh_per_info (void)
817 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
819 iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb, NULL);
824 s390_insert_watchpoint (struct target_ops *self,
825 CORE_ADDR addr, int len, enum target_hw_bp_type type,
826 struct expression *cond)
828 s390_watch_area area;
829 struct s390_debug_reg_state *state
830 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
833 area.hi_addr = addr + len - 1;
834 VEC_safe_push (s390_watch_area, state->watch_areas, &area);
836 return s390_refresh_per_info ();
840 s390_remove_watchpoint (struct target_ops *self,
841 CORE_ADDR addr, int len, enum target_hw_bp_type type,
842 struct expression *cond)
845 s390_watch_area *area;
846 struct s390_debug_reg_state *state
847 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
850 VEC_iterate (s390_watch_area, state->watch_areas, ix, area);
853 if (area->lo_addr == addr && area->hi_addr == addr + len - 1)
855 VEC_unordered_remove (s390_watch_area, state->watch_areas, ix);
856 return s390_refresh_per_info ();
860 fprintf_unfiltered (gdb_stderr,
861 "Attempt to remove nonexistent watchpoint.\n");
865 /* Implement the "can_use_hw_breakpoint" target_ops method. */
868 s390_can_use_hw_breakpoint (struct target_ops *self,
869 enum bptype type, int cnt, int othertype)
871 if (type == bp_hardware_watchpoint || type == bp_hardware_breakpoint)
876 /* Implement the "insert_hw_breakpoint" target_ops method. */
879 s390_insert_hw_breakpoint (struct target_ops *self,
880 struct gdbarch *gdbarch,
881 struct bp_target_info *bp_tgt)
883 s390_watch_area area;
884 struct s390_debug_reg_state *state;
886 area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
887 area.hi_addr = area.lo_addr;
888 state = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
889 VEC_safe_push (s390_watch_area, state->break_areas, &area);
891 return s390_refresh_per_info ();
894 /* Implement the "remove_hw_breakpoint" target_ops method. */
897 s390_remove_hw_breakpoint (struct target_ops *self,
898 struct gdbarch *gdbarch,
899 struct bp_target_info *bp_tgt)
902 struct watch_area *area;
903 struct s390_debug_reg_state *state;
905 state = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid));
907 VEC_iterate (s390_watch_area, state->break_areas, ix, area);
910 if (area->lo_addr == bp_tgt->placed_address)
912 VEC_unordered_remove (s390_watch_area, state->break_areas, ix);
913 return s390_refresh_per_info ();
917 fprintf_unfiltered (gdb_stderr,
918 "Attempt to remove nonexistent breakpoint.\n");
923 s390_region_ok_for_hw_watchpoint (struct target_ops *self,
924 CORE_ADDR addr, int cnt)
930 s390_target_wordsize (void)
934 /* Check for 64-bit inferior process. This is the case when the host is
935 64-bit, and in addition bit 32 of the PSW mask is set. */
940 pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0);
941 if (errno == 0 && (pswm & 0x100000000ul) != 0)
949 s390_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
950 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
952 int sizeof_auxv_field = s390_target_wordsize ();
953 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
954 gdb_byte *ptr = *readptr;
959 if (endptr - ptr < sizeof_auxv_field * 2)
962 *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
963 ptr += sizeof_auxv_field;
964 *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
965 ptr += sizeof_auxv_field;
971 static const struct target_desc *
972 s390_read_description (struct target_ops *ops)
974 int tid = s390_inferior_tid ();
976 have_regset_last_break
977 = check_regset (tid, NT_S390_LAST_BREAK, 8);
978 have_regset_system_call
979 = check_regset (tid, NT_S390_SYSTEM_CALL, 4);
981 /* If GDB itself is compiled as 64-bit, we are running on a machine in
982 z/Architecture mode. If the target is running in 64-bit addressing
983 mode, report s390x architecture. If the target is running in 31-bit
984 addressing mode, but the kernel supports using 64-bit registers in
985 that mode, report s390 architecture with 64-bit GPRs. */
990 target_auxv_search (¤t_target, AT_HWCAP, &hwcap);
991 have_regset_tdb = (hwcap & HWCAP_S390_TE)
992 && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset);
994 have_regset_vxrs = (hwcap & HWCAP_S390_VX)
995 && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8)
996 && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16);
998 have_regset_gs = (hwcap & HWCAP_S390_GS)
999 && check_regset (tid, NT_S390_GS_CB, 4 * 8)
1000 && check_regset (tid, NT_S390_GS_BC, 4 * 8);
1002 if (s390_target_wordsize () == 8)
1003 return (have_regset_gs ? tdesc_s390x_gs_linux64 :
1005 (have_regset_tdb ? tdesc_s390x_tevx_linux64 :
1006 tdesc_s390x_vx_linux64) :
1007 have_regset_tdb ? tdesc_s390x_te_linux64 :
1008 have_regset_system_call ? tdesc_s390x_linux64v2 :
1009 have_regset_last_break ? tdesc_s390x_linux64v1 :
1010 tdesc_s390x_linux64);
1012 if (hwcap & HWCAP_S390_HIGH_GPRS)
1013 return (have_regset_gs ? tdesc_s390_gs_linux64 :
1015 (have_regset_tdb ? tdesc_s390_tevx_linux64 :
1016 tdesc_s390_vx_linux64) :
1017 have_regset_tdb ? tdesc_s390_te_linux64 :
1018 have_regset_system_call ? tdesc_s390_linux64v2 :
1019 have_regset_last_break ? tdesc_s390_linux64v1 :
1020 tdesc_s390_linux64);
1024 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
1025 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
1026 mode, report s390 architecture with 32-bit GPRs. */
1027 return (have_regset_system_call? tdesc_s390_linux32v2 :
1028 have_regset_last_break? tdesc_s390_linux32v1 :
1029 tdesc_s390_linux32);
1033 _initialize_s390_nat (void)
1035 struct target_ops *t;
1037 /* Fill in the generic GNU/Linux methods. */
1038 t = linux_target ();
1040 /* Add our register access methods. */
1041 t->to_fetch_registers = s390_linux_fetch_inferior_registers;
1042 t->to_store_registers = s390_linux_store_inferior_registers;
1044 /* Add our watchpoint methods. */
1045 t->to_can_use_hw_breakpoint = s390_can_use_hw_breakpoint;
1046 t->to_insert_hw_breakpoint = s390_insert_hw_breakpoint;
1047 t->to_remove_hw_breakpoint = s390_remove_hw_breakpoint;
1048 t->to_region_ok_for_hw_watchpoint = s390_region_ok_for_hw_watchpoint;
1049 t->to_have_continuable_watchpoint = 1;
1050 t->to_stopped_by_watchpoint = s390_stopped_by_watchpoint;
1051 t->to_insert_watchpoint = s390_insert_watchpoint;
1052 t->to_remove_watchpoint = s390_remove_watchpoint;
1054 /* Detect target architecture. */
1055 t->to_read_description = s390_read_description;
1056 t->to_auxv_parse = s390_auxv_parse;
1058 /* Register the target. */
1059 linux_nat_add_target (t);
1060 linux_nat_set_new_thread (t, s390_new_thread);
1061 linux_nat_set_delete_thread (t, s390_delete_thread);
1062 linux_nat_set_prepare_to_resume (t, s390_prepare_to_resume);
1063 linux_nat_set_forget_process (t, s390_forget_process);
1064 linux_nat_set_new_fork (t, s390_linux_new_fork);
1066 /* A maintenance command to enable showing the PER state. */
1067 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
1068 &show_debug_regs, _("\
1069 Set whether to show the PER (debug) hardware state."), _("\
1070 Show whether to show the PER (debug) hardware state."), _("\
1071 Use \"on\" to enable, \"off\" to disable.\n\
1072 If enabled, the PER state is shown after it is changed by GDB,\n\
1073 and when the inferior triggers a breakpoint or watchpoint."),
1076 &maintenance_set_cmdlist,
1077 &maintenance_show_cmdlist);