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