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)
111 class s390_linux_nat_target final
: public linux_nat_target
114 /* Add our register access methods. */
115 void fetch_registers (struct regcache
*, int) override
;
116 void store_registers (struct regcache
*, int) override
;
118 /* Add our watchpoint methods. */
119 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
120 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*)
122 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*)
124 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
125 bool have_continuable_watchpoint () { return 1; }
126 bool stopped_by_watchpoint () override
;
127 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
128 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
129 struct expression
*) override
;
130 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
131 struct expression
*) override
;
133 /* Detect target architecture. */
134 const struct target_desc
*read_description () override
;
135 int auxv_parse (gdb_byte
**readptr
,
136 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
140 static s390_linux_nat_target the_s390_linux_nat_target
;
142 /* Fill GDB's register array with the general-purpose register values
145 When debugging a 32-bit executable running under a 64-bit kernel,
146 we have to fix up the 64-bit registers we get from the kernel to
147 make them look like 32-bit registers. */
150 supply_gregset (struct regcache
*regcache
, const gregset_t
*regp
)
153 struct gdbarch
*gdbarch
= regcache
->arch ();
154 if (gdbarch_ptr_bit (gdbarch
) == 32)
156 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
160 regcache_supply_regset (&s390_64_gregset
, regcache
, -1,
161 regp
, sizeof (gregset_t
));
162 pswm
= extract_unsigned_integer ((const gdb_byte
*) regp
163 + S390_PSWM_OFFSET
, 8, byte_order
);
164 pswa
= extract_unsigned_integer ((const gdb_byte
*) regp
165 + S390_PSWA_OFFSET
, 8, byte_order
);
166 store_unsigned_integer (buf
, 4, byte_order
, (pswm
>> 32) | 0x80000);
167 regcache_raw_supply (regcache
, S390_PSWM_REGNUM
, buf
);
168 store_unsigned_integer (buf
, 4, byte_order
,
169 (pswa
& 0x7fffffff) | (pswm
& 0x80000000));
170 regcache_raw_supply (regcache
, S390_PSWA_REGNUM
, buf
);
175 regcache_supply_regset (&s390_gregset
, regcache
, -1, regp
,
179 /* Fill register REGNO (if it is a general-purpose register) in
180 *REGP with the value in GDB's register array. If REGNO is -1,
181 do this for all registers. */
184 fill_gregset (const struct regcache
*regcache
, gregset_t
*regp
, int regno
)
187 struct gdbarch
*gdbarch
= regcache
->arch ();
188 if (gdbarch_ptr_bit (gdbarch
) == 32)
190 regcache_collect_regset (&s390_64_gregset
, regcache
, regno
,
191 regp
, sizeof (gregset_t
));
194 || regno
== S390_PSWM_REGNUM
|| regno
== S390_PSWA_REGNUM
)
196 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
199 gdb_byte
*pswm_p
= (gdb_byte
*) regp
+ S390_PSWM_OFFSET
;
200 gdb_byte
*pswa_p
= (gdb_byte
*) regp
+ S390_PSWA_OFFSET
;
202 pswm
= extract_unsigned_integer (pswm_p
, 8, byte_order
);
204 if (regno
== -1 || regno
== S390_PSWM_REGNUM
)
207 regcache_raw_collect (regcache
, S390_PSWM_REGNUM
, buf
);
208 pswm
|= (extract_unsigned_integer (buf
, 4, byte_order
)
212 if (regno
== -1 || regno
== S390_PSWA_REGNUM
)
214 regcache_raw_collect (regcache
, S390_PSWA_REGNUM
, buf
);
215 pswa
= extract_unsigned_integer (buf
, 4, byte_order
);
216 pswm
^= (pswm
^ pswa
) & 0x80000000;
218 store_unsigned_integer (pswa_p
, 8, byte_order
, pswa
);
221 store_unsigned_integer (pswm_p
, 8, byte_order
, pswm
);
227 regcache_collect_regset (&s390_gregset
, regcache
, regno
, regp
,
231 /* Fill GDB's register array with the floating-point register values
234 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*regp
)
236 regcache_supply_regset (&s390_fpregset
, regcache
, -1, regp
,
237 sizeof (fpregset_t
));
240 /* Fill register REGNO (if it is a general-purpose register) in
241 *REGP with the value in GDB's register array. If REGNO is -1,
242 do this for all registers. */
244 fill_fpregset (const struct regcache
*regcache
, fpregset_t
*regp
, int regno
)
246 regcache_collect_regset (&s390_fpregset
, regcache
, regno
, regp
,
247 sizeof (fpregset_t
));
250 /* Find the TID for the current inferior thread to use with ptrace. */
252 s390_inferior_tid (void)
254 /* GNU/Linux LWP ID's are process ID's. */
255 int tid
= ptid_get_lwp (inferior_ptid
);
257 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
262 /* Fetch all general-purpose registers from process/thread TID and
263 store their values in GDB's register cache. */
265 fetch_regs (struct regcache
*regcache
, int tid
)
270 parea
.len
= sizeof (regs
);
271 parea
.process_addr
= (addr_t
) ®s
;
272 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
273 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
274 perror_with_name (_("Couldn't get registers"));
276 supply_gregset (regcache
, (const gregset_t
*) ®s
);
279 /* Store all valid general-purpose registers in GDB's register cache
280 into the process/thread specified by TID. */
282 store_regs (const struct regcache
*regcache
, int tid
, int regnum
)
287 parea
.len
= sizeof (regs
);
288 parea
.process_addr
= (addr_t
) ®s
;
289 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
290 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
291 perror_with_name (_("Couldn't get registers"));
293 fill_gregset (regcache
, ®s
, regnum
);
295 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
, 0) < 0)
296 perror_with_name (_("Couldn't write registers"));
299 /* Fetch all floating-point registers from process/thread TID and store
300 their values in GDB's register cache. */
302 fetch_fpregs (struct regcache
*regcache
, int tid
)
307 parea
.len
= sizeof (fpregs
);
308 parea
.process_addr
= (addr_t
) &fpregs
;
309 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
310 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
311 perror_with_name (_("Couldn't get floating point status"));
313 supply_fpregset (regcache
, (const fpregset_t
*) &fpregs
);
316 /* Store all valid floating-point registers in GDB's register cache
317 into the process/thread specified by TID. */
319 store_fpregs (const struct regcache
*regcache
, int tid
, int regnum
)
324 parea
.len
= sizeof (fpregs
);
325 parea
.process_addr
= (addr_t
) &fpregs
;
326 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
327 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
, 0) < 0)
328 perror_with_name (_("Couldn't get floating point status"));
330 fill_fpregset (regcache
, &fpregs
, regnum
);
332 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
, 0) < 0)
333 perror_with_name (_("Couldn't write floating point status"));
336 /* Fetch all registers in the kernel's register set whose number is
337 REGSET_ID, whose size is REGSIZE, and whose layout is described by
338 REGSET, from process/thread TID and store their values in GDB's
341 fetch_regset (struct regcache
*regcache
, int tid
,
342 int regset_id
, int regsize
, const struct regset
*regset
)
344 void *buf
= alloca (regsize
);
348 iov
.iov_len
= regsize
;
350 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
352 if (errno
== ENODATA
)
353 regcache_supply_regset (regset
, regcache
, -1, NULL
, regsize
);
355 perror_with_name (_("Couldn't get register set"));
358 regcache_supply_regset (regset
, regcache
, -1, buf
, regsize
);
361 /* Store all registers in the kernel's register set whose number is
362 REGSET_ID, whose size is REGSIZE, and whose layout is described by
363 REGSET, from GDB's register cache back to process/thread TID. */
365 store_regset (struct regcache
*regcache
, int tid
,
366 int regset_id
, int regsize
, const struct regset
*regset
)
368 void *buf
= alloca (regsize
);
372 iov
.iov_len
= regsize
;
374 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
375 perror_with_name (_("Couldn't get register set"));
377 regcache_collect_regset (regset
, regcache
, -1, buf
, regsize
);
379 if (ptrace (PTRACE_SETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
380 perror_with_name (_("Couldn't set register set"));
383 /* Check whether the kernel provides a register set with number REGSET
384 of size REGSIZE for process/thread TID. */
386 check_regset (int tid
, int regset
, int regsize
)
388 void *buf
= alloca (regsize
);
392 iov
.iov_len
= regsize
;
394 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset
, (long) &iov
) >= 0
400 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
401 this for all registers. */
403 s390_linux_nat_target::fetch_registers (struct regcache
*regcache
, int regnum
)
405 pid_t tid
= get_ptrace_pid (regcache_get_ptid (regcache
));
407 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
408 fetch_regs (regcache
, tid
);
410 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
411 fetch_fpregs (regcache
, tid
);
413 if (have_regset_last_break
)
414 if (regnum
== -1 || regnum
== S390_LAST_BREAK_REGNUM
)
415 fetch_regset (regcache
, tid
, NT_S390_LAST_BREAK
, 8,
416 (gdbarch_ptr_bit (regcache
->arch ()) == 32
417 ? &s390_last_break_regset
: &s390x_last_break_regset
));
419 if (have_regset_system_call
)
420 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
421 fetch_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
422 &s390_system_call_regset
);
425 if (regnum
== -1 || S390_IS_TDBREGSET_REGNUM (regnum
))
426 fetch_regset (regcache
, tid
, NT_S390_TDB
, s390_sizeof_tdbregset
,
429 if (have_regset_vxrs
)
431 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
432 && regnum
<= S390_V15_LOWER_REGNUM
))
433 fetch_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
434 &s390_vxrs_low_regset
);
435 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
436 && regnum
<= S390_V31_REGNUM
))
437 fetch_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
438 &s390_vxrs_high_regset
);
443 if (regnum
== -1 || (regnum
>= S390_GSD_REGNUM
444 && regnum
<= S390_GSEPLA_REGNUM
))
445 fetch_regset (regcache
, tid
, NT_S390_GS_CB
, 4 * 8,
447 if (regnum
== -1 || (regnum
>= S390_BC_GSD_REGNUM
448 && regnum
<= S390_BC_GSEPLA_REGNUM
))
449 fetch_regset (regcache
, tid
, NT_S390_GS_BC
, 4 * 8,
454 /* Store register REGNUM back into the child process. If REGNUM is
455 -1, do this for all registers. */
457 s390_linux_nat_target::store_registers (struct regcache
*regcache
, int regnum
)
459 pid_t tid
= get_ptrace_pid (regcache_get_ptid (regcache
));
461 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
462 store_regs (regcache
, tid
, regnum
);
464 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
465 store_fpregs (regcache
, tid
, regnum
);
467 /* S390_LAST_BREAK_REGNUM is read-only. */
469 if (have_regset_system_call
)
470 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
471 store_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
472 &s390_system_call_regset
);
474 if (have_regset_vxrs
)
476 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
477 && regnum
<= S390_V15_LOWER_REGNUM
))
478 store_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
479 &s390_vxrs_low_regset
);
480 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
481 && regnum
<= S390_V31_REGNUM
))
482 store_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
483 &s390_vxrs_high_regset
);
488 /* Hardware-assisted watchpoint handling. */
490 /* For each process we maintain a list of all currently active
491 watchpoints, in order to properly handle watchpoint removal.
493 The only thing we actually need is the total address space area
494 spanned by the watchpoints. */
496 typedef struct watch_area
502 DEF_VEC_O (s390_watch_area
);
504 /* Hardware debug state. */
506 struct s390_debug_reg_state
508 VEC_s390_watch_area
*watch_areas
;
509 VEC_s390_watch_area
*break_areas
;
512 /* Per-process data. */
514 struct s390_process_info
516 struct s390_process_info
*next
;
518 struct s390_debug_reg_state state
;
521 static struct s390_process_info
*s390_process_list
= NULL
;
523 /* Find process data for process PID. */
525 static struct s390_process_info
*
526 s390_find_process_pid (pid_t pid
)
528 struct s390_process_info
*proc
;
530 for (proc
= s390_process_list
; proc
; proc
= proc
->next
)
531 if (proc
->pid
== pid
)
537 /* Add process data for process PID. Returns newly allocated info
540 static struct s390_process_info
*
541 s390_add_process (pid_t pid
)
543 struct s390_process_info
*proc
= XCNEW (struct s390_process_info
);
546 proc
->next
= s390_process_list
;
547 s390_process_list
= proc
;
552 /* Get data specific info for process PID, creating it if necessary.
553 Never returns NULL. */
555 static struct s390_process_info
*
556 s390_process_info_get (pid_t pid
)
558 struct s390_process_info
*proc
;
560 proc
= s390_find_process_pid (pid
);
562 proc
= s390_add_process (pid
);
567 /* Get hardware debug state for process PID. */
569 static struct s390_debug_reg_state
*
570 s390_get_debug_reg_state (pid_t pid
)
572 return &s390_process_info_get (pid
)->state
;
575 /* Called whenever GDB is no longer debugging process PID. It deletes
576 data structures that keep track of hardware debug state. */
579 s390_forget_process (pid_t pid
)
581 struct s390_process_info
*proc
, **proc_link
;
583 proc
= s390_process_list
;
584 proc_link
= &s390_process_list
;
588 if (proc
->pid
== pid
)
590 VEC_free (s390_watch_area
, proc
->state
.watch_areas
);
591 VEC_free (s390_watch_area
, proc
->state
.break_areas
);
592 *proc_link
= proc
->next
;
597 proc_link
= &proc
->next
;
602 /* linux_nat_new_fork hook. */
605 s390_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
608 struct s390_debug_reg_state
*parent_state
;
609 struct s390_debug_reg_state
*child_state
;
611 /* NULL means no watchpoint has ever been set in the parent. In
612 that case, there's nothing to do. */
613 if (lwp_arch_private_info (parent
) == NULL
)
616 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of
617 the parent. So copy the debug state from parent to child. */
619 parent_pid
= ptid_get_pid (parent
->ptid
);
620 parent_state
= s390_get_debug_reg_state (parent_pid
);
621 child_state
= s390_get_debug_reg_state (child_pid
);
623 child_state
->watch_areas
= VEC_copy (s390_watch_area
,
624 parent_state
->watch_areas
);
625 child_state
->break_areas
= VEC_copy (s390_watch_area
,
626 parent_state
->break_areas
);
629 /* Dump PER state. */
632 s390_show_debug_regs (int tid
, const char *where
)
637 parea
.len
= sizeof (per_info
);
638 parea
.process_addr
= (addr_t
) &per_info
;
639 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
641 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, &parea
, 0) < 0)
642 perror_with_name (_("Couldn't retrieve debug regs"));
644 debug_printf ("PER (debug) state for %d -- %s\n"
645 " cr9-11: %lx %lx %lx\n"
646 " start, end: %lx %lx\n"
647 " code/ATMID: %x address: %lx PAID: %x\n",
650 per_info
.control_regs
.words
.cr
[0],
651 per_info
.control_regs
.words
.cr
[1],
652 per_info
.control_regs
.words
.cr
[2],
653 per_info
.starting_addr
,
654 per_info
.ending_addr
,
655 per_info
.lowcore
.words
.perc_atmid
,
656 per_info
.lowcore
.words
.address
,
657 per_info
.lowcore
.words
.access_id
);
661 s390_linux_nat_target::stopped_by_watchpoint ()
663 struct s390_debug_reg_state
*state
664 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
665 per_lowcore_bits per_lowcore
;
669 s390_show_debug_regs (s390_inferior_tid (), "stop");
671 /* Speed up common case. */
672 if (VEC_empty (s390_watch_area
, state
->watch_areas
))
675 parea
.len
= sizeof (per_lowcore
);
676 parea
.process_addr
= (addr_t
) & per_lowcore
;
677 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
678 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
679 perror_with_name (_("Couldn't retrieve watchpoint status"));
681 bool result
= (per_lowcore
.perc_storage_alteration
== 1
682 && per_lowcore
.perc_store_real_address
== 0);
686 /* Do not report this watchpoint again. */
687 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
688 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
689 perror_with_name (_("Couldn't clear watchpoint status"));
695 /* Each time before resuming a thread, update its PER info. */
698 s390_prepare_to_resume (struct lwp_info
*lp
)
701 pid_t pid
= ptid_get_pid (ptid_of_lwp (lp
));
706 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
708 s390_watch_area
*area
;
709 struct arch_lwp_info
*lp_priv
= lwp_arch_private_info (lp
);
710 struct s390_debug_reg_state
*state
= s390_get_debug_reg_state (pid
);
711 int step
= lwp_is_stepping (lp
);
713 /* Nothing to do if there was never any PER info for this thread. */
717 /* If PER info has changed, update it. When single-stepping, disable
718 hardware breakpoints (if any). Otherwise we're done. */
719 if (!lp_priv
->per_info_changed
)
721 if (!step
|| VEC_empty (s390_watch_area
, state
->break_areas
))
725 lp_priv
->per_info_changed
= 0;
727 tid
= ptid_get_lwp (ptid_of_lwp (lp
));
731 parea
.len
= sizeof (per_info
);
732 parea
.process_addr
= (addr_t
) & per_info
;
733 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
735 /* Clear PER info, but adjust the single_step field (used by older
737 memset (&per_info
, 0, sizeof (per_info
));
738 per_info
.single_step
= (step
!= 0);
740 if (!VEC_empty (s390_watch_area
, state
->watch_areas
))
743 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
746 watch_lo_addr
= std::min (watch_lo_addr
, area
->lo_addr
);
747 watch_hi_addr
= std::max (watch_hi_addr
, area
->hi_addr
);
750 /* Enable storage-alteration events. */
751 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_STORE
752 | PER_CONTROL_ALTERATION
);
755 if (!VEC_empty (s390_watch_area
, state
->break_areas
))
757 /* Don't install hardware breakpoints while single-stepping, since
758 our PER settings (e.g. the nullification bit) might then conflict
759 with the kernel's. But re-install them afterwards. */
761 lp_priv
->per_info_changed
= 1;
765 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
768 watch_lo_addr
= std::min (watch_lo_addr
, area
->lo_addr
);
769 watch_hi_addr
= std::max (watch_hi_addr
, area
->hi_addr
);
772 /* If there's just one breakpoint, enable instruction-fetching
773 nullification events for the breakpoint address (fast).
774 Otherwise stop after any instruction within the PER area and
775 after any branch into it (slow). */
776 if (watch_hi_addr
== watch_lo_addr
)
777 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_NULLIFICATION
781 /* The PER area must include the instruction before the
782 first breakpoint address. */
783 watch_lo_addr
= watch_lo_addr
> 6 ? watch_lo_addr
- 6 : 0;
784 per_info
.control_regs
.words
.cr
[0]
787 | PER_CONTROL_BRANCH_ADDRESS
);
791 per_info
.starting_addr
= watch_lo_addr
;
792 per_info
.ending_addr
= watch_hi_addr
;
794 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
, 0) < 0)
795 perror_with_name (_("Couldn't modify watchpoint status"));
798 s390_show_debug_regs (tid
, "resume");
801 /* Mark the PER info as changed, so the next resume will update it. */
804 s390_mark_per_info_changed (struct lwp_info
*lp
)
806 if (lwp_arch_private_info (lp
) == NULL
)
807 lwp_set_arch_private_info (lp
, XCNEW (struct arch_lwp_info
));
809 lwp_arch_private_info (lp
)->per_info_changed
= 1;
812 /* When attaching to a new thread, mark its PER info as changed. */
815 s390_new_thread (struct lwp_info
*lp
)
817 s390_mark_per_info_changed (lp
);
820 /* Function to call when a thread is being deleted. */
823 s390_delete_thread (struct arch_lwp_info
*arch_lwp
)
828 /* Iterator callback for s390_refresh_per_info. */
831 s390_refresh_per_info_cb (struct lwp_info
*lp
, void *arg
)
833 s390_mark_per_info_changed (lp
);
835 if (!lwp_is_stopped (lp
))
840 /* Make sure that threads are stopped and mark PER info as changed. */
843 s390_refresh_per_info (void)
845 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
847 iterate_over_lwps (pid_ptid
, s390_refresh_per_info_cb
, NULL
);
852 s390_linux_nat_target::insert_watchpoint (CORE_ADDR addr
, int len
,
853 enum target_hw_bp_type type
,
854 struct expression
*cond
)
856 s390_watch_area area
;
857 struct s390_debug_reg_state
*state
858 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
861 area
.hi_addr
= addr
+ len
- 1;
862 VEC_safe_push (s390_watch_area
, state
->watch_areas
, &area
);
864 return s390_refresh_per_info ();
868 s390_linux_nat_target::remove_watchpoint (CORE_ADDR addr
, int len
,
869 enum target_hw_bp_type type
,
870 struct expression
*cond
)
873 s390_watch_area
*area
;
874 struct s390_debug_reg_state
*state
875 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
878 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
881 if (area
->lo_addr
== addr
&& area
->hi_addr
== addr
+ len
- 1)
883 VEC_unordered_remove (s390_watch_area
, state
->watch_areas
, ix
);
884 return s390_refresh_per_info ();
888 fprintf_unfiltered (gdb_stderr
,
889 "Attempt to remove nonexistent watchpoint.\n");
893 /* Implement the "can_use_hw_breakpoint" target_ops method. */
896 s390_linux_nat_target::can_use_hw_breakpoint (enum bptype type
,
897 int cnt
, int othertype
)
899 if (type
== bp_hardware_watchpoint
|| type
== bp_hardware_breakpoint
)
904 /* Implement the "insert_hw_breakpoint" target_ops method. */
907 s390_linux_nat_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
908 struct bp_target_info
*bp_tgt
)
910 s390_watch_area area
;
911 struct s390_debug_reg_state
*state
;
913 area
.lo_addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
914 area
.hi_addr
= area
.lo_addr
;
915 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
916 VEC_safe_push (s390_watch_area
, state
->break_areas
, &area
);
918 return s390_refresh_per_info ();
921 /* Implement the "remove_hw_breakpoint" target_ops method. */
924 s390_linux_nat_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
925 struct bp_target_info
*bp_tgt
)
928 struct watch_area
*area
;
929 struct s390_debug_reg_state
*state
;
931 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
933 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
936 if (area
->lo_addr
== bp_tgt
->placed_address
)
938 VEC_unordered_remove (s390_watch_area
, state
->break_areas
, ix
);
939 return s390_refresh_per_info ();
943 fprintf_unfiltered (gdb_stderr
,
944 "Attempt to remove nonexistent breakpoint.\n");
949 s390_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int cnt
)
955 s390_target_wordsize (void)
959 /* Check for 64-bit inferior process. This is the case when the host is
960 64-bit, and in addition bit 32 of the PSW mask is set. */
965 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
966 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
974 s390_linux_nat_target::auxv_parse (gdb_byte
**readptr
,
975 gdb_byte
*endptr
, CORE_ADDR
*typep
,
978 int sizeof_auxv_field
= s390_target_wordsize ();
979 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
980 gdb_byte
*ptr
= *readptr
;
985 if (endptr
- ptr
< sizeof_auxv_field
* 2)
988 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
989 ptr
+= sizeof_auxv_field
;
990 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
991 ptr
+= sizeof_auxv_field
;
997 const struct target_desc
*
998 s390_linux_nat_target::read_description ()
1000 int tid
= s390_inferior_tid ();
1002 have_regset_last_break
1003 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
1004 have_regset_system_call
1005 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
1007 /* If GDB itself is compiled as 64-bit, we are running on a machine in
1008 z/Architecture mode. If the target is running in 64-bit addressing
1009 mode, report s390x architecture. If the target is running in 31-bit
1010 addressing mode, but the kernel supports using 64-bit registers in
1011 that mode, report s390 architecture with 64-bit GPRs. */
1014 CORE_ADDR hwcap
= 0;
1016 target_auxv_search (target_stack
, AT_HWCAP
, &hwcap
);
1017 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
1018 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
1020 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
1021 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
1022 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
1024 have_regset_gs
= (hwcap
& HWCAP_S390_GS
)
1025 && check_regset (tid
, NT_S390_GS_CB
, 4 * 8)
1026 && check_regset (tid
, NT_S390_GS_BC
, 4 * 8);
1028 if (s390_target_wordsize () == 8)
1029 return (have_regset_gs
? tdesc_s390x_gs_linux64
:
1031 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
1032 tdesc_s390x_vx_linux64
) :
1033 have_regset_tdb
? tdesc_s390x_te_linux64
:
1034 have_regset_system_call
? tdesc_s390x_linux64v2
:
1035 have_regset_last_break
? tdesc_s390x_linux64v1
:
1036 tdesc_s390x_linux64
);
1038 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
1039 return (have_regset_gs
? tdesc_s390_gs_linux64
:
1041 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
1042 tdesc_s390_vx_linux64
) :
1043 have_regset_tdb
? tdesc_s390_te_linux64
:
1044 have_regset_system_call
? tdesc_s390_linux64v2
:
1045 have_regset_last_break
? tdesc_s390_linux64v1
:
1046 tdesc_s390_linux64
);
1050 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
1051 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
1052 mode, report s390 architecture with 32-bit GPRs. */
1053 return (have_regset_system_call
? tdesc_s390_linux32v2
:
1054 have_regset_last_break
? tdesc_s390_linux32v1
:
1055 tdesc_s390_linux32
);
1059 _initialize_s390_nat (void)
1061 struct target_ops
*t
= &the_s390_linux_nat_target
;
1063 /* Register the target. */
1064 linux_target
= &the_s390_linux_nat_target
;
1066 linux_nat_set_new_thread (t
, s390_new_thread
);
1067 linux_nat_set_delete_thread (t
, s390_delete_thread
);
1068 linux_nat_set_prepare_to_resume (t
, s390_prepare_to_resume
);
1069 linux_nat_set_forget_process (t
, s390_forget_process
);
1070 linux_nat_set_new_fork (t
, s390_linux_new_fork
);
1072 /* A maintenance command to enable showing the PER state. */
1073 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
1074 &show_debug_regs
, _("\
1075 Set whether to show the PER (debug) hardware state."), _("\
1076 Show whether to show the PER (debug) hardware state."), _("\
1077 Use \"on\" to enable, \"off\" to disable.\n\
1078 If enabled, the PER state is shown after it is changed by GDB,\n\
1079 and when the inferior triggers a breakpoint or watchpoint."),
1082 &maintenance_set_cmdlist
,
1083 &maintenance_show_cmdlist
);