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-tdep.h"
34 #include "s390-linux-tdep.h"
35 #include "elf/common.h"
37 #include <asm/ptrace.h>
38 #include "nat/gdb_ptrace.h"
39 #include <asm/types.h>
40 #include <sys/procfs.h>
41 #include <sys/ucontext.h>
44 #include "inf-ptrace.h"
46 /* Per-thread arch-specific data. */
50 /* Non-zero if the thread's PER info must be re-written. */
54 static int have_regset_last_break
= 0;
55 static int have_regset_system_call
= 0;
56 static int have_regset_tdb
= 0;
57 static int have_regset_vxrs
= 0;
58 static int have_regset_gs
= 0;
60 /* Register map for 32-bit executables running under a 64-bit
64 static const struct regcache_map_entry s390_64_regmap_gregset
[] =
66 /* Skip PSWM and PSWA, since they must be handled specially. */
67 { 2, REGCACHE_MAP_SKIP
, 8 },
68 { 1, S390_R0_UPPER_REGNUM
, 4 }, { 1, S390_R0_REGNUM
, 4 },
69 { 1, S390_R1_UPPER_REGNUM
, 4 }, { 1, S390_R1_REGNUM
, 4 },
70 { 1, S390_R2_UPPER_REGNUM
, 4 }, { 1, S390_R2_REGNUM
, 4 },
71 { 1, S390_R3_UPPER_REGNUM
, 4 }, { 1, S390_R3_REGNUM
, 4 },
72 { 1, S390_R4_UPPER_REGNUM
, 4 }, { 1, S390_R4_REGNUM
, 4 },
73 { 1, S390_R5_UPPER_REGNUM
, 4 }, { 1, S390_R5_REGNUM
, 4 },
74 { 1, S390_R6_UPPER_REGNUM
, 4 }, { 1, S390_R6_REGNUM
, 4 },
75 { 1, S390_R7_UPPER_REGNUM
, 4 }, { 1, S390_R7_REGNUM
, 4 },
76 { 1, S390_R8_UPPER_REGNUM
, 4 }, { 1, S390_R8_REGNUM
, 4 },
77 { 1, S390_R9_UPPER_REGNUM
, 4 }, { 1, S390_R9_REGNUM
, 4 },
78 { 1, S390_R10_UPPER_REGNUM
, 4 }, { 1, S390_R10_REGNUM
, 4 },
79 { 1, S390_R11_UPPER_REGNUM
, 4 }, { 1, S390_R11_REGNUM
, 4 },
80 { 1, S390_R12_UPPER_REGNUM
, 4 }, { 1, S390_R12_REGNUM
, 4 },
81 { 1, S390_R13_UPPER_REGNUM
, 4 }, { 1, S390_R13_REGNUM
, 4 },
82 { 1, S390_R14_UPPER_REGNUM
, 4 }, { 1, S390_R14_REGNUM
, 4 },
83 { 1, S390_R15_UPPER_REGNUM
, 4 }, { 1, S390_R15_REGNUM
, 4 },
84 { 16, S390_A0_REGNUM
, 4 },
85 { 1, REGCACHE_MAP_SKIP
, 4 }, { 1, S390_ORIG_R2_REGNUM
, 4 },
89 static const struct regset s390_64_gregset
=
91 s390_64_regmap_gregset
,
92 regcache_supply_regset
,
93 regcache_collect_regset
96 #define S390_PSWM_OFFSET 0
97 #define S390_PSWA_OFFSET 8
100 /* PER-event mask bits and PER control bits (CR9). */
102 #define PER_BIT(n) (1UL << (63 - (n)))
103 #define PER_EVENT_BRANCH PER_BIT (32)
104 #define PER_EVENT_IFETCH PER_BIT (33)
105 #define PER_EVENT_STORE PER_BIT (34)
106 #define PER_EVENT_NULLIFICATION PER_BIT (39)
107 #define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40)
108 #define PER_CONTROL_SUSPENSION PER_BIT (41)
109 #define PER_CONTROL_ALTERATION PER_BIT (42)
112 /* Fill GDB's register array with the general-purpose register values
115 When debugging a 32-bit executable running under a 64-bit kernel,
116 we have to fix up the 64-bit registers we get from the kernel to
117 make them look like 32-bit registers. */
120 supply_gregset (struct regcache
*regcache
, const gregset_t
*regp
)
123 struct gdbarch
*gdbarch
= regcache
->arch ();
124 if (gdbarch_ptr_bit (gdbarch
) == 32)
126 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
130 regcache_supply_regset (&s390_64_gregset
, regcache
, -1,
131 regp
, sizeof (gregset_t
));
132 pswm
= extract_unsigned_integer ((const gdb_byte
*) regp
133 + S390_PSWM_OFFSET
, 8, byte_order
);
134 pswa
= extract_unsigned_integer ((const gdb_byte
*) regp
135 + S390_PSWA_OFFSET
, 8, byte_order
);
136 store_unsigned_integer (buf
, 4, byte_order
, (pswm
>> 32) | 0x80000);
137 regcache_raw_supply (regcache
, S390_PSWM_REGNUM
, buf
);
138 store_unsigned_integer (buf
, 4, byte_order
,
139 (pswa
& 0x7fffffff) | (pswm
& 0x80000000));
140 regcache_raw_supply (regcache
, S390_PSWA_REGNUM
, buf
);
145 regcache_supply_regset (&s390_gregset
, regcache
, -1, regp
,
149 /* Fill register REGNO (if it is a general-purpose register) in
150 *REGP with the value in GDB's register array. If REGNO is -1,
151 do this for all registers. */
154 fill_gregset (const struct regcache
*regcache
, gregset_t
*regp
, int regno
)
157 struct gdbarch
*gdbarch
= regcache
->arch ();
158 if (gdbarch_ptr_bit (gdbarch
) == 32)
160 regcache_collect_regset (&s390_64_gregset
, regcache
, regno
,
161 regp
, sizeof (gregset_t
));
164 || regno
== S390_PSWM_REGNUM
|| regno
== S390_PSWA_REGNUM
)
166 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
169 gdb_byte
*pswm_p
= (gdb_byte
*) regp
+ S390_PSWM_OFFSET
;
170 gdb_byte
*pswa_p
= (gdb_byte
*) regp
+ S390_PSWA_OFFSET
;
172 pswm
= extract_unsigned_integer (pswm_p
, 8, byte_order
);
174 if (regno
== -1 || regno
== S390_PSWM_REGNUM
)
177 regcache_raw_collect (regcache
, S390_PSWM_REGNUM
, buf
);
178 pswm
|= (extract_unsigned_integer (buf
, 4, byte_order
)
182 if (regno
== -1 || regno
== S390_PSWA_REGNUM
)
184 regcache_raw_collect (regcache
, S390_PSWA_REGNUM
, buf
);
185 pswa
= extract_unsigned_integer (buf
, 4, byte_order
);
186 pswm
^= (pswm
^ pswa
) & 0x80000000;
188 store_unsigned_integer (pswa_p
, 8, byte_order
, pswa
);
191 store_unsigned_integer (pswm_p
, 8, byte_order
, pswm
);
197 regcache_collect_regset (&s390_gregset
, regcache
, regno
, regp
,
201 /* Fill GDB's register array with the floating-point register values
204 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*regp
)
206 regcache_supply_regset (&s390_fpregset
, regcache
, -1, regp
,
207 sizeof (fpregset_t
));
210 /* Fill register REGNO (if it is a general-purpose register) in
211 *REGP with the value in GDB's register array. If REGNO is -1,
212 do this for all registers. */
214 fill_fpregset (const struct regcache
*regcache
, fpregset_t
*regp
, int regno
)
216 regcache_collect_regset (&s390_fpregset
, regcache
, regno
, regp
,
217 sizeof (fpregset_t
));
220 /* Find the TID for the current inferior thread to use with ptrace. */
222 s390_inferior_tid (void)
224 /* GNU/Linux LWP ID's are process ID's. */
225 int tid
= ptid_get_lwp (inferior_ptid
);
227 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
232 /* Fetch all general-purpose registers from process/thread TID and
233 store their values in GDB's register cache. */
235 fetch_regs (struct regcache
*regcache
, int tid
)
240 parea
.len
= sizeof (regs
);
241 parea
.process_addr
= (addr_t
) ®s
;
242 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
243 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
244 perror_with_name (_("Couldn't get registers"));
246 supply_gregset (regcache
, (const gregset_t
*) ®s
);
249 /* Store all valid general-purpose registers in GDB's register cache
250 into the process/thread specified by TID. */
252 store_regs (const struct regcache
*regcache
, int tid
, int regnum
)
257 parea
.len
= sizeof (regs
);
258 parea
.process_addr
= (addr_t
) ®s
;
259 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
260 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
261 perror_with_name (_("Couldn't get registers"));
263 fill_gregset (regcache
, ®s
, regnum
);
265 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
, 0) < 0)
266 perror_with_name (_("Couldn't write registers"));
269 /* Fetch all floating-point registers from process/thread TID and store
270 their values in GDB's register cache. */
272 fetch_fpregs (struct regcache
*regcache
, int tid
)
277 parea
.len
= sizeof (fpregs
);
278 parea
.process_addr
= (addr_t
) &fpregs
;
279 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
280 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
281 perror_with_name (_("Couldn't get floating point status"));
283 supply_fpregset (regcache
, (const fpregset_t
*) &fpregs
);
286 /* Store all valid floating-point registers in GDB's register cache
287 into the process/thread specified by TID. */
289 store_fpregs (const struct regcache
*regcache
, int tid
, int regnum
)
294 parea
.len
= sizeof (fpregs
);
295 parea
.process_addr
= (addr_t
) &fpregs
;
296 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
297 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
298 perror_with_name (_("Couldn't get floating point status"));
300 fill_fpregset (regcache
, &fpregs
, regnum
);
302 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
, 0) < 0)
303 perror_with_name (_("Couldn't write floating point status"));
306 /* Fetch all registers in the kernel's register set whose number is
307 REGSET_ID, whose size is REGSIZE, and whose layout is described by
308 REGSET, from process/thread TID and store their values in GDB's
311 fetch_regset (struct regcache
*regcache
, int tid
,
312 int regset_id
, int regsize
, const struct regset
*regset
)
314 void *buf
= alloca (regsize
);
318 iov
.iov_len
= regsize
;
320 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
322 if (errno
== ENODATA
)
323 regcache_supply_regset (regset
, regcache
, -1, NULL
, regsize
);
325 perror_with_name (_("Couldn't get register set"));
328 regcache_supply_regset (regset
, regcache
, -1, buf
, regsize
);
331 /* Store all registers in the kernel's register set whose number is
332 REGSET_ID, whose size is REGSIZE, and whose layout is described by
333 REGSET, from GDB's register cache back to process/thread TID. */
335 store_regset (struct regcache
*regcache
, int tid
,
336 int regset_id
, int regsize
, const struct regset
*regset
)
338 void *buf
= alloca (regsize
);
342 iov
.iov_len
= regsize
;
344 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
345 perror_with_name (_("Couldn't get register set"));
347 regcache_collect_regset (regset
, regcache
, -1, buf
, regsize
);
349 if (ptrace (PTRACE_SETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
350 perror_with_name (_("Couldn't set register set"));
353 /* Check whether the kernel provides a register set with number REGSET
354 of size REGSIZE for process/thread TID. */
356 check_regset (int tid
, int regset
, int regsize
)
358 void *buf
= alloca (regsize
);
362 iov
.iov_len
= regsize
;
364 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset
, (long) &iov
) >= 0
370 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
371 this for all registers. */
373 s390_linux_fetch_inferior_registers (struct target_ops
*ops
,
374 struct regcache
*regcache
, int regnum
)
376 pid_t tid
= get_ptrace_pid (regcache_get_ptid (regcache
));
378 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
379 fetch_regs (regcache
, tid
);
381 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
382 fetch_fpregs (regcache
, tid
);
384 if (have_regset_last_break
)
385 if (regnum
== -1 || regnum
== S390_LAST_BREAK_REGNUM
)
386 fetch_regset (regcache
, tid
, NT_S390_LAST_BREAK
, 8,
387 (gdbarch_ptr_bit (regcache
->arch ()) == 32
388 ? &s390_last_break_regset
: &s390x_last_break_regset
));
390 if (have_regset_system_call
)
391 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
392 fetch_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
393 &s390_system_call_regset
);
396 if (regnum
== -1 || S390_IS_TDBREGSET_REGNUM (regnum
))
397 fetch_regset (regcache
, tid
, NT_S390_TDB
, s390_sizeof_tdbregset
,
400 if (have_regset_vxrs
)
402 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
403 && regnum
<= S390_V15_LOWER_REGNUM
))
404 fetch_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
405 &s390_vxrs_low_regset
);
406 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
407 && regnum
<= S390_V31_REGNUM
))
408 fetch_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
409 &s390_vxrs_high_regset
);
414 if (regnum
== -1 || (regnum
>= S390_GSD_REGNUM
415 && regnum
<= S390_GSEPLA_REGNUM
))
416 fetch_regset (regcache
, tid
, NT_S390_GS_CB
, 4 * 8,
418 if (regnum
== -1 || (regnum
>= S390_BC_GSD_REGNUM
419 && regnum
<= S390_BC_GSEPLA_REGNUM
))
420 fetch_regset (regcache
, tid
, NT_S390_GS_BC
, 4 * 8,
425 /* Store register REGNUM back into the child process. If REGNUM is
426 -1, do this for all registers. */
428 s390_linux_store_inferior_registers (struct target_ops
*ops
,
429 struct regcache
*regcache
, int regnum
)
431 pid_t tid
= get_ptrace_pid (regcache_get_ptid (regcache
));
433 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
434 store_regs (regcache
, tid
, regnum
);
436 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
437 store_fpregs (regcache
, tid
, regnum
);
439 /* S390_LAST_BREAK_REGNUM is read-only. */
441 if (have_regset_system_call
)
442 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
443 store_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
444 &s390_system_call_regset
);
446 if (have_regset_vxrs
)
448 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
449 && regnum
<= S390_V15_LOWER_REGNUM
))
450 store_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
451 &s390_vxrs_low_regset
);
452 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
453 && regnum
<= S390_V31_REGNUM
))
454 store_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
455 &s390_vxrs_high_regset
);
460 /* Hardware-assisted watchpoint handling. */
462 /* For each process we maintain a list of all currently active
463 watchpoints, in order to properly handle watchpoint removal.
465 The only thing we actually need is the total address space area
466 spanned by the watchpoints. */
468 typedef struct watch_area
474 DEF_VEC_O (s390_watch_area
);
476 /* Hardware debug state. */
478 struct s390_debug_reg_state
480 VEC_s390_watch_area
*watch_areas
;
481 VEC_s390_watch_area
*break_areas
;
484 /* Per-process data. */
486 struct s390_process_info
488 struct s390_process_info
*next
;
490 struct s390_debug_reg_state state
;
493 static struct s390_process_info
*s390_process_list
= NULL
;
495 /* Find process data for process PID. */
497 static struct s390_process_info
*
498 s390_find_process_pid (pid_t pid
)
500 struct s390_process_info
*proc
;
502 for (proc
= s390_process_list
; proc
; proc
= proc
->next
)
503 if (proc
->pid
== pid
)
509 /* Add process data for process PID. Returns newly allocated info
512 static struct s390_process_info
*
513 s390_add_process (pid_t pid
)
515 struct s390_process_info
*proc
= XCNEW (struct s390_process_info
);
518 proc
->next
= s390_process_list
;
519 s390_process_list
= proc
;
524 /* Get data specific info for process PID, creating it if necessary.
525 Never returns NULL. */
527 static struct s390_process_info
*
528 s390_process_info_get (pid_t pid
)
530 struct s390_process_info
*proc
;
532 proc
= s390_find_process_pid (pid
);
534 proc
= s390_add_process (pid
);
539 /* Get hardware debug state for process PID. */
541 static struct s390_debug_reg_state
*
542 s390_get_debug_reg_state (pid_t pid
)
544 return &s390_process_info_get (pid
)->state
;
547 /* Called whenever GDB is no longer debugging process PID. It deletes
548 data structures that keep track of hardware debug state. */
551 s390_forget_process (pid_t pid
)
553 struct s390_process_info
*proc
, **proc_link
;
555 proc
= s390_process_list
;
556 proc_link
= &s390_process_list
;
560 if (proc
->pid
== pid
)
562 VEC_free (s390_watch_area
, proc
->state
.watch_areas
);
563 VEC_free (s390_watch_area
, proc
->state
.break_areas
);
564 *proc_link
= proc
->next
;
569 proc_link
= &proc
->next
;
574 /* linux_nat_new_fork hook. */
577 s390_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
580 struct s390_debug_reg_state
*parent_state
;
581 struct s390_debug_reg_state
*child_state
;
583 /* NULL means no watchpoint has ever been set in the parent. In
584 that case, there's nothing to do. */
585 if (lwp_arch_private_info (parent
) == NULL
)
588 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of
589 the parent. So copy the debug state from parent to child. */
591 parent_pid
= ptid_get_pid (parent
->ptid
);
592 parent_state
= s390_get_debug_reg_state (parent_pid
);
593 child_state
= s390_get_debug_reg_state (child_pid
);
595 child_state
->watch_areas
= VEC_copy (s390_watch_area
,
596 parent_state
->watch_areas
);
597 child_state
->break_areas
= VEC_copy (s390_watch_area
,
598 parent_state
->break_areas
);
601 /* Dump PER state. */
604 s390_show_debug_regs (int tid
, const char *where
)
609 parea
.len
= sizeof (per_info
);
610 parea
.process_addr
= (addr_t
) &per_info
;
611 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
613 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, &parea
, 0) < 0)
614 perror_with_name (_("Couldn't retrieve debug regs"));
616 debug_printf ("PER (debug) state for %d -- %s\n"
617 " cr9-11: %lx %lx %lx\n"
618 " start, end: %lx %lx\n"
619 " code/ATMID: %x address: %lx PAID: %x\n",
622 per_info
.control_regs
.words
.cr
[0],
623 per_info
.control_regs
.words
.cr
[1],
624 per_info
.control_regs
.words
.cr
[2],
625 per_info
.starting_addr
,
626 per_info
.ending_addr
,
627 per_info
.lowcore
.words
.perc_atmid
,
628 per_info
.lowcore
.words
.address
,
629 per_info
.lowcore
.words
.access_id
);
633 s390_stopped_by_watchpoint (struct target_ops
*ops
)
635 struct s390_debug_reg_state
*state
636 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
637 per_lowcore_bits per_lowcore
;
642 s390_show_debug_regs (s390_inferior_tid (), "stop");
644 /* Speed up common case. */
645 if (VEC_empty (s390_watch_area
, state
->watch_areas
))
648 parea
.len
= sizeof (per_lowcore
);
649 parea
.process_addr
= (addr_t
) & per_lowcore
;
650 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
651 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
652 perror_with_name (_("Couldn't retrieve watchpoint status"));
654 result
= (per_lowcore
.perc_storage_alteration
== 1
655 && per_lowcore
.perc_store_real_address
== 0);
659 /* Do not report this watchpoint again. */
660 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
661 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
662 perror_with_name (_("Couldn't clear watchpoint status"));
668 /* Each time before resuming a thread, update its PER info. */
671 s390_prepare_to_resume (struct lwp_info
*lp
)
674 pid_t pid
= ptid_get_pid (ptid_of_lwp (lp
));
679 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
681 s390_watch_area
*area
;
682 struct arch_lwp_info
*lp_priv
= lwp_arch_private_info (lp
);
683 struct s390_debug_reg_state
*state
= s390_get_debug_reg_state (pid
);
684 int step
= lwp_is_stepping (lp
);
686 /* Nothing to do if there was never any PER info for this thread. */
690 /* If PER info has changed, update it. When single-stepping, disable
691 hardware breakpoints (if any). Otherwise we're done. */
692 if (!lp_priv
->per_info_changed
)
694 if (!step
|| VEC_empty (s390_watch_area
, state
->break_areas
))
698 lp_priv
->per_info_changed
= 0;
700 tid
= ptid_get_lwp (ptid_of_lwp (lp
));
704 parea
.len
= sizeof (per_info
);
705 parea
.process_addr
= (addr_t
) & per_info
;
706 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
708 /* Clear PER info, but adjust the single_step field (used by older
710 memset (&per_info
, 0, sizeof (per_info
));
711 per_info
.single_step
= (step
!= 0);
713 if (!VEC_empty (s390_watch_area
, state
->watch_areas
))
716 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
719 watch_lo_addr
= std::min (watch_lo_addr
, area
->lo_addr
);
720 watch_hi_addr
= std::max (watch_hi_addr
, area
->hi_addr
);
723 /* Enable storage-alteration events. */
724 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_STORE
725 | PER_CONTROL_ALTERATION
);
728 if (!VEC_empty (s390_watch_area
, state
->break_areas
))
730 /* Don't install hardware breakpoints while single-stepping, since
731 our PER settings (e.g. the nullification bit) might then conflict
732 with the kernel's. But re-install them afterwards. */
734 lp_priv
->per_info_changed
= 1;
738 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
741 watch_lo_addr
= std::min (watch_lo_addr
, area
->lo_addr
);
742 watch_hi_addr
= std::max (watch_hi_addr
, area
->hi_addr
);
745 /* If there's just one breakpoint, enable instruction-fetching
746 nullification events for the breakpoint address (fast).
747 Otherwise stop after any instruction within the PER area and
748 after any branch into it (slow). */
749 if (watch_hi_addr
== watch_lo_addr
)
750 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_NULLIFICATION
754 /* The PER area must include the instruction before the
755 first breakpoint address. */
756 watch_lo_addr
= watch_lo_addr
> 6 ? watch_lo_addr
- 6 : 0;
757 per_info
.control_regs
.words
.cr
[0]
760 | PER_CONTROL_BRANCH_ADDRESS
);
764 per_info
.starting_addr
= watch_lo_addr
;
765 per_info
.ending_addr
= watch_hi_addr
;
767 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
, 0) < 0)
768 perror_with_name (_("Couldn't modify watchpoint status"));
771 s390_show_debug_regs (tid
, "resume");
774 /* Mark the PER info as changed, so the next resume will update it. */
777 s390_mark_per_info_changed (struct lwp_info
*lp
)
779 if (lwp_arch_private_info (lp
) == NULL
)
780 lwp_set_arch_private_info (lp
, XCNEW (struct arch_lwp_info
));
782 lwp_arch_private_info (lp
)->per_info_changed
= 1;
785 /* When attaching to a new thread, mark its PER info as changed. */
788 s390_new_thread (struct lwp_info
*lp
)
790 s390_mark_per_info_changed (lp
);
793 /* Function to call when a thread is being deleted. */
796 s390_delete_thread (struct arch_lwp_info
*arch_lwp
)
801 /* Iterator callback for s390_refresh_per_info. */
804 s390_refresh_per_info_cb (struct lwp_info
*lp
, void *arg
)
806 s390_mark_per_info_changed (lp
);
808 if (!lwp_is_stopped (lp
))
813 /* Make sure that threads are stopped and mark PER info as changed. */
816 s390_refresh_per_info (void)
818 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
820 iterate_over_lwps (pid_ptid
, s390_refresh_per_info_cb
, NULL
);
825 s390_insert_watchpoint (struct target_ops
*self
,
826 CORE_ADDR addr
, int len
, enum target_hw_bp_type type
,
827 struct expression
*cond
)
829 s390_watch_area area
;
830 struct s390_debug_reg_state
*state
831 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
834 area
.hi_addr
= addr
+ len
- 1;
835 VEC_safe_push (s390_watch_area
, state
->watch_areas
, &area
);
837 return s390_refresh_per_info ();
841 s390_remove_watchpoint (struct target_ops
*self
,
842 CORE_ADDR addr
, int len
, enum target_hw_bp_type type
,
843 struct expression
*cond
)
846 s390_watch_area
*area
;
847 struct s390_debug_reg_state
*state
848 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
851 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
854 if (area
->lo_addr
== addr
&& area
->hi_addr
== addr
+ len
- 1)
856 VEC_unordered_remove (s390_watch_area
, state
->watch_areas
, ix
);
857 return s390_refresh_per_info ();
861 fprintf_unfiltered (gdb_stderr
,
862 "Attempt to remove nonexistent watchpoint.\n");
866 /* Implement the "can_use_hw_breakpoint" target_ops method. */
869 s390_can_use_hw_breakpoint (struct target_ops
*self
,
870 enum bptype type
, int cnt
, int othertype
)
872 if (type
== bp_hardware_watchpoint
|| type
== bp_hardware_breakpoint
)
877 /* Implement the "insert_hw_breakpoint" target_ops method. */
880 s390_insert_hw_breakpoint (struct target_ops
*self
,
881 struct gdbarch
*gdbarch
,
882 struct bp_target_info
*bp_tgt
)
884 s390_watch_area area
;
885 struct s390_debug_reg_state
*state
;
887 area
.lo_addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
888 area
.hi_addr
= area
.lo_addr
;
889 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
890 VEC_safe_push (s390_watch_area
, state
->break_areas
, &area
);
892 return s390_refresh_per_info ();
895 /* Implement the "remove_hw_breakpoint" target_ops method. */
898 s390_remove_hw_breakpoint (struct target_ops
*self
,
899 struct gdbarch
*gdbarch
,
900 struct bp_target_info
*bp_tgt
)
903 struct watch_area
*area
;
904 struct s390_debug_reg_state
*state
;
906 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
908 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
911 if (area
->lo_addr
== bp_tgt
->placed_address
)
913 VEC_unordered_remove (s390_watch_area
, state
->break_areas
, ix
);
914 return s390_refresh_per_info ();
918 fprintf_unfiltered (gdb_stderr
,
919 "Attempt to remove nonexistent breakpoint.\n");
924 s390_region_ok_for_hw_watchpoint (struct target_ops
*self
,
925 CORE_ADDR addr
, int cnt
)
931 s390_target_wordsize (void)
935 /* Check for 64-bit inferior process. This is the case when the host is
936 64-bit, and in addition bit 32 of the PSW mask is set. */
941 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
942 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
950 s390_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
951 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
953 int sizeof_auxv_field
= s390_target_wordsize ();
954 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
955 gdb_byte
*ptr
= *readptr
;
960 if (endptr
- ptr
< sizeof_auxv_field
* 2)
963 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
964 ptr
+= sizeof_auxv_field
;
965 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
966 ptr
+= sizeof_auxv_field
;
972 static const struct target_desc
*
973 s390_read_description (struct target_ops
*ops
)
975 int tid
= s390_inferior_tid ();
977 have_regset_last_break
978 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
979 have_regset_system_call
980 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
982 /* If GDB itself is compiled as 64-bit, we are running on a machine in
983 z/Architecture mode. If the target is running in 64-bit addressing
984 mode, report s390x architecture. If the target is running in 31-bit
985 addressing mode, but the kernel supports using 64-bit registers in
986 that mode, report s390 architecture with 64-bit GPRs. */
991 target_auxv_search (¤t_target
, AT_HWCAP
, &hwcap
);
992 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
993 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
995 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
996 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
997 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
999 have_regset_gs
= (hwcap
& HWCAP_S390_GS
)
1000 && check_regset (tid
, NT_S390_GS_CB
, 4 * 8)
1001 && check_regset (tid
, NT_S390_GS_BC
, 4 * 8);
1003 if (s390_target_wordsize () == 8)
1004 return (have_regset_gs
? tdesc_s390x_gs_linux64
:
1006 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
1007 tdesc_s390x_vx_linux64
) :
1008 have_regset_tdb
? tdesc_s390x_te_linux64
:
1009 have_regset_system_call
? tdesc_s390x_linux64v2
:
1010 have_regset_last_break
? tdesc_s390x_linux64v1
:
1011 tdesc_s390x_linux64
);
1013 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
1014 return (have_regset_gs
? tdesc_s390_gs_linux64
:
1016 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
1017 tdesc_s390_vx_linux64
) :
1018 have_regset_tdb
? tdesc_s390_te_linux64
:
1019 have_regset_system_call
? tdesc_s390_linux64v2
:
1020 have_regset_last_break
? tdesc_s390_linux64v1
:
1021 tdesc_s390_linux64
);
1025 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
1026 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
1027 mode, report s390 architecture with 32-bit GPRs. */
1028 return (have_regset_system_call
? tdesc_s390_linux32v2
:
1029 have_regset_last_break
? tdesc_s390_linux32v1
:
1030 tdesc_s390_linux32
);
1034 _initialize_s390_nat (void)
1036 struct target_ops
*t
;
1038 /* Fill in the generic GNU/Linux methods. */
1039 t
= linux_target ();
1041 /* Add our register access methods. */
1042 t
->to_fetch_registers
= s390_linux_fetch_inferior_registers
;
1043 t
->to_store_registers
= s390_linux_store_inferior_registers
;
1045 /* Add our watchpoint methods. */
1046 t
->to_can_use_hw_breakpoint
= s390_can_use_hw_breakpoint
;
1047 t
->to_insert_hw_breakpoint
= s390_insert_hw_breakpoint
;
1048 t
->to_remove_hw_breakpoint
= s390_remove_hw_breakpoint
;
1049 t
->to_region_ok_for_hw_watchpoint
= s390_region_ok_for_hw_watchpoint
;
1050 t
->to_have_continuable_watchpoint
= 1;
1051 t
->to_stopped_by_watchpoint
= s390_stopped_by_watchpoint
;
1052 t
->to_insert_watchpoint
= s390_insert_watchpoint
;
1053 t
->to_remove_watchpoint
= s390_remove_watchpoint
;
1055 /* Detect target architecture. */
1056 t
->to_read_description
= s390_read_description
;
1057 t
->to_auxv_parse
= s390_auxv_parse
;
1059 /* Register the target. */
1060 linux_nat_add_target (t
);
1061 linux_nat_set_new_thread (t
, s390_new_thread
);
1062 linux_nat_set_delete_thread (t
, s390_delete_thread
);
1063 linux_nat_set_prepare_to_resume (t
, s390_prepare_to_resume
);
1064 linux_nat_set_forget_process (t
, s390_forget_process
);
1065 linux_nat_set_new_fork (t
, s390_linux_new_fork
);
1067 /* A maintenance command to enable showing the PER state. */
1068 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
1069 &show_debug_regs
, _("\
1070 Set whether to show the PER (debug) hardware state."), _("\
1071 Show whether to show the PER (debug) hardware state."), _("\
1072 Use \"on\" to enable, \"off\" to disable.\n\
1073 If enabled, the PER state is shown after it is changed by GDB,\n\
1074 and when the inferior triggers a breakpoint or watchpoint."),
1077 &maintenance_set_cmdlist
,
1078 &maintenance_show_cmdlist
);