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 }