1 /* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright (C) 2001-2016 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 /* Per-thread arch-specific data. */
47 /* Non-zero if the thread's PER info must be re-written. */
51 static int have_regset_last_break
= 0;
52 static int have_regset_system_call
= 0;
53 static int have_regset_tdb
= 0;
54 static int have_regset_vxrs
= 0;
56 /* Register map for 32-bit executables running under a 64-bit
60 static const struct regcache_map_entry s390_64_regmap_gregset
[] =
62 /* Skip PSWM and PSWA, since they must be handled specially. */
63 { 2, REGCACHE_MAP_SKIP
, 8 },
64 { 1, S390_R0_UPPER_REGNUM
, 4 }, { 1, S390_R0_REGNUM
, 4 },
65 { 1, S390_R1_UPPER_REGNUM
, 4 }, { 1, S390_R1_REGNUM
, 4 },
66 { 1, S390_R2_UPPER_REGNUM
, 4 }, { 1, S390_R2_REGNUM
, 4 },
67 { 1, S390_R3_UPPER_REGNUM
, 4 }, { 1, S390_R3_REGNUM
, 4 },
68 { 1, S390_R4_UPPER_REGNUM
, 4 }, { 1, S390_R4_REGNUM
, 4 },
69 { 1, S390_R5_UPPER_REGNUM
, 4 }, { 1, S390_R5_REGNUM
, 4 },
70 { 1, S390_R6_UPPER_REGNUM
, 4 }, { 1, S390_R6_REGNUM
, 4 },
71 { 1, S390_R7_UPPER_REGNUM
, 4 }, { 1, S390_R7_REGNUM
, 4 },
72 { 1, S390_R8_UPPER_REGNUM
, 4 }, { 1, S390_R8_REGNUM
, 4 },
73 { 1, S390_R9_UPPER_REGNUM
, 4 }, { 1, S390_R9_REGNUM
, 4 },
74 { 1, S390_R10_UPPER_REGNUM
, 4 }, { 1, S390_R10_REGNUM
, 4 },
75 { 1, S390_R11_UPPER_REGNUM
, 4 }, { 1, S390_R11_REGNUM
, 4 },
76 { 1, S390_R12_UPPER_REGNUM
, 4 }, { 1, S390_R12_REGNUM
, 4 },
77 { 1, S390_R13_UPPER_REGNUM
, 4 }, { 1, S390_R13_REGNUM
, 4 },
78 { 1, S390_R14_UPPER_REGNUM
, 4 }, { 1, S390_R14_REGNUM
, 4 },
79 { 1, S390_R15_UPPER_REGNUM
, 4 }, { 1, S390_R15_REGNUM
, 4 },
80 { 16, S390_A0_REGNUM
, 4 },
81 { 1, REGCACHE_MAP_SKIP
, 4 }, { 1, S390_ORIG_R2_REGNUM
, 4 },
85 static const struct regset s390_64_gregset
=
87 s390_64_regmap_gregset
,
88 regcache_supply_regset
,
89 regcache_collect_regset
92 #define S390_PSWM_OFFSET 0
93 #define S390_PSWA_OFFSET 8
96 /* PER-event mask bits and PER control bits (CR9). */
98 #define PER_BIT(n) (1UL << (63 - (n)))
99 #define PER_EVENT_BRANCH PER_BIT (32)
100 #define PER_EVENT_IFETCH PER_BIT (33)
101 #define PER_EVENT_STORE PER_BIT (34)
102 #define PER_EVENT_NULLIFICATION PER_BIT (39)
103 #define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40)
104 #define PER_CONTROL_SUSPENSION PER_BIT (41)
105 #define PER_CONTROL_ALTERATION PER_BIT (42)
108 /* Fill GDB's register array with the general-purpose register values
111 When debugging a 32-bit executable running under a 64-bit kernel,
112 we have to fix up the 64-bit registers we get from the kernel to
113 make them look like 32-bit registers. */
116 supply_gregset (struct regcache
*regcache
, const gregset_t
*regp
)
119 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
120 if (gdbarch_ptr_bit (gdbarch
) == 32)
122 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
126 regcache_supply_regset (&s390_64_gregset
, regcache
, -1,
127 regp
, sizeof (gregset_t
));
128 pswm
= extract_unsigned_integer ((const gdb_byte
*) regp
129 + S390_PSWM_OFFSET
, 8, byte_order
);
130 pswa
= extract_unsigned_integer ((const gdb_byte
*) regp
131 + S390_PSWA_OFFSET
, 8, byte_order
);
132 store_unsigned_integer (buf
, 4, byte_order
, (pswm
>> 32) | 0x80000);
133 regcache_raw_supply (regcache
, S390_PSWM_REGNUM
, buf
);
134 store_unsigned_integer (buf
, 4, byte_order
,
135 (pswa
& 0x7fffffff) | (pswm
& 0x80000000));
136 regcache_raw_supply (regcache
, S390_PSWA_REGNUM
, buf
);
141 regcache_supply_regset (&s390_gregset
, regcache
, -1, regp
,
145 /* Fill register REGNO (if it is a general-purpose register) in
146 *REGP with the value in GDB's register array. If REGNO is -1,
147 do this for all registers. */
150 fill_gregset (const struct regcache
*regcache
, gregset_t
*regp
, int regno
)
153 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
154 if (gdbarch_ptr_bit (gdbarch
) == 32)
156 regcache_collect_regset (&s390_64_gregset
, regcache
, regno
,
157 regp
, sizeof (gregset_t
));
160 || regno
== S390_PSWM_REGNUM
|| regno
== S390_PSWA_REGNUM
)
162 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
165 gdb_byte
*pswm_p
= (gdb_byte
*) regp
+ S390_PSWM_OFFSET
;
166 gdb_byte
*pswa_p
= (gdb_byte
*) regp
+ S390_PSWA_OFFSET
;
168 pswm
= extract_unsigned_integer (pswm_p
, 8, byte_order
);
170 if (regno
== -1 || regno
== S390_PSWM_REGNUM
)
173 regcache_raw_collect (regcache
, S390_PSWM_REGNUM
, buf
);
174 pswm
|= (extract_unsigned_integer (buf
, 4, byte_order
)
178 if (regno
== -1 || regno
== S390_PSWA_REGNUM
)
180 regcache_raw_collect (regcache
, S390_PSWA_REGNUM
, buf
);
181 pswa
= extract_unsigned_integer (buf
, 4, byte_order
);
182 pswm
^= (pswm
^ pswa
) & 0x80000000;
184 store_unsigned_integer (pswa_p
, 8, byte_order
, pswa
);
187 store_unsigned_integer (pswm_p
, 8, byte_order
, pswm
);
193 regcache_collect_regset (&s390_gregset
, regcache
, regno
, regp
,
197 /* Fill GDB's register array with the floating-point register values
200 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*regp
)
202 regcache_supply_regset (&s390_fpregset
, regcache
, -1, regp
,
203 sizeof (fpregset_t
));
206 /* Fill register REGNO (if it is a general-purpose register) in
207 *REGP with the value in GDB's register array. If REGNO is -1,
208 do this for all registers. */
210 fill_fpregset (const struct regcache
*regcache
, fpregset_t
*regp
, int regno
)
212 regcache_collect_regset (&s390_fpregset
, regcache
, regno
, regp
,
213 sizeof (fpregset_t
));
216 /* Find the TID for the current inferior thread to use with ptrace. */
218 s390_inferior_tid (void)
220 /* GNU/Linux LWP ID's are process ID's. */
221 int tid
= ptid_get_lwp (inferior_ptid
);
223 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
228 /* Fetch all general-purpose registers from process/thread TID and
229 store their values in GDB's register cache. */
231 fetch_regs (struct regcache
*regcache
, int tid
)
236 parea
.len
= sizeof (regs
);
237 parea
.process_addr
= (addr_t
) ®s
;
238 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
239 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
240 perror_with_name (_("Couldn't get registers"));
242 supply_gregset (regcache
, (const gregset_t
*) ®s
);
245 /* Store all valid general-purpose registers in GDB's register cache
246 into the process/thread specified by TID. */
248 store_regs (const struct regcache
*regcache
, int tid
, int regnum
)
253 parea
.len
= sizeof (regs
);
254 parea
.process_addr
= (addr_t
) ®s
;
255 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
256 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
257 perror_with_name (_("Couldn't get registers"));
259 fill_gregset (regcache
, ®s
, regnum
);
261 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
, 0) < 0)
262 perror_with_name (_("Couldn't write registers"));
265 /* Fetch all floating-point registers from process/thread TID and store
266 their values in GDB's register cache. */
268 fetch_fpregs (struct regcache
*regcache
, int tid
)
273 parea
.len
= sizeof (fpregs
);
274 parea
.process_addr
= (addr_t
) &fpregs
;
275 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
276 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
277 perror_with_name (_("Couldn't get floating point status"));
279 supply_fpregset (regcache
, (const fpregset_t
*) &fpregs
);
282 /* Store all valid floating-point registers in GDB's register cache
283 into the process/thread specified by TID. */
285 store_fpregs (const struct regcache
*regcache
, int tid
, int regnum
)
290 parea
.len
= sizeof (fpregs
);
291 parea
.process_addr
= (addr_t
) &fpregs
;
292 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
293 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
294 perror_with_name (_("Couldn't get floating point status"));
296 fill_fpregset (regcache
, &fpregs
, regnum
);
298 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
, 0) < 0)
299 perror_with_name (_("Couldn't write floating point status"));
302 /* Fetch all registers in the kernel's register set whose number is
303 REGSET_ID, whose size is REGSIZE, and whose layout is described by
304 REGSET, from process/thread TID and store their values in GDB's
307 fetch_regset (struct regcache
*regcache
, int tid
,
308 int regset_id
, int regsize
, const struct regset
*regset
)
310 void *buf
= alloca (regsize
);
314 iov
.iov_len
= regsize
;
316 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
318 if (errno
== ENODATA
)
319 regcache_supply_regset (regset
, regcache
, -1, NULL
, regsize
);
321 perror_with_name (_("Couldn't get register set"));
324 regcache_supply_regset (regset
, regcache
, -1, buf
, regsize
);
327 /* Store all registers in the kernel's register set whose number is
328 REGSET_ID, whose size is REGSIZE, and whose layout is described by
329 REGSET, from GDB's register cache back to process/thread TID. */
331 store_regset (struct regcache
*regcache
, int tid
,
332 int regset_id
, int regsize
, const struct regset
*regset
)
334 void *buf
= alloca (regsize
);
338 iov
.iov_len
= regsize
;
340 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
341 perror_with_name (_("Couldn't get register set"));
343 regcache_collect_regset (regset
, regcache
, -1, buf
, regsize
);
345 if (ptrace (PTRACE_SETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
346 perror_with_name (_("Couldn't set register set"));
349 /* Check whether the kernel provides a register set with number REGSET
350 of size REGSIZE for process/thread TID. */
352 check_regset (int tid
, int regset
, int regsize
)
354 void *buf
= alloca (regsize
);
358 iov
.iov_len
= regsize
;
360 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset
, (long) &iov
) >= 0
366 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
367 this for all registers. */
369 s390_linux_fetch_inferior_registers (struct target_ops
*ops
,
370 struct regcache
*regcache
, int regnum
)
372 int tid
= s390_inferior_tid ();
374 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
375 fetch_regs (regcache
, tid
);
377 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
378 fetch_fpregs (regcache
, tid
);
380 if (have_regset_last_break
)
381 if (regnum
== -1 || regnum
== S390_LAST_BREAK_REGNUM
)
382 fetch_regset (regcache
, tid
, NT_S390_LAST_BREAK
, 8,
383 (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32
384 ? &s390_last_break_regset
: &s390x_last_break_regset
));
386 if (have_regset_system_call
)
387 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
388 fetch_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
389 &s390_system_call_regset
);
392 if (regnum
== -1 || S390_IS_TDBREGSET_REGNUM (regnum
))
393 fetch_regset (regcache
, tid
, NT_S390_TDB
, s390_sizeof_tdbregset
,
396 if (have_regset_vxrs
)
398 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
399 && regnum
<= S390_V15_LOWER_REGNUM
))
400 fetch_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
401 &s390_vxrs_low_regset
);
402 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
403 && regnum
<= S390_V31_REGNUM
))
404 fetch_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
405 &s390_vxrs_high_regset
);
409 /* Store register REGNUM back into the child process. If REGNUM is
410 -1, do this for all registers. */
412 s390_linux_store_inferior_registers (struct target_ops
*ops
,
413 struct regcache
*regcache
, int regnum
)
415 int tid
= s390_inferior_tid ();
417 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
418 store_regs (regcache
, tid
, regnum
);
420 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
421 store_fpregs (regcache
, tid
, regnum
);
423 /* S390_LAST_BREAK_REGNUM is read-only. */
425 if (have_regset_system_call
)
426 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
427 store_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
428 &s390_system_call_regset
);
430 if (have_regset_vxrs
)
432 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
433 && regnum
<= S390_V15_LOWER_REGNUM
))
434 store_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
435 &s390_vxrs_low_regset
);
436 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
437 && regnum
<= S390_V31_REGNUM
))
438 store_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
439 &s390_vxrs_high_regset
);
444 /* Hardware-assisted watchpoint handling. */
446 /* For each process we maintain a list of all currently active
447 watchpoints, in order to properly handle watchpoint removal.
449 The only thing we actually need is the total address space area
450 spanned by the watchpoints. */
452 typedef struct watch_area
458 DEF_VEC_O (s390_watch_area
);
460 /* Hardware debug state. */
462 struct s390_debug_reg_state
464 VEC_s390_watch_area
*watch_areas
;
465 VEC_s390_watch_area
*break_areas
;
468 /* Per-process data. */
470 struct s390_process_info
472 struct s390_process_info
*next
;
474 struct s390_debug_reg_state state
;
477 static struct s390_process_info
*s390_process_list
= NULL
;
479 /* Find process data for process PID. */
481 static struct s390_process_info
*
482 s390_find_process_pid (pid_t pid
)
484 struct s390_process_info
*proc
;
486 for (proc
= s390_process_list
; proc
; proc
= proc
->next
)
487 if (proc
->pid
== pid
)
493 /* Add process data for process PID. Returns newly allocated info
496 static struct s390_process_info
*
497 s390_add_process (pid_t pid
)
499 struct s390_process_info
*proc
= XCNEW (struct s390_process_info
);
502 proc
->next
= s390_process_list
;
503 s390_process_list
= proc
;
508 /* Get data specific info for process PID, creating it if necessary.
509 Never returns NULL. */
511 static struct s390_process_info
*
512 s390_process_info_get (pid_t pid
)
514 struct s390_process_info
*proc
;
516 proc
= s390_find_process_pid (pid
);
518 proc
= s390_add_process (pid
);
523 /* Get hardware debug state for process PID. */
525 static struct s390_debug_reg_state
*
526 s390_get_debug_reg_state (pid_t pid
)
528 return &s390_process_info_get (pid
)->state
;
531 /* Called whenever GDB is no longer debugging process PID. It deletes
532 data structures that keep track of hardware debug state. */
535 s390_forget_process (pid_t pid
)
537 struct s390_process_info
*proc
, **proc_link
;
539 proc
= s390_process_list
;
540 proc_link
= &s390_process_list
;
544 if (proc
->pid
== pid
)
546 VEC_free (s390_watch_area
, proc
->state
.watch_areas
);
547 VEC_free (s390_watch_area
, proc
->state
.break_areas
);
548 *proc_link
= proc
->next
;
553 proc_link
= &proc
->next
;
558 /* linux_nat_new_fork hook. */
561 s390_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
564 struct s390_debug_reg_state
*parent_state
;
565 struct s390_debug_reg_state
*child_state
;
567 /* NULL means no watchpoint has ever been set in the parent. In
568 that case, there's nothing to do. */
569 if (lwp_arch_private_info (parent
) == NULL
)
572 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of
573 the parent. So copy the debug state from parent to child. */
575 parent_pid
= ptid_get_pid (parent
->ptid
);
576 parent_state
= s390_get_debug_reg_state (parent_pid
);
577 child_state
= s390_get_debug_reg_state (child_pid
);
579 child_state
->watch_areas
= VEC_copy (s390_watch_area
,
580 parent_state
->watch_areas
);
581 child_state
->break_areas
= VEC_copy (s390_watch_area
,
582 parent_state
->break_areas
);
585 /* Dump PER state. */
588 s390_show_debug_regs (int tid
, const char *where
)
593 parea
.len
= sizeof (per_info
);
594 parea
.process_addr
= (addr_t
) &per_info
;
595 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
597 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, &parea
, 0) < 0)
598 perror_with_name (_("Couldn't retrieve debug regs"));
600 debug_printf ("PER (debug) state for %d -- %s\n"
601 " cr9-11: %lx %lx %lx\n"
602 " start, end: %lx %lx\n"
603 " code/ATMID: %x address: %lx PAID: %x\n",
606 per_info
.control_regs
.words
.cr
[0],
607 per_info
.control_regs
.words
.cr
[1],
608 per_info
.control_regs
.words
.cr
[2],
609 per_info
.starting_addr
,
610 per_info
.ending_addr
,
611 per_info
.lowcore
.words
.perc_atmid
,
612 per_info
.lowcore
.words
.address
,
613 per_info
.lowcore
.words
.access_id
);
617 s390_stopped_by_watchpoint (struct target_ops
*ops
)
619 struct s390_debug_reg_state
*state
620 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
621 per_lowcore_bits per_lowcore
;
626 s390_show_debug_regs (s390_inferior_tid (), "stop");
628 /* Speed up common case. */
629 if (VEC_empty (s390_watch_area
, state
->watch_areas
))
632 parea
.len
= sizeof (per_lowcore
);
633 parea
.process_addr
= (addr_t
) & per_lowcore
;
634 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
635 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
636 perror_with_name (_("Couldn't retrieve watchpoint status"));
638 result
= (per_lowcore
.perc_storage_alteration
== 1
639 && per_lowcore
.perc_store_real_address
== 0);
643 /* Do not report this watchpoint again. */
644 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
645 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
646 perror_with_name (_("Couldn't clear watchpoint status"));
652 /* Each time before resuming a thread, update its PER info. */
655 s390_prepare_to_resume (struct lwp_info
*lp
)
658 pid_t pid
= ptid_get_pid (ptid_of_lwp (lp
));
663 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
665 s390_watch_area
*area
;
666 struct arch_lwp_info
*lp_priv
= lwp_arch_private_info (lp
);
667 struct s390_debug_reg_state
*state
= s390_get_debug_reg_state (pid
);
668 int step
= lwp_is_stepping (lp
);
670 /* Nothing to do if there was never any PER info for this thread. */
674 /* If PER info has changed, update it. When single-stepping, disable
675 hardware breakpoints (if any). Otherwise we're done. */
676 if (!lp_priv
->per_info_changed
)
678 if (!step
|| VEC_empty (s390_watch_area
, state
->break_areas
))
682 lp_priv
->per_info_changed
= 0;
684 tid
= ptid_get_lwp (ptid_of_lwp (lp
));
688 parea
.len
= sizeof (per_info
);
689 parea
.process_addr
= (addr_t
) & per_info
;
690 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
692 /* Clear PER info, but adjust the single_step field (used by older
694 memset (&per_info
, 0, sizeof (per_info
));
695 per_info
.single_step
= (step
!= 0);
697 if (!VEC_empty (s390_watch_area
, state
->watch_areas
))
700 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
703 watch_lo_addr
= min (watch_lo_addr
, area
->lo_addr
);
704 watch_hi_addr
= max (watch_hi_addr
, area
->hi_addr
);
707 /* Enable storage-alteration events. */
708 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_STORE
709 | PER_CONTROL_ALTERATION
);
712 if (!VEC_empty (s390_watch_area
, state
->break_areas
))
714 /* Don't install hardware breakpoints while single-stepping, since
715 our PER settings (e.g. the nullification bit) might then conflict
716 with the kernel's. But re-install them afterwards. */
718 lp_priv
->per_info_changed
= 1;
722 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
725 watch_lo_addr
= min (watch_lo_addr
, area
->lo_addr
);
726 watch_hi_addr
= max (watch_hi_addr
, area
->hi_addr
);
729 /* If there's just one breakpoint, enable instruction-fetching
730 nullification events for the breakpoint address (fast).
731 Otherwise stop after any instruction within the PER area and
732 after any branch into it (slow). */
733 if (watch_hi_addr
== watch_lo_addr
)
734 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_NULLIFICATION
738 /* The PER area must include the instruction before the
739 first breakpoint address. */
740 watch_lo_addr
= watch_lo_addr
> 6 ? watch_lo_addr
- 6 : 0;
741 per_info
.control_regs
.words
.cr
[0]
744 | PER_CONTROL_BRANCH_ADDRESS
);
748 per_info
.starting_addr
= watch_lo_addr
;
749 per_info
.ending_addr
= watch_hi_addr
;
751 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
, 0) < 0)
752 perror_with_name (_("Couldn't modify watchpoint status"));
755 s390_show_debug_regs (tid
, "resume");
758 /* Mark the PER info as changed, so the next resume will update it. */
761 s390_mark_per_info_changed (struct lwp_info
*lp
)
763 if (lwp_arch_private_info (lp
) == NULL
)
764 lwp_set_arch_private_info (lp
, XCNEW (struct arch_lwp_info
));
766 lwp_arch_private_info (lp
)->per_info_changed
= 1;
769 /* When attaching to a new thread, mark its PER info as changed. */
772 s390_new_thread (struct lwp_info
*lp
)
774 s390_mark_per_info_changed (lp
);
777 /* Iterator callback for s390_refresh_per_info. */
780 s390_refresh_per_info_cb (struct lwp_info
*lp
, void *arg
)
782 s390_mark_per_info_changed (lp
);
784 if (!lwp_is_stopped (lp
))
789 /* Make sure that threads are stopped and mark PER info as changed. */
792 s390_refresh_per_info (void)
794 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
796 iterate_over_lwps (pid_ptid
, s390_refresh_per_info_cb
, NULL
);
801 s390_insert_watchpoint (struct target_ops
*self
,
802 CORE_ADDR addr
, int len
, enum target_hw_bp_type type
,
803 struct expression
*cond
)
805 s390_watch_area area
;
806 struct s390_debug_reg_state
*state
807 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
810 area
.hi_addr
= addr
+ len
- 1;
811 VEC_safe_push (s390_watch_area
, state
->watch_areas
, &area
);
813 return s390_refresh_per_info ();
817 s390_remove_watchpoint (struct target_ops
*self
,
818 CORE_ADDR addr
, int len
, enum target_hw_bp_type type
,
819 struct expression
*cond
)
822 s390_watch_area
*area
;
823 struct s390_debug_reg_state
*state
824 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
827 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
830 if (area
->lo_addr
== addr
&& area
->hi_addr
== addr
+ len
- 1)
832 VEC_unordered_remove (s390_watch_area
, state
->watch_areas
, ix
);
833 return s390_refresh_per_info ();
837 fprintf_unfiltered (gdb_stderr
,
838 "Attempt to remove nonexistent watchpoint.\n");
842 /* Implement the "can_use_hw_breakpoint" target_ops method. */
845 s390_can_use_hw_breakpoint (struct target_ops
*self
,
846 enum bptype type
, int cnt
, int othertype
)
848 if (type
== bp_hardware_watchpoint
|| type
== bp_hardware_breakpoint
)
853 /* Implement the "insert_hw_breakpoint" target_ops method. */
856 s390_insert_hw_breakpoint (struct target_ops
*self
,
857 struct gdbarch
*gdbarch
,
858 struct bp_target_info
*bp_tgt
)
860 s390_watch_area area
;
861 struct s390_debug_reg_state
*state
;
863 area
.lo_addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
864 area
.hi_addr
= area
.lo_addr
;
865 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
866 VEC_safe_push (s390_watch_area
, state
->break_areas
, &area
);
868 return s390_refresh_per_info ();
871 /* Implement the "remove_hw_breakpoint" target_ops method. */
874 s390_remove_hw_breakpoint (struct target_ops
*self
,
875 struct gdbarch
*gdbarch
,
876 struct bp_target_info
*bp_tgt
)
879 struct watch_area
*area
;
880 struct s390_debug_reg_state
*state
;
882 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
884 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
887 if (area
->lo_addr
== bp_tgt
->placed_address
)
889 VEC_unordered_remove (s390_watch_area
, state
->break_areas
, ix
);
890 return s390_refresh_per_info ();
894 fprintf_unfiltered (gdb_stderr
,
895 "Attempt to remove nonexistent breakpoint.\n");
900 s390_region_ok_for_hw_watchpoint (struct target_ops
*self
,
901 CORE_ADDR addr
, int cnt
)
907 s390_target_wordsize (void)
911 /* Check for 64-bit inferior process. This is the case when the host is
912 64-bit, and in addition bit 32 of the PSW mask is set. */
917 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
918 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
926 s390_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
927 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
929 int sizeof_auxv_field
= s390_target_wordsize ();
930 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
931 gdb_byte
*ptr
= *readptr
;
936 if (endptr
- ptr
< sizeof_auxv_field
* 2)
939 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
940 ptr
+= sizeof_auxv_field
;
941 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
942 ptr
+= sizeof_auxv_field
;
948 static const struct target_desc
*
949 s390_read_description (struct target_ops
*ops
)
951 int tid
= s390_inferior_tid ();
953 have_regset_last_break
954 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
955 have_regset_system_call
956 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
958 /* If GDB itself is compiled as 64-bit, we are running on a machine in
959 z/Architecture mode. If the target is running in 64-bit addressing
960 mode, report s390x architecture. If the target is running in 31-bit
961 addressing mode, but the kernel supports using 64-bit registers in
962 that mode, report s390 architecture with 64-bit GPRs. */
967 target_auxv_search (¤t_target
, AT_HWCAP
, &hwcap
);
968 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
969 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
971 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
972 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
973 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
975 if (s390_target_wordsize () == 8)
976 return (have_regset_vxrs
?
977 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
978 tdesc_s390x_vx_linux64
) :
979 have_regset_tdb
? tdesc_s390x_te_linux64
:
980 have_regset_system_call
? tdesc_s390x_linux64v2
:
981 have_regset_last_break
? tdesc_s390x_linux64v1
:
982 tdesc_s390x_linux64
);
984 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
985 return (have_regset_vxrs
?
986 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
987 tdesc_s390_vx_linux64
) :
988 have_regset_tdb
? tdesc_s390_te_linux64
:
989 have_regset_system_call
? tdesc_s390_linux64v2
:
990 have_regset_last_break
? tdesc_s390_linux64v1
:
995 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
996 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
997 mode, report s390 architecture with 32-bit GPRs. */
998 return (have_regset_system_call
? tdesc_s390_linux32v2
:
999 have_regset_last_break
? tdesc_s390_linux32v1
:
1000 tdesc_s390_linux32
);
1003 void _initialize_s390_nat (void);
1006 _initialize_s390_nat (void)
1008 struct target_ops
*t
;
1010 /* Fill in the generic GNU/Linux methods. */
1011 t
= linux_target ();
1013 /* Add our register access methods. */
1014 t
->to_fetch_registers
= s390_linux_fetch_inferior_registers
;
1015 t
->to_store_registers
= s390_linux_store_inferior_registers
;
1017 /* Add our watchpoint methods. */
1018 t
->to_can_use_hw_breakpoint
= s390_can_use_hw_breakpoint
;
1019 t
->to_insert_hw_breakpoint
= s390_insert_hw_breakpoint
;
1020 t
->to_remove_hw_breakpoint
= s390_remove_hw_breakpoint
;
1021 t
->to_region_ok_for_hw_watchpoint
= s390_region_ok_for_hw_watchpoint
;
1022 t
->to_have_continuable_watchpoint
= 1;
1023 t
->to_stopped_by_watchpoint
= s390_stopped_by_watchpoint
;
1024 t
->to_insert_watchpoint
= s390_insert_watchpoint
;
1025 t
->to_remove_watchpoint
= s390_remove_watchpoint
;
1027 /* Detect target architecture. */
1028 t
->to_read_description
= s390_read_description
;
1029 t
->to_auxv_parse
= s390_auxv_parse
;
1031 /* Register the target. */
1032 linux_nat_add_target (t
);
1033 linux_nat_set_new_thread (t
, s390_new_thread
);
1034 linux_nat_set_prepare_to_resume (t
, s390_prepare_to_resume
);
1035 linux_nat_set_forget_process (t
, s390_forget_process
);
1036 linux_nat_set_new_fork (t
, s390_linux_new_fork
);
1038 /* A maintenance command to enable showing the PER state. */
1039 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
1040 &show_debug_regs
, _("\
1041 Set whether to show the PER (debug) hardware state."), _("\
1042 Show whether to show the PER (debug) hardware state."), _("\
1043 Use \"on\" to enable, \"off\" to disable.\n\
1044 If enabled, the PER state is shown after it is changed by GDB,\n\
1045 and when the inferior triggers a breakpoint or watchpoint."),
1048 &maintenance_set_cmdlist
,
1049 &maintenance_show_cmdlist
);