gdb/s390-linux-nat.c

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