1 /* S390 native-dependent code for GDB, the GNU debugger.
2 Copyright 2001 Free Software Foundation, Inc
3 Contributed by D.J. Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
4 for IBM Deutschland Entwicklung GmbH, IBM Corporation.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 #include <asm/ptrace.h>
26 #include <sys/ptrace.h>
27 #include <asm/processor.h>
28 #include <asm/types.h>
29 #include <sys/procfs.h>
32 #include <sys/ucontext.h>
34 #define offsetof(type,member) ((size_t) &((type *)0)->member)
39 s390_register_u_addr (int blockend, int regnum)
43 if (regnum >= S390_GP0_REGNUM && regnum <= S390_GP_LAST_REGNUM)
44 retval = PT_GPR0 + ((regnum - S390_GP0_REGNUM) * S390_GPR_SIZE);
45 else if (regnum >= S390_PSWM_REGNUM && regnum <= S390_PC_REGNUM)
46 retval = PT_PSWMASK + ((regnum - S390_PSWM_REGNUM) * S390_PSW_MASK_SIZE);
47 else if (regnum == S390_FPC_REGNUM)
49 else if (regnum >= S390_FP0_REGNUM && regnum <= S390_FPLAST_REGNUM)
56 + ((regnum - S390_FP0_REGNUM) * S390_FPR_SIZE);
57 else if (regnum >= S390_FIRST_ACR && regnum <= S390_LAST_ACR)
58 retval = PT_ACR0 + ((regnum - S390_FIRST_ACR) * S390_ACR_SIZE);
59 else if (regnum >= (S390_FIRST_CR + 9) && regnum <= (S390_FIRST_CR + 11))
60 retval = PT_CR_9 + ((regnum - (S390_FIRST_CR + 9)) * S390_CR_SIZE);
63 internal_error (__FILE__, __LINE__,
64 "s390_register_u_addr invalid regnum regnum=%d",
68 return retval + blockend;
71 /* watch_areas are required if you put 2 or more watchpoints on the same
72 address or overlapping areas gdb will call us to delete the watchpoint
73 more than once when we try to delete them.
74 attempted reference counting to reduce the number of areas unfortunately
75 they didn't shrink when areas had to be split overlapping occurs. */
77 typedef struct watch_area watch_area;
85 static watch_area *watch_base = NULL;
86 int watch_area_cnt = 0;
87 static CORE_ADDR watch_lo_addr = 0, watch_hi_addr = 0;
92 s390_stopped_by_watchpoint (int pid)
94 per_lowcore_bits per_lowcore;
97 parea.len = sizeof (per_lowcore);
98 parea.process_addr = (addr_t) & per_lowcore;
99 parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
100 ptrace (PTRACE_PEEKUSR_AREA, pid, &parea);
101 return ((per_lowcore.perc_storage_alteration == 1) &&
102 (per_lowcore.perc_store_real_address == 0));
107 s390_fix_watch_points (int pid)
112 parea.len = sizeof (per_info);
113 parea.process_addr = (addr_t) & per_info;
114 parea.kernel_addr = PT_CR_9;
115 ptrace (PTRACE_PEEKUSR_AREA, pid, &parea);
116 /* The kernel automatically sets the psw for per depending */
117 /* on whether the per control registers are set for event recording */
118 /* & sets cr9 & cr10 appropriately also */
121 per_info.control_regs.bits.em_storage_alteration = 1;
122 per_info.control_regs.bits.storage_alt_space_ctl = 1;
126 per_info.control_regs.bits.em_storage_alteration = 0;
127 per_info.control_regs.bits.storage_alt_space_ctl = 0;
129 per_info.starting_addr = watch_lo_addr;
130 per_info.ending_addr = watch_hi_addr;
131 ptrace (PTRACE_POKEUSR_AREA, pid, &parea);
135 s390_insert_watchpoint (int pid, CORE_ADDR addr, int len, int rw)
137 CORE_ADDR hi_addr = addr + len - 1;
138 watch_area *newarea = (watch_area *) xmalloc (sizeof (watch_area));
143 newarea->next = watch_base;
144 watch_base = newarea;
145 watch_lo_addr = min (watch_lo_addr, addr);
146 watch_hi_addr = max (watch_hi_addr, hi_addr);
147 newarea->lo_addr = addr;
148 newarea->hi_addr = hi_addr;
149 if (watch_area_cnt == 0)
151 watch_lo_addr = newarea->lo_addr;
152 watch_hi_addr = newarea->hi_addr;
155 s390_fix_watch_points (pid);
157 return newarea ? 0 : -1;
162 s390_remove_watchpoint (int pid, CORE_ADDR addr, int len)
164 watch_area *curr = watch_base, *prev, *matchCurr;
165 CORE_ADDR hi_addr = addr + len - 1;
166 CORE_ADDR watch_second_lo_addr = 0xffffffffUL, watch_second_hi_addr = 0;
167 int lo_addr_ref_cnt, hi_addr_ref_cnt;
168 prev = matchCurr = NULL;
169 lo_addr_ref_cnt = (addr == watch_lo_addr);
170 hi_addr_ref_cnt = (addr == watch_hi_addr);
173 if (matchCurr == NULL)
175 if (curr->lo_addr == addr && curr->hi_addr == hi_addr)
179 prev->next = curr->next;
181 watch_base = curr->next;
187 if (watch_lo_addr == curr->lo_addr)
189 if (curr->lo_addr > watch_lo_addr &&
190 curr->lo_addr < watch_second_lo_addr)
191 watch_second_lo_addr = curr->lo_addr;
195 if (watch_hi_addr == curr->hi_addr)
197 if (curr->hi_addr < watch_hi_addr &&
198 curr->hi_addr > watch_second_hi_addr)
199 watch_second_hi_addr = curr->hi_addr;
209 if (lo_addr_ref_cnt == 2)
210 watch_lo_addr = watch_second_lo_addr;
211 if (hi_addr_ref_cnt == 2)
212 watch_hi_addr = watch_second_hi_addr;
216 watch_lo_addr = watch_hi_addr = 0;
218 s390_fix_watch_points (pid);
223 fprintf_unfiltered (gdb_stderr,
224 "Attempt to remove nonexistent watchpoint in s390_remove_watchpoint\n");
232 return sizeof (struct user);
236 #if (defined (S390_FP0_REGNUM) && defined (HAVE_FPREGSET_T) && defined(HAVE_SYS_PROCFS_H) && defined (HAVE_GREGSET_T))
238 supply_gregset (gregset_t * gregsetp)
241 greg_t *gregp = (greg_t *) gregsetp;
243 supply_register (S390_PSWM_REGNUM, (char *) &gregp[S390_PSWM_REGNUM]);
244 supply_register (S390_PC_REGNUM, (char *) &gregp[S390_PC_REGNUM]);
245 for (regi = 0; regi < S390_NUM_GPRS; regi++)
246 supply_register (S390_GP0_REGNUM + regi,
247 (char *) &gregp[S390_GP0_REGNUM + regi]);
249 #if defined (CONFIG_ARCH_S390X)
250 /* On the s390x, each element of gregset_t is 8 bytes long, but
251 each access register is still only 32 bits long. So they're
252 packed two per element. It's apparently traditional that
253 gregset_t must be an array, so when the registers it provides
254 have different sizes, something has to get strange
257 unsigned int *acrs = (unsigned int *) &gregp[S390_FIRST_ACR];
259 for (regi = 0; regi < S390_NUM_ACRS; regi++)
260 supply_register (S390_FIRST_ACR + regi, (char *) &acrs[regi]);
263 for (regi = 0; regi < S390_NUM_ACRS; regi++)
264 supply_register (S390_FIRST_ACR + regi,
265 (char *) &gregp[S390_FIRST_ACR + regi]);
268 /* unfortunately this isn't in gregsetp */
269 for (regi = 0; regi < S390_NUM_CRS; regi++)
270 supply_register (S390_FIRST_CR + regi, NULL);
275 supply_fpregset (fpregset_t * fpregsetp)
279 supply_register (S390_FPC_REGNUM, (char *) &fpregsetp->fpc);
280 for (regi = 0; regi < S390_NUM_FPRS; regi++)
281 supply_register (S390_FP0_REGNUM + regi, (char *) &fpregsetp->fprs[regi]);
286 fill_gregset (gregset_t * gregsetp, int regno)
289 greg_t *gregp = (greg_t *) gregsetp;
293 regcache_collect (S390_PSWM_REGNUM, &gregp[S390_PSWM_REGNUM]);
294 regcache_collect (S390_PC_REGNUM, &gregp[S390_PC_REGNUM]);
295 for (regi = 0; regi < S390_NUM_GPRS; regi++)
296 regcache_collect (S390_GP0_REGNUM + regi,
297 &gregp[S390_GP0_REGNUM + regi]);
298 #if defined (CONFIG_ARCH_S390X)
299 /* See the comments about the access registers in
300 supply_gregset, above. */
302 unsigned int *acrs = (unsigned int *) &gregp[S390_FIRST_ACR];
304 for (regi = 0; regi < S390_NUM_ACRS; regi++)
305 regcache_collect (S390_FIRST_ACR + regi, &acrs[regi]);
308 for (regi = 0; regi < S390_NUM_ACRS; regi++)
309 regcache_collect (S390_FIRST_ACR + regi,
310 &gregp[S390_FIRST_ACR + regi]);
313 else if (regno >= S390_PSWM_REGNUM && regno < S390_FIRST_ACR)
314 regcache_collect (regno, &gregp[regno]);
315 else if (regno >= S390_FIRST_ACR && regno <= S390_LAST_ACR)
317 #if defined (CONFIG_ARCH_S390X)
318 /* See the comments about the access registers in
319 supply_gregset, above. */
320 unsigned int *acrs = (unsigned int *) &gregp[S390_FIRST_ACR];
322 regcache_collect (regno, &acrs[regno - S390_FIRST_ACR]);
324 regcache_collect (regno, &gregp[regno]);
329 /* Given a pointer to a floating point register set in /proc format
330 (fpregset_t *), update the register specified by REGNO from gdb's idea
331 of the current floating point register set. If REGNO is -1, update
335 fill_fpregset (fpregset_t * fpregsetp, int regno)
341 regcache_collect (S390_FPC_REGNUM, &fpregsetp->fpc);
342 for (regi = 0; regi < S390_NUM_FPRS; regi++)
343 regcache_collect (S390_FP0_REGNUM + regi, &fpregsetp->fprs[regi]);
345 else if (regno == S390_FPC_REGNUM)
346 regcache_collect (S390_FPC_REGNUM, &fpregsetp->fpc);
347 else if (regno >= S390_FP0_REGNUM && regno <= S390_FPLAST_REGNUM)
348 regcache_collect (regno, &fpregsetp->fprs[regno - S390_FP0_REGNUM]);
353 #error "There are a few possibilities here"
354 #error "1) You aren't compiling for linux & don't need a core dumps to work."
355 #error "2) The header files sys/elf.h sys/user.h sys/ptrace.h & sys/procfs.h"
356 #error "libc files are inconsistent with linux/include/asm-s390/"
357 #error "3) you didn't do a completely clean build & delete config.cache."