GDB (xrefs)
Loading...
Searching...
No Matches
s390-linux-nat.c
Go to the documentation of this file.
1/* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright (C) 2001-2023 Free Software Foundation, Inc.
3
4 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
5 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22#include "defs.h"
23#include "regcache.h"
24#include "inferior.h"
25#include "target.h"
26#include "linux-nat.h"
27#include "auxv.h"
28#include "gregset.h"
29#include "regset.h"
30#include "nat/linux-ptrace.h"
31#include "gdbcmd.h"
32#include "gdbarch.h"
33
34#include "s390-tdep.h"
35#include "s390-linux-tdep.h"
36#include "elf/common.h"
37
38#include <asm/ptrace.h>
39#include "nat/gdb_ptrace.h"
40#include <asm/types.h>
41#include <sys/procfs.h>
42#include <sys/ucontext.h>
43#include <elf.h>
44#include <algorithm>
45#include "inf-ptrace.h"
46#include "linux-tdep.h"
47
48/* Per-thread arch-specific data. */
49
50struct arch_lwp_info
51{
52 /* Non-zero if the thread's PER info must be re-written. */
54};
55
58static int have_regset_tdb = 0;
59static int have_regset_vxrs = 0;
60static int have_regset_gs = 0;
61
62/* Register map for 32-bit executables running under a 64-bit
63 kernel. */
64
65#ifdef __s390x__
66static const struct regcache_map_entry s390_64_regmap_gregset[] =
67 {
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 },
88 { 0 }
89 };
90
91static const struct regset s390_64_gregset =
92 {
93 s390_64_regmap_gregset,
96 };
97
98#define S390_PSWM_OFFSET 0
99#define S390_PSWA_OFFSET 8
100#endif
101
102/* PER-event mask bits and PER control bits (CR9). */
103
104#define PER_BIT(n) (1UL << (63 - (n)))
105#define PER_EVENT_BRANCH PER_BIT (32)
106#define PER_EVENT_IFETCH PER_BIT (33)
107#define PER_EVENT_STORE PER_BIT (34)
108#define PER_EVENT_NULLIFICATION PER_BIT (39)
109#define PER_CONTROL_BRANCH_ADDRESS PER_BIT (40)
110#define PER_CONTROL_SUSPENSION PER_BIT (41)
111#define PER_CONTROL_ALTERATION PER_BIT (42)
112
114{
115public:
116 /* Add our register access methods. */
117 void fetch_registers (struct regcache *, int) override;
118 void store_registers (struct regcache *, int) override;
119
120 /* Add our watchpoint methods. */
121 int can_use_hw_breakpoint (enum bptype, int, int) override;
122 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *)
123 override;
124 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *)
125 override;
126 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
127 bool stopped_by_watchpoint () 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;
132
133 /* Detect target architecture. */
134 const struct target_desc *read_description () override;
135 int auxv_parse (const gdb_byte **readptr,
136 const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
137 override;
138
139 /* Override linux_nat_target low methods. */
140 void low_new_thread (struct lwp_info *lp) override;
141 void low_delete_thread (struct arch_lwp_info *lp) override;
142 void low_prepare_to_resume (struct lwp_info *lp) override;
143 void low_new_fork (struct lwp_info *parent, pid_t child_pid) override;
144 void low_forget_process (pid_t pid) override;
145};
146
148
149/* Fill GDB's register array with the general-purpose register values
150 in *REGP.
151
152 When debugging a 32-bit executable running under a 64-bit kernel,
153 we have to fix up the 64-bit registers we get from the kernel to
154 make them look like 32-bit registers. */
155
156void
157supply_gregset (struct regcache *regcache, const gregset_t *regp)
158{
159#ifdef __s390x__
160 struct gdbarch *gdbarch = regcache->arch ();
161 if (gdbarch_ptr_bit (gdbarch) == 32)
162 {
163 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
164 ULONGEST pswm, pswa;
165 gdb_byte buf[4];
166
167 regcache_supply_regset (&s390_64_gregset, regcache, -1,
168 regp, sizeof (gregset_t));
169 pswm = extract_unsigned_integer ((const gdb_byte *) regp
170 + S390_PSWM_OFFSET, 8, byte_order);
171 pswa = extract_unsigned_integer ((const gdb_byte *) regp
172 + S390_PSWA_OFFSET, 8, byte_order);
173 store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000);
175 store_unsigned_integer (buf, 4, byte_order,
176 (pswa & 0x7fffffff) | (pswm & 0x80000000));
178 return;
179 }
180#endif
181
183 sizeof (gregset_t));
184}
185
186/* Fill register REGNO (if it is a general-purpose register) in
187 *REGP with the value in GDB's register array. If REGNO is -1,
188 do this for all registers. */
189
190void
191fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno)
192{
193#ifdef __s390x__
194 struct gdbarch *gdbarch = regcache->arch ();
195 if (gdbarch_ptr_bit (gdbarch) == 32)
196 {
197 regcache_collect_regset (&s390_64_gregset, regcache, regno,
198 regp, sizeof (gregset_t));
199
200 if (regno == -1
201 || regno == S390_PSWM_REGNUM || regno == S390_PSWA_REGNUM)
202 {
203 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
204 ULONGEST pswa, pswm;
205 gdb_byte buf[4];
206 gdb_byte *pswm_p = (gdb_byte *) regp + S390_PSWM_OFFSET;
207 gdb_byte *pswa_p = (gdb_byte *) regp + S390_PSWA_OFFSET;
208
209 pswm = extract_unsigned_integer (pswm_p, 8, byte_order);
210
211 if (regno == -1 || regno == S390_PSWM_REGNUM)
212 {
213 pswm &= 0x80000000;
215 pswm |= (extract_unsigned_integer (buf, 4, byte_order)
216 & 0xfff7ffff) << 32;
217 }
218
219 if (regno == -1 || regno == S390_PSWA_REGNUM)
220 {
222 pswa = extract_unsigned_integer (buf, 4, byte_order);
223 pswm ^= (pswm ^ pswa) & 0x80000000;
224 pswa &= 0x7fffffff;
225 store_unsigned_integer (pswa_p, 8, byte_order, pswa);
226 }
227
228 store_unsigned_integer (pswm_p, 8, byte_order, pswm);
229 }
230 return;
231 }
232#endif
233
235 sizeof (gregset_t));
236}
237
238/* Fill GDB's register array with the floating-point register values
239 in *REGP. */
240void
241supply_fpregset (struct regcache *regcache, const fpregset_t *regp)
242{
244 sizeof (fpregset_t));
245}
246
247/* Fill register REGNO (if it is a general-purpose register) in
248 *REGP with the value in GDB's register array. If REGNO is -1,
249 do this for all registers. */
250void
251fill_fpregset (const struct regcache *regcache, fpregset_t *regp, int regno)
252{
254 sizeof (fpregset_t));
255}
256
257/* Find the TID for the current inferior thread to use with ptrace. */
258static int
260{
261 /* GNU/Linux LWP ID's are process ID's. */
262 int tid = inferior_ptid.lwp ();
263 if (tid == 0)
264 tid = inferior_ptid.pid (); /* Not a threaded program. */
265
266 return tid;
267}
268
269/* Fetch all general-purpose registers from process/thread TID and
270 store their values in GDB's register cache. */
271static void
272fetch_regs (struct regcache *regcache, int tid)
273{
274 gregset_t regs;
275 ptrace_area parea;
276
277 parea.len = sizeof (regs);
278 parea.process_addr = (addr_t) &regs;
279 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
280 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
281 perror_with_name (_("Couldn't get registers"));
282
283 supply_gregset (regcache, (const gregset_t *) &regs);
284}
285
286/* Store all valid general-purpose registers in GDB's register cache
287 into the process/thread specified by TID. */
288static void
289store_regs (const struct regcache *regcache, int tid, int regnum)
290{
291 gregset_t regs;
292 ptrace_area parea;
293
294 parea.len = sizeof (regs);
295 parea.process_addr = (addr_t) &regs;
296 parea.kernel_addr = offsetof (struct user_regs_struct, psw);
297 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
298 perror_with_name (_("Couldn't get registers"));
299
300 fill_gregset (regcache, &regs, regnum);
301
302 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
303 perror_with_name (_("Couldn't write registers"));
304}
305
306/* Fetch all floating-point registers from process/thread TID and store
307 their values in GDB's register cache. */
308static void
310{
311 fpregset_t fpregs;
312 ptrace_area parea;
313
314 parea.len = sizeof (fpregs);
315 parea.process_addr = (addr_t) &fpregs;
316 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
317 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
318 perror_with_name (_("Couldn't get floating point status"));
319
320 supply_fpregset (regcache, (const fpregset_t *) &fpregs);
321}
322
323/* Store all valid floating-point registers in GDB's register cache
324 into the process/thread specified by TID. */
325static void
326store_fpregs (const struct regcache *regcache, int tid, int regnum)
327{
328 fpregset_t fpregs;
329 ptrace_area parea;
330
331 parea.len = sizeof (fpregs);
332 parea.process_addr = (addr_t) &fpregs;
333 parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
334 if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea, 0) < 0)
335 perror_with_name (_("Couldn't get floating point status"));
336
337 fill_fpregset (regcache, &fpregs, regnum);
338
339 if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea, 0) < 0)
340 perror_with_name (_("Couldn't write floating point status"));
341}
342
343/* Fetch all registers in the kernel's register set whose number is
344 REGSET_ID, whose size is REGSIZE, and whose layout is described by
345 REGSET, from process/thread TID and store their values in GDB's
346 register cache. */
347static void
349 int regset_id, int regsize, const struct regset *regset)
350{
351 void *buf = alloca (regsize);
352 struct iovec iov;
353
354 iov.iov_base = buf;
355 iov.iov_len = regsize;
356
357 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
358 {
359 if (errno == ENODATA)
360 regcache_supply_regset (regset, regcache, -1, NULL, regsize);
361 else
362 perror_with_name (_("Couldn't get register set"));
363 }
364 else
365 regcache_supply_regset (regset, regcache, -1, buf, regsize);
366}
367
368/* Store all registers in the kernel's register set whose number is
369 REGSET_ID, whose size is REGSIZE, and whose layout is described by
370 REGSET, from GDB's register cache back to process/thread TID. */
371static void
373 int regset_id, int regsize, const struct regset *regset)
374{
375 void *buf = alloca (regsize);
376 struct iovec iov;
377
378 iov.iov_base = buf;
379 iov.iov_len = regsize;
380
381 if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
382 perror_with_name (_("Couldn't get register set"));
383
384 regcache_collect_regset (regset, regcache, -1, buf, regsize);
385
386 if (ptrace (PTRACE_SETREGSET, tid, (long) regset_id, (long) &iov) < 0)
387 perror_with_name (_("Couldn't set register set"));
388}
389
390/* Check whether the kernel provides a register set with number REGSET
391 of size REGSIZE for process/thread TID. */
392static int
393check_regset (int tid, int regset, int regsize)
394{
395 void *buf = alloca (regsize);
396 struct iovec iov;
397
398 iov.iov_base = buf;
399 iov.iov_len = regsize;
400
401 if (ptrace (PTRACE_GETREGSET, tid, (long) regset, (long) &iov) >= 0
402 || errno == ENODATA)
403 return 1;
404 return 0;
405}
406
407/* Fetch register REGNUM from the child process. If REGNUM is -1, do
408 this for all registers. */
409void
411{
412 pid_t tid = get_ptrace_pid (regcache->ptid ());
413
414 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
415 fetch_regs (regcache, tid);
416
418 fetch_fpregs (regcache, tid);
419
421 if (regnum == -1 || regnum == S390_LAST_BREAK_REGNUM)
422 fetch_regset (regcache, tid, NT_S390_LAST_BREAK, 8,
423 (gdbarch_ptr_bit (regcache->arch ()) == 32
425
427 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
428 fetch_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
430
431 if (have_regset_tdb)
433 fetch_regset (regcache, tid, NT_S390_TDB, s390_sizeof_tdbregset,
435
437 {
438 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
440 fetch_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
442 if (regnum == -1 || (regnum >= S390_V16_REGNUM
443 && regnum <= S390_V31_REGNUM))
444 fetch_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
446 }
447
448 if (have_regset_gs)
449 {
450 if (regnum == -1 || (regnum >= S390_GSD_REGNUM
452 fetch_regset (regcache, tid, NT_S390_GS_CB, 4 * 8,
454 if (regnum == -1 || (regnum >= S390_BC_GSD_REGNUM
456 fetch_regset (regcache, tid, NT_S390_GS_BC, 4 * 8,
458 }
459}
460
461/* Store register REGNUM back into the child process. If REGNUM is
462 -1, do this for all registers. */
463void
465{
466 pid_t tid = get_ptrace_pid (regcache->ptid ());
467
468 if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
469 store_regs (regcache, tid, regnum);
470
473
474 /* S390_LAST_BREAK_REGNUM is read-only. */
475
477 if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
478 store_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
480
482 {
483 if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
485 store_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
487 if (regnum == -1 || (regnum >= S390_V16_REGNUM
488 && regnum <= S390_V31_REGNUM))
489 store_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
491 }
492}
493
494
495/* Hardware-assisted watchpoint handling. */
496
497/* For each process we maintain a list of all currently active
498 watchpoints, in order to properly handle watchpoint removal.
499
500 The only thing we actually need is the total address space area
501 spanned by the watchpoints. */
502
504{
505 CORE_ADDR lo_addr;
506 CORE_ADDR hi_addr;
507};
508
509/* Hardware debug state. */
510
512{
513 std::vector<watch_area> watch_areas;
514 std::vector<watch_area> break_areas;
515};
516
517/* Per-process data. */
518
520{
521 struct s390_process_info *next = nullptr;
522 pid_t pid = 0;
524};
525
527
528/* Find process data for process PID. */
529
530static struct s390_process_info *
532{
533 struct s390_process_info *proc;
534
536 if (proc->pid == pid)
537 return proc;
538
539 return NULL;
540}
541
542/* Add process data for process PID. Returns newly allocated info
543 object. */
544
545static struct s390_process_info *
547{
548 struct s390_process_info *proc = new struct s390_process_info;
549
550 proc->pid = pid;
553
554 return proc;
555}
556
557/* Get data specific info for process PID, creating it if necessary.
558 Never returns NULL. */
559
560static struct s390_process_info *
562{
563 struct s390_process_info *proc;
564
566 if (proc == NULL)
568
569 return proc;
570}
571
572/* Get hardware debug state for process PID. */
573
574static struct s390_debug_reg_state *
579
580/* Called whenever GDB is no longer debugging process PID. It deletes
581 data structures that keep track of hardware debug state. */
582
583void
585{
586 struct s390_process_info *proc, **proc_link;
587
589 proc_link = &s390_process_list;
590
591 while (proc != NULL)
592 {
593 if (proc->pid == pid)
594 {
595 *proc_link = proc->next;
596 delete proc;
597 return;
598 }
599
600 proc_link = &proc->next;
601 proc = *proc_link;
602 }
603}
604
605/* linux_nat_new_fork hook. */
606
607void
608s390_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid)
609{
610 pid_t parent_pid;
611 struct s390_debug_reg_state *parent_state;
612 struct s390_debug_reg_state *child_state;
613
614 /* NULL means no watchpoint has ever been set in the parent. In
615 that case, there's nothing to do. */
616 if (lwp_arch_private_info (parent) == NULL)
617 return;
618
619 /* GDB core assumes the child inherits the watchpoints/hw breakpoints of
620 the parent. So copy the debug state from parent to child. */
621
622 parent_pid = parent->ptid.pid ();
623 parent_state = s390_get_debug_reg_state (parent_pid);
624 child_state = s390_get_debug_reg_state (child_pid);
625
626 child_state->watch_areas = parent_state->watch_areas;
627 child_state->break_areas = parent_state->break_areas;
628}
629
630/* Dump PER state. */
631
632static void
633s390_show_debug_regs (int tid, const char *where)
634{
635 per_struct per_info;
636 ptrace_area parea;
637
638 parea.len = sizeof (per_info);
639 parea.process_addr = (addr_t) &per_info;
640 parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
641
642 if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea, 0) < 0)
643 perror_with_name (_("Couldn't retrieve debug regs"));
644
645 debug_printf ("PER (debug) state for %d -- %s\n"
646 " cr9-11: %lx %lx %lx\n"
647 " start, end: %lx %lx\n"
648 " code/ATMID: %x address: %lx PAID: %x\n",
649 tid,
650 where,
651 per_info.control_regs.words.cr[0],
652 per_info.control_regs.words.cr[1],
653 per_info.control_regs.words.cr[2],
654 per_info.starting_addr,
655 per_info.ending_addr,
656 per_info.lowcore.words.perc_atmid,
657 per_info.lowcore.words.address,
658 per_info.lowcore.words.access_id);
659}
660
661bool
663{
664 struct s390_debug_reg_state *state
666 per_lowcore_bits per_lowcore;
667 ptrace_area parea;
668
669 if (show_debug_regs)
671
672 /* Speed up common case. */
673 if (state->watch_areas.empty ())
674 return false;
675
676 siginfo_t siginfo;
677 if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
678 return false;
679 if (siginfo.si_signo != SIGTRAP
680 || (siginfo.si_code & 0xffff) != TRAP_HWBKPT)
681 return false;
682
683 parea.len = sizeof (per_lowcore);
684 parea.process_addr = (addr_t) & per_lowcore;
685 parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
686 if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
687 perror_with_name (_("Couldn't retrieve watchpoint status"));
688
689 bool result = (per_lowcore.perc_storage_alteration == 1
690 && per_lowcore.perc_store_real_address == 0);
691
692 return result;
693}
694
695/* Each time before resuming a thread, update its PER info. */
696
697void
699{
700 int tid;
701 pid_t pid = ptid_of_lwp (lp).pid ();
702
703 per_struct per_info;
704 ptrace_area parea;
705
706 CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0;
707 struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp);
709 int step = lwp_is_stepping (lp);
710
711 /* Nothing to do if there was never any PER info for this thread. */
712 if (lp_priv == NULL)
713 return;
714
715 /* If PER info has changed, update it. When single-stepping, disable
716 hardware breakpoints (if any). Otherwise we're done. */
717 if (!lp_priv->per_info_changed)
718 {
719 if (!step || state->break_areas.empty ())
720 return;
721 }
722
723 lp_priv->per_info_changed = 0;
724
725 tid = ptid_of_lwp (lp).lwp ();
726 if (tid == 0)
727 tid = pid;
728
729 parea.len = sizeof (per_info);
730 parea.process_addr = (addr_t) & per_info;
731 parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
732
733 /* Clear PER info, but adjust the single_step field (used by older
734 kernels only). */
735 memset (&per_info, 0, sizeof (per_info));
736 per_info.single_step = (step != 0);
737
738 if (!state->watch_areas.empty ())
739 {
740 for (const auto &area : state->watch_areas)
741 {
742 watch_lo_addr = std::min (watch_lo_addr, area.lo_addr);
743 watch_hi_addr = std::max (watch_hi_addr, area.hi_addr);
744 }
745
746 /* Enable storage-alteration events. */
747 per_info.control_regs.words.cr[0] |= (PER_EVENT_STORE
749 }
750
751 if (!state->break_areas.empty ())
752 {
753 /* Don't install hardware breakpoints while single-stepping, since
754 our PER settings (e.g. the nullification bit) might then conflict
755 with the kernel's. But re-install them afterwards. */
756 if (step)
757 lp_priv->per_info_changed = 1;
758 else
759 {
760 for (const auto &area : state->break_areas)
761 {
762 watch_lo_addr = std::min (watch_lo_addr, area.lo_addr);
763 watch_hi_addr = std::max (watch_hi_addr, area.hi_addr);
764 }
765
766 /* If there's just one breakpoint, enable instruction-fetching
767 nullification events for the breakpoint address (fast).
768 Otherwise stop after any instruction within the PER area and
769 after any branch into it (slow). */
770 if (watch_hi_addr == watch_lo_addr)
771 per_info.control_regs.words.cr[0] |= (PER_EVENT_NULLIFICATION
773 else
774 {
775 /* The PER area must include the instruction before the
776 first breakpoint address. */
777 watch_lo_addr = watch_lo_addr > 6 ? watch_lo_addr - 6 : 0;
778 per_info.control_regs.words.cr[0]
782 }
783 }
784 }
785 per_info.starting_addr = watch_lo_addr;
786 per_info.ending_addr = watch_hi_addr;
787
788 if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea, 0) < 0)
789 perror_with_name (_("Couldn't modify watchpoint status"));
790
791 if (show_debug_regs)
792 s390_show_debug_regs (tid, "resume");
793}
794
795/* Mark the PER info as changed, so the next resume will update it. */
796
797static void
799{
800 if (lwp_arch_private_info (lp) == NULL)
801 lwp_set_arch_private_info (lp, XCNEW (struct arch_lwp_info));
802
804}
805
806/* When attaching to a new thread, mark its PER info as changed. */
807
808void
813
814/* Function to call when a thread is being deleted. */
815
816void
818{
819 xfree (arch_lwp);
820}
821
822/* Iterator callback for s390_refresh_per_info. */
823
824static int
826{
828
829 if (!lwp_is_stopped (lp))
830 linux_stop_lwp (lp);
831 return 0;
832}
833
834/* Make sure that threads are stopped and mark PER info as changed. */
835
836static int
838{
839 ptid_t pid_ptid = ptid_t (current_lwp_ptid ().pid ());
840
842 return 0;
843}
844
845int
847 enum target_hw_bp_type type,
848 struct expression *cond)
849{
850 watch_area area;
851 struct s390_debug_reg_state *state
853
854 area.lo_addr = addr;
855 area.hi_addr = addr + len - 1;
856 state->watch_areas.push_back (area);
857
858 return s390_refresh_per_info ();
859}
860
861int
863 enum target_hw_bp_type type,
864 struct expression *cond)
865{
866 unsigned ix;
867 struct s390_debug_reg_state *state
869
870 for (ix = 0; ix < state->watch_areas.size (); ix++)
871 {
872 watch_area &area = state->watch_areas[ix];
873 if (area.lo_addr == addr && area.hi_addr == addr + len - 1)
874 {
875 unordered_remove (state->watch_areas, ix);
876 return s390_refresh_per_info ();
877 }
878 }
879
881 "Attempt to remove nonexistent watchpoint.\n");
882 return -1;
883}
884
885/* Implement the "can_use_hw_breakpoint" target_ops method. */
886
887int
889 int cnt, int othertype)
890{
892 return 1;
893 return 0;
894}
895
896/* Implement the "insert_hw_breakpoint" target_ops method. */
897
898int
900 struct bp_target_info *bp_tgt)
901{
902 watch_area area;
903 struct s390_debug_reg_state *state;
904
905 area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
906 area.hi_addr = area.lo_addr;
908 state->break_areas.push_back (area);
909
910 return s390_refresh_per_info ();
911}
912
913/* Implement the "remove_hw_breakpoint" target_ops method. */
914
915int
917 struct bp_target_info *bp_tgt)
918{
919 unsigned ix;
920 struct s390_debug_reg_state *state;
921
923 for (ix = 0; state->break_areas.size (); ix++)
924 {
925 watch_area &area = state->break_areas[ix];
926 if (area.lo_addr == bp_tgt->placed_address)
927 {
928 unordered_remove (state->break_areas, ix);
929 return s390_refresh_per_info ();
930 }
931 }
932
934 "Attempt to remove nonexistent breakpoint.\n");
935 return -1;
936}
937
938int
940{
941 return 1;
942}
943
944static int
946{
947 int wordsize = 4;
948
949 /* Check for 64-bit inferior process. This is the case when the host is
950 64-bit, and in addition bit 32 of the PSW mask is set. */
951#ifdef __s390x__
952 long pswm;
953
954 errno = 0;
955 pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0);
956 if (errno == 0 && (pswm & 0x100000000ul) != 0)
957 wordsize = 8;
958#endif
959
960 return wordsize;
961}
962
963int
964s390_linux_nat_target::auxv_parse (const gdb_byte **readptr,
965 const gdb_byte *endptr, CORE_ADDR *typep,
966 CORE_ADDR *valp)
967{
968 int sizeof_auxv_field = s390_target_wordsize ();
969 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
970 const gdb_byte *ptr = *readptr;
971
972 if (endptr == ptr)
973 return 0;
974
975 if (endptr - ptr < sizeof_auxv_field * 2)
976 return -1;
977
978 *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
979 ptr += sizeof_auxv_field;
980 *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
981 ptr += sizeof_auxv_field;
982
983 *readptr = ptr;
984 return 1;
985}
986
987const struct target_desc *
989{
990 if (inferior_ptid == null_ptid)
991 return this->beneath ()->read_description ();
992
993 int tid = inferior_ptid.pid ();
994
996 = check_regset (tid, NT_S390_LAST_BREAK, 8);
998 = check_regset (tid, NT_S390_SYSTEM_CALL, 4);
999
1000 /* If GDB itself is compiled as 64-bit, we are running on a machine in
1001 z/Architecture mode. If the target is running in 64-bit addressing
1002 mode, report s390x architecture. If the target is running in 31-bit
1003 addressing mode, but the kernel supports using 64-bit registers in
1004 that mode, report s390 architecture with 64-bit GPRs. */
1005#ifdef __s390x__
1006 {
1007 CORE_ADDR hwcap = linux_get_hwcap ();
1008
1009 have_regset_tdb = (hwcap & HWCAP_S390_TE)
1010 && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset);
1011
1013 && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8)
1014 && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16);
1015
1016 have_regset_gs = (hwcap & HWCAP_S390_GS)
1017 && check_regset (tid, NT_S390_GS_CB, 4 * 8)
1018 && check_regset (tid, NT_S390_GS_BC, 4 * 8);
1019
1020 if (s390_target_wordsize () == 8)
1029
1030 if (hwcap & HWCAP_S390_HIGH_GPRS)
1039 }
1040#endif
1041
1042 /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
1043 on a 64-bit kernel that does not support using 64-bit registers in 31-bit
1044 mode, report s390 architecture with 32-bit GPRs. */
1048}
1049
1050void _initialize_s390_nat ();
1051void
1053{
1054 /* Register the target. */
1057
1058 /* A maintenance command to enable showing the PER state. */
1059 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
1060 &show_debug_regs, _("\
1061Set whether to show the PER (debug) hardware state."), _("\
1062Show whether to show the PER (debug) hardware state."), _("\
1063Use \"on\" to enable, \"off\" to disable.\n\
1064If enabled, the PER state is shown after it is changed by GDB,\n\
1065and when the inferior triggers a breakpoint or watchpoint."),
1066 NULL,
1067 NULL,
1070}
#define TRAP_HWBKPT
int regnum
void xfree(void *)
struct gdbarch * target_gdbarch(void)
bptype
Definition breakpoint.h:84
@ bp_hardware_breakpoint
Definition breakpoint.h:87
@ bp_hardware_watchpoint
Definition breakpoint.h:92
gdbarch * arch() const
Definition regcache.c:231
void raw_collect(int regnum, void *buf) const override
Definition regcache.c:1127
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
ptid_t ptid() const
Definition regcache.h:408
void low_new_fork(struct lwp_info *parent, pid_t child_pid) override
int remove_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
void store_registers(struct regcache *, int) override
void fetch_registers(struct regcache *, int) override
int insert_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
int can_use_hw_breakpoint(enum bptype, int, int) override
void low_prepare_to_resume(struct lwp_info *lp) override
int insert_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
int region_ok_for_hw_watchpoint(CORE_ADDR, int) override
bool stopped_by_watchpoint() override
int remove_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
const struct target_desc * read_description() override
void low_delete_thread(struct arch_lwp_info *lp) override
void low_new_thread(struct lwp_info *lp) override
void low_forget_process(pid_t pid) override
int auxv_parse(const gdb_byte **readptr, const gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) override
struct cmd_list_element * maintenance_show_cmdlist
Definition maint.c:752
struct cmd_list_element * maintenance_set_cmdlist
Definition maint.c:751
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
@ class_maintenance
Definition command.h:65
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:515
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
#define ptrace(request, pid, addr, data)
Definition gdb_ptrace.h:141
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1791
void add_inf_child_target(inf_child_target *target)
Definition inf-child.c:418
pid_t get_ptrace_pid(ptid_t ptid)
Definition inf-ptrace.c:238
ptid_t inferior_ptid
Definition infcmd.c:74
ptid_t ptid_of_lwp(struct lwp_info *lwp)
Definition linux-nat.c:277
void linux_stop_lwp(struct lwp_info *lwp)
Definition linux-nat.c:2204
bool linux_nat_get_siginfo(ptid_t ptid, siginfo_t *siginfo)
Definition linux-nat.c:4479
ptid_t current_lwp_ptid(void)
Definition linux-nat.c:4488
void lwp_set_arch_private_info(struct lwp_info *lwp, struct arch_lwp_info *info)
Definition linux-nat.c:285
struct arch_lwp_info * lwp_arch_private_info(struct lwp_info *lwp)
Definition linux-nat.c:294
struct lwp_info * iterate_over_lwps(ptid_t filter, gdb::function_view< iterate_over_lwps_ftype > callback)
Definition linux-nat.c:860
struct linux_nat_target * linux_target
Definition linux-nat.c:189
int lwp_is_stepping(struct lwp_info *lwp)
Definition linux-nat.c:318
int lwp_is_stopped(struct lwp_info *lwp)
Definition linux-nat.c:302
#define PTRACE_SETREGSET
#define PTRACE_GETREGSET
CORE_ADDR linux_get_hwcap()
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition regcache.c:1273
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition regcache.c:1251
@ REGCACHE_MAP_SKIP
Definition regcache.h:121
const struct target_desc * tdesc_s390_gs_linux64
static void store_regs(const struct regcache *regcache, int tid, int regnum)
void supply_fpregset(struct regcache *regcache, const fpregset_t *regp)
#define PER_EVENT_STORE
#define PER_EVENT_BRANCH
#define PER_EVENT_NULLIFICATION
#define PER_CONTROL_ALTERATION
static int have_regset_vxrs
static void fetch_fpregs(struct regcache *regcache, int tid)
static struct s390_process_info * s390_process_list
static void fetch_regs(struct regcache *regcache, int tid)
static struct s390_process_info * s390_find_process_pid(pid_t pid)
void fill_fpregset(const struct regcache *regcache, fpregset_t *regp, int regno)
static void s390_mark_per_info_changed(struct lwp_info *lp)
static int have_regset_gs
void _initialize_s390_nat()
static int s390_inferior_tid(void)
static void store_fpregs(const struct regcache *regcache, int tid, int regnum)
static int have_regset_tdb
static int s390_target_wordsize(void)
static void store_regset(struct regcache *regcache, int tid, int regset_id, int regsize, const struct regset *regset)
static s390_linux_nat_target the_s390_linux_nat_target
static int have_regset_last_break
#define PER_CONTROL_BRANCH_ADDRESS
static void s390_show_debug_regs(int tid, const char *where)
static struct s390_process_info * s390_add_process(pid_t pid)
#define PER_EVENT_IFETCH
void fill_gregset(const struct regcache *regcache, gregset_t *regp, int regno)
static struct s390_debug_reg_state * s390_get_debug_reg_state(pid_t pid)
static void fetch_regset(struct regcache *regcache, int tid, int regset_id, int regsize, const struct regset *regset)
static int s390_refresh_per_info(void)
static int s390_refresh_per_info_cb(struct lwp_info *lp)
void supply_gregset(struct regcache *regcache, const gregset_t *regp)
static int have_regset_system_call
static int check_regset(int tid, int regset, int regsize)
static struct s390_process_info * s390_process_info_get(pid_t pid)
const struct regset s390_gs_regset
const struct regset s390_last_break_regset
const struct regset s390_tdb_regset
const struct regset s390x_last_break_regset
const struct regset s390_vxrs_high_regset
const struct regset s390_system_call_regset
const struct regset s390_gsbc_regset
const struct regset s390_vxrs_low_regset
const struct regset s390_fpregset
const struct regset s390_gregset
#define S390_IS_TDBREGSET_REGNUM(i)
#define S390_IS_FPREGSET_REGNUM(i)
#define s390_sizeof_tdbregset
#define S390_IS_GREGSET_REGNUM(i)
const struct target_desc * tdesc_s390_linux32
Definition s390-linux32.c:8
const struct target_desc * tdesc_s390_linux32v1
const struct target_desc * tdesc_s390_linux32v2
const struct target_desc * tdesc_s390_linux64
Definition s390-linux64.c:8
const struct target_desc * tdesc_s390_linux64v1
const struct target_desc * tdesc_s390_linux64v2
#define S390_BC_GSD_REGNUM
Definition s390-tdep.h:300
#define S390_R4_UPPER_REGNUM
Definition s390-tdep.h:227
#define S390_R5_UPPER_REGNUM
Definition s390-tdep.h:228
#define S390_LAST_BREAK_REGNUM
Definition s390-tdep.h:241
#define S390_PSWA_REGNUM
Definition s390-tdep.h:168
#define S390_R1_UPPER_REGNUM
Definition s390-tdep.h:224
#define HWCAP_S390_VX
Definition s390-tdep.h:157
#define S390_R0_UPPER_REGNUM
Definition s390-tdep.h:223
#define S390_R2_UPPER_REGNUM
Definition s390-tdep.h:225
#define S390_R15_REGNUM
Definition s390-tdep.h:185
#define S390_R1_REGNUM
Definition s390-tdep.h:171
#define S390_R7_UPPER_REGNUM
Definition s390-tdep.h:230
#define S390_GSEPLA_REGNUM
Definition s390-tdep.h:299
#define S390_R15_UPPER_REGNUM
Definition s390-tdep.h:238
#define S390_R9_REGNUM
Definition s390-tdep.h:179
#define S390_V16_REGNUM
Definition s390-tdep.h:281
#define S390_R2_REGNUM
Definition s390-tdep.h:172
#define S390_PSWM_REGNUM
Definition s390-tdep.h:167
#define HWCAP_S390_TE
Definition s390-tdep.h:153
#define S390_R13_REGNUM
Definition s390-tdep.h:183
#define S390_R14_REGNUM
Definition s390-tdep.h:184
#define S390_R12_UPPER_REGNUM
Definition s390-tdep.h:235
#define S390_R10_UPPER_REGNUM
Definition s390-tdep.h:233
#define S390_V15_LOWER_REGNUM
Definition s390-tdep.h:280
#define HWCAP_S390_HIGH_GPRS
Definition s390-tdep.h:149
#define S390_R11_REGNUM
Definition s390-tdep.h:181
#define S390_BC_GSEPLA_REGNUM
Definition s390-tdep.h:302
#define S390_V31_REGNUM
Definition s390-tdep.h:296
#define S390_R9_UPPER_REGNUM
Definition s390-tdep.h:232
#define S390_SYSTEM_CALL_REGNUM
Definition s390-tdep.h:242
#define S390_R8_UPPER_REGNUM
Definition s390-tdep.h:231
#define S390_R6_REGNUM
Definition s390-tdep.h:176
#define S390_R8_REGNUM
Definition s390-tdep.h:178
#define S390_R10_REGNUM
Definition s390-tdep.h:180
#define S390_R13_UPPER_REGNUM
Definition s390-tdep.h:236
#define S390_R3_REGNUM
Definition s390-tdep.h:173
#define S390_V0_LOWER_REGNUM
Definition s390-tdep.h:265
#define S390_R14_UPPER_REGNUM
Definition s390-tdep.h:237
#define S390_R11_UPPER_REGNUM
Definition s390-tdep.h:234
#define S390_A0_REGNUM
Definition s390-tdep.h:187
#define S390_R5_REGNUM
Definition s390-tdep.h:175
#define S390_R0_REGNUM
Definition s390-tdep.h:170
#define S390_R7_REGNUM
Definition s390-tdep.h:177
#define S390_ORIG_R2_REGNUM
Definition s390-tdep.h:240
#define S390_GSD_REGNUM
Definition s390-tdep.h:297
#define S390_R4_REGNUM
Definition s390-tdep.h:174
#define S390_R3_UPPER_REGNUM
Definition s390-tdep.h:226
#define S390_R6_UPPER_REGNUM
Definition s390-tdep.h:229
#define HWCAP_S390_GS
Definition s390-tdep.h:161
#define S390_R12_REGNUM
Definition s390-tdep.h:182
const struct target_desc * tdesc_s390_te_linux64
const struct target_desc * tdesc_s390_tevx_linux64
const struct target_desc * tdesc_s390_vx_linux64
const struct target_desc * tdesc_s390x_gs_linux64
const struct target_desc * tdesc_s390x_linux64
const struct target_desc * tdesc_s390x_linux64v1
const struct target_desc * tdesc_s390x_linux64v2
const struct target_desc * tdesc_s390x_te_linux64
const struct target_desc * tdesc_s390x_tevx_linux64
const struct target_desc * tdesc_s390x_vx_linux64
CORE_ADDR placed_address
Definition breakpoint.h:266
CORE_ADDR reqstd_address
Definition breakpoint.h:269
ptid_t ptid
Definition linux-nat.h:211
Definition gnu-nat.h:58
struct proc * next
Definition gnu-nat.h:88
Definition regcache.h:111
std::vector< watch_area > watch_areas
std::vector< watch_area > break_areas
struct s390_debug_reg_state state
target_ops * beneath() const
Definition target.c:3041
virtual const struct target_desc * read_description() TARGET_DEFAULT_RETURN(NULL)
CORE_ADDR hi_addr
CORE_ADDR lo_addr
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187