[deliverable/binutils-gdb.git] / gdb / alphanbsd-tdep.c

/* Target-dependent code for NetBSD/Alpha.
   Copyright 2002, 2003 Free Software Foundation, Inc.
   Contributed by Wasabi Systems, 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 "gdbcore.h"
#include "frame.h"
#include "regcache.h"
#include "value.h"
#include "osabi.h"

#include "solib-svr4.h"

#include "alpha-tdep.h"
#include "alphabsd-tdep.h"
#include "nbsd-tdep.h"

static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
                      CORE_ADDR ignore)
{
  char *regs, *fpregs;
  int regno;

  /* Table to map a gdb register number to a trapframe register index.  */
  static const int regmap[] =
  {
     0,   1,   2,   3,
     4,   5,   6,   7,
     8,   9,  10,  11,
    12,  13,  14,  15, 
    30,  31,  32,  16, 
    17,  18,  19,  20,
    21,  22,  23,  24,
    25,  29,  26
  };
#define SIZEOF_TRAPFRAME (33 * 8)

  /* We get everything from one section.  */
  if (which != 0)
    return;

  regs = core_reg_sect;
  fpregs = core_reg_sect + SIZEOF_TRAPFRAME;

  if (core_reg_size < (SIZEOF_TRAPFRAME + SIZEOF_STRUCT_FPREG))
    {
      warning ("Wrong size register set in core file.");
      return;
    }

  /* Integer registers.  */
  for (regno = 0; regno < ALPHA_ZERO_REGNUM; regno++)
    supply_register (regno, regs + (regmap[regno] * 8));
  supply_register (ALPHA_ZERO_REGNUM, NULL);
  supply_register (FP_REGNUM, NULL);
  supply_register (PC_REGNUM, regs + (28 * 8));

  /* Floating point registers.  */
  alphabsd_supply_fpreg (fpregs, -1);
}

static void
fetch_elfcore_registers (char *core_reg_sect, unsigned core_reg_size, int which,
                         CORE_ADDR ignore)
{
  switch (which)
    {
    case 0:  /* Integer registers.  */
      if (core_reg_size != SIZEOF_STRUCT_REG)
	warning ("Wrong size register set in core file.");
      else
	alphabsd_supply_reg (core_reg_sect, -1);
      break;

    case 2:  /* Floating point registers.  */
      if (core_reg_size != SIZEOF_STRUCT_FPREG)
	warning ("Wrong size FP register set in core file.");
      else
	alphabsd_supply_fpreg (core_reg_sect, -1);
      break;

    default:
      /* Don't know what kind of register request this is; just ignore it.  */
      break;
    }
}

static struct core_fns alphanbsd_core_fns =
{
  bfd_target_unknown_flavour,		/* core_flavour */
  default_check_format,			/* check_format */
  default_core_sniffer,			/* core_sniffer */
  fetch_core_registers,			/* core_read_registers */
  NULL					/* next */
};

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

/* Under NetBSD/alpha, signal handler invocations can be identified by the
   designated code sequence that is used to return from a signal handler.
   In particular, the return address of a signal handler points to the
   following code sequence:

	ldq	a0, 0(sp)
	lda	sp, 16(sp)
	lda	v0, 295(zero)	# __sigreturn14
	call_pal callsys

   Each instruction has a unique encoding, so we simply attempt to match
   the instruction the PC is pointing to with any of the above instructions.
   If there is a hit, we know the offset to the start of the designated
   sequence and can then check whether we really are executing in the
   signal trampoline.  If not, -1 is returned, otherwise the offset from the
   start of the return sequence is returned.  */
static const unsigned char sigtramp_retcode[] =
{
  0x00, 0x00, 0x1e, 0xa6,	/* ldq a0, 0(sp) */
  0x10, 0x00, 0xde, 0x23,	/* lda sp, 16(sp) */
  0x27, 0x01, 0x1f, 0x20,	/* lda v0, 295(zero) */
  0x83, 0x00, 0x00, 0x00,	/* call_pal callsys */
};
#define RETCODE_NWORDS		4
#define RETCODE_SIZE		(RETCODE_NWORDS * 4)

LONGEST
alphanbsd_sigtramp_offset (CORE_ADDR pc)
{
  unsigned char ret[RETCODE_SIZE], w[4];
  LONGEST off;
  int i;

  if (read_memory_nobpt (pc, (char *) w, 4) != 0)
    return -1;

  for (i = 0; i < RETCODE_NWORDS; i++)
    {
      if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0)
	break;
    }
  if (i == RETCODE_NWORDS)
    return (-1);

  off = i * 4;
  pc -= off;

  if (read_memory_nobpt (pc, (char *) ret, sizeof (ret)) != 0)
    return -1;

  if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0)
    return off;

  return -1;
}

static int
alphanbsd_pc_in_sigtramp (CORE_ADDR pc, char *func_name)
{
  return (nbsd_pc_in_sigtramp (pc, func_name)
	  || alphanbsd_sigtramp_offset (pc) >= 0);
}

static CORE_ADDR
alphanbsd_sigcontext_addr (struct frame_info *frame)
{
  /* FIXME: This is not correct for all versions of NetBSD/alpha.
     We will probably need to disassemble the trampoline to figure
     out which trampoline frame type we have.  */
  return frame->frame;
}

static CORE_ADDR
alphanbsd_skip_sigtramp_frame (struct frame_info *frame, CORE_ADDR pc)
{
  char *name;

  /* FIXME: This is not correct for all versions of NetBSD/alpha.
     We will probably need to disassemble the trampoline to figure
     out which trampoline frame type we have.  */
  find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
  if (PC_IN_SIGTRAMP (pc, name))
    return frame->frame;
  return 0;
}

static void
alphanbsd_init_abi (struct gdbarch_info info,
                    struct gdbarch *gdbarch)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  set_gdbarch_pc_in_sigtramp (gdbarch, alphanbsd_pc_in_sigtramp);

  /* NetBSD/alpha does not provide single step support via ptrace(2); we
     must use software single-stepping.  */
  set_gdbarch_software_single_step (gdbarch, alpha_software_single_step);

  set_solib_svr4_fetch_link_map_offsets (gdbarch,
                                 nbsd_lp64_solib_svr4_fetch_link_map_offsets);

  tdep->skip_sigtramp_frame = alphanbsd_skip_sigtramp_frame;
  tdep->dynamic_sigtramp_offset = alphanbsd_sigtramp_offset;
  tdep->sigcontext_addr = alphanbsd_sigcontext_addr;

  tdep->jb_pc = 2;
  tdep->jb_elt_size = 8;
}

void
_initialize_alphanbsd_tdep (void)
{
  gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_ELF,
                          alphanbsd_init_abi);

  add_core_fns (&alphanbsd_core_fns);
  add_core_fns (&alphanbsd_elfcore_fns);
}
Commit	Line	Data
da8ca43d	1	/* Target-dependent code for NetBSD/Alpha.
4be87837	2	Copyright 2002, 2003 Free Software Foundation, Inc.
da8ca43d JT	3	Contributed by Wasabi Systems, Inc.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
	21
	22	#include "defs.h"
	23	#include "gdbcore.h"
2ca8ae21	24	#include "frame.h"
8513dd2d	25	#include "regcache.h"
da8ca43d	26	#include "value.h"
4be87837	27	#include "osabi.h"
da8ca43d	28
9964235a JT	29	#include "solib-svr4.h"
9964235a JT	30
da8ca43d	31	#include "alpha-tdep.h"
8513dd2d	32	#include "alphabsd-tdep.h"
ea5bc2a6	33	#include "nbsd-tdep.h"
8513dd2d JT	34
	35	static void
	36	fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
	37	CORE_ADDR ignore)
	38	{
	39	char regs, fpregs;
	40	int regno;
	41
	42	/* Table to map a gdb register number to a trapframe register index. */
	43	static const int regmap[] =
	44	{
	45	0, 1, 2, 3,
	46	4, 5, 6, 7,
	47	8, 9, 10, 11,
	48	12, 13, 14, 15,
	49	30, 31, 32, 16,
	50	17, 18, 19, 20,
	51	21, 22, 23, 24,
	52	25, 29, 26
	53	};
	54	#define SIZEOF_TRAPFRAME (33 * 8)
	55
	56	/* We get everything from one section. */
	57	if (which != 0)
	58	return;
	59
	60	regs = core_reg_sect;
	61	fpregs = core_reg_sect + SIZEOF_TRAPFRAME;
	62
	63	if (core_reg_size < (SIZEOF_TRAPFRAME + SIZEOF_STRUCT_FPREG))
	64	{
	65	warning ("Wrong size register set in core file.");
	66	return;
	67	}
	68
	69	/* Integer registers. */
	70	for (regno = 0; regno < ALPHA_ZERO_REGNUM; regno++)
	71	supply_register (regno, regs + (regmap[regno] * 8));
	72	supply_register (ALPHA_ZERO_REGNUM, NULL);
	73	supply_register (FP_REGNUM, NULL);
	74	supply_register (PC_REGNUM, regs + (28 * 8));
	75
	76	/* Floating point registers. */
	77	alphabsd_supply_fpreg (fpregs, -1);
	78	}
	79
	80	static void
	81	fetch_elfcore_registers (char *core_reg_sect, unsigned core_reg_size, int which,
	82	CORE_ADDR ignore)
	83	{
	84	switch (which)
	85	{
	86	case 0: /* Integer registers. */
	87	if (core_reg_size != SIZEOF_STRUCT_REG)
	88	warning ("Wrong size register set in core file.");
	89	else
	90	alphabsd_supply_reg (core_reg_sect, -1);
	91	break;
	92
	93	case 2: /* Floating point registers. */
	94	if (core_reg_size != SIZEOF_STRUCT_FPREG)
	95	warning ("Wrong size FP register set in core file.");
	96	else
	97	alphabsd_supply_fpreg (core_reg_sect, -1);
98	break;
99
100	default:
101	/* Don't know what kind of register request this is; just ignore it. */
102	break;
103	}
104	}
105
106	static struct core_fns alphanbsd_core_fns =
107	{
108	bfd_target_unknown_flavour, /* core_flavour */
109	default_check_format, /* check_format */
110	default_core_sniffer, /* core_sniffer */
111	fetch_core_registers, /* core_read_registers */
112	NULL /* next */
113	};
114
115	static struct core_fns alphanbsd_elfcore_fns =
116	{
117	bfd_target_elf_flavour, /* core_flavour */
118	default_check_format, /* check_format */
119	default_core_sniffer, /* core_sniffer */
120	fetch_elfcore_registers, /* core_read_registers */
121	NULL /* next */
122	};
da8ca43d	123
da8ca43d JT	124	/* Under NetBSD/alpha, signal handler invocations can be identified by the
	125	designated code sequence that is used to return from a signal handler.
	126	In particular, the return address of a signal handler points to the
	127	following code sequence:
	128
	129	ldq a0, 0(sp)
	130	lda sp, 16(sp)
	131	lda v0, 295(zero) # __sigreturn14
	132	call_pal callsys
	133
	134	Each instruction has a unique encoding, so we simply attempt to match
	135	the instruction the PC is pointing to with any of the above instructions.
	136	If there is a hit, we know the offset to the start of the designated
	137	sequence and can then check whether we really are executing in the
	138	signal trampoline. If not, -1 is returned, otherwise the offset from the
	139	start of the return sequence is returned. */
cfef91e4	140	static const unsigned char sigtramp_retcode[] =
da8ca43d	141	{
cfef91e4 JT	142	0x00, 0x00, 0x1e, 0xa6, /* ldq a0, 0(sp) */
	143	0x10, 0x00, 0xde, 0x23, /* lda sp, 16(sp) */
	144	0x27, 0x01, 0x1f, 0x20, /* lda v0, 295(zero) */
	145	0x83, 0x00, 0x00, 0x00, /* call_pal callsys */
da8ca43d	146	};
cfef91e4 JT	147	#define RETCODE_NWORDS 4
cfef91e4 JT	148	#define RETCODE_SIZE (RETCODE_NWORDS * 4)
da8ca43d JT	149
	150	LONGEST
	151	alphanbsd_sigtramp_offset (CORE_ADDR pc)
	152	{
cfef91e4	153	unsigned char ret[RETCODE_SIZE], w[4];
da8ca43d JT	154	LONGEST off;
	155	int i;
	156
cfef91e4	157	if (read_memory_nobpt (pc, (char *) w, 4) != 0)
da8ca43d JT	158	return -1;
	159
	160	for (i = 0; i < RETCODE_NWORDS; i++)
	161	{
cfef91e4	162	if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0)
da8ca43d JT	163	break;
	164	}
	165	if (i == RETCODE_NWORDS)
	166	return (-1);
	167
	168	off = i * 4;
	169	pc -= off;
	170
	171	if (read_memory_nobpt (pc, (char *) ret, sizeof (ret)) != 0)
	172	return -1;
	173
cfef91e4	174	if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0)
da8ca43d JT	175	return off;
	176
	177	return -1;
	178	}
	179
6c72f9f9 JT	180	static int
	181	alphanbsd_pc_in_sigtramp (CORE_ADDR pc, char *func_name)
	182	{
3d9b49b0 JT	183	return (nbsd_pc_in_sigtramp (pc, func_name)
3d9b49b0 JT	184	\|\| alphanbsd_sigtramp_offset (pc) >= 0);
6c72f9f9 JT	185	}
6c72f9f9 JT	186
2ca8ae21 JT	187	static CORE_ADDR
	188	alphanbsd_sigcontext_addr (struct frame_info *frame)
	189	{
	190	/* FIXME: This is not correct for all versions of NetBSD/alpha.
	191	We will probably need to disassemble the trampoline to figure
	192	out which trampoline frame type we have. */
	193	return frame->frame;
	194	}
	195
	196	static CORE_ADDR
	197	alphanbsd_skip_sigtramp_frame (struct frame_info *frame, CORE_ADDR pc)
	198	{
	199	char *name;
	200
	201	/* FIXME: This is not correct for all versions of NetBSD/alpha.
	202	We will probably need to disassemble the trampoline to figure
	203	out which trampoline frame type we have. */
	204	find_pc_partial_function (pc, &name, (CORE_ADDR ) NULL, (CORE_ADDR ) NULL);
	205	if (PC_IN_SIGTRAMP (pc, name))
	206	return frame->frame;
	207	return 0;
	208	}
	209
da8ca43d JT	210	static void
	211	alphanbsd_init_abi (struct gdbarch_info info,
	212	struct gdbarch *gdbarch)
	213	{
	214	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	215
6c72f9f9 JT	216	set_gdbarch_pc_in_sigtramp (gdbarch, alphanbsd_pc_in_sigtramp);
6c72f9f9 JT	217
da8ca43d JT	218	/* NetBSD/alpha does not provide single step support via ptrace(2); we
	219	must use software single-stepping. */
	220	set_gdbarch_software_single_step (gdbarch, alpha_software_single_step);
	221
	222	set_solib_svr4_fetch_link_map_offsets (gdbarch,
ea5bc2a6	223	nbsd_lp64_solib_svr4_fetch_link_map_offsets);
da8ca43d	224
2ca8ae21	225	tdep->skip_sigtramp_frame = alphanbsd_skip_sigtramp_frame;
da8ca43d	226	tdep->dynamic_sigtramp_offset = alphanbsd_sigtramp_offset;
2ca8ae21	227	tdep->sigcontext_addr = alphanbsd_sigcontext_addr;
accc6d1f JT	228
	229	tdep->jb_pc = 2;
	230	tdep->jb_elt_size = 8;
da8ca43d JT	231	}
	232
	233	void
	234	_initialize_alphanbsd_tdep (void)
	235	{
05816f70	236	gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD_ELF,
70f80edf	237	alphanbsd_init_abi);
8513dd2d JT	238
	239	add_core_fns (&alphanbsd_core_fns);
	240	add_core_fns (&alphanbsd_elfcore_fns);
da8ca43d	241	}