[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_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; no fill function.  */
  { PTRACE_GETREGSET, -1, NT_S390_LAST_BREAK, 0, EXTENDED_REGS,
    NULL, 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->size >= 0; 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. */
c642a434 UW	291
c642a434 UW	292	static void
	293	s390_store_last_break (struct regcache regcache, const void buf)
	294	{
3aee8918 PA	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);
c642a434 UW	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
3aee8918	313	static struct regset_info s390_regsets[] = {
1570b33e	314	{ 0, 0, 0, 0, GENERAL_REGS, s390_fill_gregset, NULL },
feea5f36 AA	315	/* Last break address is read-only; no fill function. */
	316	{ PTRACE_GETREGSET, -1, NT_S390_LAST_BREAK, 0, EXTENDED_REGS,
	317	NULL, s390_store_last_break },
c642a434 UW	318	{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_S390_SYSTEM_CALL, 0,
c642a434 UW	319	EXTENDED_REGS, s390_fill_system_call, s390_store_system_call },
1570b33e	320	{ 0, 0, 0, -1, -1, NULL, NULL }
b7149293 UW	321	};
b7149293 UW	322
b0ded00b	323
f450004a	324	static const unsigned char s390_breakpoint[] = { 0, 1 };
b0ded00b UW	325	#define s390_breakpoint_len 2
	326
	327	static CORE_ADDR
442ea881	328	s390_get_pc (struct regcache *regcache)
b0ded00b	329	{
3aee8918	330	if (register_size (regcache->tdesc, 0) == 4)
d61ddec4	331	{
d6db1fab UW	332	unsigned int pswa;
	333	collect_register_by_name (regcache, "pswa", &pswa);
	334	return pswa & 0x7fffffff;
d61ddec4 UW	335	}
	336	else
	337	{
	338	unsigned long pc;
442ea881	339	collect_register_by_name (regcache, "pswa", &pc);
d61ddec4 UW	340	return pc;
d61ddec4 UW	341	}
b0ded00b UW	342	}
	343
	344	static void
442ea881	345	s390_set_pc (struct regcache *regcache, CORE_ADDR newpc)
b0ded00b	346	{
3aee8918	347	if (register_size (regcache->tdesc, 0) == 4)
d61ddec4	348	{
d6db1fab UW	349	unsigned int pswa;
	350	collect_register_by_name (regcache, "pswa", &pswa);
	351	pswa = (pswa & 0x80000000) \| (newpc & 0x7fffffff);
	352	supply_register_by_name (regcache, "pswa", &pswa);
d61ddec4 UW	353	}
	354	else
	355	{
	356	unsigned long pc = newpc;
442ea881	357	supply_register_by_name (regcache, "pswa", &pc);
d61ddec4	358	}
b0ded00b UW	359	}
b0ded00b UW	360
7803799a UW	361	#ifdef __s390x__
7803799a UW	362	static unsigned long
3aee8918	363	s390_get_hwcap (const struct target_desc *tdesc)
7803799a	364	{
3aee8918	365	int wordsize = register_size (tdesc, 0);
7803799a UW	366	unsigned char data = alloca (2 wordsize);
	367	int offset = 0;
	368
	369	while ((the_target->read_auxv) (offset, data, 2 wordsize) == 2 * wordsize)
	370	{
	371	if (wordsize == 4)
	372	{
	373	unsigned int data_p = (unsigned int )data;
	374	if (data_p[0] == AT_HWCAP)
	375	return data_p[1];
	376	}
	377	else
	378	{
	379	unsigned long data_p = (unsigned long )data;
	380	if (data_p[0] == AT_HWCAP)
	381	return data_p[1];
	382	}
	383
	384	offset += 2 * wordsize;
	385	}
	386
	387	return 0;
	388	}
	389	#endif
d61ddec4	390
c642a434 UW	391	static int
	392	s390_check_regset (int pid, int regset, int regsize)
	393	{
	394	gdb_byte *buf = alloca (regsize);
	395	struct iovec iov;
	396
	397	iov.iov_base = buf;
	398	iov.iov_len = regsize;
	399
4ac33720 UW	400	if (ptrace (PTRACE_GETREGSET, pid, (long) regset, (long) &iov) >= 0
4ac33720 UW	401	\|\| errno == ENODATA)
c642a434	402	return 1;
4ac33720	403	return 0;
c642a434 UW	404	}
c642a434 UW	405
3aee8918 PA	406	#ifdef __s390x__
	407	/* For a 31-bit inferior, whether the kernel supports using the full
	408	64-bit GPRs. */
	409	static int have_hwcap_s390_high_gprs = 0;
	410	#endif
	411
d61ddec4 UW	412	static void
	413	s390_arch_setup (void)
	414	{
3aee8918	415	const struct target_desc *tdesc;
c642a434 UW	416	struct regset_info *regset;
	417
	418	/* Check whether the kernel supports extra register sets. */
0bfdf32f	419	int pid = pid_of (current_thread);
c642a434 UW	420	int have_regset_last_break
	421	= s390_check_regset (pid, NT_S390_LAST_BREAK, 8);
	422	int have_regset_system_call
	423	= s390_check_regset (pid, NT_S390_SYSTEM_CALL, 4);
4ac33720	424	int have_regset_tdb = s390_check_regset (pid, NT_S390_TDB, 256);
c642a434	425
d61ddec4	426	/* Assume 31-bit inferior process. */
c642a434	427	if (have_regset_system_call)
3aee8918	428	tdesc = tdesc_s390_linux32v2;
c642a434	429	else if (have_regset_last_break)
3aee8918	430	tdesc = tdesc_s390_linux32v1;
c642a434	431	else
3aee8918	432	tdesc = tdesc_s390_linux32;
d61ddec4 UW	433
	434	/* On a 64-bit host, check the low bit of the (31-bit) PSWM
	435	-- if this is one, we actually have a 64-bit inferior. */
	436	#ifdef __s390x__
	437	{
	438	unsigned int pswm;
3aee8918	439	struct regcache *regcache = new_register_cache (tdesc);
6682d959	440
3aee8918	441	fetch_inferior_registers (regcache, find_regno (tdesc, "pswm"));
442ea881	442	collect_register_by_name (regcache, "pswm", &pswm);
92b72907 UW	443	free_register_cache (regcache);
92b72907 UW	444
d61ddec4	445	if (pswm & 1)
c642a434	446	{
6682d959 AA	447	if (have_regset_tdb)
	448	have_regset_tdb =
	449	(s390_get_hwcap (tdesc_s390x_linux64v2) & HWCAP_S390_TE) != 0;
	450
4ac33720 UW	451	if (have_regset_tdb)
4ac33720 UW	452	tdesc = tdesc_s390x_te_linux64;
6682d959	453	else if (have_regset_system_call)
3aee8918	454	tdesc = tdesc_s390x_linux64v2;
c642a434	455	else if (have_regset_last_break)
3aee8918	456	tdesc = tdesc_s390x_linux64v1;
c642a434	457	else
3aee8918	458	tdesc = tdesc_s390x_linux64;
c642a434	459	}
7803799a UW	460
	461	/* For a 31-bit inferior, check whether the kernel supports
	462	using the full 64-bit GPRs. */
3aee8918	463	else if (s390_get_hwcap (tdesc) & HWCAP_S390_HIGH_GPRS)
7803799a	464	{
3aee8918	465	have_hwcap_s390_high_gprs = 1;
6682d959 AA	466	if (have_regset_tdb)
6682d959 AA	467	have_regset_tdb = (s390_get_hwcap (tdesc) & HWCAP_S390_TE) != 0;
3aee8918	468
4ac33720 UW	469	if (have_regset_tdb)
	470	tdesc = tdesc_s390_te_linux64;
	471	else if (have_regset_system_call)
3aee8918	472	tdesc = tdesc_s390_linux64v2;
c642a434	473	else if (have_regset_last_break)
3aee8918	474	tdesc = tdesc_s390_linux64v1;
c642a434	475	else
3aee8918	476	tdesc = tdesc_s390_linux64;
7803799a	477	}
d61ddec4 UW	478	}
d61ddec4 UW	479	#endif
6682d959 AA	480
6682d959 AA	481	/* Update target_regsets according to available register sets. */
feea5f36	482	for (regset = s390_regsets; regset->size >= 0; regset++)
6682d959 AA	483	if (regset->get_request == PTRACE_GETREGSET)
	484	switch (regset->nt_type)
	485	{
	486	case NT_S390_LAST_BREAK:
	487	regset->size = have_regset_last_break? 8 : 0;
	488	break;
	489	case NT_S390_SYSTEM_CALL:
	490	regset->size = have_regset_system_call? 4 : 0;
	491	break;
	492	case NT_S390_TDB:
	493	regset->size = have_regset_tdb ? 256 : 0;
	494	default:
	495	break;
	496	}
	497
3aee8918	498	current_process ()->tdesc = tdesc;
d61ddec4 UW	499	}
	500
	501
b0ded00b UW	502	static int
	503	s390_breakpoint_at (CORE_ADDR pc)
	504	{
	505	unsigned char c[s390_breakpoint_len];
	506	read_inferior_memory (pc, c, s390_breakpoint_len);
	507	return memcmp (c, s390_breakpoint, s390_breakpoint_len) == 0;
	508	}
	509
3aee8918 PA	510	static struct usrregs_info s390_usrregs_info =
	511	{
	512	s390_num_regs,
	513	s390_regmap,
	514	};
	515
	516	static struct regsets_info s390_regsets_info =
	517	{
	518	s390_regsets, /* regsets */
	519	0, /* num_regsets */
	520	NULL, /* disabled_regsets */
	521	};
	522
	523	static struct regs_info regs_info =
	524	{
	525	NULL, /* regset_bitmap */
	526	&s390_usrregs_info,
	527	&s390_regsets_info
	528	};
	529
	530	#ifdef __s390x__
	531	static struct usrregs_info s390_usrregs_info_3264 =
	532	{
	533	s390_num_regs_3264,
	534	s390_regmap_3264
	535	};
	536
	537	static struct regsets_info s390_regsets_info_3264 =
	538	{
	539	s390_regsets, /* regsets */
	540	0, /* num_regsets */
	541	NULL, /* disabled_regsets */
	542	};
	543
	544	static struct regs_info regs_info_3264 =
	545	{
	546	NULL, /* regset_bitmap */
	547	&s390_usrregs_info_3264,
	548	&s390_regsets_info_3264
	549	};
	550	#endif
	551
	552	static const struct regs_info *
	553	s390_regs_info (void)
	554	{
	555	#ifdef __s390x__
	556	if (have_hwcap_s390_high_gprs)
	557	{
	558	const struct target_desc *tdesc = current_process ()->tdesc;
	559
	560	if (register_size (tdesc, 0) == 4)
	561	return &regs_info_3264;
	562	}
	563	#endif
	564	return &regs_info;
	565	}
b0ded00b	566
2ec06d2e	567	struct linux_target_ops the_low_target = {
d61ddec4	568	s390_arch_setup,
3aee8918	569	s390_regs_info,
2ec06d2e DJ	570	s390_cannot_fetch_register,
2ec06d2e DJ	571	s390_cannot_store_register,
c14dfd32	572	NULL, /* fetch_register */
b0ded00b UW	573	s390_get_pc,
	574	s390_set_pc,
	575	s390_breakpoint,
	576	s390_breakpoint_len,
	577	NULL,
	578	s390_breakpoint_len,
	579	s390_breakpoint_at,
802e8e6d	580	NULL, /* supports_z_point_type */
ee1a7ae4 UW	581	NULL,
	582	NULL,
	583	NULL,
	584	NULL,
	585	s390_collect_ptrace_register,
	586	s390_supply_ptrace_register,
2ec06d2e	587	};
3aee8918 PA	588
	589	void
	590	initialize_low_arch (void)
	591	{
	592	/* Initialize the Linux target descriptions. */
	593
	594	init_registers_s390_linux32 ();
	595	init_registers_s390_linux32v1 ();
	596	init_registers_s390_linux32v2 ();
	597	init_registers_s390_linux64 ();
	598	init_registers_s390_linux64v1 ();
	599	init_registers_s390_linux64v2 ();
4ac33720	600	init_registers_s390_te_linux64 ();
3aee8918 PA	601	init_registers_s390x_linux64 ();
	602	init_registers_s390x_linux64v1 ();
	603	init_registers_s390x_linux64v2 ();
4ac33720	604	init_registers_s390x_te_linux64 ();
3aee8918 PA	605
	606	initialize_regsets_info (&s390_regsets_info);
	607	#ifdef __s390x__
	608	initialize_regsets_info (&s390_regsets_info_3264);
	609	#endif
	610	}