[deliverable/binutils-gdb.git] / gdb / gdbserver / linux-s390-low.c

/* GNU/Linux S/390 specific low level interface, for the remote server
   for GDB.
   Copyright (C) 2001-2014 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* This file is used for both 31-bit and 64-bit S/390 systems.  */

#include "server.h"
#include "linux-low.h"
#include "elf/common.h"

#include <asm/ptrace.h>
#include <sys/ptrace.h>
#include <sys/uio.h>
#include <elf.h>

#ifndef HWCAP_S390_HIGH_GPRS
#define HWCAP_S390_HIGH_GPRS 512
#endif

#ifndef HWCAP_S390_TE
#define HWCAP_S390_TE 1024
#endif

#ifndef PTRACE_GETREGSET
#define PTRACE_GETREGSET 0x4204
#endif

#ifndef PTRACE_SETREGSET
#define PTRACE_SETREGSET 0x4205
#endif

/* Defined in auto-generated file s390-linux32.c.  */
void init_registers_s390_linux32 (void);
extern const struct target_desc *tdesc_s390_linux32;

/* Defined in auto-generated file s390-linux32v1.c.  */
void init_registers_s390_linux32v1 (void);
extern const struct target_desc *tdesc_s390_linux32v1;

/* Defined in auto-generated file s390-linux32v2.c.  */
void init_registers_s390_linux32v2 (void);
extern const struct target_desc *tdesc_s390_linux32v2;

/* Defined in auto-generated file s390-linux64.c.  */
void init_registers_s390_linux64 (void);
extern const struct target_desc *tdesc_s390_linux64;

/* Defined in auto-generated file s390-linux64v1.c.  */
void init_registers_s390_linux64v1 (void);
extern const struct target_desc *tdesc_s390_linux64v1;

/* Defined in auto-generated file s390-linux64v2.c.  */
void init_registers_s390_linux64v2 (void);
extern const struct target_desc *tdesc_s390_linux64v2;

/* Defined in auto-generated file s390-te-linux64.c.  */
void init_registers_s390_te_linux64 (void);
extern const struct target_desc *tdesc_s390_te_linux64;

/* Defined in auto-generated file s390x-linux64.c.  */
void init_registers_s390x_linux64 (void);
extern const struct target_desc *tdesc_s390x_linux64;

/* Defined in auto-generated file s390x-linux64v1.c.  */
void init_registers_s390x_linux64v1 (void);
extern const struct target_desc *tdesc_s390x_linux64v1;

/* Defined in auto-generated file s390x-linux64v2.c.  */
void init_registers_s390x_linux64v2 (void);
extern const struct target_desc *tdesc_s390x_linux64v2;

/* Defined in auto-generated file s390x-te-linux64.c.  */
void init_registers_s390x_te_linux64 (void);
extern const struct target_desc *tdesc_s390x_te_linux64;

#define s390_num_regs 52

static int s390_regmap[] = {
  PT_PSWMASK, PT_PSWADDR,

  PT_GPR0, PT_GPR1, PT_GPR2, PT_GPR3,
  PT_GPR4, PT_GPR5, PT_GPR6, PT_GPR7,
  PT_GPR8, PT_GPR9, PT_GPR10, PT_GPR11,
  PT_GPR12, PT_GPR13, PT_GPR14, PT_GPR15,

  PT_ACR0, PT_ACR1, PT_ACR2, PT_ACR3,
  PT_ACR4, PT_ACR5, PT_ACR6, PT_ACR7,
  PT_ACR8, PT_ACR9, PT_ACR10, PT_ACR11,
  PT_ACR12, PT_ACR13, PT_ACR14, PT_ACR15,

  PT_FPC,

#ifndef __s390x__
  PT_FPR0_HI, PT_FPR1_HI, PT_FPR2_HI, PT_FPR3_HI,
  PT_FPR4_HI, PT_FPR5_HI, PT_FPR6_HI, PT_FPR7_HI,
  PT_FPR8_HI, PT_FPR9_HI, PT_FPR10_HI, PT_FPR11_HI,
  PT_FPR12_HI, PT_FPR13_HI, PT_FPR14_HI, PT_FPR15_HI,
#else
  PT_FPR0, PT_FPR1, PT_FPR2, PT_FPR3,
  PT_FPR4, PT_FPR5, PT_FPR6, PT_FPR7,
  PT_FPR8, PT_FPR9, PT_FPR10, PT_FPR11,
  PT_FPR12, PT_FPR13, PT_FPR14, PT_FPR15,
#endif

  PT_ORIGGPR2,
};

#ifdef __s390x__
#define s390_num_regs_3264 68

static int s390_regmap_3264[] = {
  PT_PSWMASK, PT_PSWADDR,

  PT_GPR0, PT_GPR0, PT_GPR1, PT_GPR1,
  PT_GPR2, PT_GPR2, PT_GPR3, PT_GPR3,
  PT_GPR4, PT_GPR4, PT_GPR5, PT_GPR5,
  PT_GPR6, PT_GPR6, PT_GPR7, PT_GPR7,
  PT_GPR8, PT_GPR8, PT_GPR9, PT_GPR9,
  PT_GPR10, PT_GPR10, PT_GPR11, PT_GPR11,
  PT_GPR12, PT_GPR12, PT_GPR13, PT_GPR13,
  PT_GPR14, PT_GPR14, PT_GPR15, PT_GPR15,

  PT_ACR0, PT_ACR1, PT_ACR2, PT_ACR3,
  PT_ACR4, PT_ACR5, PT_ACR6, PT_ACR7,
  PT_ACR8, PT_ACR9, PT_ACR10, PT_ACR11,
  PT_ACR12, PT_ACR13, PT_ACR14, PT_ACR15,

  PT_FPC,

  PT_FPR0, PT_FPR1, PT_FPR2, PT_FPR3,
  PT_FPR4, PT_FPR5, PT_FPR6, PT_FPR7,
  PT_FPR8, PT_FPR9, PT_FPR10, PT_FPR11,
  PT_FPR12, PT_FPR13, PT_FPR14, PT_FPR15,

  PT_ORIGGPR2,
};
#endif


static int
s390_cannot_fetch_register (int regno)
{
  return 0;
}

static int
s390_cannot_store_register (int regno)
{
  return 0;
}

static void
s390_collect_ptrace_register (struct regcache *regcache, int regno, char *buf)
{
  int size = register_size (regcache->tdesc, regno);
  if (size < sizeof (long))
    {
      const struct regs_info *regs_info = (*the_low_target.regs_info) ();
      struct usrregs_info *usr = regs_info->usrregs;
      int regaddr = usr->regmap[regno];

      memset (buf, 0, sizeof (long));

      if ((regno ^ 1) < usr->num_regs
	  && usr->regmap[regno ^ 1] == regaddr)
	{
	  collect_register (regcache, regno & ~1, buf);
	  collect_register (regcache, (regno & ~1) + 1,
			    buf + sizeof (long) - size);
	}
      else if (regaddr == PT_PSWMASK)
	{
	  /* Convert 4-byte PSW mask to 8 bytes by clearing bit 12 and copying
	     the basic addressing mode bit from the PSW address.  */
	  char *addr = alloca (register_size (regcache->tdesc, regno ^ 1));
	  collect_register (regcache, regno, buf);
	  collect_register (regcache, regno ^ 1, addr);
	  buf[1] &= ~0x8;
	  buf[size] |= (addr[0] & 0x80);
	}
      else if (regaddr == PT_PSWADDR)
	{
	  /* Convert 4-byte PSW address to 8 bytes by clearing the addressing
	     mode bit (which gets copied to the PSW mask instead).  */
	  collect_register (regcache, regno, buf + sizeof (long) - size);
	  buf[sizeof (long) - size] &= ~0x80;
	}
      else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15)
	       || regaddr == PT_ORIGGPR2)
	collect_register (regcache, regno, buf + sizeof (long) - size);
      else
	collect_register (regcache, regno, buf);
    }
  else
    collect_register (regcache, regno, buf);
}

static void
s390_supply_ptrace_register (struct regcache *regcache,
			     int regno, const char *buf)
{
  int size = register_size (regcache->tdesc, regno);
  if (size < sizeof (long))
    {
      const struct regs_info *regs_info = (*the_low_target.regs_info) ();
      struct usrregs_info *usr = regs_info->usrregs;
      int regaddr = usr->regmap[regno];

      if ((regno ^ 1) < usr->num_regs
	  && usr->regmap[regno ^ 1] == regaddr)
	{
	  supply_register (regcache, regno & ~1, buf);
	  supply_register (regcache, (regno & ~1) + 1,
			   buf + sizeof (long) - size);
	}
      else if (regaddr == PT_PSWMASK)
	{
	  /* Convert 8-byte PSW mask to 4 bytes by setting bit 12 and copying
	     the basic addressing mode into the PSW address.  */
	  char *mask = alloca (size);
	  char *addr = alloca (register_size (regcache->tdesc, regno ^ 1));
	  memcpy (mask, buf, size);
	  mask[1] |= 0x8;
	  supply_register (regcache, regno, mask);

	  collect_register (regcache, regno ^ 1, addr);
	  addr[0] &= ~0x80;
	  addr[0] |= (buf[size] & 0x80);
	  supply_register (regcache, regno ^ 1, addr);
	}
      else if (regaddr == PT_PSWADDR)
	{
	  /* Convert 8-byte PSW address to 4 bytes by truncating, but
	     keeping the addressing mode bit (which was set from the mask).  */
	  char *addr = alloca (size);
	  char amode;
	  collect_register (regcache, regno, addr);
	  amode = addr[0] & 0x80;
	  memcpy (addr, buf + sizeof (long) - size, size);
	  addr[0] &= ~0x80;
	  addr[0] |= amode;
	  supply_register (regcache, regno, addr);
	}
      else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15)
	       || regaddr == PT_ORIGGPR2)
	supply_register (regcache, regno, buf + sizeof (long) - size);
      else
	supply_register (regcache, regno, buf);
    }
  else
    supply_register (regcache, regno, buf);
}

/* Provide only a fill function for the general register set.  ps_lgetregs
   will use this for NPTL support.  */

static void
s390_fill_gregset (struct regcache *regcache, void *buf)
{
  int i;
  const struct regs_info *regs_info = (*the_low_target.regs_info) ();
  struct usrregs_info *usr = regs_info->usrregs;

  for (i = 0; i < usr->num_regs; i++)
    {
      if (usr->regmap[i] < PT_PSWMASK
	  || usr->regmap[i] > PT_ACR15)
	continue;

      s390_collect_ptrace_register (regcache, i,
				    (char *) buf + usr->regmap[i]);
    }
}

/* Fill and store functions for extended register sets.  */

static void
s390_fill_last_break (struct regcache *regcache, void *buf)
{
  /* Last break address is read-only.  */
}

static void
s390_store_last_break (struct regcache *regcache, const void *buf)
{
  const char *p;

  p = (const char *) buf + 8 - register_size (regcache->tdesc, 0);
  supply_register_by_name (regcache, "last_break", p);
}

static void
s390_fill_system_call (struct regcache *regcache, void *buf)
{
  collect_register_by_name (regcache, "system_call", buf);
}

static void
s390_store_system_call (struct regcache *regcache, const void *buf)
{
  supply_register_by_name (regcache, "system_call", buf);
}

static struct regset_info s390_regsets[] = {
  { 0, 0, 0, 0, GENERAL_REGS, s390_fill_gregset, NULL },
  /* Last break address is read-only; do not attempt PTRACE_SETREGSET.  */
  { PTRACE_GETREGSET, PTRACE_GETREGSET, NT_S390_LAST_BREAK, 0,
    EXTENDED_REGS, s390_fill_last_break, s390_store_last_break },
  { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_S390_SYSTEM_CALL, 0,
    EXTENDED_REGS, s390_fill_system_call, s390_store_system_call },
  { 0, 0, 0, -1, -1, NULL, NULL }
};


static const unsigned char s390_breakpoint[] = { 0, 1 };
#define s390_breakpoint_len 2

static CORE_ADDR
s390_get_pc (struct regcache *regcache)
{
  if (register_size (regcache->tdesc, 0) == 4)
    {
      unsigned int pswa;
      collect_register_by_name (regcache, "pswa", &pswa);
      return pswa & 0x7fffffff;
    }
  else
    {
      unsigned long pc;
      collect_register_by_name (regcache, "pswa", &pc);
      return pc;
    }
}

static void
s390_set_pc (struct regcache *regcache, CORE_ADDR newpc)
{
  if (register_size (regcache->tdesc, 0) == 4)
    {
      unsigned int pswa;
      collect_register_by_name (regcache, "pswa", &pswa);
      pswa = (pswa & 0x80000000) | (newpc & 0x7fffffff);
      supply_register_by_name (regcache, "pswa", &pswa);
    }
  else
    {
      unsigned long pc = newpc;
      supply_register_by_name (regcache, "pswa", &pc);
    }
}

#ifdef __s390x__
static unsigned long
s390_get_hwcap (const struct target_desc *tdesc)
{
  int wordsize = register_size (tdesc, 0);
  unsigned char *data = alloca (2 * wordsize);
  int offset = 0;

  while ((*the_target->read_auxv) (offset, data, 2 * wordsize) == 2 * wordsize)
    {
      if (wordsize == 4)
        {
          unsigned int *data_p = (unsigned int *)data;
          if (data_p[0] == AT_HWCAP)
	    return data_p[1];
        }
      else
        {
          unsigned long *data_p = (unsigned long *)data;
          if (data_p[0] == AT_HWCAP)
	    return data_p[1];
        }

      offset += 2 * wordsize;
    }

  return 0;
}
#endif

static int
s390_check_regset (int pid, int regset, int regsize)
{
  gdb_byte *buf = alloca (regsize);
  struct iovec iov;

  iov.iov_base = buf;
  iov.iov_len = regsize;

  if (ptrace (PTRACE_GETREGSET, pid, (long) regset, (long) &iov) >= 0
      || errno == ENODATA)
    return 1;
  return 0;
}

#ifdef __s390x__
/* For a 31-bit inferior, whether the kernel supports using the full
   64-bit GPRs.  */
static int have_hwcap_s390_high_gprs = 0;
#endif

static void
s390_arch_setup (void)
{
  const struct target_desc *tdesc;
  struct regset_info *regset;

  /* Check whether the kernel supports extra register sets.  */
  int pid = pid_of (current_thread);
  int have_regset_last_break
    = s390_check_regset (pid, NT_S390_LAST_BREAK, 8);
  int have_regset_system_call
    = s390_check_regset (pid, NT_S390_SYSTEM_CALL, 4);
  int have_regset_tdb = s390_check_regset (pid, NT_S390_TDB, 256);

  /* Assume 31-bit inferior process.  */
  if (have_regset_system_call)
    tdesc = tdesc_s390_linux32v2;
  else if (have_regset_last_break)
    tdesc = tdesc_s390_linux32v1;
  else
    tdesc = tdesc_s390_linux32;

  /* On a 64-bit host, check the low bit of the (31-bit) PSWM
     -- if this is one, we actually have a 64-bit inferior.  */
#ifdef __s390x__
  {
    unsigned int pswm;
    struct regcache *regcache = new_register_cache (tdesc);

    fetch_inferior_registers (regcache, find_regno (tdesc, "pswm"));
    collect_register_by_name (regcache, "pswm", &pswm);
    free_register_cache (regcache);

    if (pswm & 1)
      {
	if (have_regset_tdb)
	  have_regset_tdb =
	    (s390_get_hwcap (tdesc_s390x_linux64v2) & HWCAP_S390_TE) != 0;

	if (have_regset_tdb)
	  tdesc = tdesc_s390x_te_linux64;
	else if (have_regset_system_call)
	  tdesc = tdesc_s390x_linux64v2;
	else if (have_regset_last_break)
	  tdesc = tdesc_s390x_linux64v1;
	else
	  tdesc = tdesc_s390x_linux64;
      }

    /* For a 31-bit inferior, check whether the kernel supports
       using the full 64-bit GPRs.  */
    else if (s390_get_hwcap (tdesc) & HWCAP_S390_HIGH_GPRS)
      {
	have_hwcap_s390_high_gprs = 1;
	if (have_regset_tdb)
	  have_regset_tdb = (s390_get_hwcap (tdesc) & HWCAP_S390_TE) != 0;

	if (have_regset_tdb)
	  tdesc = tdesc_s390_te_linux64;
	else if (have_regset_system_call)
	  tdesc = tdesc_s390_linux64v2;
	else if (have_regset_last_break)
	  tdesc = tdesc_s390_linux64v1;
	else
	  tdesc = tdesc_s390_linux64;
      }
  }
#endif

  /* Update target_regsets according to available register sets.  */
  for (regset = s390_regsets; regset->fill_function != NULL; regset++)
    if (regset->get_request == PTRACE_GETREGSET)
      switch (regset->nt_type)
	{
	case NT_S390_LAST_BREAK:
	  regset->size = have_regset_last_break? 8 : 0;
	  break;
	case NT_S390_SYSTEM_CALL:
	  regset->size = have_regset_system_call? 4 : 0;
	  break;
	case NT_S390_TDB:
	  regset->size = have_regset_tdb ? 256 : 0;
	default:
	  break;
	}

  current_process ()->tdesc = tdesc;
}


static int
s390_breakpoint_at (CORE_ADDR pc)
{
  unsigned char c[s390_breakpoint_len];
  read_inferior_memory (pc, c, s390_breakpoint_len);
  return memcmp (c, s390_breakpoint, s390_breakpoint_len) == 0;
}

static struct usrregs_info s390_usrregs_info =
  {
    s390_num_regs,
    s390_regmap,
  };

static struct regsets_info s390_regsets_info =
  {
    s390_regsets, /* regsets */
    0, /* num_regsets */
    NULL, /* disabled_regsets */
  };

static struct regs_info regs_info =
  {
    NULL, /* regset_bitmap */
    &s390_usrregs_info,
    &s390_regsets_info
  };

#ifdef __s390x__
static struct usrregs_info s390_usrregs_info_3264 =
  {
    s390_num_regs_3264,
    s390_regmap_3264
  };

static struct regsets_info s390_regsets_info_3264 =
  {
    s390_regsets, /* regsets */
    0, /* num_regsets */
    NULL, /* disabled_regsets */
  };

static struct regs_info regs_info_3264 =
  {
    NULL, /* regset_bitmap */
    &s390_usrregs_info_3264,
    &s390_regsets_info_3264
  };
#endif

static const struct regs_info *
s390_regs_info (void)
{
#ifdef __s390x__
  if (have_hwcap_s390_high_gprs)
    {
      const struct target_desc *tdesc = current_process ()->tdesc;

      if (register_size (tdesc, 0) == 4)
	return &regs_info_3264;
    }
#endif
  return &regs_info;
}

struct linux_target_ops the_low_target = {
  s390_arch_setup,
  s390_regs_info,
  s390_cannot_fetch_register,
  s390_cannot_store_register,
  NULL, /* fetch_register */
  s390_get_pc,
  s390_set_pc,
  s390_breakpoint,
  s390_breakpoint_len,
  NULL,
  s390_breakpoint_len,
  s390_breakpoint_at,
  NULL,  /* supports_z_point_type */
  NULL,
  NULL,
  NULL,
  NULL,
  s390_collect_ptrace_register,
  s390_supply_ptrace_register,
};

void
initialize_low_arch (void)
{
  /* Initialize the Linux target descriptions.  */

  init_registers_s390_linux32 ();
  init_registers_s390_linux32v1 ();
  init_registers_s390_linux32v2 ();
  init_registers_s390_linux64 ();
  init_registers_s390_linux64v1 ();
  init_registers_s390_linux64v2 ();
  init_registers_s390_te_linux64 ();
  init_registers_s390x_linux64 ();
  init_registers_s390x_linux64v1 ();
  init_registers_s390x_linux64v2 ();
  init_registers_s390x_te_linux64 ();

  initialize_regsets_info (&s390_regsets_info);
#ifdef __s390x__
  initialize_regsets_info (&s390_regsets_info_3264);
#endif
}
Commit	Line	Data
265f716b DJ	1	/* GNU/Linux S/390 specific low level interface, for the remote server
265f716b DJ	2	for GDB.
ecd75fc8	3	Copyright (C) 2001-2014 Free Software Foundation, Inc.
265f716b DJ	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
265f716b DJ	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
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
265f716b DJ	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"
c642a434	24	#include "elf/common.h"
265f716b DJ	25
265f716b DJ	26	#include <asm/ptrace.h>
c642a434 UW	27	#include <sys/ptrace.h>
c642a434 UW	28	#include <sys/uio.h>
7803799a	29	#include <elf.h>
265f716b	30
7803799a UW	31	#ifndef HWCAP_S390_HIGH_GPRS
	32	#define HWCAP_S390_HIGH_GPRS 512
	33	#endif
d05b4ac3	34
6682d959 AA	35	#ifndef HWCAP_S390_TE
	36	#define HWCAP_S390_TE 1024
	37	#endif
	38
c642a434 UW	39	#ifndef PTRACE_GETREGSET
	40	#define PTRACE_GETREGSET 0x4204
	41	#endif
	42
	43	#ifndef PTRACE_SETREGSET
	44	#define PTRACE_SETREGSET 0x4205
	45	#endif
	46
7803799a UW	47	/* Defined in auto-generated file s390-linux32.c. */
7803799a UW	48	void init_registers_s390_linux32 (void);
3aee8918 PA	49	extern const struct target_desc *tdesc_s390_linux32;
3aee8918 PA	50
c642a434 UW	51	/* Defined in auto-generated file s390-linux32v1.c. */
c642a434 UW	52	void init_registers_s390_linux32v1 (void);
3aee8918 PA	53	extern const struct target_desc *tdesc_s390_linux32v1;
3aee8918 PA	54
c642a434 UW	55	/* Defined in auto-generated file s390-linux32v2.c. */
c642a434 UW	56	void init_registers_s390_linux32v2 (void);
3aee8918 PA	57	extern const struct target_desc *tdesc_s390_linux32v2;
3aee8918 PA	58
7803799a UW	59	/* Defined in auto-generated file s390-linux64.c. */
7803799a UW	60	void init_registers_s390_linux64 (void);
3aee8918 PA	61	extern const struct target_desc *tdesc_s390_linux64;
3aee8918 PA	62
c642a434 UW	63	/* Defined in auto-generated file s390-linux64v1.c. */
c642a434 UW	64	void init_registers_s390_linux64v1 (void);
3aee8918 PA	65	extern const struct target_desc *tdesc_s390_linux64v1;
3aee8918 PA	66
c642a434 UW	67	/* Defined in auto-generated file s390-linux64v2.c. */
c642a434 UW	68	void init_registers_s390_linux64v2 (void);
3aee8918 PA	69	extern const struct target_desc *tdesc_s390_linux64v2;
3aee8918 PA	70
4ac33720 UW	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
7803799a UW	75	/* Defined in auto-generated file s390x-linux64.c. */
7803799a UW	76	void init_registers_s390x_linux64 (void);
3aee8918 PA	77	extern const struct target_desc *tdesc_s390x_linux64;
3aee8918 PA	78
c642a434 UW	79	/* Defined in auto-generated file s390x-linux64v1.c. */
c642a434 UW	80	void init_registers_s390x_linux64v1 (void);
3aee8918 PA	81	extern const struct target_desc *tdesc_s390x_linux64v1;
3aee8918 PA	82
c642a434 UW	83	/* Defined in auto-generated file s390x-linux64v2.c. */
c642a434 UW	84	void init_registers_s390x_linux64v2 (void);
3aee8918	85	extern const struct target_desc *tdesc_s390x_linux64v2;
d05b4ac3	86
4ac33720 UW	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
c642a434	91	#define s390_num_regs 52
265f716b	92
2ec06d2e	93	static int s390_regmap[] = {
265f716b DJ	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
265f716b DJ	106	PT_FPC,
265f716b DJ	107
d0f54f9d	108	#ifndef __s390x__
265f716b DJ	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
c642a434 UW	119
c642a434 UW	120	PT_ORIGGPR2,
265f716b DJ	121	};
265f716b DJ	122
7803799a	123	#ifdef __s390x__
c642a434	124	#define s390_num_regs_3264 68
7803799a UW	125
	126	static int s390_regmap_3264[] = {
	127	PT_PSWMASK, PT_PSWADDR,
	128
493e2a69 MS	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,
7803799a UW	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,
c642a434 UW	149
c642a434 UW	150	PT_ORIGGPR2,
7803799a UW	151	};
	152	#endif
	153
	154
2ec06d2e DJ	155	static int
2ec06d2e DJ	156	s390_cannot_fetch_register (int regno)
265f716b	157	{
265f716b DJ	158	return 0;
	159	}
	160
2ec06d2e DJ	161	static int
2ec06d2e DJ	162	s390_cannot_store_register (int regno)
265f716b	163	{
265f716b DJ	164	return 0;
265f716b DJ	165	}
2ec06d2e	166
ee1a7ae4	167	static void
442ea881	168	s390_collect_ptrace_register (struct regcache regcache, int regno, char buf)
ee1a7ae4	169	{
3aee8918	170	int size = register_size (regcache->tdesc, regno);
ee1a7ae4 UW	171	if (size < sizeof (long))
ee1a7ae4 UW	172	{
3aee8918 PA	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];
7803799a	176
ee1a7ae4 UW	177	memset (buf, 0, sizeof (long));
ee1a7ae4 UW	178
3aee8918 PA	179	if ((regno ^ 1) < usr->num_regs
3aee8918 PA	180	&& usr->regmap[regno ^ 1] == regaddr)
7803799a	181	{
18f5de3b JK	182	collect_register (regcache, regno & ~1, buf);
	183	collect_register (regcache, (regno & ~1) + 1,
	184	buf + sizeof (long) - size);
7803799a	185	}
d6db1fab UW	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. */
3aee8918	190	char *addr = alloca (register_size (regcache->tdesc, regno ^ 1));
d6db1fab UW	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	}
c642a434 UW	203	else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15)
c642a434 UW	204	\|\| regaddr == PT_ORIGGPR2)
442ea881	205	collect_register (regcache, regno, buf + sizeof (long) - size);
ee1a7ae4	206	else
442ea881	207	collect_register (regcache, regno, buf);
ee1a7ae4 UW	208	}
ee1a7ae4 UW	209	else
18f5de3b	210	collect_register (regcache, regno, buf);
ee1a7ae4 UW	211	}
	212
	213	static void
493e2a69 MS	214	s390_supply_ptrace_register (struct regcache *regcache,
493e2a69 MS	215	int regno, const char *buf)
ee1a7ae4	216	{
3aee8918	217	int size = register_size (regcache->tdesc, regno);
ee1a7ae4 UW	218	if (size < sizeof (long))
ee1a7ae4 UW	219	{
3aee8918 PA	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];
7803799a	223
3aee8918 PA	224	if ((regno ^ 1) < usr->num_regs
3aee8918 PA	225	&& usr->regmap[regno ^ 1] == regaddr)
7803799a	226	{
18f5de3b JK	227	supply_register (regcache, regno & ~1, buf);
	228	supply_register (regcache, (regno & ~1) + 1,
	229	buf + sizeof (long) - size);
7803799a	230	}
d6db1fab UW	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);
3aee8918	236	char *addr = alloca (register_size (regcache->tdesc, regno ^ 1));
d6db1fab UW	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	}
c642a434 UW	259	else if ((regaddr >= PT_GPR0 && regaddr <= PT_GPR15)
c642a434 UW	260	\|\| regaddr == PT_ORIGGPR2)
442ea881	261	supply_register (regcache, regno, buf + sizeof (long) - size);
ee1a7ae4	262	else
442ea881	263	supply_register (regcache, regno, buf);
ee1a7ae4 UW	264	}
ee1a7ae4 UW	265	else
442ea881	266	supply_register (regcache, regno, buf);
ee1a7ae4 UW	267	}
ee1a7ae4 UW	268
b7149293 UW	269	/* Provide only a fill function for the general register set. ps_lgetregs
	270	will use this for NPTL support. */
	271
3aee8918 PA	272	static void
3aee8918 PA	273	s390_fill_gregset (struct regcache regcache, void buf)
b7149293 UW	274	{
b7149293 UW	275	int i;
3aee8918 PA	276	const struct regs_info regs_info = (the_low_target.regs_info) ();
3aee8918 PA	277	struct usrregs_info *usr = regs_info->usrregs;
b7149293	278
3aee8918	279	for (i = 0; i < usr->num_regs; i++)
7803799a	280	{
3aee8918 PA	281	if (usr->regmap[i] < PT_PSWMASK
3aee8918 PA	282	\|\| usr->regmap[i] > PT_ACR15)
7803799a UW	283	continue;
7803799a UW	284
3aee8918 PA	285	s390_collect_ptrace_register (regcache, i,
3aee8918 PA	286	(char *) buf + usr->regmap[i]);
7803799a	287	}
b7149293 UW	288	}
b7149293 UW	289
c642a434 UW	290	/* Fill and store functions for extended register sets. */
	291
	292	static void
	293	s390_fill_last_break (struct regcache regcache, void buf)
	294	{
	295	/* Last break address is read-only. */
	296	}
	297
	298	static void
	299	s390_store_last_break (struct regcache regcache, const void buf)
	300	{
3aee8918 PA	301	const char *p;
	302
	303	p = (const char *) buf + 8 - register_size (regcache->tdesc, 0);
	304	supply_register_by_name (regcache, "last_break", p);
c642a434 UW	305	}
	306
	307	static void
	308	s390_fill_system_call (struct regcache regcache, void buf)
	309	{
	310	collect_register_by_name (regcache, "system_call", buf);
	311	}
	312
	313	static void
	314	s390_store_system_call (struct regcache regcache, const void buf)
	315	{
	316	supply_register_by_name (regcache, "system_call", buf);
	317	}
	318
3aee8918	319	static struct regset_info s390_regsets[] = {
1570b33e	320	{ 0, 0, 0, 0, GENERAL_REGS, s390_fill_gregset, NULL },
c642a434 UW	321	/* Last break address is read-only; do not attempt PTRACE_SETREGSET. */
	322	{ PTRACE_GETREGSET, PTRACE_GETREGSET, NT_S390_LAST_BREAK, 0,
	323	EXTENDED_REGS, s390_fill_last_break, s390_store_last_break },
	324	{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_S390_SYSTEM_CALL, 0,
	325	EXTENDED_REGS, s390_fill_system_call, s390_store_system_call },
1570b33e	326	{ 0, 0, 0, -1, -1, NULL, NULL }
b7149293 UW	327	};
b7149293 UW	328
b0ded00b	329
f450004a	330	static const unsigned char s390_breakpoint[] = { 0, 1 };
b0ded00b UW	331	#define s390_breakpoint_len 2
	332
	333	static CORE_ADDR
442ea881	334	s390_get_pc (struct regcache *regcache)
b0ded00b	335	{
3aee8918	336	if (register_size (regcache->tdesc, 0) == 4)
d61ddec4	337	{
d6db1fab UW	338	unsigned int pswa;
	339	collect_register_by_name (regcache, "pswa", &pswa);
	340	return pswa & 0x7fffffff;
d61ddec4 UW	341	}
	342	else
	343	{
	344	unsigned long pc;
442ea881	345	collect_register_by_name (regcache, "pswa", &pc);
d61ddec4 UW	346	return pc;
d61ddec4 UW	347	}
b0ded00b UW	348	}
	349
	350	static void
442ea881	351	s390_set_pc (struct regcache *regcache, CORE_ADDR newpc)
b0ded00b	352	{
3aee8918	353	if (register_size (regcache->tdesc, 0) == 4)
d61ddec4	354	{
d6db1fab UW	355	unsigned int pswa;
	356	collect_register_by_name (regcache, "pswa", &pswa);
	357	pswa = (pswa & 0x80000000) \| (newpc & 0x7fffffff);
	358	supply_register_by_name (regcache, "pswa", &pswa);
d61ddec4 UW	359	}
	360	else
	361	{
	362	unsigned long pc = newpc;
442ea881	363	supply_register_by_name (regcache, "pswa", &pc);
d61ddec4	364	}
b0ded00b UW	365	}
b0ded00b UW	366
7803799a UW	367	#ifdef __s390x__
7803799a UW	368	static unsigned long
3aee8918	369	s390_get_hwcap (const struct target_desc *tdesc)
7803799a	370	{
3aee8918	371	int wordsize = register_size (tdesc, 0);
7803799a UW	372	unsigned char data = alloca (2 wordsize);
	373	int offset = 0;
	374
	375	while ((the_target->read_auxv) (offset, data, 2 wordsize) == 2 * wordsize)
	376	{
	377	if (wordsize == 4)
	378	{
	379	unsigned int data_p = (unsigned int )data;
	380	if (data_p[0] == AT_HWCAP)
	381	return data_p[1];
	382	}
	383	else
	384	{
	385	unsigned long data_p = (unsigned long )data;
	386	if (data_p[0] == AT_HWCAP)
	387	return data_p[1];
	388	}
	389
	390	offset += 2 * wordsize;
	391	}
	392
	393	return 0;
	394	}
	395	#endif
d61ddec4	396
c642a434 UW	397	static int
	398	s390_check_regset (int pid, int regset, int regsize)
	399	{
	400	gdb_byte *buf = alloca (regsize);
	401	struct iovec iov;
	402
	403	iov.iov_base = buf;
	404	iov.iov_len = regsize;
	405
4ac33720 UW	406	if (ptrace (PTRACE_GETREGSET, pid, (long) regset, (long) &iov) >= 0
4ac33720 UW	407	\|\| errno == ENODATA)
c642a434	408	return 1;
4ac33720	409	return 0;
c642a434 UW	410	}
c642a434 UW	411
3aee8918 PA	412	#ifdef __s390x__
	413	/* For a 31-bit inferior, whether the kernel supports using the full
	414	64-bit GPRs. */
	415	static int have_hwcap_s390_high_gprs = 0;
	416	#endif
	417
d61ddec4 UW	418	static void
	419	s390_arch_setup (void)
	420	{
3aee8918	421	const struct target_desc *tdesc;
c642a434 UW	422	struct regset_info *regset;
	423
	424	/* Check whether the kernel supports extra register sets. */
0bfdf32f	425	int pid = pid_of (current_thread);
c642a434 UW	426	int have_regset_last_break
	427	= s390_check_regset (pid, NT_S390_LAST_BREAK, 8);
	428	int have_regset_system_call
	429	= s390_check_regset (pid, NT_S390_SYSTEM_CALL, 4);
4ac33720	430	int have_regset_tdb = s390_check_regset (pid, NT_S390_TDB, 256);
c642a434	431
d61ddec4	432	/* Assume 31-bit inferior process. */
c642a434	433	if (have_regset_system_call)
3aee8918	434	tdesc = tdesc_s390_linux32v2;
c642a434	435	else if (have_regset_last_break)
3aee8918	436	tdesc = tdesc_s390_linux32v1;
c642a434	437	else
3aee8918	438	tdesc = tdesc_s390_linux32;
d61ddec4 UW	439
	440	/* On a 64-bit host, check the low bit of the (31-bit) PSWM
	441	-- if this is one, we actually have a 64-bit inferior. */
	442	#ifdef __s390x__
	443	{
	444	unsigned int pswm;
3aee8918	445	struct regcache *regcache = new_register_cache (tdesc);
6682d959	446
3aee8918	447	fetch_inferior_registers (regcache, find_regno (tdesc, "pswm"));
442ea881	448	collect_register_by_name (regcache, "pswm", &pswm);
92b72907 UW	449	free_register_cache (regcache);
92b72907 UW	450
d61ddec4	451	if (pswm & 1)
c642a434	452	{
6682d959 AA	453	if (have_regset_tdb)
	454	have_regset_tdb =
	455	(s390_get_hwcap (tdesc_s390x_linux64v2) & HWCAP_S390_TE) != 0;
	456
4ac33720 UW	457	if (have_regset_tdb)
4ac33720 UW	458	tdesc = tdesc_s390x_te_linux64;
6682d959	459	else if (have_regset_system_call)
3aee8918	460	tdesc = tdesc_s390x_linux64v2;
c642a434	461	else if (have_regset_last_break)
3aee8918	462	tdesc = tdesc_s390x_linux64v1;
c642a434	463	else
3aee8918	464	tdesc = tdesc_s390x_linux64;
c642a434	465	}
7803799a UW	466
	467	/* For a 31-bit inferior, check whether the kernel supports
	468	using the full 64-bit GPRs. */
3aee8918	469	else if (s390_get_hwcap (tdesc) & HWCAP_S390_HIGH_GPRS)
7803799a	470	{
3aee8918	471	have_hwcap_s390_high_gprs = 1;
6682d959 AA	472	if (have_regset_tdb)
6682d959 AA	473	have_regset_tdb = (s390_get_hwcap (tdesc) & HWCAP_S390_TE) != 0;
3aee8918	474
4ac33720 UW	475	if (have_regset_tdb)
	476	tdesc = tdesc_s390_te_linux64;
	477	else if (have_regset_system_call)
3aee8918	478	tdesc = tdesc_s390_linux64v2;
c642a434	479	else if (have_regset_last_break)
3aee8918	480	tdesc = tdesc_s390_linux64v1;
c642a434	481	else
3aee8918	482	tdesc = tdesc_s390_linux64;
7803799a	483	}
d61ddec4 UW	484	}
d61ddec4 UW	485	#endif
6682d959 AA	486
	487	/* Update target_regsets according to available register sets. */
	488	for (regset = s390_regsets; regset->fill_function != NULL; regset++)
	489	if (regset->get_request == PTRACE_GETREGSET)
	490	switch (regset->nt_type)
	491	{
	492	case NT_S390_LAST_BREAK:
	493	regset->size = have_regset_last_break? 8 : 0;
	494	break;
	495	case NT_S390_SYSTEM_CALL:
	496	regset->size = have_regset_system_call? 4 : 0;
	497	break;
	498	case NT_S390_TDB:
	499	regset->size = have_regset_tdb ? 256 : 0;
	500	default:
	501	break;
	502	}
	503
3aee8918	504	current_process ()->tdesc = tdesc;
d61ddec4 UW	505	}
	506
	507
b0ded00b UW	508	static int
	509	s390_breakpoint_at (CORE_ADDR pc)
	510	{
	511	unsigned char c[s390_breakpoint_len];
	512	read_inferior_memory (pc, c, s390_breakpoint_len);
	513	return memcmp (c, s390_breakpoint, s390_breakpoint_len) == 0;
	514	}
	515
3aee8918 PA	516	static struct usrregs_info s390_usrregs_info =
	517	{
	518	s390_num_regs,
	519	s390_regmap,
	520	};
	521
	522	static struct regsets_info s390_regsets_info =
	523	{
	524	s390_regsets, /* regsets */
	525	0, /* num_regsets */
	526	NULL, /* disabled_regsets */
	527	};
	528
	529	static struct regs_info regs_info =
	530	{
	531	NULL, /* regset_bitmap */
	532	&s390_usrregs_info,
	533	&s390_regsets_info
	534	};
	535
	536	#ifdef __s390x__
	537	static struct usrregs_info s390_usrregs_info_3264 =
	538	{
	539	s390_num_regs_3264,
	540	s390_regmap_3264
	541	};
	542
	543	static struct regsets_info s390_regsets_info_3264 =
	544	{
	545	s390_regsets, /* regsets */
	546	0, /* num_regsets */
	547	NULL, /* disabled_regsets */
	548	};
	549
	550	static struct regs_info regs_info_3264 =
	551	{
	552	NULL, /* regset_bitmap */
	553	&s390_usrregs_info_3264,
	554	&s390_regsets_info_3264
	555	};
	556	#endif
	557
	558	static const struct regs_info *
	559	s390_regs_info (void)
	560	{
	561	#ifdef __s390x__
	562	if (have_hwcap_s390_high_gprs)
	563	{
	564	const struct target_desc *tdesc = current_process ()->tdesc;
	565
	566	if (register_size (tdesc, 0) == 4)
	567	return &regs_info_3264;
	568	}
	569	#endif
	570	return &regs_info;
	571	}
b0ded00b	572
2ec06d2e	573	struct linux_target_ops the_low_target = {
d61ddec4	574	s390_arch_setup,
3aee8918	575	s390_regs_info,
2ec06d2e DJ	576	s390_cannot_fetch_register,
2ec06d2e DJ	577	s390_cannot_store_register,
c14dfd32	578	NULL, /* fetch_register */
b0ded00b UW	579	s390_get_pc,
	580	s390_set_pc,
	581	s390_breakpoint,
	582	s390_breakpoint_len,
	583	NULL,
	584	s390_breakpoint_len,
	585	s390_breakpoint_at,
802e8e6d	586	NULL, /* supports_z_point_type */
ee1a7ae4 UW	587	NULL,
	588	NULL,
	589	NULL,
	590	NULL,
	591	s390_collect_ptrace_register,
	592	s390_supply_ptrace_register,
2ec06d2e	593	};
3aee8918 PA	594
	595	void
	596	initialize_low_arch (void)
	597	{
	598	/* Initialize the Linux target descriptions. */
	599
	600	init_registers_s390_linux32 ();
	601	init_registers_s390_linux32v1 ();
	602	init_registers_s390_linux32v2 ();
	603	init_registers_s390_linux64 ();
	604	init_registers_s390_linux64v1 ();
	605	init_registers_s390_linux64v2 ();
4ac33720	606	init_registers_s390_te_linux64 ();
3aee8918 PA	607	init_registers_s390x_linux64 ();
	608	init_registers_s390x_linux64v1 ();
	609	init_registers_s390x_linux64v2 ();
4ac33720	610	init_registers_s390x_te_linux64 ();
3aee8918 PA	611
	612	initialize_regsets_info (&s390_regsets_info);
	613	#ifdef __s390x__
	614	initialize_regsets_info (&s390_regsets_info_3264);
	615	#endif
	616	}