1 /* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright (C) 2001-2015 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"
31 #include "s390-linux-tdep.h"
32 #include "elf/common.h"
34 #include <asm/ptrace.h>
35 #include <sys/ptrace.h>
36 #include <asm/types.h>
37 #include <sys/procfs.h>
38 #include <sys/ucontext.h>
41 #ifndef PTRACE_GETREGSET
42 #define PTRACE_GETREGSET 0x4204
45 #ifndef PTRACE_SETREGSET
46 #define PTRACE_SETREGSET 0x4205
49 static int have_regset_last_break
= 0;
50 static int have_regset_system_call
= 0;
51 static int have_regset_tdb
= 0;
52 static int have_regset_vxrs
= 0;
54 /* Register map for 32-bit executables running under a 64-bit
58 static const struct regcache_map_entry s390_64_regmap_gregset
[] =
60 /* Skip PSWM and PSWA, since they must be handled specially. */
61 { 2, REGCACHE_MAP_SKIP
, 8 },
62 { 1, S390_R0_UPPER_REGNUM
, 4 }, { 1, S390_R0_REGNUM
, 4 },
63 { 1, S390_R1_UPPER_REGNUM
, 4 }, { 1, S390_R1_REGNUM
, 4 },
64 { 1, S390_R2_UPPER_REGNUM
, 4 }, { 1, S390_R2_REGNUM
, 4 },
65 { 1, S390_R3_UPPER_REGNUM
, 4 }, { 1, S390_R3_REGNUM
, 4 },
66 { 1, S390_R4_UPPER_REGNUM
, 4 }, { 1, S390_R4_REGNUM
, 4 },
67 { 1, S390_R5_UPPER_REGNUM
, 4 }, { 1, S390_R5_REGNUM
, 4 },
68 { 1, S390_R6_UPPER_REGNUM
, 4 }, { 1, S390_R6_REGNUM
, 4 },
69 { 1, S390_R7_UPPER_REGNUM
, 4 }, { 1, S390_R7_REGNUM
, 4 },
70 { 1, S390_R8_UPPER_REGNUM
, 4 }, { 1, S390_R8_REGNUM
, 4 },
71 { 1, S390_R9_UPPER_REGNUM
, 4 }, { 1, S390_R9_REGNUM
, 4 },
72 { 1, S390_R10_UPPER_REGNUM
, 4 }, { 1, S390_R10_REGNUM
, 4 },
73 { 1, S390_R11_UPPER_REGNUM
, 4 }, { 1, S390_R11_REGNUM
, 4 },
74 { 1, S390_R12_UPPER_REGNUM
, 4 }, { 1, S390_R12_REGNUM
, 4 },
75 { 1, S390_R13_UPPER_REGNUM
, 4 }, { 1, S390_R13_REGNUM
, 4 },
76 { 1, S390_R14_UPPER_REGNUM
, 4 }, { 1, S390_R14_REGNUM
, 4 },
77 { 1, S390_R15_UPPER_REGNUM
, 4 }, { 1, S390_R15_REGNUM
, 4 },
78 { 16, S390_A0_REGNUM
, 4 },
79 { 1, REGCACHE_MAP_SKIP
, 4 }, { 1, S390_ORIG_R2_REGNUM
, 4 },
83 static const struct regset s390_64_gregset
=
85 s390_64_regmap_gregset
,
86 regcache_supply_regset
,
87 regcache_collect_regset
90 #define S390_PSWM_OFFSET 0
91 #define S390_PSWA_OFFSET 8
94 /* Fill GDB's register array with the general-purpose register values
97 When debugging a 32-bit executable running under a 64-bit kernel,
98 we have to fix up the 64-bit registers we get from the kernel to
99 make them look like 32-bit registers. */
102 supply_gregset (struct regcache
*regcache
, const gregset_t
*regp
)
105 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
106 if (gdbarch_ptr_bit (gdbarch
) == 32)
108 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
112 regcache_supply_regset (&s390_64_gregset
, regcache
, -1,
113 regp
, sizeof (gregset_t
));
114 pswm
= extract_unsigned_integer ((const gdb_byte
*) regp
115 + S390_PSWM_OFFSET
, 8, byte_order
);
116 pswa
= extract_unsigned_integer ((const gdb_byte
*) regp
117 + S390_PSWA_OFFSET
, 8, byte_order
);
118 store_unsigned_integer (buf
, 4, byte_order
, (pswm
>> 32) | 0x80000);
119 regcache_raw_supply (regcache
, S390_PSWM_REGNUM
, buf
);
120 store_unsigned_integer (buf
, 4, byte_order
,
121 (pswa
& 0x7fffffff) | (pswm
& 0x80000000));
122 regcache_raw_supply (regcache
, S390_PSWA_REGNUM
, buf
);
127 regcache_supply_regset (&s390_gregset
, regcache
, -1, regp
,
131 /* Fill register REGNO (if it is a general-purpose register) in
132 *REGP with the value in GDB's register array. If REGNO is -1,
133 do this for all registers. */
136 fill_gregset (const struct regcache
*regcache
, gregset_t
*regp
, int regno
)
139 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
140 if (gdbarch_ptr_bit (gdbarch
) == 32)
142 regcache_collect_regset (&s390_64_gregset
, regcache
, regno
,
143 regp
, sizeof (gregset_t
));
146 || regno
== S390_PSWM_REGNUM
|| regno
== S390_PSWA_REGNUM
)
148 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
152 regcache_raw_collect (regcache
, S390_PSWM_REGNUM
, buf
);
153 pswm
= extract_unsigned_integer (buf
, 4, byte_order
);
154 regcache_raw_collect (regcache
, S390_PSWA_REGNUM
, buf
);
155 pswa
= extract_unsigned_integer (buf
, 4, byte_order
);
157 if (regno
== -1 || regno
== S390_PSWM_REGNUM
)
158 store_unsigned_integer ((gdb_byte
*) regp
+ S390_PSWM_OFFSET
, 8,
159 byte_order
, ((pswm
& 0xfff7ffff) << 32) |
160 (pswa
& 0x80000000));
161 if (regno
== -1 || regno
== S390_PSWA_REGNUM
)
162 store_unsigned_integer ((gdb_byte
*) regp
+ S390_PSWA_OFFSET
, 8,
163 byte_order
, pswa
& 0x7fffffff);
169 regcache_collect_regset (&s390_gregset
, regcache
, regno
, regp
,
173 /* Fill GDB's register array with the floating-point register values
176 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*regp
)
178 regcache_supply_regset (&s390_fpregset
, regcache
, -1, regp
,
179 sizeof (fpregset_t
));
182 /* Fill register REGNO (if it is a general-purpose register) in
183 *REGP with the value in GDB's register array. If REGNO is -1,
184 do this for all registers. */
186 fill_fpregset (const struct regcache
*regcache
, fpregset_t
*regp
, int regno
)
188 regcache_collect_regset (&s390_fpregset
, regcache
, regno
, regp
,
189 sizeof (fpregset_t
));
192 /* Find the TID for the current inferior thread to use with ptrace. */
194 s390_inferior_tid (void)
196 /* GNU/Linux LWP ID's are process ID's. */
197 int tid
= ptid_get_lwp (inferior_ptid
);
199 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
204 /* Fetch all general-purpose registers from process/thread TID and
205 store their values in GDB's register cache. */
207 fetch_regs (struct regcache
*regcache
, int tid
)
212 parea
.len
= sizeof (regs
);
213 parea
.process_addr
= (addr_t
) ®s
;
214 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
215 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
216 perror_with_name (_("Couldn't get registers"));
218 supply_gregset (regcache
, (const gregset_t
*) ®s
);
221 /* Store all valid general-purpose registers in GDB's register cache
222 into the process/thread specified by TID. */
224 store_regs (const struct regcache
*regcache
, int tid
, int regnum
)
229 parea
.len
= sizeof (regs
);
230 parea
.process_addr
= (addr_t
) ®s
;
231 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
232 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
233 perror_with_name (_("Couldn't get registers"));
235 fill_gregset (regcache
, ®s
, regnum
);
237 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
) < 0)
238 perror_with_name (_("Couldn't write registers"));
241 /* Fetch all floating-point registers from process/thread TID and store
242 their values in GDB's register cache. */
244 fetch_fpregs (struct regcache
*regcache
, int tid
)
249 parea
.len
= sizeof (fpregs
);
250 parea
.process_addr
= (addr_t
) &fpregs
;
251 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
252 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
253 perror_with_name (_("Couldn't get floating point status"));
255 supply_fpregset (regcache
, (const fpregset_t
*) &fpregs
);
258 /* Store all valid floating-point registers in GDB's register cache
259 into the process/thread specified by TID. */
261 store_fpregs (const struct regcache
*regcache
, int tid
, int regnum
)
266 parea
.len
= sizeof (fpregs
);
267 parea
.process_addr
= (addr_t
) &fpregs
;
268 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
269 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
270 perror_with_name (_("Couldn't get floating point status"));
272 fill_fpregset (regcache
, &fpregs
, regnum
);
274 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
) < 0)
275 perror_with_name (_("Couldn't write floating point status"));
278 /* Fetch all registers in the kernel's register set whose number is
279 REGSET_ID, whose size is REGSIZE, and whose layout is described by
280 REGSET, from process/thread TID and store their values in GDB's
283 fetch_regset (struct regcache
*regcache
, int tid
,
284 int regset_id
, int regsize
, const struct regset
*regset
)
286 gdb_byte
*buf
= alloca (regsize
);
290 iov
.iov_len
= regsize
;
292 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
294 if (errno
== ENODATA
)
295 regcache_supply_regset (regset
, regcache
, -1, NULL
, regsize
);
297 perror_with_name (_("Couldn't get register set"));
300 regcache_supply_regset (regset
, regcache
, -1, buf
, regsize
);
303 /* Store all registers in the kernel's register set whose number is
304 REGSET_ID, whose size is REGSIZE, and whose layout is described by
305 REGSET, from GDB's register cache back to process/thread TID. */
307 store_regset (struct regcache
*regcache
, int tid
,
308 int regset_id
, int regsize
, const struct regset
*regset
)
310 gdb_byte
*buf
= alloca (regsize
);
314 iov
.iov_len
= regsize
;
316 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
317 perror_with_name (_("Couldn't get register set"));
319 regcache_collect_regset (regset
, regcache
, -1, buf
, regsize
);
321 if (ptrace (PTRACE_SETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
322 perror_with_name (_("Couldn't set register set"));
325 /* Check whether the kernel provides a register set with number REGSET
326 of size REGSIZE for process/thread TID. */
328 check_regset (int tid
, int regset
, int regsize
)
330 gdb_byte
*buf
= alloca (regsize
);
334 iov
.iov_len
= regsize
;
336 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset
, (long) &iov
) >= 0
342 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
343 this for all registers. */
345 s390_linux_fetch_inferior_registers (struct target_ops
*ops
,
346 struct regcache
*regcache
, int regnum
)
348 int tid
= s390_inferior_tid ();
350 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
351 fetch_regs (regcache
, tid
);
353 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
354 fetch_fpregs (regcache
, tid
);
356 if (have_regset_last_break
)
357 if (regnum
== -1 || regnum
== S390_LAST_BREAK_REGNUM
)
358 fetch_regset (regcache
, tid
, NT_S390_LAST_BREAK
, 8,
359 (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32
360 ? &s390_last_break_regset
: &s390x_last_break_regset
));
362 if (have_regset_system_call
)
363 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
364 fetch_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
365 &s390_system_call_regset
);
368 if (regnum
== -1 || S390_IS_TDBREGSET_REGNUM (regnum
))
369 fetch_regset (regcache
, tid
, NT_S390_TDB
, s390_sizeof_tdbregset
,
372 if (have_regset_vxrs
)
374 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
375 && regnum
<= S390_V15_LOWER_REGNUM
))
376 fetch_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
377 &s390_vxrs_low_regset
);
378 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
379 && regnum
<= S390_V31_REGNUM
))
380 fetch_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
381 &s390_vxrs_high_regset
);
385 /* Store register REGNUM back into the child process. If REGNUM is
386 -1, do this for all registers. */
388 s390_linux_store_inferior_registers (struct target_ops
*ops
,
389 struct regcache
*regcache
, int regnum
)
391 int tid
= s390_inferior_tid ();
393 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
394 store_regs (regcache
, tid
, regnum
);
396 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
397 store_fpregs (regcache
, tid
, regnum
);
399 /* S390_LAST_BREAK_REGNUM is read-only. */
401 if (have_regset_system_call
)
402 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
403 store_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
404 &s390_system_call_regset
);
406 if (have_regset_vxrs
)
408 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
409 && regnum
<= S390_V15_LOWER_REGNUM
))
410 store_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
411 &s390_vxrs_low_regset
);
412 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
413 && regnum
<= S390_V31_REGNUM
))
414 store_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
415 &s390_vxrs_high_regset
);
420 /* Hardware-assisted watchpoint handling. */
422 /* We maintain a list of all currently active watchpoints in order
423 to properly handle watchpoint removal.
425 The only thing we actually need is the total address space area
426 spanned by the watchpoints. */
430 struct watch_area
*next
;
435 static struct watch_area
*watch_base
= NULL
;
438 s390_stopped_by_watchpoint (struct target_ops
*ops
)
440 per_lowcore_bits per_lowcore
;
444 /* Speed up common case. */
448 parea
.len
= sizeof (per_lowcore
);
449 parea
.process_addr
= (addr_t
) & per_lowcore
;
450 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
451 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
) < 0)
452 perror_with_name (_("Couldn't retrieve watchpoint status"));
454 result
= (per_lowcore
.perc_storage_alteration
== 1
455 && per_lowcore
.perc_store_real_address
== 0);
459 /* Do not report this watchpoint again. */
460 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
461 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
) < 0)
462 perror_with_name (_("Couldn't clear watchpoint status"));
469 s390_fix_watch_points (struct lwp_info
*lp
)
476 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
477 struct watch_area
*area
;
479 tid
= ptid_get_lwp (lp
->ptid
);
481 tid
= ptid_get_pid (lp
->ptid
);
483 for (area
= watch_base
; area
; area
= area
->next
)
485 watch_lo_addr
= min (watch_lo_addr
, area
->lo_addr
);
486 watch_hi_addr
= max (watch_hi_addr
, area
->hi_addr
);
489 parea
.len
= sizeof (per_info
);
490 parea
.process_addr
= (addr_t
) & per_info
;
491 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
492 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, &parea
) < 0)
493 perror_with_name (_("Couldn't retrieve watchpoint status"));
497 per_info
.control_regs
.bits
.em_storage_alteration
= 1;
498 per_info
.control_regs
.bits
.storage_alt_space_ctl
= 1;
502 per_info
.control_regs
.bits
.em_storage_alteration
= 0;
503 per_info
.control_regs
.bits
.storage_alt_space_ctl
= 0;
505 per_info
.starting_addr
= watch_lo_addr
;
506 per_info
.ending_addr
= watch_hi_addr
;
508 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
) < 0)
509 perror_with_name (_("Couldn't modify watchpoint status"));
513 s390_insert_watchpoint (struct target_ops
*self
,
514 CORE_ADDR addr
, int len
, int type
,
515 struct expression
*cond
)
518 struct watch_area
*area
= xmalloc (sizeof (struct watch_area
));
523 area
->lo_addr
= addr
;
524 area
->hi_addr
= addr
+ len
- 1;
526 area
->next
= watch_base
;
530 s390_fix_watch_points (lp
);
535 s390_remove_watchpoint (struct target_ops
*self
,
536 CORE_ADDR addr
, int len
, int type
,
537 struct expression
*cond
)
540 struct watch_area
*area
, **parea
;
542 for (parea
= &watch_base
; *parea
; parea
= &(*parea
)->next
)
543 if ((*parea
)->lo_addr
== addr
544 && (*parea
)->hi_addr
== addr
+ len
- 1)
549 fprintf_unfiltered (gdb_stderr
,
550 "Attempt to remove nonexistent watchpoint.\n");
559 s390_fix_watch_points (lp
);
564 s390_can_use_hw_breakpoint (struct target_ops
*self
,
565 int type
, int cnt
, int othertype
)
567 return type
== bp_hardware_watchpoint
;
571 s390_region_ok_for_hw_watchpoint (struct target_ops
*self
,
572 CORE_ADDR addr
, int cnt
)
578 s390_target_wordsize (void)
582 /* Check for 64-bit inferior process. This is the case when the host is
583 64-bit, and in addition bit 32 of the PSW mask is set. */
588 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
589 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
597 s390_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
598 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
600 int sizeof_auxv_field
= s390_target_wordsize ();
601 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
602 gdb_byte
*ptr
= *readptr
;
607 if (endptr
- ptr
< sizeof_auxv_field
* 2)
610 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
611 ptr
+= sizeof_auxv_field
;
612 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
613 ptr
+= sizeof_auxv_field
;
619 static const struct target_desc
*
620 s390_read_description (struct target_ops
*ops
)
622 int tid
= s390_inferior_tid ();
624 have_regset_last_break
625 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
626 have_regset_system_call
627 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
629 /* If GDB itself is compiled as 64-bit, we are running on a machine in
630 z/Architecture mode. If the target is running in 64-bit addressing
631 mode, report s390x architecture. If the target is running in 31-bit
632 addressing mode, but the kernel supports using 64-bit registers in
633 that mode, report s390 architecture with 64-bit GPRs. */
638 target_auxv_search (¤t_target
, AT_HWCAP
, &hwcap
);
639 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
640 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
642 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
643 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
644 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
646 if (s390_target_wordsize () == 8)
647 return (have_regset_vxrs
?
648 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
649 tdesc_s390x_vx_linux64
) :
650 have_regset_tdb
? tdesc_s390x_te_linux64
:
651 have_regset_system_call
? tdesc_s390x_linux64v2
:
652 have_regset_last_break
? tdesc_s390x_linux64v1
:
653 tdesc_s390x_linux64
);
655 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
656 return (have_regset_vxrs
?
657 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
658 tdesc_s390_vx_linux64
) :
659 have_regset_tdb
? tdesc_s390_te_linux64
:
660 have_regset_system_call
? tdesc_s390_linux64v2
:
661 have_regset_last_break
? tdesc_s390_linux64v1
:
666 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
667 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
668 mode, report s390 architecture with 32-bit GPRs. */
669 return (have_regset_system_call
? tdesc_s390_linux32v2
:
670 have_regset_last_break
? tdesc_s390_linux32v1
:
674 void _initialize_s390_nat (void);
677 _initialize_s390_nat (void)
679 struct target_ops
*t
;
681 /* Fill in the generic GNU/Linux methods. */
684 /* Add our register access methods. */
685 t
->to_fetch_registers
= s390_linux_fetch_inferior_registers
;
686 t
->to_store_registers
= s390_linux_store_inferior_registers
;
688 /* Add our watchpoint methods. */
689 t
->to_can_use_hw_breakpoint
= s390_can_use_hw_breakpoint
;
690 t
->to_region_ok_for_hw_watchpoint
= s390_region_ok_for_hw_watchpoint
;
691 t
->to_have_continuable_watchpoint
= 1;
692 t
->to_stopped_by_watchpoint
= s390_stopped_by_watchpoint
;
693 t
->to_insert_watchpoint
= s390_insert_watchpoint
;
694 t
->to_remove_watchpoint
= s390_remove_watchpoint
;
696 /* Detect target architecture. */
697 t
->to_read_description
= s390_read_description
;
698 t
->to_auxv_parse
= s390_auxv_parse
;
700 /* Register the target. */
701 linux_nat_add_target (t
);
702 linux_nat_set_new_thread (t
, s390_fix_watch_points
);