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 /* Per-thread arch-specific data. */
53 /* Non-zero if the thread's PER info must be re-written. */
57 static int have_regset_last_break
= 0;
58 static int have_regset_system_call
= 0;
59 static int have_regset_tdb
= 0;
60 static int have_regset_vxrs
= 0;
62 /* Register map for 32-bit executables running under a 64-bit
66 static const struct regcache_map_entry s390_64_regmap_gregset
[] =
68 /* Skip PSWM and PSWA, since they must be handled specially. */
69 { 2, REGCACHE_MAP_SKIP
, 8 },
70 { 1, S390_R0_UPPER_REGNUM
, 4 }, { 1, S390_R0_REGNUM
, 4 },
71 { 1, S390_R1_UPPER_REGNUM
, 4 }, { 1, S390_R1_REGNUM
, 4 },
72 { 1, S390_R2_UPPER_REGNUM
, 4 }, { 1, S390_R2_REGNUM
, 4 },
73 { 1, S390_R3_UPPER_REGNUM
, 4 }, { 1, S390_R3_REGNUM
, 4 },
74 { 1, S390_R4_UPPER_REGNUM
, 4 }, { 1, S390_R4_REGNUM
, 4 },
75 { 1, S390_R5_UPPER_REGNUM
, 4 }, { 1, S390_R5_REGNUM
, 4 },
76 { 1, S390_R6_UPPER_REGNUM
, 4 }, { 1, S390_R6_REGNUM
, 4 },
77 { 1, S390_R7_UPPER_REGNUM
, 4 }, { 1, S390_R7_REGNUM
, 4 },
78 { 1, S390_R8_UPPER_REGNUM
, 4 }, { 1, S390_R8_REGNUM
, 4 },
79 { 1, S390_R9_UPPER_REGNUM
, 4 }, { 1, S390_R9_REGNUM
, 4 },
80 { 1, S390_R10_UPPER_REGNUM
, 4 }, { 1, S390_R10_REGNUM
, 4 },
81 { 1, S390_R11_UPPER_REGNUM
, 4 }, { 1, S390_R11_REGNUM
, 4 },
82 { 1, S390_R12_UPPER_REGNUM
, 4 }, { 1, S390_R12_REGNUM
, 4 },
83 { 1, S390_R13_UPPER_REGNUM
, 4 }, { 1, S390_R13_REGNUM
, 4 },
84 { 1, S390_R14_UPPER_REGNUM
, 4 }, { 1, S390_R14_REGNUM
, 4 },
85 { 1, S390_R15_UPPER_REGNUM
, 4 }, { 1, S390_R15_REGNUM
, 4 },
86 { 16, S390_A0_REGNUM
, 4 },
87 { 1, REGCACHE_MAP_SKIP
, 4 }, { 1, S390_ORIG_R2_REGNUM
, 4 },
91 static const struct regset s390_64_gregset
=
93 s390_64_regmap_gregset
,
94 regcache_supply_regset
,
95 regcache_collect_regset
98 #define S390_PSWM_OFFSET 0
99 #define S390_PSWA_OFFSET 8
102 /* Fill GDB's register array with the general-purpose register values
105 When debugging a 32-bit executable running under a 64-bit kernel,
106 we have to fix up the 64-bit registers we get from the kernel to
107 make them look like 32-bit registers. */
110 supply_gregset (struct regcache
*regcache
, const gregset_t
*regp
)
113 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
114 if (gdbarch_ptr_bit (gdbarch
) == 32)
116 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
120 regcache_supply_regset (&s390_64_gregset
, regcache
, -1,
121 regp
, sizeof (gregset_t
));
122 pswm
= extract_unsigned_integer ((const gdb_byte
*) regp
123 + S390_PSWM_OFFSET
, 8, byte_order
);
124 pswa
= extract_unsigned_integer ((const gdb_byte
*) regp
125 + S390_PSWA_OFFSET
, 8, byte_order
);
126 store_unsigned_integer (buf
, 4, byte_order
, (pswm
>> 32) | 0x80000);
127 regcache_raw_supply (regcache
, S390_PSWM_REGNUM
, buf
);
128 store_unsigned_integer (buf
, 4, byte_order
,
129 (pswa
& 0x7fffffff) | (pswm
& 0x80000000));
130 regcache_raw_supply (regcache
, S390_PSWA_REGNUM
, buf
);
135 regcache_supply_regset (&s390_gregset
, regcache
, -1, regp
,
139 /* Fill register REGNO (if it is a general-purpose register) in
140 *REGP with the value in GDB's register array. If REGNO is -1,
141 do this for all registers. */
144 fill_gregset (const struct regcache
*regcache
, gregset_t
*regp
, int regno
)
147 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
148 if (gdbarch_ptr_bit (gdbarch
) == 32)
150 regcache_collect_regset (&s390_64_gregset
, regcache
, regno
,
151 regp
, sizeof (gregset_t
));
154 || regno
== S390_PSWM_REGNUM
|| regno
== S390_PSWA_REGNUM
)
156 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
159 gdb_byte
*pswm_p
= (gdb_byte
*) regp
+ S390_PSWM_OFFSET
;
160 gdb_byte
*pswa_p
= (gdb_byte
*) regp
+ S390_PSWA_OFFSET
;
162 pswm
= extract_unsigned_integer (pswm_p
, 8, byte_order
);
164 if (regno
== -1 || regno
== S390_PSWM_REGNUM
)
167 regcache_raw_collect (regcache
, S390_PSWM_REGNUM
, buf
);
168 pswm
|= (extract_unsigned_integer (buf
, 4, byte_order
)
172 if (regno
== -1 || regno
== S390_PSWA_REGNUM
)
174 regcache_raw_collect (regcache
, S390_PSWA_REGNUM
, buf
);
175 pswa
= extract_unsigned_integer (buf
, 4, byte_order
);
176 pswm
^= (pswm
^ pswa
) & 0x80000000;
178 store_unsigned_integer (pswa_p
, 8, byte_order
, pswa
);
181 store_unsigned_integer (pswm_p
, 8, byte_order
, pswm
);
187 regcache_collect_regset (&s390_gregset
, regcache
, regno
, regp
,
191 /* Fill GDB's register array with the floating-point register values
194 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*regp
)
196 regcache_supply_regset (&s390_fpregset
, regcache
, -1, regp
,
197 sizeof (fpregset_t
));
200 /* Fill register REGNO (if it is a general-purpose register) in
201 *REGP with the value in GDB's register array. If REGNO is -1,
202 do this for all registers. */
204 fill_fpregset (const struct regcache
*regcache
, fpregset_t
*regp
, int regno
)
206 regcache_collect_regset (&s390_fpregset
, regcache
, regno
, regp
,
207 sizeof (fpregset_t
));
210 /* Find the TID for the current inferior thread to use with ptrace. */
212 s390_inferior_tid (void)
214 /* GNU/Linux LWP ID's are process ID's. */
215 int tid
= ptid_get_lwp (inferior_ptid
);
217 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
222 /* Fetch all general-purpose registers from process/thread TID and
223 store their values in GDB's register cache. */
225 fetch_regs (struct regcache
*regcache
, int tid
)
230 parea
.len
= sizeof (regs
);
231 parea
.process_addr
= (addr_t
) ®s
;
232 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
233 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
234 perror_with_name (_("Couldn't get registers"));
236 supply_gregset (regcache
, (const gregset_t
*) ®s
);
239 /* Store all valid general-purpose registers in GDB's register cache
240 into the process/thread specified by TID. */
242 store_regs (const struct regcache
*regcache
, int tid
, int regnum
)
247 parea
.len
= sizeof (regs
);
248 parea
.process_addr
= (addr_t
) ®s
;
249 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
250 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
251 perror_with_name (_("Couldn't get registers"));
253 fill_gregset (regcache
, ®s
, regnum
);
255 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
) < 0)
256 perror_with_name (_("Couldn't write registers"));
259 /* Fetch all floating-point registers from process/thread TID and store
260 their values in GDB's register cache. */
262 fetch_fpregs (struct regcache
*regcache
, int tid
)
267 parea
.len
= sizeof (fpregs
);
268 parea
.process_addr
= (addr_t
) &fpregs
;
269 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
270 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
271 perror_with_name (_("Couldn't get floating point status"));
273 supply_fpregset (regcache
, (const fpregset_t
*) &fpregs
);
276 /* Store all valid floating-point registers in GDB's register cache
277 into the process/thread specified by TID. */
279 store_fpregs (const struct regcache
*regcache
, int tid
, int regnum
)
284 parea
.len
= sizeof (fpregs
);
285 parea
.process_addr
= (addr_t
) &fpregs
;
286 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
287 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
288 perror_with_name (_("Couldn't get floating point status"));
290 fill_fpregset (regcache
, &fpregs
, regnum
);
292 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
) < 0)
293 perror_with_name (_("Couldn't write floating point status"));
296 /* Fetch all registers in the kernel's register set whose number is
297 REGSET_ID, whose size is REGSIZE, and whose layout is described by
298 REGSET, from process/thread TID and store their values in GDB's
301 fetch_regset (struct regcache
*regcache
, int tid
,
302 int regset_id
, int regsize
, const struct regset
*regset
)
304 gdb_byte
*buf
= alloca (regsize
);
308 iov
.iov_len
= regsize
;
310 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
312 if (errno
== ENODATA
)
313 regcache_supply_regset (regset
, regcache
, -1, NULL
, regsize
);
315 perror_with_name (_("Couldn't get register set"));
318 regcache_supply_regset (regset
, regcache
, -1, buf
, regsize
);
321 /* Store all registers in the kernel's register set whose number is
322 REGSET_ID, whose size is REGSIZE, and whose layout is described by
323 REGSET, from GDB's register cache back to process/thread TID. */
325 store_regset (struct regcache
*regcache
, int tid
,
326 int regset_id
, int regsize
, const struct regset
*regset
)
328 gdb_byte
*buf
= alloca (regsize
);
332 iov
.iov_len
= regsize
;
334 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
335 perror_with_name (_("Couldn't get register set"));
337 regcache_collect_regset (regset
, regcache
, -1, buf
, regsize
);
339 if (ptrace (PTRACE_SETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
340 perror_with_name (_("Couldn't set register set"));
343 /* Check whether the kernel provides a register set with number REGSET
344 of size REGSIZE for process/thread TID. */
346 check_regset (int tid
, int regset
, int regsize
)
348 gdb_byte
*buf
= alloca (regsize
);
352 iov
.iov_len
= regsize
;
354 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset
, (long) &iov
) >= 0
360 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
361 this for all registers. */
363 s390_linux_fetch_inferior_registers (struct target_ops
*ops
,
364 struct regcache
*regcache
, int regnum
)
366 int tid
= s390_inferior_tid ();
368 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
369 fetch_regs (regcache
, tid
);
371 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
372 fetch_fpregs (regcache
, tid
);
374 if (have_regset_last_break
)
375 if (regnum
== -1 || regnum
== S390_LAST_BREAK_REGNUM
)
376 fetch_regset (regcache
, tid
, NT_S390_LAST_BREAK
, 8,
377 (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32
378 ? &s390_last_break_regset
: &s390x_last_break_regset
));
380 if (have_regset_system_call
)
381 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
382 fetch_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
383 &s390_system_call_regset
);
386 if (regnum
== -1 || S390_IS_TDBREGSET_REGNUM (regnum
))
387 fetch_regset (regcache
, tid
, NT_S390_TDB
, s390_sizeof_tdbregset
,
390 if (have_regset_vxrs
)
392 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
393 && regnum
<= S390_V15_LOWER_REGNUM
))
394 fetch_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
395 &s390_vxrs_low_regset
);
396 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
397 && regnum
<= S390_V31_REGNUM
))
398 fetch_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
399 &s390_vxrs_high_regset
);
403 /* Store register REGNUM back into the child process. If REGNUM is
404 -1, do this for all registers. */
406 s390_linux_store_inferior_registers (struct target_ops
*ops
,
407 struct regcache
*regcache
, int regnum
)
409 int tid
= s390_inferior_tid ();
411 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
412 store_regs (regcache
, tid
, regnum
);
414 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
415 store_fpregs (regcache
, tid
, regnum
);
417 /* S390_LAST_BREAK_REGNUM is read-only. */
419 if (have_regset_system_call
)
420 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
421 store_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
422 &s390_system_call_regset
);
424 if (have_regset_vxrs
)
426 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
427 && regnum
<= S390_V15_LOWER_REGNUM
))
428 store_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
429 &s390_vxrs_low_regset
);
430 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
431 && regnum
<= S390_V31_REGNUM
))
432 store_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
433 &s390_vxrs_high_regset
);
438 /* Hardware-assisted watchpoint handling. */
440 /* We maintain a list of all currently active watchpoints in order
441 to properly handle watchpoint removal.
443 The only thing we actually need is the total address space area
444 spanned by the watchpoints. */
448 struct watch_area
*next
;
453 static struct watch_area
*watch_base
= NULL
;
456 s390_stopped_by_watchpoint (struct target_ops
*ops
)
458 per_lowcore_bits per_lowcore
;
462 /* Speed up common case. */
466 parea
.len
= sizeof (per_lowcore
);
467 parea
.process_addr
= (addr_t
) & per_lowcore
;
468 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
469 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
) < 0)
470 perror_with_name (_("Couldn't retrieve watchpoint status"));
472 result
= (per_lowcore
.perc_storage_alteration
== 1
473 && per_lowcore
.perc_store_real_address
== 0);
477 /* Do not report this watchpoint again. */
478 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
479 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
) < 0)
480 perror_with_name (_("Couldn't clear watchpoint status"));
486 /* Each time before resuming a thread, update its PER info. */
489 s390_prepare_to_resume (struct lwp_info
*lp
)
496 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
497 struct watch_area
*area
;
499 if (lp
->arch_private
== NULL
500 || !lp
->arch_private
->per_info_changed
)
503 lp
->arch_private
->per_info_changed
= 0;
505 tid
= ptid_get_lwp (lp
->ptid
);
507 tid
= ptid_get_pid (lp
->ptid
);
509 for (area
= watch_base
; area
; area
= area
->next
)
511 watch_lo_addr
= min (watch_lo_addr
, area
->lo_addr
);
512 watch_hi_addr
= max (watch_hi_addr
, area
->hi_addr
);
515 parea
.len
= sizeof (per_info
);
516 parea
.process_addr
= (addr_t
) & per_info
;
517 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
518 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, &parea
) < 0)
519 perror_with_name (_("Couldn't retrieve watchpoint status"));
523 per_info
.control_regs
.bits
.em_storage_alteration
= 1;
524 per_info
.control_regs
.bits
.storage_alt_space_ctl
= 1;
528 per_info
.control_regs
.bits
.em_storage_alteration
= 0;
529 per_info
.control_regs
.bits
.storage_alt_space_ctl
= 0;
531 per_info
.starting_addr
= watch_lo_addr
;
532 per_info
.ending_addr
= watch_hi_addr
;
534 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
) < 0)
535 perror_with_name (_("Couldn't modify watchpoint status"));
538 /* Make sure that LP is stopped and mark its PER info as changed, so
539 the next resume will update it. */
542 s390_refresh_per_info (struct lwp_info
*lp
)
544 if (lp
->arch_private
== NULL
)
545 lp
->arch_private
= XCNEW (struct arch_lwp_info
);
547 lp
->arch_private
->per_info_changed
= 1;
553 /* When attaching to a new thread, mark its PER info as changed. */
556 s390_new_thread (struct lwp_info
*lp
)
558 lp
->arch_private
= XCNEW (struct arch_lwp_info
);
559 lp
->arch_private
->per_info_changed
= 1;
563 s390_insert_watchpoint (struct target_ops
*self
,
564 CORE_ADDR addr
, int len
, int type
,
565 struct expression
*cond
)
568 struct watch_area
*area
= xmalloc (sizeof (struct watch_area
));
573 area
->lo_addr
= addr
;
574 area
->hi_addr
= addr
+ len
- 1;
576 area
->next
= watch_base
;
580 s390_refresh_per_info (lp
);
585 s390_remove_watchpoint (struct target_ops
*self
,
586 CORE_ADDR addr
, int len
, int type
,
587 struct expression
*cond
)
590 struct watch_area
*area
, **parea
;
592 for (parea
= &watch_base
; *parea
; parea
= &(*parea
)->next
)
593 if ((*parea
)->lo_addr
== addr
594 && (*parea
)->hi_addr
== addr
+ len
- 1)
599 fprintf_unfiltered (gdb_stderr
,
600 "Attempt to remove nonexistent watchpoint.\n");
609 s390_refresh_per_info (lp
);
614 s390_can_use_hw_breakpoint (struct target_ops
*self
,
615 int type
, int cnt
, int othertype
)
617 return type
== bp_hardware_watchpoint
;
621 s390_region_ok_for_hw_watchpoint (struct target_ops
*self
,
622 CORE_ADDR addr
, int cnt
)
628 s390_target_wordsize (void)
632 /* Check for 64-bit inferior process. This is the case when the host is
633 64-bit, and in addition bit 32 of the PSW mask is set. */
638 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
639 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
647 s390_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
648 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
650 int sizeof_auxv_field
= s390_target_wordsize ();
651 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
652 gdb_byte
*ptr
= *readptr
;
657 if (endptr
- ptr
< sizeof_auxv_field
* 2)
660 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
661 ptr
+= sizeof_auxv_field
;
662 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
663 ptr
+= sizeof_auxv_field
;
669 static const struct target_desc
*
670 s390_read_description (struct target_ops
*ops
)
672 int tid
= s390_inferior_tid ();
674 have_regset_last_break
675 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
676 have_regset_system_call
677 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
679 /* If GDB itself is compiled as 64-bit, we are running on a machine in
680 z/Architecture mode. If the target is running in 64-bit addressing
681 mode, report s390x architecture. If the target is running in 31-bit
682 addressing mode, but the kernel supports using 64-bit registers in
683 that mode, report s390 architecture with 64-bit GPRs. */
688 target_auxv_search (¤t_target
, AT_HWCAP
, &hwcap
);
689 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
690 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
692 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
693 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
694 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
696 if (s390_target_wordsize () == 8)
697 return (have_regset_vxrs
?
698 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
699 tdesc_s390x_vx_linux64
) :
700 have_regset_tdb
? tdesc_s390x_te_linux64
:
701 have_regset_system_call
? tdesc_s390x_linux64v2
:
702 have_regset_last_break
? tdesc_s390x_linux64v1
:
703 tdesc_s390x_linux64
);
705 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
706 return (have_regset_vxrs
?
707 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
708 tdesc_s390_vx_linux64
) :
709 have_regset_tdb
? tdesc_s390_te_linux64
:
710 have_regset_system_call
? tdesc_s390_linux64v2
:
711 have_regset_last_break
? tdesc_s390_linux64v1
:
716 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
717 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
718 mode, report s390 architecture with 32-bit GPRs. */
719 return (have_regset_system_call
? tdesc_s390_linux32v2
:
720 have_regset_last_break
? tdesc_s390_linux32v1
:
724 void _initialize_s390_nat (void);
727 _initialize_s390_nat (void)
729 struct target_ops
*t
;
731 /* Fill in the generic GNU/Linux methods. */
734 /* Add our register access methods. */
735 t
->to_fetch_registers
= s390_linux_fetch_inferior_registers
;
736 t
->to_store_registers
= s390_linux_store_inferior_registers
;
738 /* Add our watchpoint methods. */
739 t
->to_can_use_hw_breakpoint
= s390_can_use_hw_breakpoint
;
740 t
->to_region_ok_for_hw_watchpoint
= s390_region_ok_for_hw_watchpoint
;
741 t
->to_have_continuable_watchpoint
= 1;
742 t
->to_stopped_by_watchpoint
= s390_stopped_by_watchpoint
;
743 t
->to_insert_watchpoint
= s390_insert_watchpoint
;
744 t
->to_remove_watchpoint
= s390_remove_watchpoint
;
746 /* Detect target architecture. */
747 t
->to_read_description
= s390_read_description
;
748 t
->to_auxv_parse
= s390_auxv_parse
;
750 /* Register the target. */
751 linux_nat_add_target (t
);
752 linux_nat_set_new_thread (t
, s390_new_thread
);
753 linux_nat_set_prepare_to_resume (t
, s390_prepare_to_resume
);