Move PTRACE_GETREGSET and PTRACE_SETREGSET to nat/linux-ptrace.h
[external/binutils.git] / gdb / s390-linux-nat.c
1 /* S390 native-dependent code for GDB, the GNU debugger.
2    Copyright (C) 2001-2015 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
32 #include "s390-linux-tdep.h"
33 #include "elf/common.h"
34
35 #include <asm/ptrace.h>
36 #include <sys/ptrace.h>
37 #include <asm/types.h>
38 #include <sys/procfs.h>
39 #include <sys/ucontext.h>
40 #include <elf.h>
41
42 /* Per-thread arch-specific data.  */
43
44 struct arch_lwp_info
45 {
46   /* Non-zero if the thread's PER info must be re-written.  */
47   int per_info_changed;
48 };
49
50 static int have_regset_last_break = 0;
51 static int have_regset_system_call = 0;
52 static int have_regset_tdb = 0;
53 static int have_regset_vxrs = 0;
54
55 /* Register map for 32-bit executables running under a 64-bit
56    kernel.  */
57
58 #ifdef __s390x__
59 static const struct regcache_map_entry s390_64_regmap_gregset[] =
60   {
61     /* Skip PSWM and PSWA, since they must be handled specially.  */
62     { 2, REGCACHE_MAP_SKIP, 8 },
63     { 1, S390_R0_UPPER_REGNUM, 4 }, { 1, S390_R0_REGNUM, 4 },
64     { 1, S390_R1_UPPER_REGNUM, 4 }, { 1, S390_R1_REGNUM, 4 },
65     { 1, S390_R2_UPPER_REGNUM, 4 }, { 1, S390_R2_REGNUM, 4 },
66     { 1, S390_R3_UPPER_REGNUM, 4 }, { 1, S390_R3_REGNUM, 4 },
67     { 1, S390_R4_UPPER_REGNUM, 4 }, { 1, S390_R4_REGNUM, 4 },
68     { 1, S390_R5_UPPER_REGNUM, 4 }, { 1, S390_R5_REGNUM, 4 },
69     { 1, S390_R6_UPPER_REGNUM, 4 }, { 1, S390_R6_REGNUM, 4 },
70     { 1, S390_R7_UPPER_REGNUM, 4 }, { 1, S390_R7_REGNUM, 4 },
71     { 1, S390_R8_UPPER_REGNUM, 4 }, { 1, S390_R8_REGNUM, 4 },
72     { 1, S390_R9_UPPER_REGNUM, 4 }, { 1, S390_R9_REGNUM, 4 },
73     { 1, S390_R10_UPPER_REGNUM, 4 }, { 1, S390_R10_REGNUM, 4 },
74     { 1, S390_R11_UPPER_REGNUM, 4 }, { 1, S390_R11_REGNUM, 4 },
75     { 1, S390_R12_UPPER_REGNUM, 4 }, { 1, S390_R12_REGNUM, 4 },
76     { 1, S390_R13_UPPER_REGNUM, 4 }, { 1, S390_R13_REGNUM, 4 },
77     { 1, S390_R14_UPPER_REGNUM, 4 }, { 1, S390_R14_REGNUM, 4 },
78     { 1, S390_R15_UPPER_REGNUM, 4 }, { 1, S390_R15_REGNUM, 4 },
79     { 16, S390_A0_REGNUM, 4 },
80     { 1, REGCACHE_MAP_SKIP, 4 }, { 1, S390_ORIG_R2_REGNUM, 4 },
81     { 0 }
82   };
83
84 static const struct regset s390_64_gregset =
85   {
86     s390_64_regmap_gregset,
87     regcache_supply_regset,
88     regcache_collect_regset
89   };
90
91 #define S390_PSWM_OFFSET 0
92 #define S390_PSWA_OFFSET 8
93 #endif
94
95 /* Fill GDB's register array with the general-purpose register values
96    in *REGP.
97
98    When debugging a 32-bit executable running under a 64-bit kernel,
99    we have to fix up the 64-bit registers we get from the kernel to
100    make them look like 32-bit registers.  */
101
102 void
103 supply_gregset (struct regcache *regcache, const gregset_t *regp)
104 {
105 #ifdef __s390x__
106   struct gdbarch *gdbarch = get_regcache_arch (regcache);
107   if (gdbarch_ptr_bit (gdbarch) == 32)
108     {
109       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
110       ULONGEST pswm, pswa;
111       gdb_byte buf[4];
112
113       regcache_supply_regset (&s390_64_gregset, regcache, -1,
114                               regp, sizeof (gregset_t));
115       pswm = extract_unsigned_integer ((const gdb_byte *) regp
116                                        + S390_PSWM_OFFSET, 8, byte_order);
117       pswa = extract_unsigned_integer ((const gdb_byte *) regp
118                                        + S390_PSWA_OFFSET, 8, byte_order);
119       store_unsigned_integer (buf, 4, byte_order, (pswm >> 32) | 0x80000);
120       regcache_raw_supply (regcache, S390_PSWM_REGNUM, buf);
121       store_unsigned_integer (buf, 4, byte_order,
122                               (pswa & 0x7fffffff) | (pswm & 0x80000000));
123       regcache_raw_supply (regcache, S390_PSWA_REGNUM, buf);
124       return;
125     }
126 #endif
127
128   regcache_supply_regset (&s390_gregset, regcache, -1, regp,
129                           sizeof (gregset_t));
130 }
131
132 /* Fill register REGNO (if it is a general-purpose register) in
133    *REGP with the value in GDB's register array.  If REGNO is -1,
134    do this for all registers.  */
135
136 void
137 fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno)
138 {
139 #ifdef __s390x__
140   struct gdbarch *gdbarch = get_regcache_arch (regcache);
141   if (gdbarch_ptr_bit (gdbarch) == 32)
142     {
143       regcache_collect_regset (&s390_64_gregset, regcache, regno,
144                                regp, sizeof (gregset_t));
145
146       if (regno == -1
147           || regno == S390_PSWM_REGNUM || regno == S390_PSWA_REGNUM)
148         {
149           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
150           ULONGEST pswa, pswm;
151           gdb_byte buf[4];
152           gdb_byte *pswm_p = (gdb_byte *) regp + S390_PSWM_OFFSET;
153           gdb_byte *pswa_p = (gdb_byte *) regp + S390_PSWA_OFFSET;
154
155           pswm = extract_unsigned_integer (pswm_p, 8, byte_order);
156
157           if (regno == -1 || regno == S390_PSWM_REGNUM)
158             {
159               pswm &= 0x80000000;
160               regcache_raw_collect (regcache, S390_PSWM_REGNUM, buf);
161               pswm |= (extract_unsigned_integer (buf, 4, byte_order)
162                        & 0xfff7ffff) << 32;
163             }
164
165           if (regno == -1 || regno == S390_PSWA_REGNUM)
166             {
167               regcache_raw_collect (regcache, S390_PSWA_REGNUM, buf);
168               pswa = extract_unsigned_integer (buf, 4, byte_order);
169               pswm ^= (pswm ^ pswa) & 0x80000000;
170               pswa &= 0x7fffffff;
171               store_unsigned_integer (pswa_p, 8, byte_order, pswa);
172             }
173
174           store_unsigned_integer (pswm_p, 8, byte_order, pswm);
175         }
176       return;
177     }
178 #endif
179
180   regcache_collect_regset (&s390_gregset, regcache, regno, regp,
181                            sizeof (gregset_t));
182 }
183
184 /* Fill GDB's register array with the floating-point register values
185    in *REGP.  */
186 void
187 supply_fpregset (struct regcache *regcache, const fpregset_t *regp)
188 {
189   regcache_supply_regset (&s390_fpregset, regcache, -1, regp,
190                           sizeof (fpregset_t));
191 }
192
193 /* Fill register REGNO (if it is a general-purpose register) in
194    *REGP with the value in GDB's register array.  If REGNO is -1,
195    do this for all registers.  */
196 void
197 fill_fpregset (const struct regcache *regcache, fpregset_t *regp, int regno)
198 {
199   regcache_collect_regset (&s390_fpregset, regcache, regno, regp,
200                            sizeof (fpregset_t));
201 }
202
203 /* Find the TID for the current inferior thread to use with ptrace.  */
204 static int
205 s390_inferior_tid (void)
206 {
207   /* GNU/Linux LWP ID's are process ID's.  */
208   int tid = ptid_get_lwp (inferior_ptid);
209   if (tid == 0)
210     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
211
212   return tid;
213 }
214
215 /* Fetch all general-purpose registers from process/thread TID and
216    store their values in GDB's register cache.  */
217 static void
218 fetch_regs (struct regcache *regcache, int tid)
219 {
220   gregset_t regs;
221   ptrace_area parea;
222
223   parea.len = sizeof (regs);
224   parea.process_addr = (addr_t) &regs;
225   parea.kernel_addr = offsetof (struct user_regs_struct, psw);
226   if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
227     perror_with_name (_("Couldn't get registers"));
228
229   supply_gregset (regcache, (const gregset_t *) &regs);
230 }
231
232 /* Store all valid general-purpose registers in GDB's register cache
233    into the process/thread specified by TID.  */
234 static void
235 store_regs (const struct regcache *regcache, int tid, int regnum)
236 {
237   gregset_t regs;
238   ptrace_area parea;
239
240   parea.len = sizeof (regs);
241   parea.process_addr = (addr_t) &regs;
242   parea.kernel_addr = offsetof (struct user_regs_struct, psw);
243   if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
244     perror_with_name (_("Couldn't get registers"));
245
246   fill_gregset (regcache, &regs, regnum);
247
248   if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
249     perror_with_name (_("Couldn't write registers"));
250 }
251
252 /* Fetch all floating-point registers from process/thread TID and store
253    their values in GDB's register cache.  */
254 static void
255 fetch_fpregs (struct regcache *regcache, int tid)
256 {
257   fpregset_t fpregs;
258   ptrace_area parea;
259
260   parea.len = sizeof (fpregs);
261   parea.process_addr = (addr_t) &fpregs;
262   parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
263   if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
264     perror_with_name (_("Couldn't get floating point status"));
265
266   supply_fpregset (regcache, (const fpregset_t *) &fpregs);
267 }
268
269 /* Store all valid floating-point registers in GDB's register cache
270    into the process/thread specified by TID.  */
271 static void
272 store_fpregs (const struct regcache *regcache, int tid, int regnum)
273 {
274   fpregset_t fpregs;
275   ptrace_area parea;
276
277   parea.len = sizeof (fpregs);
278   parea.process_addr = (addr_t) &fpregs;
279   parea.kernel_addr = offsetof (struct user_regs_struct, fp_regs);
280   if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
281     perror_with_name (_("Couldn't get floating point status"));
282
283   fill_fpregset (regcache, &fpregs, regnum);
284
285   if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
286     perror_with_name (_("Couldn't write floating point status"));
287 }
288
289 /* Fetch all registers in the kernel's register set whose number is
290    REGSET_ID, whose size is REGSIZE, and whose layout is described by
291    REGSET, from process/thread TID and store their values in GDB's
292    register cache.  */
293 static void
294 fetch_regset (struct regcache *regcache, int tid,
295               int regset_id, int regsize, const struct regset *regset)
296 {
297   gdb_byte *buf = alloca (regsize);
298   struct iovec iov;
299
300   iov.iov_base = buf;
301   iov.iov_len = regsize;
302
303   if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
304     {
305       if (errno == ENODATA)
306         regcache_supply_regset (regset, regcache, -1, NULL, regsize);
307       else
308         perror_with_name (_("Couldn't get register set"));
309     }
310   else
311     regcache_supply_regset (regset, regcache, -1, buf, regsize);
312 }
313
314 /* Store all registers in the kernel's register set whose number is
315    REGSET_ID, whose size is REGSIZE, and whose layout is described by
316    REGSET, from GDB's register cache back to process/thread TID.  */
317 static void
318 store_regset (struct regcache *regcache, int tid,
319               int regset_id, int regsize, const struct regset *regset)
320 {
321   gdb_byte *buf = alloca (regsize);
322   struct iovec iov;
323
324   iov.iov_base = buf;
325   iov.iov_len = regsize;
326
327   if (ptrace (PTRACE_GETREGSET, tid, (long) regset_id, (long) &iov) < 0)
328     perror_with_name (_("Couldn't get register set"));
329
330   regcache_collect_regset (regset, regcache, -1, buf, regsize);
331
332   if (ptrace (PTRACE_SETREGSET, tid, (long) regset_id, (long) &iov) < 0)
333     perror_with_name (_("Couldn't set register set"));
334 }
335
336 /* Check whether the kernel provides a register set with number REGSET
337    of size REGSIZE for process/thread TID.  */
338 static int
339 check_regset (int tid, int regset, int regsize)
340 {
341   gdb_byte *buf = alloca (regsize);
342   struct iovec iov;
343
344   iov.iov_base = buf;
345   iov.iov_len = regsize;
346
347   if (ptrace (PTRACE_GETREGSET, tid, (long) regset, (long) &iov) >= 0
348       || errno == ENODATA)
349     return 1;
350   return 0;
351 }
352
353 /* Fetch register REGNUM from the child process.  If REGNUM is -1, do
354    this for all registers.  */
355 static void
356 s390_linux_fetch_inferior_registers (struct target_ops *ops,
357                                      struct regcache *regcache, int regnum)
358 {
359   int tid = s390_inferior_tid ();
360
361   if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
362     fetch_regs (regcache, tid);
363
364   if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum))
365     fetch_fpregs (regcache, tid);
366
367   if (have_regset_last_break)
368     if (regnum == -1 || regnum == S390_LAST_BREAK_REGNUM)
369       fetch_regset (regcache, tid, NT_S390_LAST_BREAK, 8,
370                     (gdbarch_ptr_bit (get_regcache_arch (regcache)) == 32
371                      ? &s390_last_break_regset : &s390x_last_break_regset));
372
373   if (have_regset_system_call)
374     if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
375       fetch_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
376                     &s390_system_call_regset);
377
378   if (have_regset_tdb)
379     if (regnum == -1 || S390_IS_TDBREGSET_REGNUM (regnum))
380       fetch_regset (regcache, tid, NT_S390_TDB, s390_sizeof_tdbregset,
381                     &s390_tdb_regset);
382
383   if (have_regset_vxrs)
384     {
385       if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
386                            && regnum <= S390_V15_LOWER_REGNUM))
387         fetch_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
388                       &s390_vxrs_low_regset);
389       if (regnum == -1 || (regnum >= S390_V16_REGNUM
390                            && regnum <= S390_V31_REGNUM))
391         fetch_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
392                       &s390_vxrs_high_regset);
393     }
394 }
395
396 /* Store register REGNUM back into the child process.  If REGNUM is
397    -1, do this for all registers.  */
398 static void
399 s390_linux_store_inferior_registers (struct target_ops *ops,
400                                      struct regcache *regcache, int regnum)
401 {
402   int tid = s390_inferior_tid ();
403
404   if (regnum == -1 || S390_IS_GREGSET_REGNUM (regnum))
405     store_regs (regcache, tid, regnum);
406
407   if (regnum == -1 || S390_IS_FPREGSET_REGNUM (regnum))
408     store_fpregs (regcache, tid, regnum);
409
410   /* S390_LAST_BREAK_REGNUM is read-only.  */
411
412   if (have_regset_system_call)
413     if (regnum == -1 || regnum == S390_SYSTEM_CALL_REGNUM)
414       store_regset (regcache, tid, NT_S390_SYSTEM_CALL, 4,
415                     &s390_system_call_regset);
416
417   if (have_regset_vxrs)
418     {
419       if (regnum == -1 || (regnum >= S390_V0_LOWER_REGNUM
420                            && regnum <= S390_V15_LOWER_REGNUM))
421         store_regset (regcache, tid, NT_S390_VXRS_LOW, 16 * 8,
422                       &s390_vxrs_low_regset);
423       if (regnum == -1 || (regnum >= S390_V16_REGNUM
424                            && regnum <= S390_V31_REGNUM))
425         store_regset (regcache, tid, NT_S390_VXRS_HIGH, 16 * 16,
426                       &s390_vxrs_high_regset);
427     }
428 }
429
430
431 /* Hardware-assisted watchpoint handling.  */
432
433 /* We maintain a list of all currently active watchpoints in order
434    to properly handle watchpoint removal.
435
436    The only thing we actually need is the total address space area
437    spanned by the watchpoints.  */
438
439 struct watch_area
440 {
441   struct watch_area *next;
442   CORE_ADDR lo_addr;
443   CORE_ADDR hi_addr;
444 };
445
446 static struct watch_area *watch_base = NULL;
447
448 static int
449 s390_stopped_by_watchpoint (struct target_ops *ops)
450 {
451   per_lowcore_bits per_lowcore;
452   ptrace_area parea;
453   int result;
454
455   /* Speed up common case.  */
456   if (!watch_base)
457     return 0;
458
459   parea.len = sizeof (per_lowcore);
460   parea.process_addr = (addr_t) & per_lowcore;
461   parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
462   if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea) < 0)
463     perror_with_name (_("Couldn't retrieve watchpoint status"));
464
465   result = (per_lowcore.perc_storage_alteration == 1
466             && per_lowcore.perc_store_real_address == 0);
467
468   if (result)
469     {
470       /* Do not report this watchpoint again.  */
471       memset (&per_lowcore, 0, sizeof (per_lowcore));
472       if (ptrace (PTRACE_POKEUSR_AREA, s390_inferior_tid (), &parea) < 0)
473         perror_with_name (_("Couldn't clear watchpoint status"));
474     }
475
476   return result;
477 }
478
479 /* Each time before resuming a thread, update its PER info.  */
480
481 static void
482 s390_prepare_to_resume (struct lwp_info *lp)
483 {
484   int tid;
485
486   per_struct per_info;
487   ptrace_area parea;
488
489   CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0;
490   struct watch_area *area;
491
492   if (lp->arch_private == NULL
493       || !lp->arch_private->per_info_changed)
494     return;
495
496   lp->arch_private->per_info_changed = 0;
497
498   tid = ptid_get_lwp (lp->ptid);
499   if (tid == 0)
500     tid = ptid_get_pid (lp->ptid);
501
502   for (area = watch_base; area; area = area->next)
503     {
504       watch_lo_addr = min (watch_lo_addr, area->lo_addr);
505       watch_hi_addr = max (watch_hi_addr, area->hi_addr);
506     }
507
508   parea.len = sizeof (per_info);
509   parea.process_addr = (addr_t) & per_info;
510   parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
511   if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea) < 0)
512     perror_with_name (_("Couldn't retrieve watchpoint status"));
513
514   if (watch_base)
515     {
516       per_info.control_regs.bits.em_storage_alteration = 1;
517       per_info.control_regs.bits.storage_alt_space_ctl = 1;
518     }
519   else
520     {
521       per_info.control_regs.bits.em_storage_alteration = 0;
522       per_info.control_regs.bits.storage_alt_space_ctl = 0;
523     }
524   per_info.starting_addr = watch_lo_addr;
525   per_info.ending_addr = watch_hi_addr;
526
527   if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea) < 0)
528     perror_with_name (_("Couldn't modify watchpoint status"));
529 }
530
531 /* Make sure that LP is stopped and mark its PER info as changed, so
532    the next resume will update it.  */
533
534 static void
535 s390_refresh_per_info (struct lwp_info *lp)
536 {
537   if (lp->arch_private == NULL)
538     lp->arch_private = XCNEW (struct arch_lwp_info);
539
540   lp->arch_private->per_info_changed = 1;
541
542   if (!lp->stopped)
543     linux_stop_lwp (lp);
544 }
545
546 /* When attaching to a new thread, mark its PER info as changed.  */
547
548 static void
549 s390_new_thread (struct lwp_info *lp)
550 {
551   lp->arch_private = XCNEW (struct arch_lwp_info);
552   lp->arch_private->per_info_changed = 1;
553 }
554
555 static int
556 s390_insert_watchpoint (struct target_ops *self,
557                         CORE_ADDR addr, int len, int type,
558                         struct expression *cond)
559 {
560   struct lwp_info *lp;
561   struct watch_area *area = xmalloc (sizeof (struct watch_area));
562
563   if (!area)
564     return -1;
565
566   area->lo_addr = addr;
567   area->hi_addr = addr + len - 1;
568
569   area->next = watch_base;
570   watch_base = area;
571
572   ALL_LWPS (lp)
573     s390_refresh_per_info (lp);
574   return 0;
575 }
576
577 static int
578 s390_remove_watchpoint (struct target_ops *self,
579                         CORE_ADDR addr, int len, int type,
580                         struct expression *cond)
581 {
582   struct lwp_info *lp;
583   struct watch_area *area, **parea;
584
585   for (parea = &watch_base; *parea; parea = &(*parea)->next)
586     if ((*parea)->lo_addr == addr
587         && (*parea)->hi_addr == addr + len - 1)
588       break;
589
590   if (!*parea)
591     {
592       fprintf_unfiltered (gdb_stderr,
593                           "Attempt to remove nonexistent watchpoint.\n");
594       return -1;
595     }
596
597   area = *parea;
598   *parea = area->next;
599   xfree (area);
600
601   ALL_LWPS (lp)
602     s390_refresh_per_info (lp);
603   return 0;
604 }
605
606 static int
607 s390_can_use_hw_breakpoint (struct target_ops *self,
608                             int type, int cnt, int othertype)
609 {
610   return type == bp_hardware_watchpoint;
611 }
612
613 static int
614 s390_region_ok_for_hw_watchpoint (struct target_ops *self,
615                                   CORE_ADDR addr, int cnt)
616 {
617   return 1;
618 }
619
620 static int
621 s390_target_wordsize (void)
622 {
623   int wordsize = 4;
624
625   /* Check for 64-bit inferior process.  This is the case when the host is
626      64-bit, and in addition bit 32 of the PSW mask is set.  */
627 #ifdef __s390x__
628   long pswm;
629
630   errno = 0;
631   pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0);
632   if (errno == 0 && (pswm & 0x100000000ul) != 0)
633     wordsize = 8;
634 #endif
635
636   return wordsize;
637 }
638
639 static int
640 s390_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
641                  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
642 {
643   int sizeof_auxv_field = s390_target_wordsize ();
644   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
645   gdb_byte *ptr = *readptr;
646
647   if (endptr == ptr)
648     return 0;
649
650   if (endptr - ptr < sizeof_auxv_field * 2)
651     return -1;
652
653   *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
654   ptr += sizeof_auxv_field;
655   *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
656   ptr += sizeof_auxv_field;
657
658   *readptr = ptr;
659   return 1;
660 }
661
662 static const struct target_desc *
663 s390_read_description (struct target_ops *ops)
664 {
665   int tid = s390_inferior_tid ();
666
667   have_regset_last_break
668     = check_regset (tid, NT_S390_LAST_BREAK, 8);
669   have_regset_system_call
670     = check_regset (tid, NT_S390_SYSTEM_CALL, 4);
671
672   /* If GDB itself is compiled as 64-bit, we are running on a machine in
673      z/Architecture mode.  If the target is running in 64-bit addressing
674      mode, report s390x architecture.  If the target is running in 31-bit
675      addressing mode, but the kernel supports using 64-bit registers in
676      that mode, report s390 architecture with 64-bit GPRs.  */
677 #ifdef __s390x__
678   {
679     CORE_ADDR hwcap = 0;
680
681     target_auxv_search (&current_target, AT_HWCAP, &hwcap);
682     have_regset_tdb = (hwcap & HWCAP_S390_TE)
683       && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset);
684
685     have_regset_vxrs = (hwcap & HWCAP_S390_VX)
686       && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8)
687       && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16);
688
689     if (s390_target_wordsize () == 8)
690       return (have_regset_vxrs ?
691               (have_regset_tdb ? tdesc_s390x_tevx_linux64 :
692                tdesc_s390x_vx_linux64) :
693               have_regset_tdb ? tdesc_s390x_te_linux64 :
694               have_regset_system_call ? tdesc_s390x_linux64v2 :
695               have_regset_last_break ? tdesc_s390x_linux64v1 :
696               tdesc_s390x_linux64);
697
698     if (hwcap & HWCAP_S390_HIGH_GPRS)
699       return (have_regset_vxrs ?
700               (have_regset_tdb ? tdesc_s390_tevx_linux64 :
701                tdesc_s390_vx_linux64) :
702               have_regset_tdb ? tdesc_s390_te_linux64 :
703               have_regset_system_call ? tdesc_s390_linux64v2 :
704               have_regset_last_break ? tdesc_s390_linux64v1 :
705               tdesc_s390_linux64);
706   }
707 #endif
708
709   /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
710      on a 64-bit kernel that does not support using 64-bit registers in 31-bit
711      mode, report s390 architecture with 32-bit GPRs.  */
712   return (have_regset_system_call? tdesc_s390_linux32v2 :
713           have_regset_last_break? tdesc_s390_linux32v1 :
714           tdesc_s390_linux32);
715 }
716
717 void _initialize_s390_nat (void);
718
719 void
720 _initialize_s390_nat (void)
721 {
722   struct target_ops *t;
723
724   /* Fill in the generic GNU/Linux methods.  */
725   t = linux_target ();
726
727   /* Add our register access methods.  */
728   t->to_fetch_registers = s390_linux_fetch_inferior_registers;
729   t->to_store_registers = s390_linux_store_inferior_registers;
730
731   /* Add our watchpoint methods.  */
732   t->to_can_use_hw_breakpoint = s390_can_use_hw_breakpoint;
733   t->to_region_ok_for_hw_watchpoint = s390_region_ok_for_hw_watchpoint;
734   t->to_have_continuable_watchpoint = 1;
735   t->to_stopped_by_watchpoint = s390_stopped_by_watchpoint;
736   t->to_insert_watchpoint = s390_insert_watchpoint;
737   t->to_remove_watchpoint = s390_remove_watchpoint;
738
739   /* Detect target architecture.  */
740   t->to_read_description = s390_read_description;
741   t->to_auxv_parse = s390_auxv_parse;
742
743   /* Register the target.  */
744   linux_nat_add_target (t);
745   linux_nat_set_new_thread (t, s390_new_thread);
746   linux_nat_set_prepare_to_resume (t, s390_prepare_to_resume);
747 }