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
);
160 regcache_raw_collect (regcache
, S390_PSWM_REGNUM
, buf
);
161 pswm
= extract_unsigned_integer (buf
, 4, byte_order
);
162 regcache_raw_collect (regcache
, S390_PSWA_REGNUM
, buf
);
163 pswa
= extract_unsigned_integer (buf
, 4, byte_order
);
165 if (regno
== -1 || regno
== S390_PSWM_REGNUM
)
166 store_unsigned_integer ((gdb_byte
*) regp
+ S390_PSWM_OFFSET
, 8,
167 byte_order
, ((pswm
& 0xfff7ffff) << 32) |
168 (pswa
& 0x80000000));
169 if (regno
== -1 || regno
== S390_PSWA_REGNUM
)
170 store_unsigned_integer ((gdb_byte
*) regp
+ S390_PSWA_OFFSET
, 8,
171 byte_order
, pswa
& 0x7fffffff);
177 regcache_collect_regset (&s390_gregset
, regcache
, regno
, regp
,
181 /* Fill GDB's register array with the floating-point register values
184 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*regp
)
186 regcache_supply_regset (&s390_fpregset
, regcache
, -1, regp
,
187 sizeof (fpregset_t
));
190 /* Fill register REGNO (if it is a general-purpose register) in
191 *REGP with the value in GDB's register array. If REGNO is -1,
192 do this for all registers. */
194 fill_fpregset (const struct regcache
*regcache
, fpregset_t
*regp
, int regno
)
196 regcache_collect_regset (&s390_fpregset
, regcache
, regno
, regp
,
197 sizeof (fpregset_t
));
200 /* Find the TID for the current inferior thread to use with ptrace. */
202 s390_inferior_tid (void)
204 /* GNU/Linux LWP ID's are process ID's. */
205 int tid
= ptid_get_lwp (inferior_ptid
);
207 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
212 /* Fetch all general-purpose registers from process/thread TID and
213 store their values in GDB's register cache. */
215 fetch_regs (struct regcache
*regcache
, int tid
)
220 parea
.len
= sizeof (regs
);
221 parea
.process_addr
= (addr_t
) ®s
;
222 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
223 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
224 perror_with_name (_("Couldn't get registers"));
226 supply_gregset (regcache
, (const gregset_t
*) ®s
);
229 /* Store all valid general-purpose registers in GDB's register cache
230 into the process/thread specified by TID. */
232 store_regs (const struct regcache
*regcache
, int tid
, int regnum
)
237 parea
.len
= sizeof (regs
);
238 parea
.process_addr
= (addr_t
) ®s
;
239 parea
.kernel_addr
= offsetof (struct user_regs_struct
, psw
);
240 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
241 perror_with_name (_("Couldn't get registers"));
243 fill_gregset (regcache
, ®s
, regnum
);
245 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
) < 0)
246 perror_with_name (_("Couldn't write registers"));
249 /* Fetch all floating-point registers from process/thread TID and store
250 their values in GDB's register cache. */
252 fetch_fpregs (struct regcache
*regcache
, int tid
)
257 parea
.len
= sizeof (fpregs
);
258 parea
.process_addr
= (addr_t
) &fpregs
;
259 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
260 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
261 perror_with_name (_("Couldn't get floating point status"));
263 supply_fpregset (regcache
, (const fpregset_t
*) &fpregs
);
266 /* Store all valid floating-point registers in GDB's register cache
267 into the process/thread specified by TID. */
269 store_fpregs (const struct regcache
*regcache
, int tid
, int regnum
)
274 parea
.len
= sizeof (fpregs
);
275 parea
.process_addr
= (addr_t
) &fpregs
;
276 parea
.kernel_addr
= offsetof (struct user_regs_struct
, fp_regs
);
277 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, (long) &parea
) < 0)
278 perror_with_name (_("Couldn't get floating point status"));
280 fill_fpregset (regcache
, &fpregs
, regnum
);
282 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, (long) &parea
) < 0)
283 perror_with_name (_("Couldn't write floating point status"));
286 /* Fetch all registers in the kernel's register set whose number is
287 REGSET_ID, whose size is REGSIZE, and whose layout is described by
288 REGSET, from process/thread TID and store their values in GDB's
291 fetch_regset (struct regcache
*regcache
, int tid
,
292 int regset_id
, int regsize
, const struct regset
*regset
)
294 gdb_byte
*buf
= alloca (regsize
);
298 iov
.iov_len
= regsize
;
300 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
302 if (errno
== ENODATA
)
303 regcache_supply_regset (regset
, regcache
, -1, NULL
, regsize
);
305 perror_with_name (_("Couldn't get register set"));
308 regcache_supply_regset (regset
, regcache
, -1, buf
, regsize
);
311 /* Store all registers in the kernel's register set whose number is
312 REGSET_ID, whose size is REGSIZE, and whose layout is described by
313 REGSET, from GDB's register cache back to process/thread TID. */
315 store_regset (struct regcache
*regcache
, int tid
,
316 int regset_id
, int regsize
, const struct regset
*regset
)
318 gdb_byte
*buf
= alloca (regsize
);
322 iov
.iov_len
= regsize
;
324 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
325 perror_with_name (_("Couldn't get register set"));
327 regcache_collect_regset (regset
, regcache
, -1, buf
, regsize
);
329 if (ptrace (PTRACE_SETREGSET
, tid
, (long) regset_id
, (long) &iov
) < 0)
330 perror_with_name (_("Couldn't set register set"));
333 /* Check whether the kernel provides a register set with number REGSET
334 of size REGSIZE for process/thread TID. */
336 check_regset (int tid
, int regset
, int regsize
)
338 gdb_byte
*buf
= alloca (regsize
);
342 iov
.iov_len
= regsize
;
344 if (ptrace (PTRACE_GETREGSET
, tid
, (long) regset
, (long) &iov
) >= 0
350 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
351 this for all registers. */
353 s390_linux_fetch_inferior_registers (struct target_ops
*ops
,
354 struct regcache
*regcache
, int regnum
)
356 int tid
= s390_inferior_tid ();
358 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
359 fetch_regs (regcache
, tid
);
361 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
362 fetch_fpregs (regcache
, tid
);
364 if (have_regset_last_break
)
365 if (regnum
== -1 || regnum
== S390_LAST_BREAK_REGNUM
)
366 fetch_regset (regcache
, tid
, NT_S390_LAST_BREAK
, 8,
367 (gdbarch_ptr_bit (get_regcache_arch (regcache
)) == 32
368 ? &s390_last_break_regset
: &s390x_last_break_regset
));
370 if (have_regset_system_call
)
371 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
372 fetch_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
373 &s390_system_call_regset
);
376 if (regnum
== -1 || S390_IS_TDBREGSET_REGNUM (regnum
))
377 fetch_regset (regcache
, tid
, NT_S390_TDB
, s390_sizeof_tdbregset
,
380 if (have_regset_vxrs
)
382 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
383 && regnum
<= S390_V15_LOWER_REGNUM
))
384 fetch_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
385 &s390_vxrs_low_regset
);
386 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
387 && regnum
<= S390_V31_REGNUM
))
388 fetch_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
389 &s390_vxrs_high_regset
);
393 /* Store register REGNUM back into the child process. If REGNUM is
394 -1, do this for all registers. */
396 s390_linux_store_inferior_registers (struct target_ops
*ops
,
397 struct regcache
*regcache
, int regnum
)
399 int tid
= s390_inferior_tid ();
401 if (regnum
== -1 || S390_IS_GREGSET_REGNUM (regnum
))
402 store_regs (regcache
, tid
, regnum
);
404 if (regnum
== -1 || S390_IS_FPREGSET_REGNUM (regnum
))
405 store_fpregs (regcache
, tid
, regnum
);
407 /* S390_LAST_BREAK_REGNUM is read-only. */
409 if (have_regset_system_call
)
410 if (regnum
== -1 || regnum
== S390_SYSTEM_CALL_REGNUM
)
411 store_regset (regcache
, tid
, NT_S390_SYSTEM_CALL
, 4,
412 &s390_system_call_regset
);
414 if (have_regset_vxrs
)
416 if (regnum
== -1 || (regnum
>= S390_V0_LOWER_REGNUM
417 && regnum
<= S390_V15_LOWER_REGNUM
))
418 store_regset (regcache
, tid
, NT_S390_VXRS_LOW
, 16 * 8,
419 &s390_vxrs_low_regset
);
420 if (regnum
== -1 || (regnum
>= S390_V16_REGNUM
421 && regnum
<= S390_V31_REGNUM
))
422 store_regset (regcache
, tid
, NT_S390_VXRS_HIGH
, 16 * 16,
423 &s390_vxrs_high_regset
);
428 /* Hardware-assisted watchpoint handling. */
430 /* We maintain a list of all currently active watchpoints in order
431 to properly handle watchpoint removal.
433 The only thing we actually need is the total address space area
434 spanned by the watchpoints. */
438 struct watch_area
*next
;
443 static struct watch_area
*watch_base
= NULL
;
446 s390_stopped_by_watchpoint (struct target_ops
*ops
)
448 per_lowcore_bits per_lowcore
;
452 /* Speed up common case. */
456 parea
.len
= sizeof (per_lowcore
);
457 parea
.process_addr
= (addr_t
) & per_lowcore
;
458 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
.lowcore
);
459 if (ptrace (PTRACE_PEEKUSR_AREA
, s390_inferior_tid (), &parea
) < 0)
460 perror_with_name (_("Couldn't retrieve watchpoint status"));
462 result
= (per_lowcore
.perc_storage_alteration
== 1
463 && per_lowcore
.perc_store_real_address
== 0);
467 /* Do not report this watchpoint again. */
468 memset (&per_lowcore
, 0, sizeof (per_lowcore
));
469 if (ptrace (PTRACE_POKEUSR_AREA
, s390_inferior_tid (), &parea
) < 0)
470 perror_with_name (_("Couldn't clear watchpoint status"));
476 /* Each time before resuming a thread, update its PER info. */
479 s390_prepare_to_resume (struct lwp_info
*lp
)
486 CORE_ADDR watch_lo_addr
= (CORE_ADDR
)-1, watch_hi_addr
= 0;
487 struct watch_area
*area
;
489 if (lp
->arch_private
== NULL
490 || !lp
->arch_private
->per_info_changed
)
493 lp
->arch_private
->per_info_changed
= 0;
495 tid
= ptid_get_lwp (lp
->ptid
);
497 tid
= ptid_get_pid (lp
->ptid
);
499 for (area
= watch_base
; area
; area
= area
->next
)
501 watch_lo_addr
= min (watch_lo_addr
, area
->lo_addr
);
502 watch_hi_addr
= max (watch_hi_addr
, area
->hi_addr
);
505 parea
.len
= sizeof (per_info
);
506 parea
.process_addr
= (addr_t
) & per_info
;
507 parea
.kernel_addr
= offsetof (struct user_regs_struct
, per_info
);
508 if (ptrace (PTRACE_PEEKUSR_AREA
, tid
, &parea
) < 0)
509 perror_with_name (_("Couldn't retrieve watchpoint status"));
513 per_info
.control_regs
.bits
.em_storage_alteration
= 1;
514 per_info
.control_regs
.bits
.storage_alt_space_ctl
= 1;
518 per_info
.control_regs
.bits
.em_storage_alteration
= 0;
519 per_info
.control_regs
.bits
.storage_alt_space_ctl
= 0;
521 per_info
.starting_addr
= watch_lo_addr
;
522 per_info
.ending_addr
= watch_hi_addr
;
524 if (ptrace (PTRACE_POKEUSR_AREA
, tid
, &parea
) < 0)
525 perror_with_name (_("Couldn't modify watchpoint status"));
528 /* Make sure that LP is stopped and mark its PER info as changed, so
529 the next resume will update it. */
532 s390_refresh_per_info (struct lwp_info
*lp
)
534 if (lp
->arch_private
== NULL
)
535 lp
->arch_private
= XCNEW (struct arch_lwp_info
);
537 lp
->arch_private
->per_info_changed
= 1;
543 /* When attaching to a new thread, mark its PER info as changed. */
546 s390_new_thread (struct lwp_info
*lp
)
548 lp
->arch_private
= XCNEW (struct arch_lwp_info
);
549 lp
->arch_private
->per_info_changed
= 1;
553 s390_insert_watchpoint (struct target_ops
*self
,
554 CORE_ADDR addr
, int len
, int type
,
555 struct expression
*cond
)
558 struct watch_area
*area
= xmalloc (sizeof (struct watch_area
));
563 area
->lo_addr
= addr
;
564 area
->hi_addr
= addr
+ len
- 1;
566 area
->next
= watch_base
;
570 s390_refresh_per_info (lp
);
575 s390_remove_watchpoint (struct target_ops
*self
,
576 CORE_ADDR addr
, int len
, int type
,
577 struct expression
*cond
)
580 struct watch_area
*area
, **parea
;
582 for (parea
= &watch_base
; *parea
; parea
= &(*parea
)->next
)
583 if ((*parea
)->lo_addr
== addr
584 && (*parea
)->hi_addr
== addr
+ len
- 1)
589 fprintf_unfiltered (gdb_stderr
,
590 "Attempt to remove nonexistent watchpoint.\n");
599 s390_refresh_per_info (lp
);
604 s390_can_use_hw_breakpoint (struct target_ops
*self
,
605 int type
, int cnt
, int othertype
)
607 return type
== bp_hardware_watchpoint
;
611 s390_region_ok_for_hw_watchpoint (struct target_ops
*self
,
612 CORE_ADDR addr
, int cnt
)
618 s390_target_wordsize (void)
622 /* Check for 64-bit inferior process. This is the case when the host is
623 64-bit, and in addition bit 32 of the PSW mask is set. */
628 pswm
= (long) ptrace (PTRACE_PEEKUSER
, s390_inferior_tid (), PT_PSWMASK
, 0);
629 if (errno
== 0 && (pswm
& 0x100000000ul
) != 0)
637 s390_auxv_parse (struct target_ops
*ops
, gdb_byte
**readptr
,
638 gdb_byte
*endptr
, CORE_ADDR
*typep
, CORE_ADDR
*valp
)
640 int sizeof_auxv_field
= s390_target_wordsize ();
641 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
642 gdb_byte
*ptr
= *readptr
;
647 if (endptr
- ptr
< sizeof_auxv_field
* 2)
650 *typep
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
651 ptr
+= sizeof_auxv_field
;
652 *valp
= extract_unsigned_integer (ptr
, sizeof_auxv_field
, byte_order
);
653 ptr
+= sizeof_auxv_field
;
659 static const struct target_desc
*
660 s390_read_description (struct target_ops
*ops
)
662 int tid
= s390_inferior_tid ();
664 have_regset_last_break
665 = check_regset (tid
, NT_S390_LAST_BREAK
, 8);
666 have_regset_system_call
667 = check_regset (tid
, NT_S390_SYSTEM_CALL
, 4);
669 /* If GDB itself is compiled as 64-bit, we are running on a machine in
670 z/Architecture mode. If the target is running in 64-bit addressing
671 mode, report s390x architecture. If the target is running in 31-bit
672 addressing mode, but the kernel supports using 64-bit registers in
673 that mode, report s390 architecture with 64-bit GPRs. */
678 target_auxv_search (¤t_target
, AT_HWCAP
, &hwcap
);
679 have_regset_tdb
= (hwcap
& HWCAP_S390_TE
)
680 && check_regset (tid
, NT_S390_TDB
, s390_sizeof_tdbregset
);
682 have_regset_vxrs
= (hwcap
& HWCAP_S390_VX
)
683 && check_regset (tid
, NT_S390_VXRS_LOW
, 16 * 8)
684 && check_regset (tid
, NT_S390_VXRS_HIGH
, 16 * 16);
686 if (s390_target_wordsize () == 8)
687 return (have_regset_vxrs
?
688 (have_regset_tdb
? tdesc_s390x_tevx_linux64
:
689 tdesc_s390x_vx_linux64
) :
690 have_regset_tdb
? tdesc_s390x_te_linux64
:
691 have_regset_system_call
? tdesc_s390x_linux64v2
:
692 have_regset_last_break
? tdesc_s390x_linux64v1
:
693 tdesc_s390x_linux64
);
695 if (hwcap
& HWCAP_S390_HIGH_GPRS
)
696 return (have_regset_vxrs
?
697 (have_regset_tdb
? tdesc_s390_tevx_linux64
:
698 tdesc_s390_vx_linux64
) :
699 have_regset_tdb
? tdesc_s390_te_linux64
:
700 have_regset_system_call
? tdesc_s390_linux64v2
:
701 have_regset_last_break
? tdesc_s390_linux64v1
:
706 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
707 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
708 mode, report s390 architecture with 32-bit GPRs. */
709 return (have_regset_system_call
? tdesc_s390_linux32v2
:
710 have_regset_last_break
? tdesc_s390_linux32v1
:
714 void _initialize_s390_nat (void);
717 _initialize_s390_nat (void)
719 struct target_ops
*t
;
721 /* Fill in the generic GNU/Linux methods. */
724 /* Add our register access methods. */
725 t
->to_fetch_registers
= s390_linux_fetch_inferior_registers
;
726 t
->to_store_registers
= s390_linux_store_inferior_registers
;
728 /* Add our watchpoint methods. */
729 t
->to_can_use_hw_breakpoint
= s390_can_use_hw_breakpoint
;
730 t
->to_region_ok_for_hw_watchpoint
= s390_region_ok_for_hw_watchpoint
;
731 t
->to_have_continuable_watchpoint
= 1;
732 t
->to_stopped_by_watchpoint
= s390_stopped_by_watchpoint
;
733 t
->to_insert_watchpoint
= s390_insert_watchpoint
;
734 t
->to_remove_watchpoint
= s390_remove_watchpoint
;
736 /* Detect target architecture. */
737 t
->to_read_description
= s390_read_description
;
738 t
->to_auxv_parse
= s390_auxv_parse
;
740 /* Register the target. */
741 linux_nat_add_target (t
);
742 linux_nat_set_new_thread (t
, s390_new_thread
);
743 linux_nat_set_prepare_to_resume (t
, s390_prepare_to_resume
);