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 int have_continuable_watchpoint () { return 1; }
126 int stopped_by_watchpoint () override
;
127 int 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
;
670 s390_show_debug_regs (s390_inferior_tid (), "stop");
672 /* Speed up common case. */
673 if (VEC_empty (s390_watch_area
, state
->watch_areas
))
676 parea
.len
= sizeof (per_lowcore
);
677 parea
.process_addr
= (addr_t
) & per_lowcore
;
678 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
679 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
680 perror_with_name (_("Couldn't retrieve watchpoint status"));
682 result
= (per_lowcore
.perc_storage_alteration
== 1
683 && per_lowcore
.perc_store_real_address
== 0);
687 /* Do not report this watchpoint again. */
688 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
689 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
, 0) < 0)
690 perror_with_name (_("Couldn't clear watchpoint status"));
696 /* Each time before resuming a thread, update its PER info. */
699 s390_prepare_to_resume (struct lwp_info
*lp
)
702 pid_t pid
= ptid_get_pid (ptid_of_lwp (lp
));
707 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
709 s390_watch_area
*area
;
710 struct arch_lwp_info
*lp_priv
= lwp_arch_private_info (lp
);
711 struct s390_debug_reg_state
*state
= s390_get_debug_reg_state (pid
);
712 int step
= lwp_is_stepping (lp
);
714 /* Nothing to do if there was never any PER info for this thread. */
718 /* If PER info has changed, update it. When single-stepping, disable
719 hardware breakpoints (if any). Otherwise we're done. */
720 if (!lp_priv
->per_info_changed
)
722 if (!step
|| VEC_empty (s390_watch_area
, state
->break_areas
))
726 lp_priv
->per_info_changed
= 0;
728 tid
= ptid_get_lwp (ptid_of_lwp (lp
));
732 parea
.len
= sizeof (per_info
);
733 parea
.process_addr
= (addr_t
) & per_info
;
734 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
736 /* Clear PER info, but adjust the single_step field (used by older
738 memset (&per_info
, 0, sizeof (per_info
));
739 per_info
.single_step
= (step
!= 0);
741 if (!VEC_empty (s390_watch_area
, state
->watch_areas
))
744 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
747 watch_lo_addr
= std::min (watch_lo_addr
, area
->lo_addr
);
748 watch_hi_addr
= std::max (watch_hi_addr
, area
->hi_addr
);
751 /* Enable storage-alteration events. */
752 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_STORE
753 | PER_CONTROL_ALTERATION
);
756 if (!VEC_empty (s390_watch_area
, state
->break_areas
))
758 /* Don't install hardware breakpoints while single-stepping, since
759 our PER settings (e.g. the nullification bit) might then conflict
760 with the kernel's. But re-install them afterwards. */
762 lp_priv
->per_info_changed
= 1;
766 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
769 watch_lo_addr
= std::min (watch_lo_addr
, area
->lo_addr
);
770 watch_hi_addr
= std::max (watch_hi_addr
, area
->hi_addr
);
773 /* If there's just one breakpoint, enable instruction-fetching
774 nullification events for the breakpoint address (fast).
775 Otherwise stop after any instruction within the PER area and
776 after any branch into it (slow). */
777 if (watch_hi_addr
== watch_lo_addr
)
778 per_info
.control_regs
.words
.cr
[0] |= (PER_EVENT_NULLIFICATION
782 /* The PER area must include the instruction before the
783 first breakpoint address. */
784 watch_lo_addr
= watch_lo_addr
> 6 ? watch_lo_addr
- 6 : 0;
785 per_info
.control_regs
.words
.cr
[0]
788 | PER_CONTROL_BRANCH_ADDRESS
);
792 per_info
.starting_addr
= watch_lo_addr
;
793 per_info
.ending_addr
= watch_hi_addr
;
795 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
, 0) < 0)
796 perror_with_name (_("Couldn't modify watchpoint status"));
799 s390_show_debug_regs (tid
, "resume");
802 /* Mark the PER info as changed, so the next resume will update it. */
805 s390_mark_per_info_changed (struct lwp_info
*lp
)
807 if (lwp_arch_private_info (lp
) == NULL
)
808 lwp_set_arch_private_info (lp
, XCNEW (struct arch_lwp_info
));
810 lwp_arch_private_info (lp
)->per_info_changed
= 1;
813 /* When attaching to a new thread, mark its PER info as changed. */
816 s390_new_thread (struct lwp_info
*lp
)
818 s390_mark_per_info_changed (lp
);
821 /* Function to call when a thread is being deleted. */
824 s390_delete_thread (struct arch_lwp_info
*arch_lwp
)
829 /* Iterator callback for s390_refresh_per_info. */
832 s390_refresh_per_info_cb (struct lwp_info
*lp
, void *arg
)
834 s390_mark_per_info_changed (lp
);
836 if (!lwp_is_stopped (lp
))
841 /* Make sure that threads are stopped and mark PER info as changed. */
844 s390_refresh_per_info (void)
846 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
848 iterate_over_lwps (pid_ptid
, s390_refresh_per_info_cb
, NULL
);
853 s390_linux_nat_target::insert_watchpoint (CORE_ADDR addr
, int len
,
854 enum target_hw_bp_type type
,
855 struct expression
*cond
)
857 s390_watch_area area
;
858 struct s390_debug_reg_state
*state
859 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
862 area
.hi_addr
= addr
+ len
- 1;
863 VEC_safe_push (s390_watch_area
, state
->watch_areas
, &area
);
865 return s390_refresh_per_info ();
869 s390_linux_nat_target::remove_watchpoint (CORE_ADDR addr
, int len
,
870 enum target_hw_bp_type type
,
871 struct expression
*cond
)
874 s390_watch_area
*area
;
875 struct s390_debug_reg_state
*state
876 = s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
879 VEC_iterate (s390_watch_area
, state
->watch_areas
, ix
, area
);
882 if (area
->lo_addr
== addr
&& area
->hi_addr
== addr
+ len
- 1)
884 VEC_unordered_remove (s390_watch_area
, state
->watch_areas
, ix
);
885 return s390_refresh_per_info ();
889 fprintf_unfiltered (gdb_stderr
,
890 "Attempt to remove nonexistent watchpoint.\n");
894 /* Implement the "can_use_hw_breakpoint" target_ops method. */
897 s390_linux_nat_target::can_use_hw_breakpoint (enum bptype type
,
898 int cnt
, int othertype
)
900 if (type
== bp_hardware_watchpoint
|| type
== bp_hardware_breakpoint
)
905 /* Implement the "insert_hw_breakpoint" target_ops method. */
908 s390_linux_nat_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
909 struct bp_target_info
*bp_tgt
)
911 s390_watch_area area
;
912 struct s390_debug_reg_state
*state
;
914 area
.lo_addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
915 area
.hi_addr
= area
.lo_addr
;
916 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
917 VEC_safe_push (s390_watch_area
, state
->break_areas
, &area
);
919 return s390_refresh_per_info ();
922 /* Implement the "remove_hw_breakpoint" target_ops method. */
925 s390_linux_nat_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
926 struct bp_target_info
*bp_tgt
)
929 struct watch_area
*area
;
930 struct s390_debug_reg_state
*state
;
932 state
= s390_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
934 VEC_iterate (s390_watch_area
, state
->break_areas
, ix
, area
);
937 if (area
->lo_addr
== bp_tgt
->placed_address
)
939 VEC_unordered_remove (s390_watch_area
, state
->break_areas
, ix
);
940 return s390_refresh_per_info ();
944 fprintf_unfiltered (gdb_stderr
,
945 "Attempt to remove nonexistent breakpoint.\n");
950 s390_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int cnt
)
956 s390_target_wordsize (void)
960 /* Check for 64-bit inferior process. This is the case when the host is
961 64-bit, and in addition bit 32 of the PSW mask is set. */
966 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
967 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
975 s390_linux_nat_target::auxv_parse (gdb_byte
**readptr
,
976 gdb_byte
*endptr
, CORE_ADDR
*typep
,
979 int sizeof_auxv_field
= s390_target_wordsize ();
980 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
981 gdb_byte
*ptr
= *readptr
;
986 if (endptr
- ptr
< sizeof_auxv_field
* 2)
989 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
990 ptr
+= sizeof_auxv_field
;
991 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
992 ptr
+= sizeof_auxv_field
;
998 const struct target_desc
*
999 s390_linux_nat_target::read_description ()
1001 int tid
= s390_inferior_tid ();
1003 have_regset_last_break
1004 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
1005 have_regset_system_call
1006 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
1008 /* If GDB itself is compiled as 64-bit, we are running on a machine in
1009 z/Architecture mode. If the target is running in 64-bit addressing
1010 mode, report s390x architecture. If the target is running in 31-bit
1011 addressing mode, but the kernel supports using 64-bit registers in
1012 that mode, report s390 architecture with 64-bit GPRs. */
1015 CORE_ADDR hwcap
= 0;
1017 target_auxv_search (target_stack
, AT_HWCAP
, &hwcap
);
1018 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
1019 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
1021 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
1022 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
1023 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
1025 have_regset_gs
= (hwcap
& HWCAP_S390_GS
)
1026 && check_regset (tid
, NT_S390_GS_CB
, 4 * 8)
1027 && check_regset (tid
, NT_S390_GS_BC
, 4 * 8);
1029 if (s390_target_wordsize () == 8)
1030 return (have_regset_gs
? tdesc_s390x_gs_linux64
:
1032 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
1033 tdesc_s390x_vx_linux64
) :
1034 have_regset_tdb
? tdesc_s390x_te_linux64
:
1035 have_regset_system_call
? tdesc_s390x_linux64v2
:
1036 have_regset_last_break
? tdesc_s390x_linux64v1
:
1037 tdesc_s390x_linux64
);
1039 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
1040 return (have_regset_gs
? tdesc_s390_gs_linux64
:
1042 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
1043 tdesc_s390_vx_linux64
) :
1044 have_regset_tdb
? tdesc_s390_te_linux64
:
1045 have_regset_system_call
? tdesc_s390_linux64v2
:
1046 have_regset_last_break
? tdesc_s390_linux64v1
:
1047 tdesc_s390_linux64
);
1051 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
1052 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
1053 mode, report s390 architecture with 32-bit GPRs. */
1054 return (have_regset_system_call
? tdesc_s390_linux32v2
:
1055 have_regset_last_break
? tdesc_s390_linux32v1
:
1056 tdesc_s390_linux32
);
1060 _initialize_s390_nat (void)
1062 struct target_ops
*t
= &the_s390_linux_nat_target
;
1064 /* Register the target. */
1065 linux_target
= &the_s390_linux_nat_target
;
1067 linux_nat_set_new_thread (t
, s390_new_thread
);
1068 linux_nat_set_delete_thread (t
, s390_delete_thread
);
1069 linux_nat_set_prepare_to_resume (t
, s390_prepare_to_resume
);
1070 linux_nat_set_forget_process (t
, s390_forget_process
);
1071 linux_nat_set_new_fork (t
, s390_linux_new_fork
);
1073 /* A maintenance command to enable showing the PER state. */
1074 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
1075 &show_debug_regs
, _("\
1076 Set whether to show the PER (debug) hardware state."), _("\
1077 Show whether to show the PER (debug) hardware state."), _("\
1078 Use \"on\" to enable, \"off\" to disable.\n\
1079 If enabled, the PER state is shown after it is changed by GDB,\n\
1080 and when the inferior triggers a breakpoint or watchpoint."),
1083 &maintenance_set_cmdlist
,
1084 &maintenance_show_cmdlist
);