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