gdb/gdbserver/linux-s390-low.c

   1 /* GNU/Linux S/390 specific low level interface, for the remote server
   2    for GDB.
   3    Copyright (C) 2001-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file is used for both 31-bit and 64-bit S/390 systems.  */
  21
  22 #include "server.h"
  23 #include "linux-low.h"
  24 #include "elf/common.h"
  25
  26 #include <asm/ptrace.h>
  27 #include <sys/ptrace.h>
  28 #include <sys/uio.h>
  29 #include <elf.h>
  30
  31 #ifndef HWCAP_S390_HIGH_GPRS
  32 #define HWCAP_S390_HIGH_GPRS 512
  33 #endif
  34
  35 #ifndef HWCAP_S390_TE
  36 #define HWCAP_S390_TE 1024
  37 #endif
  38
  39 #ifndef HWCAP_S390_VX
  40 #define HWCAP_S390_VX 2048
  41 #endif
  42
  43 #ifndef PTRACE_GETREGSET
  44 #define PTRACE_GETREGSET 0x4204
  45 #endif
  46
  47 #ifndef PTRACE_SETREGSET
  48 #define PTRACE_SETREGSET 0x4205
  49 #endif
  50
  51 /* Defined in auto-generated file s390-linux32.c.  */
  52 void init_registers_s390_linux32 (void);
  53 extern const struct target_desc *tdesc_s390_linux32;
  54
  55 /* Defined in auto-generated file s390-linux32v1.c.  */
  56 void init_registers_s390_linux32v1 (void);
  57 extern const struct target_desc *tdesc_s390_linux32v1;
  58
  59 /* Defined in auto-generated file s390-linux32v2.c.  */
  60 void init_registers_s390_linux32v2 (void);
  61 extern const struct target_desc *tdesc_s390_linux32v2;
  62
  63 /* Defined in auto-generated file s390-linux64.c.  */
  64 void init_registers_s390_linux64 (void);
  65 extern const struct target_desc *tdesc_s390_linux64;
  66
  67 /* Defined in auto-generated file s390-linux64v1.c.  */
  68 void init_registers_s390_linux64v1 (void);
  69 extern const struct target_desc *tdesc_s390_linux64v1;
  70
  71 /* Defined in auto-generated file s390-linux64v2.c.  */
  72 void init_registers_s390_linux64v2 (void);
  73 extern const struct target_desc *tdesc_s390_linux64v2;
  74
  75 /* Defined in auto-generated file s390-te-linux64.c.  */
  76 void init_registers_s390_te_linux64 (void);
  77 extern const struct target_desc *tdesc_s390_te_linux64;
  78
  79 /* Defined in auto-generated file s390-vx-linux64.c.  */
  80 void init_registers_s390_vx_linux64 (void);
  81 extern const struct target_desc *tdesc_s390_vx_linux64;
  82
  83 /* Defined in auto-generated file s390-tevx-linux64.c.  */
  84 void init_registers_s390_tevx_linux64 (void);
  85 extern const struct target_desc *tdesc_s390_tevx_linux64;
  86
  87 /* Defined in auto-generated file s390x-linux64.c.  */
  88 void init_registers_s390x_linux64 (void);
  89 extern const struct target_desc *tdesc_s390x_linux64;
  90
  91 /* Defined in auto-generated file s390x-linux64v1.c.  */
  92 void init_registers_s390x_linux64v1 (void);
  93 extern const struct target_desc *tdesc_s390x_linux64v1;
  94
  95 /* Defined in auto-generated file s390x-linux64v2.c.  */
  96 void init_registers_s390x_linux64v2 (void);
  97 extern const struct target_desc *tdesc_s390x_linux64v2;
  98
  99 /* Defined in auto-generated file s390x-te-linux64.c.  */
 100 void init_registers_s390x_te_linux64 (void);
 101 extern const struct target_desc *tdesc_s390x_te_linux64;
 102
 103 /* Defined in auto-generated file s390x-vx-linux64.c.  */
 104 void init_registers_s390x_vx_linux64 (void);
 105 extern const struct target_desc *tdesc_s390x_vx_linux64;
 106
 107 /* Defined in auto-generated file s390x-tevx-linux64.c.  */
 108 void init_registers_s390x_tevx_linux64 (void);
 109 extern const struct target_desc *tdesc_s390x_tevx_linux64;
 110
 111 #define s390_num_regs 52
 112
 113 static int s390_regmap[] = {
 114   PT_PSWMASK, PT_PSWADDR,
 115
 116   PT_GPR0, PT_GPR1, PT_GPR2, PT_GPR3,
 117   PT_GPR4, PT_GPR5, PT_GPR6, PT_GPR7,
 118   PT_GPR8, PT_GPR9, PT_GPR10, PT_GPR11,
 119   PT_GPR12, PT_GPR13, PT_GPR14, PT_GPR15,
 120
 121   PT_ACR0, PT_ACR1, PT_ACR2, PT_ACR3,
 122   PT_ACR4, PT_ACR5, PT_ACR6, PT_ACR7,
 123   PT_ACR8, PT_ACR9, PT_ACR10, PT_ACR11,
 124   PT_ACR12, PT_ACR13, PT_ACR14, PT_ACR15,
 125
 126   PT_FPC,
 127
 128 #ifndef __s390x__
 129   PT_FPR0_HI, PT_FPR1_HI, PT_FPR2_HI, PT_FPR3_HI,
 130   PT_FPR4_HI, PT_FPR5_HI, PT_FPR6_HI, PT_FPR7_HI,
 131   PT_FPR8_HI, PT_FPR9_HI, PT_FPR10_HI, PT_FPR11_HI,
 132   PT_FPR12_HI, PT_FPR13_HI, PT_FPR14_HI, PT_FPR15_HI,
 133 #else
 134   PT_FPR0, PT_FPR1, PT_FPR2, PT_FPR3,
 135   PT_FPR4, PT_FPR5, PT_FPR6, PT_FPR7,
 136   PT_FPR8, PT_FPR9, PT_FPR10, PT_FPR11,
 137   PT_FPR12, PT_FPR13, PT_FPR14, PT_FPR15,
 138 #endif
 139
 140   PT_ORIGGPR2,
 141 };
 142
 143 #ifdef __s390x__
 144 #define s390_num_regs_3264 68
 145
 146 static int s390_regmap_3264[] = {
 147   PT_PSWMASK, PT_PSWADDR,
 148
 149   PT_GPR0, PT_GPR0, PT_GPR1, PT_GPR1,
 150   PT_GPR2, PT_GPR2, PT_GPR3, PT_GPR3,
 151   PT_GPR4, PT_GPR4, PT_GPR5, PT_GPR5,
 152   PT_GPR6, PT_GPR6, PT_GPR7, PT_GPR7,
 153   PT_GPR8, PT_GPR8, PT_GPR9, PT_GPR9,
 154   PT_GPR10, PT_GPR10, PT_GPR11, PT_GPR11,
 155   PT_GPR12, PT_GPR12, PT_GPR13, PT_GPR13,
 156   PT_GPR14, PT_GPR14, PT_GPR15, PT_GPR15,
 157
 158   PT_ACR0, PT_ACR1, PT_ACR2, PT_ACR3,
 159   PT_ACR4, PT_ACR5, PT_ACR6, PT_ACR7,
 160   PT_ACR8, PT_ACR9, PT_ACR10, PT_ACR11,
 161   PT_ACR12, PT_ACR13, PT_ACR14, PT_ACR15,
 162
 163   PT_FPC,
 164
 165   PT_FPR0, PT_FPR1, PT_FPR2, PT_FPR3,
 166   PT_FPR4, PT_FPR5, PT_FPR6, PT_FPR7,
 167   PT_FPR8, PT_FPR9, PT_FPR10, PT_FPR11,
 168   PT_FPR12, PT_FPR13, PT_FPR14, PT_FPR15,
 169
 170   PT_ORIGGPR2,
 171 };
 172 #endif
 173
 174
 175 static int
 176 s390_cannot_fetch_register (int regno)
 177 {
 178   return 0;
 179 }
 180
 181 static int
 182 s390_cannot_store_register (int regno)
 183 {
 184   return 0;
 185 }
 186
 187 static void
 188 s390_collect_ptrace_register (struct regcache *regcache, int regno, char *buf)
 189 {
 190   int size = register_size (regcache->tdesc, regno);
 191   if (size < sizeof (long))
 192     {
 193       const struct regs_info *regs_info = (*the_low_target.regs_info) ();
 194       struct usrregs_info *usr = regs_info->usrregs;
 195       int regaddr = usr->regmap[regno];
 196
 197       memset (buf, 0, sizeof (long));
 198
 199       if ((regno ^ 1) < usr->num_regs
 200           && usr->regmap[regno ^ 1] == regaddr)
 201         {
 202           collect_register (regcache, regno & ~1, buf);
 203           collect_register (regcache, (regno & ~1) + 1,
 204                             buf + sizeof (long) - size);
 205         }
 206       else if (regaddr == PT_PSWMASK)
 207         {
 208           /* Convert 4-byte PSW mask to 8 bytes by clearing bit 12 and copying
 209              the basic addressing mode bit from the PSW address.  */
 210           char *addr = alloca (register_size (regcache->tdesc, regno ^ 1));
 211           collect_register (regcache, regno, buf);
 212           collect_register (regcache, regno ^ 1, addr);
 213           buf[1] &= ~0x8;
 214           buf[size] |= (addr[0] & 0x80);
 215         }
 216       else if (regaddr == PT_PSWADDR)
 217         {
 218           /* Convert 4-byte PSW address to 8 bytes by clearing the addressing
 219              mode bit (which gets copied to the PSW mask instead).  */
 220           collect_register (regcache, regno, buf + sizeof (long) - size);
 221           buf[sizeof (long) - size] &= ~0x80;
 222         }
 223       else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15)
 224                || regaddr == PT_ORIGGPR2)
 225         collect_register (regcache, regno, buf + sizeof (long) - size);
 226       else
 227         collect_register (regcache, regno, buf);
 228     }
 229   else
 230     collect_register (regcache, regno, buf);
 231 }
 232
 233 static void
 234 s390_supply_ptrace_register (struct regcache *regcache,
 235                              int regno, const char *buf)
 236 {
 237   int size = register_size (regcache->tdesc, regno);
 238   if (size < sizeof (long))
 239     {
 240       const struct regs_info *regs_info = (*the_low_target.regs_info) ();
 241       struct usrregs_info *usr = regs_info->usrregs;
 242       int regaddr = usr->regmap[regno];
 243
 244       if ((regno ^ 1) < usr->num_regs
 245           && usr->regmap[regno ^ 1] == regaddr)
 246         {
 247           supply_register (regcache, regno & ~1, buf);
 248           supply_register (regcache, (regno & ~1) + 1,
 249                            buf + sizeof (long) - size);
 250         }
 251       else if (regaddr == PT_PSWMASK)
 252         {
 253           /* Convert 8-byte PSW mask to 4 bytes by setting bit 12 and copying
 254              the basic addressing mode into the PSW address.  */
 255           char *mask = alloca (size);
 256           char *addr = alloca (register_size (regcache->tdesc, regno ^ 1));
 257           memcpy (mask, buf, size);
 258           mask[1] |= 0x8;
 259           supply_register (regcache, regno, mask);
 260
 261           collect_register (regcache, regno ^ 1, addr);
 262           addr[0] &= ~0x80;
 263           addr[0] |= (buf[size] & 0x80);
 264           supply_register (regcache, regno ^ 1, addr);
 265         }
 266       else if (regaddr == PT_PSWADDR)
 267         {
 268           /* Convert 8-byte PSW address to 4 bytes by truncating, but
 269              keeping the addressing mode bit (which was set from the mask).  */
 270           char *addr = alloca (size);
 271           char amode;
 272           collect_register (regcache, regno, addr);
 273           amode = addr[0] & 0x80;
 274           memcpy (addr, buf + sizeof (long) - size, size);
 275           addr[0] &= ~0x80;
 276           addr[0] |= amode;
 277           supply_register (regcache, regno, addr);
 278         }
 279       else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15)
 280                || regaddr == PT_ORIGGPR2)
 281         supply_register (regcache, regno, buf + sizeof (long) - size);
 282       else
 283         supply_register (regcache, regno, buf);
 284     }
 285   else
 286     supply_register (regcache, regno, buf);
 287 }
 288
 289 /* Provide only a fill function for the general register set.  ps_lgetregs
 290    will use this for NPTL support.  */
 291
 292 static void
 293 s390_fill_gregset (struct regcache *regcache, void *buf)
 294 {
 295   int i;
 296   const struct regs_info *regs_info = (*the_low_target.regs_info) ();
 297   struct usrregs_info *usr = regs_info->usrregs;
 298
 299   for (i = 0; i < usr->num_regs; i++)
 300     {
 301       if (usr->regmap[i] < PT_PSWMASK
 302           || usr->regmap[i] > PT_ACR15)
 303         continue;
 304
 305       s390_collect_ptrace_register (regcache, i,
 306                                     (char *) buf + usr->regmap[i]);
 307     }
 308 }
 309
 310 /* Fill and store functions for extended register sets.  */
 311
 312 static void
 313 s390_store_last_break (struct regcache *regcache, const void *buf)
 314 {
 315   const char *p;
 316
 317   p = (const char *) buf + 8 - register_size (regcache->tdesc, 0);
 318   supply_register_by_name (regcache, "last_break", p);
 319 }
 320
 321 static void
 322 s390_fill_system_call (struct regcache *regcache, void *buf)
 323 {
 324   collect_register_by_name (regcache, "system_call", buf);
 325 }
 326
 327 static void
 328 s390_store_system_call (struct regcache *regcache, const void *buf)
 329 {
 330   supply_register_by_name (regcache, "system_call", buf);
 331 }
 332
 333 static void
 334 s390_store_tdb (struct regcache *regcache, const void *buf)
 335 {
 336   int tdb0 = find_regno (regcache->tdesc, "tdb0");
 337   int tr0 = find_regno (regcache->tdesc, "tr0");
 338   int i;
 339
 340   for (i = 0; i < 4; i++)
 341     supply_register (regcache, tdb0 + i, (const char *) buf + 8 * i);
 342
 343   for (i = 0; i < 16; i++)
 344     supply_register (regcache, tr0 + i, (const char *) buf + 8 * (16 + i));
 345 }
 346
 347 static void
 348 s390_fill_vxrs_low (struct regcache *regcache, void *buf)
 349 {
 350   int v0 = find_regno (regcache->tdesc, "v0l");
 351   int i;
 352
 353   for (i = 0; i < 16; i++)
 354     collect_register (regcache, v0 + i, (char *) buf + 8 * i);
 355 }
 356
 357 static void
 358 s390_store_vxrs_low (struct regcache *regcache, const void *buf)
 359 {
 360   int v0 = find_regno (regcache->tdesc, "v0l");
 361   int i;
 362
 363   for (i = 0; i < 16; i++)
 364     supply_register (regcache, v0 + i, (const char *) buf + 8 * i);
 365 }
 366
 367 static void
 368 s390_fill_vxrs_high (struct regcache *regcache, void *buf)
 369 {
 370   int v16 = find_regno (regcache->tdesc, "v16");
 371   int i;
 372
 373   for (i = 0; i < 16; i++)
 374     collect_register (regcache, v16 + i, (char *) buf + 16 * i);
 375 }
 376
 377 static void
 378 s390_store_vxrs_high (struct regcache *regcache, const void *buf)
 379 {
 380   int v16 = find_regno (regcache->tdesc, "v16");
 381   int i;
 382
 383   for (i = 0; i < 16; i++)
 384     supply_register (regcache, v16 + i, (const char *) buf + 16 * i);
 385 }
 386
 387 static struct regset_info s390_regsets[] = {
 388   { 0, 0, 0, 0, GENERAL_REGS, s390_fill_gregset, NULL },
 389   /* Last break address is read-only; no fill function.  */
 390   { PTRACE_GETREGSET, -1, NT_S390_LAST_BREAK, 0, EXTENDED_REGS,
 391     NULL, s390_store_last_break },
 392   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_S390_SYSTEM_CALL, 0,
 393     EXTENDED_REGS, s390_fill_system_call, s390_store_system_call },
 394   /* TDB is read-only.  */
 395   { PTRACE_GETREGSET, -1, NT_S390_TDB, 0, EXTENDED_REGS,
 396     NULL, s390_store_tdb },
 397   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_S390_VXRS_LOW, 0,
 398     EXTENDED_REGS, s390_fill_vxrs_low, s390_store_vxrs_low },
 399   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_S390_VXRS_HIGH, 0,
 400     EXTENDED_REGS, s390_fill_vxrs_high, s390_store_vxrs_high },
 401   { 0, 0, 0, -1, -1, NULL, NULL }
 402 };
 403
 404
 405 static const unsigned char s390_breakpoint[] = { 0, 1 };
 406 #define s390_breakpoint_len 2
 407
 408 static CORE_ADDR
 409 s390_get_pc (struct regcache *regcache)
 410 {
 411   if (register_size (regcache->tdesc, 0) == 4)
 412     {
 413       unsigned int pswa;
 414       collect_register_by_name (regcache, "pswa", &pswa);
 415       return pswa & 0x7fffffff;
 416     }
 417   else
 418     {
 419       unsigned long pc;
 420       collect_register_by_name (regcache, "pswa", &pc);
 421       return pc;
 422     }
 423 }
 424
 425 static void
 426 s390_set_pc (struct regcache *regcache, CORE_ADDR newpc)
 427 {
 428   if (register_size (regcache->tdesc, 0) == 4)
 429     {
 430       unsigned int pswa;
 431       collect_register_by_name (regcache, "pswa", &pswa);
 432       pswa = (pswa & 0x80000000) | (newpc & 0x7fffffff);
 433       supply_register_by_name (regcache, "pswa", &pswa);
 434     }
 435   else
 436     {
 437       unsigned long pc = newpc;
 438       supply_register_by_name (regcache, "pswa", &pc);
 439     }
 440 }
 441
 442 #ifdef __s390x__
 443 static unsigned long
 444 s390_get_hwcap (const struct target_desc *tdesc)
 445 {
 446   int wordsize = register_size (tdesc, 0);
 447   unsigned char *data = alloca (2 * wordsize);
 448   int offset = 0;
 449
 450   while ((*the_target->read_auxv) (offset, data, 2 * wordsize) == 2 * wordsize)
 451     {
 452       if (wordsize == 4)
 453         {
 454           unsigned int *data_p = (unsigned int *)data;
 455           if (data_p[0] == AT_HWCAP)
 456             return data_p[1];
 457         }
 458       else
 459         {
 460           unsigned long *data_p = (unsigned long *)data;
 461           if (data_p[0] == AT_HWCAP)
 462             return data_p[1];
 463         }
 464
 465       offset += 2 * wordsize;
 466     }
 467
 468   return 0;
 469 }
 470 #endif
 471
 472 static int
 473 s390_check_regset (int pid, int regset, int regsize)
 474 {
 475   gdb_byte *buf = alloca (regsize);
 476   struct iovec iov;
 477
 478   iov.iov_base = buf;
 479   iov.iov_len = regsize;
 480
 481   if (ptrace (PTRACE_GETREGSET, pid, (long) regset, (long) &iov) >= 0
 482       || errno == ENODATA)
 483     return 1;
 484   return 0;
 485 }
 486
 487 #ifdef __s390x__
 488 /* For a 31-bit inferior, whether the kernel supports using the full
 489    64-bit GPRs.  */
 490 static int have_hwcap_s390_high_gprs = 0;
 491 #endif
 492
 493 static void
 494 s390_arch_setup (void)
 495 {
 496   const struct target_desc *tdesc;
 497   struct regset_info *regset;
 498
 499   /* Check whether the kernel supports extra register sets.  */
 500   int pid = pid_of (current_thread);
 501   int have_regset_last_break
 502     = s390_check_regset (pid, NT_S390_LAST_BREAK, 8);
 503   int have_regset_system_call
 504     = s390_check_regset (pid, NT_S390_SYSTEM_CALL, 4);
 505   int have_regset_tdb = s390_check_regset (pid, NT_S390_TDB, 256);
 506   int have_regset_vxrs = s390_check_regset (pid, NT_S390_VXRS_LOW, 128)
 507     && s390_check_regset (pid, NT_S390_VXRS_HIGH, 256);
 508
 509   /* Assume 31-bit inferior process.  */
 510   if (have_regset_system_call)
 511     tdesc = tdesc_s390_linux32v2;
 512   else if (have_regset_last_break)
 513     tdesc = tdesc_s390_linux32v1;
 514   else
 515     tdesc = tdesc_s390_linux32;
 516
 517   /* On a 64-bit host, check the low bit of the (31-bit) PSWM
 518      -- if this is one, we actually have a 64-bit inferior.  */
 519 #ifdef __s390x__
 520   {
 521     unsigned int pswm;
 522     struct regcache *regcache = new_register_cache (tdesc);
 523
 524     fetch_inferior_registers (regcache, find_regno (tdesc, "pswm"));
 525     collect_register_by_name (regcache, "pswm", &pswm);
 526     free_register_cache (regcache);
 527
 528     if (pswm & 1)
 529       {
 530         if (have_regset_tdb)
 531           have_regset_tdb =
 532             (s390_get_hwcap (tdesc_s390x_linux64v2) & HWCAP_S390_TE) != 0;
 533         if (have_regset_vxrs)
 534           have_regset_vxrs =
 535             (s390_get_hwcap (tdesc_s390x_linux64v2) & HWCAP_S390_VX) != 0;
 536
 537         if (have_regset_vxrs)
 538           tdesc = (have_regset_tdb ? tdesc_s390x_tevx_linux64 :
 539                    tdesc_s390x_vx_linux64);
 540         else if (have_regset_tdb)
 541           tdesc = tdesc_s390x_te_linux64;
 542         else if (have_regset_system_call)
 543           tdesc = tdesc_s390x_linux64v2;
 544         else if (have_regset_last_break)
 545           tdesc = tdesc_s390x_linux64v1;
 546         else
 547           tdesc = tdesc_s390x_linux64;
 548       }
 549
 550     /* For a 31-bit inferior, check whether the kernel supports
 551        using the full 64-bit GPRs.  */
 552     else if (s390_get_hwcap (tdesc) & HWCAP_S390_HIGH_GPRS)
 553       {
 554         have_hwcap_s390_high_gprs = 1;
 555         if (have_regset_tdb)
 556           have_regset_tdb = (s390_get_hwcap (tdesc) & HWCAP_S390_TE) != 0;
 557         if (have_regset_vxrs)
 558           have_regset_vxrs = (s390_get_hwcap (tdesc) & HWCAP_S390_VX) != 0;
 559
 560         if (have_regset_vxrs)
 561           tdesc = (have_regset_tdb ? tdesc_s390_tevx_linux64 :
 562                    tdesc_s390_vx_linux64);
 563         else if (have_regset_tdb)
 564           tdesc = tdesc_s390_te_linux64;
 565         else if (have_regset_system_call)
 566           tdesc = tdesc_s390_linux64v2;
 567         else if (have_regset_last_break)
 568           tdesc = tdesc_s390_linux64v1;
 569         else
 570           tdesc = tdesc_s390_linux64;
 571       }
 572   }
 573 #endif
 574
 575   /* Update target_regsets according to available register sets.  */
 576   for (regset = s390_regsets; regset->size >= 0; regset++)
 577     if (regset->get_request == PTRACE_GETREGSET)
 578       switch (regset->nt_type)
 579         {
 580         case NT_S390_LAST_BREAK:
 581           regset->size = have_regset_last_break? 8 : 0;
 582           break;
 583         case NT_S390_SYSTEM_CALL:
 584           regset->size = have_regset_system_call? 4 : 0;
 585           break;
 586         case NT_S390_TDB:
 587           regset->size = have_regset_tdb ? 256 : 0;
 588           break;
 589         case NT_S390_VXRS_LOW:
 590           regset->size = have_regset_vxrs ? 128 : 0;
 591           break;
 592         case NT_S390_VXRS_HIGH:
 593           regset->size = have_regset_vxrs ? 256 : 0;
 594           break;
 595         default:
 596           break;
 597         }
 598
 599   current_process ()->tdesc = tdesc;
 600 }
 601
 602
 603 static int
 604 s390_breakpoint_at (CORE_ADDR pc)
 605 {
 606   unsigned char c[s390_breakpoint_len];
 607   read_inferior_memory (pc, c, s390_breakpoint_len);
 608   return memcmp (c, s390_breakpoint, s390_breakpoint_len) == 0;
 609 }
 610
 611 static struct usrregs_info s390_usrregs_info =
 612   {
 613     s390_num_regs,
 614     s390_regmap,
 615   };
 616
 617 static struct regsets_info s390_regsets_info =
 618   {
 619     s390_regsets, /* regsets */
 620     0, /* num_regsets */
 621     NULL, /* disabled_regsets */
 622   };
 623
 624 static struct regs_info regs_info =
 625   {
 626     NULL, /* regset_bitmap */
 627     &s390_usrregs_info,
 628     &s390_regsets_info
 629   };
 630
 631 #ifdef __s390x__
 632 static struct usrregs_info s390_usrregs_info_3264 =
 633   {
 634     s390_num_regs_3264,
 635     s390_regmap_3264
 636   };
 637
 638 static struct regsets_info s390_regsets_info_3264 =
 639   {
 640     s390_regsets, /* regsets */
 641     0, /* num_regsets */
 642     NULL, /* disabled_regsets */
 643   };
 644
 645 static struct regs_info regs_info_3264 =
 646   {
 647     NULL, /* regset_bitmap */
 648     &s390_usrregs_info_3264,
 649     &s390_regsets_info_3264
 650   };
 651 #endif
 652
 653 static const struct regs_info *
 654 s390_regs_info (void)
 655 {
 656 #ifdef __s390x__
 657   if (have_hwcap_s390_high_gprs)
 658     {
 659       const struct target_desc *tdesc = current_process ()->tdesc;
 660
 661       if (register_size (tdesc, 0) == 4)
 662         return &regs_info_3264;
 663     }
 664 #endif
 665   return &regs_info;
 666 }
 667
 668 struct linux_target_ops the_low_target = {
 669   s390_arch_setup,
 670   s390_regs_info,
 671   s390_cannot_fetch_register,
 672   s390_cannot_store_register,
 673   NULL, /* fetch_register */
 674   s390_get_pc,
 675   s390_set_pc,
 676   s390_breakpoint,
 677   s390_breakpoint_len,
 678   NULL,
 679   s390_breakpoint_len,
 680   s390_breakpoint_at,
 681   NULL,  /* supports_z_point_type */
 682   NULL,
 683   NULL,
 684   NULL,
 685   NULL,
 686   s390_collect_ptrace_register,
 687   s390_supply_ptrace_register,
 688 };
 689
 690 void
 691 initialize_low_arch (void)
 692 {
 693   /* Initialize the Linux target descriptions.  */
 694
 695   init_registers_s390_linux32 ();
 696   init_registers_s390_linux32v1 ();
 697   init_registers_s390_linux32v2 ();
 698   init_registers_s390_linux64 ();
 699   init_registers_s390_linux64v1 ();
 700   init_registers_s390_linux64v2 ();
 701   init_registers_s390_te_linux64 ();
 702   init_registers_s390_vx_linux64 ();
 703   init_registers_s390_tevx_linux64 ();
 704   init_registers_s390x_linux64 ();
 705   init_registers_s390x_linux64v1 ();
 706   init_registers_s390x_linux64v2 ();
 707   init_registers_s390x_te_linux64 ();
 708   init_registers_s390x_vx_linux64 ();
 709   init_registers_s390x_tevx_linux64 ();
 710
 711   initialize_regsets_info (&s390_regsets_info);
 712 #ifdef __s390x__
 713   initialize_regsets_info (&s390_regsets_info_3264);
 714 #endif
 715 }