[deliverable/binutils-gdb.git] / gdb / alpha-nat.c

/* Low level Alpha interface, for GDB when running native.
   Copyright 1993, 1995, 1996, 1998 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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "target.h"
#include <sys/ptrace.h>
#ifdef __linux__
#include <asm/reg.h>
#include <alpha/ptrace.h>
#else
#include <machine/reg.h>
#endif
#include <sys/user.h>

/* Prototypes for local functions. */

static void fetch_osf_core_registers (char *, unsigned, int, CORE_ADDR);
static void fetch_elf_core_registers (char *, unsigned, int, CORE_ADDR);

/* Size of elements in jmpbuf */

#define JB_ELEMENT_SIZE 8

/* The definition for JB_PC in machine/reg.h is wrong.
   And we can't get at the correct definition in setjmp.h as it is
   not always available (eg. if _POSIX_SOURCE is defined which is the
   default). As the defintion is unlikely to change (see comment
   in <setjmp.h>, define the correct value here.  */

#undef JB_PC
#define JB_PC 2

/* Figure out where the longjmp will land.
   We expect the first arg to be a pointer to the jmp_buf structure from which
   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
   This routine returns true on success. */

int
get_longjmp_target (pc)
     CORE_ADDR *pc;
{
  CORE_ADDR jb_addr;
  char raw_buffer[MAX_REGISTER_RAW_SIZE];

  jb_addr = read_register (A0_REGNUM);

  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, raw_buffer,
			  sizeof (CORE_ADDR)))
    return 0;

  *pc = extract_address (raw_buffer, sizeof (CORE_ADDR));
  return 1;
}

/* Extract the register values out of the core file and store
   them where `read_register' will find them.

   CORE_REG_SECT points to the register values themselves, read into memory.
   CORE_REG_SIZE is the size of that area.
   WHICH says which set of registers we are handling (0 = int, 2 = float
   on machines where they are discontiguous).
   REG_ADDR is the offset from u.u_ar0 to the register values relative to
   core_reg_sect.  This is used with old-fashioned core files to
   locate the registers in a large upage-plus-stack ".reg" section.
   Original upage address X is at location core_reg_sect+x+reg_addr.
 */

static void
fetch_osf_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
     char *core_reg_sect;
     unsigned core_reg_size;
     int which;
     CORE_ADDR reg_addr;
{
  register int regno;
  register int addr;
  int bad_reg = -1;

  /* Table to map a gdb regnum to an index in the core register section.
     The floating point register values are garbage in OSF/1.2 core files.  */
  static int core_reg_mapping[NUM_REGS] =
  {
#define EFL (EF_SIZE / 8)
    EF_V0, EF_T0, EF_T1, EF_T2, EF_T3, EF_T4, EF_T5, EF_T6,
    EF_T7, EF_S0, EF_S1, EF_S2, EF_S3, EF_S4, EF_S5, EF_S6,
    EF_A0, EF_A1, EF_A2, EF_A3, EF_A4, EF_A5, EF_T8, EF_T9,
    EF_T10, EF_T11, EF_RA, EF_T12, EF_AT, EF_GP, EF_SP, -1,
    EFL + 0, EFL + 1, EFL + 2, EFL + 3, EFL + 4, EFL + 5, EFL + 6, EFL + 7,
    EFL + 8, EFL + 9, EFL + 10, EFL + 11, EFL + 12, EFL + 13, EFL + 14, EFL + 15,
    EFL + 16, EFL + 17, EFL + 18, EFL + 19, EFL + 20, EFL + 21, EFL + 22, EFL + 23,
    EFL + 24, EFL + 25, EFL + 26, EFL + 27, EFL + 28, EFL + 29, EFL + 30, EFL + 31,
    EF_PC, -1
  };
  static char zerobuf[MAX_REGISTER_RAW_SIZE] =
  {0};

  for (regno = 0; regno < NUM_REGS; regno++)
    {
      if (CANNOT_FETCH_REGISTER (regno))
	{
	  supply_register (regno, zerobuf);
	  continue;
	}
      addr = 8 * core_reg_mapping[regno];
      if (addr < 0 || addr >= core_reg_size)
	{
	  if (bad_reg < 0)
	    bad_reg = regno;
	}
      else
	{
	  supply_register (regno, core_reg_sect + addr);
	}
    }
  if (bad_reg >= 0)
    {
      error ("Register %s not found in core file.", REGISTER_NAME (bad_reg));
    }
}

static void
fetch_elf_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
     char *core_reg_sect;
     unsigned core_reg_size;
     int which;
     CORE_ADDR reg_addr;
{
  if (core_reg_size < 32 * 8)
    {
      error ("Core file register section too small (%u bytes).", core_reg_size);
      return;
    }

  if (which == 2)
    {
      /* The FPU Registers.  */
      memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 31 * 8);
      memset (&registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8);
      memset (&register_valid[FP0_REGNUM], 1, 32);
    }
  else
    {
      /* The General Registers.  */
      memcpy (&registers[REGISTER_BYTE (V0_REGNUM)], core_reg_sect, 31 * 8);
      memcpy (&registers[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8);
      memset (&registers[REGISTER_BYTE (ZERO_REGNUM)], 0, 8);
      memset (&register_valid[V0_REGNUM], 1, 32);
      register_valid[PC_REGNUM] = 1;
    }
}


/* Map gdb internal register number to a ptrace ``address''.
   These ``addresses'' are defined in <sys/ptrace.h> */

#define REGISTER_PTRACE_ADDR(regno) \
   (regno < FP0_REGNUM ? 	GPR_BASE + (regno) \
  : regno == PC_REGNUM ?	PC	\
  : regno >= FP0_REGNUM ?	FPR_BASE + ((regno) - FP0_REGNUM) \
  : 0)

/* Return the ptrace ``address'' of register REGNO. */

CORE_ADDR
register_addr (regno, blockend)
     int regno;
     CORE_ADDR blockend;
{
  return REGISTER_PTRACE_ADDR (regno);
}

int
kernel_u_size ()
{
  return (sizeof (struct user));
}

#if defined(USE_PROC_FS) || defined(HAVE_GREGSET_T)
#include <sys/procfs.h>

/* Prototypes for supply_gregset etc. */
#include "gregset.h"

/*
 * See the comment in m68k-tdep.c regarding the utility of these functions.
 */

void
supply_gregset (gregsetp)
     gregset_t *gregsetp;
{
  register int regi;
  register long *regp = ALPHA_REGSET_BASE (gregsetp);
  static char zerobuf[MAX_REGISTER_RAW_SIZE] =
  {0};

  for (regi = 0; regi < 31; regi++)
    supply_register (regi, (char *) (regp + regi));

  supply_register (PC_REGNUM, (char *) (regp + 31));

  /* Fill inaccessible registers with zero.  */
  supply_register (ZERO_REGNUM, zerobuf);
  supply_register (FP_REGNUM, zerobuf);
}

void
fill_gregset (gregsetp, regno)
     gregset_t *gregsetp;
     int regno;
{
  int regi;
  register long *regp = ALPHA_REGSET_BASE (gregsetp);

  for (regi = 0; regi < 31; regi++)
    if ((regno == -1) || (regno == regi))
      *(regp + regi) = *(long *) &registers[REGISTER_BYTE (regi)];

  if ((regno == -1) || (regno == PC_REGNUM))
    *(regp + 31) = *(long *) &registers[REGISTER_BYTE (PC_REGNUM)];
}

/*
 * Now we do the same thing for floating-point registers.
 * Again, see the comments in m68k-tdep.c.
 */

void
supply_fpregset (fpregsetp)
     fpregset_t *fpregsetp;
{
  register int regi;
  register long *regp = ALPHA_REGSET_BASE (fpregsetp);

  for (regi = 0; regi < 32; regi++)
    supply_register (regi + FP0_REGNUM, (char *) (regp + regi));
}

void
fill_fpregset (fpregsetp, regno)
     fpregset_t *fpregsetp;
     int regno;
{
  int regi;
  register long *regp = ALPHA_REGSET_BASE (fpregsetp);

  for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
    {
      if ((regno == -1) || (regno == regi))
	{
	  *(regp + regi - FP0_REGNUM) =
	    *(long *) &registers[REGISTER_BYTE (regi)];
	}
    }
}
#endif
\f

/* Register that we are able to handle alpha core file formats. */

static struct core_fns alpha_osf_core_fns =
{
  /* This really is bfd_target_unknown_flavour.  */

  bfd_target_unknown_flavour,		/* core_flavour */
  default_check_format,			/* check_format */
  default_core_sniffer,			/* core_sniffer */
  fetch_osf_core_registers,		/* core_read_registers */
  NULL					/* next */
};

static struct core_fns alpha_elf_core_fns =
{
  bfd_target_elf_flavour,		/* core_flavour */
  default_check_format,			/* check_format */
  default_core_sniffer,			/* core_sniffer */
  fetch_elf_core_registers,		/* core_read_registers */
  NULL					/* next */
};

void
_initialize_core_alpha ()
{
  add_core_fns (&alpha_osf_core_fns);
  add_core_fns (&alpha_elf_core_fns);
}
Commit	Line	Data
c906108c SS	1	/* Low level Alpha interface, for GDB when running native.
	2	Copyright 1993, 1995, 1996, 1998 Free Software Foundation, Inc.
	3
c5aa993b	4	This file is part of GDB.
c906108c	5
c5aa993b JM	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
c906108c	10
c5aa993b JM	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
c906108c	15
c5aa993b JM	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
c906108c SS	20
	21	#include "defs.h"
	22	#include "inferior.h"
	23	#include "gdbcore.h"
	24	#include "target.h"
	25	#include <sys/ptrace.h>
	26	#ifdef __linux__
c5aa993b JM	27	#include <asm/reg.h>
c5aa993b JM	28	#include <alpha/ptrace.h>
c906108c	29	#else
c5aa993b	30	#include <machine/reg.h>
c906108c SS	31	#endif
	32	#include <sys/user.h>
	33
	34	/* Prototypes for local functions. */
	35
a14ed312 KB	36	static void fetch_osf_core_registers (char *, unsigned, int, CORE_ADDR);
a14ed312 KB	37	static void fetch_elf_core_registers (char *, unsigned, int, CORE_ADDR);
c906108c SS	38
	39	/* Size of elements in jmpbuf */
	40
	41	#define JB_ELEMENT_SIZE 8
	42
	43	/* The definition for JB_PC in machine/reg.h is wrong.
	44	And we can't get at the correct definition in setjmp.h as it is
	45	not always available (eg. if _POSIX_SOURCE is defined which is the
	46	default). As the defintion is unlikely to change (see comment
	47	in <setjmp.h>, define the correct value here. */
	48
	49	#undef JB_PC
	50	#define JB_PC 2
	51
	52	/* Figure out where the longjmp will land.
	53	We expect the first arg to be a pointer to the jmp_buf structure from which
	54	we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
	55	This routine returns true on success. */
	56
	57	int
	58	get_longjmp_target (pc)
	59	CORE_ADDR *pc;
	60	{
	61	CORE_ADDR jb_addr;
	62	char raw_buffer[MAX_REGISTER_RAW_SIZE];
	63
c5aa993b	64	jb_addr = read_register (A0_REGNUM);
c906108c	65
c5aa993b JM	66	if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, raw_buffer,
c5aa993b JM	67	sizeof (CORE_ADDR)))
c906108c SS	68	return 0;
c906108c SS	69
c5aa993b	70	*pc = extract_address (raw_buffer, sizeof (CORE_ADDR));
c906108c SS	71	return 1;
	72	}
	73
	74	/* Extract the register values out of the core file and store
	75	them where `read_register' will find them.
	76
	77	CORE_REG_SECT points to the register values themselves, read into memory.
	78	CORE_REG_SIZE is the size of that area.
	79	WHICH says which set of registers we are handling (0 = int, 2 = float
c5aa993b	80	on machines where they are discontiguous).
c906108c	81	REG_ADDR is the offset from u.u_ar0 to the register values relative to
c5aa993b JM	82	core_reg_sect. This is used with old-fashioned core files to
	83	locate the registers in a large upage-plus-stack ".reg" section.
	84	Original upage address X is at location core_reg_sect+x+reg_addr.
c906108c SS	85	*/
	86
	87	static void
	88	fetch_osf_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
	89	char *core_reg_sect;
	90	unsigned core_reg_size;
	91	int which;
	92	CORE_ADDR reg_addr;
	93	{
	94	register int regno;
	95	register int addr;
	96	int bad_reg = -1;
	97
	98	/* Table to map a gdb regnum to an index in the core register section.
	99	The floating point register values are garbage in OSF/1.2 core files. */
	100	static int core_reg_mapping[NUM_REGS] =
	101	{
	102	#define EFL (EF_SIZE / 8)
c5aa993b JM	103	EF_V0, EF_T0, EF_T1, EF_T2, EF_T3, EF_T4, EF_T5, EF_T6,
	104	EF_T7, EF_S0, EF_S1, EF_S2, EF_S3, EF_S4, EF_S5, EF_S6,
	105	EF_A0, EF_A1, EF_A2, EF_A3, EF_A4, EF_A5, EF_T8, EF_T9,
	106	EF_T10, EF_T11, EF_RA, EF_T12, EF_AT, EF_GP, EF_SP, -1,
	107	EFL + 0, EFL + 1, EFL + 2, EFL + 3, EFL + 4, EFL + 5, EFL + 6, EFL + 7,
	108	EFL + 8, EFL + 9, EFL + 10, EFL + 11, EFL + 12, EFL + 13, EFL + 14, EFL + 15,
	109	EFL + 16, EFL + 17, EFL + 18, EFL + 19, EFL + 20, EFL + 21, EFL + 22, EFL + 23,
	110	EFL + 24, EFL + 25, EFL + 26, EFL + 27, EFL + 28, EFL + 29, EFL + 30, EFL + 31,
	111	EF_PC, -1
c906108c	112	};
c5aa993b JM	113	static char zerobuf[MAX_REGISTER_RAW_SIZE] =
c5aa993b JM	114	{0};
c906108c SS	115
	116	for (regno = 0; regno < NUM_REGS; regno++)
	117	{
	118	if (CANNOT_FETCH_REGISTER (regno))
	119	{
	120	supply_register (regno, zerobuf);
	121	continue;
	122	}
	123	addr = 8 * core_reg_mapping[regno];
	124	if (addr < 0 \|\| addr >= core_reg_size)
	125	{
	126	if (bad_reg < 0)
	127	bad_reg = regno;
	128	}
	129	else
	130	{
	131	supply_register (regno, core_reg_sect + addr);
	132	}
	133	}
	134	if (bad_reg >= 0)
	135	{
	136	error ("Register %s not found in core file.", REGISTER_NAME (bad_reg));
	137	}
	138	}
	139
	140	static void
	141	fetch_elf_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
	142	char *core_reg_sect;
	143	unsigned core_reg_size;
	144	int which;
	145	CORE_ADDR reg_addr;
	146	{
c5aa993b	147	if (core_reg_size < 32 * 8)
c906108c SS	148	{
	149	error ("Core file register section too small (%u bytes).", core_reg_size);
	150	return;
	151	}
	152
	153	if (which == 2)
	154	{
	155	/* The FPU Registers. */
c5aa993b JM	156	memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], core_reg_sect, 31 * 8);
c5aa993b JM	157	memset (&registers[REGISTER_BYTE (FP0_REGNUM + 31)], 0, 8);
c906108c SS	158	memset (&register_valid[FP0_REGNUM], 1, 32);
	159	}
	160	else
	161	{
	162	/* The General Registers. */
c5aa993b JM	163	memcpy (&registers[REGISTER_BYTE (V0_REGNUM)], core_reg_sect, 31 * 8);
c5aa993b JM	164	memcpy (&registers[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8);
c906108c SS	165	memset (&registers[REGISTER_BYTE (ZERO_REGNUM)], 0, 8);
	166	memset (&register_valid[V0_REGNUM], 1, 32);
	167	register_valid[PC_REGNUM] = 1;
	168	}
	169	}
	170
	171
	172	/* Map gdb internal register number to a ptrace ``address''.
	173	These ``addresses'' are defined in <sys/ptrace.h> */
	174
	175	#define REGISTER_PTRACE_ADDR(regno) \
	176	(regno < FP0_REGNUM ? GPR_BASE + (regno) \
	177	: regno == PC_REGNUM ? PC \
	178	: regno >= FP0_REGNUM ? FPR_BASE + ((regno) - FP0_REGNUM) \
	179	: 0)
	180
	181	/* Return the ptrace ``address'' of register REGNO. */
	182
	183	CORE_ADDR
	184	register_addr (regno, blockend)
	185	int regno;
	186	CORE_ADDR blockend;
	187	{
	188	return REGISTER_PTRACE_ADDR (regno);
	189	}
	190
	191	int
	192	kernel_u_size ()
	193	{
	194	return (sizeof (struct user));
	195	}
	196
	197	#if defined(USE_PROC_FS) \|\| defined(HAVE_GREGSET_T)
	198	#include <sys/procfs.h>
	199
c60c0f5f MS	200	/* Prototypes for supply_gregset etc. */
	201	#include "gregset.h"
	202
c906108c SS	203	/*
	204	* See the comment in m68k-tdep.c regarding the utility of these functions.
	205	*/
	206
c5aa993b	207	void
c906108c SS	208	supply_gregset (gregsetp)
	209	gregset_t *gregsetp;
	210	{
	211	register int regi;
	212	register long *regp = ALPHA_REGSET_BASE (gregsetp);
c5aa993b JM	213	static char zerobuf[MAX_REGISTER_RAW_SIZE] =
c5aa993b JM	214	{0};
c906108c SS	215
c906108c SS	216	for (regi = 0; regi < 31; regi++)
c5aa993b	217	supply_register (regi, (char *) (regp + regi));
c906108c	218
c5aa993b	219	supply_register (PC_REGNUM, (char *) (regp + 31));
c906108c SS	220
	221	/* Fill inaccessible registers with zero. */
	222	supply_register (ZERO_REGNUM, zerobuf);
	223	supply_register (FP_REGNUM, zerobuf);
	224	}
	225
	226	void
	227	fill_gregset (gregsetp, regno)
	228	gregset_t *gregsetp;
	229	int regno;
	230	{
	231	int regi;
	232	register long *regp = ALPHA_REGSET_BASE (gregsetp);
	233
	234	for (regi = 0; regi < 31; regi++)
	235	if ((regno == -1) \|\| (regno == regi))
	236	(regp + regi) = (long *) &registers[REGISTER_BYTE (regi)];
	237
	238	if ((regno == -1) \|\| (regno == PC_REGNUM))
	239	(regp + 31) = (long *) &registers[REGISTER_BYTE (PC_REGNUM)];
	240	}
	241
	242	/*
	243	* Now we do the same thing for floating-point registers.
	244	* Again, see the comments in m68k-tdep.c.
	245	*/
	246
	247	void
	248	supply_fpregset (fpregsetp)
	249	fpregset_t *fpregsetp;
	250	{
	251	register int regi;
	252	register long *regp = ALPHA_REGSET_BASE (fpregsetp);
	253
	254	for (regi = 0; regi < 32; regi++)
c5aa993b	255	supply_register (regi + FP0_REGNUM, (char *) (regp + regi));
c906108c SS	256	}
	257
	258	void
	259	fill_fpregset (fpregsetp, regno)
	260	fpregset_t *fpregsetp;
	261	int regno;
	262	{
	263	int regi;
	264	register long *regp = ALPHA_REGSET_BASE (fpregsetp);
	265
	266	for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
	267	{
	268	if ((regno == -1) \|\| (regno == regi))
	269	{
	270	*(regp + regi - FP0_REGNUM) =
	271	(long ) &registers[REGISTER_BYTE (regi)];
	272	}
	273	}
	274	}
	275	#endif
c906108c	276	\f
c5aa993b	277
c906108c SS	278	/* Register that we are able to handle alpha core file formats. */
	279
	280	static struct core_fns alpha_osf_core_fns =
	281	{
	282	/* This really is bfd_target_unknown_flavour. */
	283
2acceee2 JM	284	bfd_target_unknown_flavour, /* core_flavour */
	285	default_check_format, /* check_format */
	286	default_core_sniffer, /* core_sniffer */
	287	fetch_osf_core_registers, /* core_read_registers */
	288	NULL /* next */
c906108c SS	289	};
	290
	291	static struct core_fns alpha_elf_core_fns =
	292	{
2acceee2 JM	293	bfd_target_elf_flavour, /* core_flavour */
	294	default_check_format, /* check_format */
	295	default_core_sniffer, /* core_sniffer */
	296	fetch_elf_core_registers, /* core_read_registers */
	297	NULL /* next */
c906108c SS	298	};
	299
	300	void
	301	_initialize_core_alpha ()
	302	{
	303	add_core_fns (&alpha_osf_core_fns);
	304	add_core_fns (&alpha_elf_core_fns);
	305	}