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