gdb/s390-linux-nat.c

   1 /* S390 native-dependent code for GDB, the GNU debugger.
   2    Copyright (C) 2001-2016 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 "nat/gdb_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) < 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) < 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) < 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) < 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) < 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) < 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   void *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   void *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   void *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 typedef struct watch_area
 440 {
 441   CORE_ADDR lo_addr;
 442   CORE_ADDR hi_addr;
 443 } s390_watch_area;
 444
 445 DEF_VEC_O (s390_watch_area);
 446
 447 VEC_s390_watch_area *watch_areas = NULL;
 448
 449 static int
 450 s390_stopped_by_watchpoint (struct target_ops *ops)
 451 {
 452   per_lowcore_bits per_lowcore;
 453   ptrace_area parea;
 454   int result;
 455
 456   /* Speed up common case.  */
 457   if (VEC_empty (s390_watch_area, watch_areas))
 458     return 0;
 459
 460   parea.len = sizeof (per_lowcore);
 461   parea.process_addr = (addr_t) & per_lowcore;
 462   parea.kernel_addr = offsetof (struct user_regs_struct, per_info.lowcore);
 463   if (ptrace (PTRACE_PEEKUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
 464     perror_with_name (_("Couldn't retrieve watchpoint status"));
 465
 466   result = (per_lowcore.perc_storage_alteration == 1
 467             && per_lowcore.perc_store_real_address == 0);
 468
 469   if (result)
 470     {
 471       /* Do not report this watchpoint again.  */
 472       memset (&per_lowcore, 0, sizeof (per_lowcore));
 473       if (ptrace (PTRACE_POKEUSR_AREA, s390_inferior_tid (), &parea, 0) < 0)
 474         perror_with_name (_("Couldn't clear watchpoint status"));
 475     }
 476
 477   return result;
 478 }
 479
 480 /* Each time before resuming a thread, update its PER info.  */
 481
 482 static void
 483 s390_prepare_to_resume (struct lwp_info *lp)
 484 {
 485   int tid;
 486
 487   per_struct per_info;
 488   ptrace_area parea;
 489
 490   CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0;
 491   unsigned ix;
 492   s390_watch_area *area;
 493   struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp);
 494
 495   if (lp_priv == NULL || !lp_priv->per_info_changed)
 496     return;
 497
 498   lp_priv->per_info_changed = 0;
 499
 500   tid = ptid_get_lwp (ptid_of_lwp (lp));
 501   if (tid == 0)
 502     tid = ptid_get_pid (ptid_of_lwp (lp));
 503
 504   parea.len = sizeof (per_info);
 505   parea.process_addr = (addr_t) & per_info;
 506   parea.kernel_addr = offsetof (struct user_regs_struct, per_info);
 507   if (ptrace (PTRACE_PEEKUSR_AREA, tid, &parea, 0) < 0)
 508     perror_with_name (_("Couldn't retrieve watchpoint status"));
 509
 510   if (!VEC_empty (s390_watch_area, watch_areas))
 511     {
 512       for (ix = 0;
 513            VEC_iterate (s390_watch_area, watch_areas, ix, area);
 514            ix++)
 515         {
 516           watch_lo_addr = min (watch_lo_addr, area->lo_addr);
 517           watch_hi_addr = max (watch_hi_addr, area->hi_addr);
 518         }
 519
 520       per_info.control_regs.bits.em_storage_alteration = 1;
 521       per_info.control_regs.bits.storage_alt_space_ctl = 1;
 522     }
 523   else
 524     {
 525       per_info.control_regs.bits.em_storage_alteration = 0;
 526       per_info.control_regs.bits.storage_alt_space_ctl = 0;
 527     }
 528   per_info.starting_addr = watch_lo_addr;
 529   per_info.ending_addr = watch_hi_addr;
 530
 531   if (ptrace (PTRACE_POKEUSR_AREA, tid, &parea, 0) < 0)
 532     perror_with_name (_("Couldn't modify watchpoint status"));
 533 }
 534
 535 /* Mark the PER info as changed, so the next resume will update it.  */
 536
 537 static void
 538 s390_mark_per_info_changed (struct lwp_info *lp)
 539 {
 540   if (lwp_arch_private_info (lp) == NULL)
 541     lwp_set_arch_private_info (lp, XCNEW (struct arch_lwp_info));
 542
 543   lwp_arch_private_info (lp)->per_info_changed = 1;
 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   s390_mark_per_info_changed (lp);
 552 }
 553
 554 /* Iterator callback for s390_refresh_per_info.  */
 555
 556 static int
 557 s390_refresh_per_info_cb (struct lwp_info *lp, void *arg)
 558 {
 559   s390_mark_per_info_changed (lp);
 560
 561   if (!lwp_is_stopped (lp))
 562     linux_stop_lwp (lp);
 563   return 0;
 564 }
 565
 566 /* Make sure that threads are stopped and mark PER info as changed.  */
 567
 568 static int
 569 s390_refresh_per_info (void)
 570 {
 571   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
 572
 573   iterate_over_lwps (pid_ptid, s390_refresh_per_info_cb, NULL);
 574   return 0;
 575 }
 576
 577 static int
 578 s390_insert_watchpoint (struct target_ops *self,
 579                         CORE_ADDR addr, int len, enum target_hw_bp_type type,
 580                         struct expression *cond)
 581 {
 582   s390_watch_area area;
 583
 584   area.lo_addr = addr;
 585   area.hi_addr = addr + len - 1;
 586   VEC_safe_push (s390_watch_area, watch_areas, &area);
 587
 588   return s390_refresh_per_info ();
 589 }
 590
 591 static int
 592 s390_remove_watchpoint (struct target_ops *self,
 593                         CORE_ADDR addr, int len, enum target_hw_bp_type type,
 594                         struct expression *cond)
 595 {
 596   unsigned ix;
 597   s390_watch_area *area;
 598
 599   for (ix = 0;
 600        VEC_iterate (s390_watch_area, watch_areas, ix, area);
 601        ix++)
 602     {
 603       if (area->lo_addr == addr && area->hi_addr == addr + len - 1)
 604         {
 605           VEC_unordered_remove (s390_watch_area, watch_areas, ix);
 606           return s390_refresh_per_info ();
 607         }
 608     }
 609
 610   fprintf_unfiltered (gdb_stderr,
 611                       "Attempt to remove nonexistent watchpoint.\n");
 612   return -1;
 613 }
 614
 615 static int
 616 s390_can_use_hw_breakpoint (struct target_ops *self,
 617                             enum bptype type, int cnt, int othertype)
 618 {
 619   return type == bp_hardware_watchpoint;
 620 }
 621
 622 static int
 623 s390_region_ok_for_hw_watchpoint (struct target_ops *self,
 624                                   CORE_ADDR addr, int cnt)
 625 {
 626   return 1;
 627 }
 628
 629 static int
 630 s390_target_wordsize (void)
 631 {
 632   int wordsize = 4;
 633
 634   /* Check for 64-bit inferior process.  This is the case when the host is
 635      64-bit, and in addition bit 32 of the PSW mask is set.  */
 636 #ifdef __s390x__
 637   long pswm;
 638
 639   errno = 0;
 640   pswm = (long) ptrace (PTRACE_PEEKUSER, s390_inferior_tid (), PT_PSWMASK, 0);
 641   if (errno == 0 && (pswm & 0x100000000ul) != 0)
 642     wordsize = 8;
 643 #endif
 644
 645   return wordsize;
 646 }
 647
 648 static int
 649 s390_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
 650                  gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 651 {
 652   int sizeof_auxv_field = s390_target_wordsize ();
 653   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 654   gdb_byte *ptr = *readptr;
 655
 656   if (endptr == ptr)
 657     return 0;
 658
 659   if (endptr - ptr < sizeof_auxv_field * 2)
 660     return -1;
 661
 662   *typep = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 663   ptr += sizeof_auxv_field;
 664   *valp = extract_unsigned_integer (ptr, sizeof_auxv_field, byte_order);
 665   ptr += sizeof_auxv_field;
 666
 667   *readptr = ptr;
 668   return 1;
 669 }
 670
 671 static const struct target_desc *
 672 s390_read_description (struct target_ops *ops)
 673 {
 674   int tid = s390_inferior_tid ();
 675
 676   have_regset_last_break
 677     = check_regset (tid, NT_S390_LAST_BREAK, 8);
 678   have_regset_system_call
 679     = check_regset (tid, NT_S390_SYSTEM_CALL, 4);
 680
 681   /* If GDB itself is compiled as 64-bit, we are running on a machine in
 682      z/Architecture mode.  If the target is running in 64-bit addressing
 683      mode, report s390x architecture.  If the target is running in 31-bit
 684      addressing mode, but the kernel supports using 64-bit registers in
 685      that mode, report s390 architecture with 64-bit GPRs.  */
 686 #ifdef __s390x__
 687   {
 688     CORE_ADDR hwcap = 0;
 689
 690     target_auxv_search (&current_target, AT_HWCAP, &hwcap);
 691     have_regset_tdb = (hwcap & HWCAP_S390_TE)
 692       && check_regset (tid, NT_S390_TDB, s390_sizeof_tdbregset);
 693
 694     have_regset_vxrs = (hwcap & HWCAP_S390_VX)
 695       && check_regset (tid, NT_S390_VXRS_LOW, 16 * 8)
 696       && check_regset (tid, NT_S390_VXRS_HIGH, 16 * 16);
 697
 698     if (s390_target_wordsize () == 8)
 699       return (have_regset_vxrs ?
 700               (have_regset_tdb ? tdesc_s390x_tevx_linux64 :
 701                tdesc_s390x_vx_linux64) :
 702               have_regset_tdb ? tdesc_s390x_te_linux64 :
 703               have_regset_system_call ? tdesc_s390x_linux64v2 :
 704               have_regset_last_break ? tdesc_s390x_linux64v1 :
 705               tdesc_s390x_linux64);
 706
 707     if (hwcap & HWCAP_S390_HIGH_GPRS)
 708       return (have_regset_vxrs ?
 709               (have_regset_tdb ? tdesc_s390_tevx_linux64 :
 710                tdesc_s390_vx_linux64) :
 711               have_regset_tdb ? tdesc_s390_te_linux64 :
 712               have_regset_system_call ? tdesc_s390_linux64v2 :
 713               have_regset_last_break ? tdesc_s390_linux64v1 :
 714               tdesc_s390_linux64);
 715   }
 716 #endif
 717
 718   /* If GDB itself is compiled as 31-bit, or if we're running a 31-bit inferior
 719      on a 64-bit kernel that does not support using 64-bit registers in 31-bit
 720      mode, report s390 architecture with 32-bit GPRs.  */
 721   return (have_regset_system_call? tdesc_s390_linux32v2 :
 722           have_regset_last_break? tdesc_s390_linux32v1 :
 723           tdesc_s390_linux32);
 724 }
 725
 726 void _initialize_s390_nat (void);
 727
 728 void
 729 _initialize_s390_nat (void)
 730 {
 731   struct target_ops *t;
 732
 733   /* Fill in the generic GNU/Linux methods.  */
 734   t = linux_target ();
 735
 736   /* Add our register access methods.  */
 737   t->to_fetch_registers = s390_linux_fetch_inferior_registers;
 738   t->to_store_registers = s390_linux_store_inferior_registers;
 739
 740   /* Add our watchpoint methods.  */
 741   t->to_can_use_hw_breakpoint = s390_can_use_hw_breakpoint;
 742   t->to_region_ok_for_hw_watchpoint = s390_region_ok_for_hw_watchpoint;
 743   t->to_have_continuable_watchpoint = 1;
 744   t->to_stopped_by_watchpoint = s390_stopped_by_watchpoint;
 745   t->to_insert_watchpoint = s390_insert_watchpoint;
 746   t->to_remove_watchpoint = s390_remove_watchpoint;
 747
 748   /* Detect target architecture.  */
 749   t->to_read_description = s390_read_description;
 750   t->to_auxv_parse = s390_auxv_parse;
 751
 752   /* Register the target.  */
 753   linux_nat_add_target (t);
 754   linux_nat_set_new_thread (t, s390_new_thread);
 755   linux_nat_set_prepare_to_resume (t, s390_prepare_to_resume);
 756 }