[deliverable/binutils-gdb.git] / gdb / mips-linux-tdep.c

/* Target-dependent code for GNU/Linux on MIPS processors.
   Copyright 2001 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 "gdbcore.h"
#include "target.h"
#include "solib-svr4.h"

/* Copied from <asm/elf.h>.  */
#define ELF_NGREG       45
#define ELF_NFPREG      33

typedef unsigned char elf_greg_t[4];
typedef elf_greg_t elf_gregset_t[ELF_NGREG];

typedef unsigned char elf_fpreg_t[8];
typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];

/* 0 - 31 are integer registers, 32 - 63 are fp registers.  */
#define FPR_BASE        32
#define PC              64
#define CAUSE           65
#define BADVADDR        66
#define MMHI            67
#define MMLO            68
#define FPC_CSR         69
#define FPC_EIR         70

#define EF_REG0			6
#define EF_REG31		37
#define EF_LO			38
#define EF_HI			39
#define EF_CP0_EPC		40
#define EF_CP0_BADVADDR		41
#define EF_CP0_STATUS		42
#define EF_CP0_CAUSE		43

#define EF_SIZE			180

/* 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 (MIPS_LINUX_JB_PC) that we will land at.  The pc
   is copied into PC.  This routine returns 1 on success.  */

int
mips_linux_get_longjmp_target (CORE_ADDR *pc)
{
  CORE_ADDR jb_addr;
  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];

  jb_addr = read_register (A0_REGNUM);

  if (target_read_memory (jb_addr
			  + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
			  buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
    return 0;

  *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);

  return 1;
}

/* Unpack an elf_gregset_t into GDB's register cache.  */

void 
supply_gregset (elf_gregset_t *gregsetp)
{
  int regi;
  elf_greg_t *regp = *gregsetp;
  char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);

  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);

  for (regi = EF_REG0; regi <= EF_REG31; regi++)
    supply_register ((regi - EF_REG0), (char *)(regp + regi));

  supply_register (LO_REGNUM, (char *)(regp + EF_LO));
  supply_register (HI_REGNUM, (char *)(regp + EF_HI));

  supply_register (PC_REGNUM, (char *)(regp + EF_CP0_EPC));
  supply_register (BADVADDR_REGNUM, (char *)(regp + EF_CP0_BADVADDR));
  supply_register (PS_REGNUM, (char *)(regp + EF_CP0_STATUS));
  supply_register (CAUSE_REGNUM, (char *)(regp + EF_CP0_CAUSE));

  /* Fill inaccessible registers with zero.  */
  supply_register (FP_REGNUM, zerobuf);
  supply_register (UNUSED_REGNUM, zerobuf);
  for (regi = FIRST_EMBED_REGNUM; regi < LAST_EMBED_REGNUM; regi++)
    supply_register (regi, zerobuf);
}

/* Pack our registers (or one register) into an elf_gregset_t.  */

void
fill_gregset (elf_gregset_t *gregsetp, int regno)
{
  int regaddr, regi;
  elf_greg_t *regp = *gregsetp;
  void *src, *dst;

  if (regno == -1)
    {
      memset (regp, 0, sizeof (elf_gregset_t));
      for (regi = 0; regi < 32; regi++)
        fill_gregset (gregsetp, regi);
      fill_gregset (gregsetp, LO_REGNUM);
      fill_gregset (gregsetp, HI_REGNUM);
      fill_gregset (gregsetp, PC_REGNUM);
      fill_gregset (gregsetp, BADVADDR_REGNUM);
      fill_gregset (gregsetp, PS_REGNUM);
      fill_gregset (gregsetp, CAUSE_REGNUM);

      return;
   }

  if (regno < 32)
    {
      src = &registers[REGISTER_BYTE (regno)];
      dst = regp + regno + EF_REG0;
      memcpy (dst, src, sizeof (elf_greg_t));
      return;
    }

  regaddr = -1;
  switch (regno)
    {
      case LO_REGNUM:
	regaddr = EF_LO;
	break;
      case HI_REGNUM:
	regaddr = EF_HI;
	break;
      case PC_REGNUM:
	regaddr = EF_CP0_EPC;
	break;
      case BADVADDR_REGNUM:
	regaddr = EF_CP0_BADVADDR;
	break;
      case PS_REGNUM:
	regaddr = EF_CP0_STATUS;
	break;
      case CAUSE_REGNUM:
	regaddr = EF_CP0_CAUSE;
	break;
    }

  if (regaddr != -1)
    {
      src = &registers[REGISTER_BYTE (regno)];
      dst = regp + regaddr;
      memcpy (dst, src, sizeof (elf_greg_t));
    }
}

/* Likewise, unpack an elf_fpregset_t.  */

void
supply_fpregset (elf_fpregset_t *fpregsetp)
{
  register int regi;
  char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);

  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);

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

  supply_register (FCRCS_REGNUM, (char *)(*fpregsetp + 32));

  /* FIXME: how can we supply FCRIR_REGNUM?  The ABI doesn't tell us. */
  supply_register (FCRIR_REGNUM, zerobuf);
}

/* Likewise, pack one or all floating point registers into an
   elf_fpregset_t.  */

void
fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
{
  char *from, *to;

  if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
    {
      from = (char *) &registers[REGISTER_BYTE (regno)];
      to = (char *) (*fpregsetp + regno - FP0_REGNUM);
      memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
    }
  else if (regno == FCRCS_REGNUM)
    {
      from = (char *) &registers[REGISTER_BYTE (regno)];
      to = (char *) (*fpregsetp + 32);
      memcpy (to, from, REGISTER_RAW_SIZE (regno));
    }
  else if (regno == -1)
    {
      int regi;

      for (regi = 0; regi < 32; regi++)
	fill_fpregset (fpregsetp, FP0_REGNUM + regi);
      fill_fpregset(fpregsetp, FCRCS_REGNUM);
    }
}

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

CORE_ADDR
register_addr (int regno, CORE_ADDR blockend)
{
  int regaddr;

  if (regno < 0 || regno >= NUM_REGS)
    error ("Bogon register number %d.", regno);

  if (regno < 32)
    regaddr = regno;
  else if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
    regaddr = FPR_BASE + (regno - FP0_REGNUM);
  else if (regno == PC_REGNUM)
    regaddr = PC;
  else if (regno == CAUSE_REGNUM)
    regaddr = CAUSE;
  else if (regno == BADVADDR_REGNUM)
    regaddr = BADVADDR;
  else if (regno == LO_REGNUM)
    regaddr = MMLO;
  else if (regno == HI_REGNUM)
    regaddr = MMHI;
  else if (regno == FCRCS_REGNUM)
    regaddr = FPC_CSR;
  else if (regno == FCRIR_REGNUM)
    regaddr = FPC_EIR;
  else
    error ("Unknowable register number %d.", regno);

  return regaddr;
}

/*  Use a local version of this function to get the correct types for
    regsets, until multi-arch core support is ready.  */

static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
		      int which, CORE_ADDR reg_addr)
{
  elf_gregset_t gregset;
  elf_fpregset_t fpregset;

  if (which == 0)
    {
      if (core_reg_size != sizeof (gregset))
	{
	  warning ("wrong size gregset struct in core file");
	}
      else
	{
	  memcpy ((char *) &gregset, core_reg_sect, sizeof (gregset));
	  supply_gregset (&gregset);
	}
    }
  else if (which == 2)
    {
      if (core_reg_size != sizeof (fpregset))
	{
	  warning ("wrong size fpregset struct in core file");
	}
      else
	{
	  memcpy ((char *) &fpregset, core_reg_sect, sizeof (fpregset));
	  supply_fpregset (&fpregset);
	}
    }
}

/* Register that we are able to handle ELF file formats using standard
   procfs "regset" structures.  */

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

/* Fetch (and possibly build) an appropriate link_map_offsets
   structure for native GNU/Linux MIPS targets using the struct offsets
   defined in link.h (but without actual reference to that file).

   This makes it possible to access GNU/Linux MIPS shared libraries from a
   GDB that was built on a different host platform (for cross debugging).  */

struct link_map_offsets *
mips_linux_svr4_fetch_link_map_offsets (void)
{ 
  static struct link_map_offsets lmo;
  static struct link_map_offsets *lmp = NULL;

  if (lmp == NULL)
    { 
      lmp = &lmo;

      lmo.r_debug_size = 8;	/* The actual size is 20 bytes, but
				   this is all we need.  */
      lmo.r_map_offset = 4;
      lmo.r_map_size   = 4;

      lmo.link_map_size = 20;

      lmo.l_addr_offset = 0;
      lmo.l_addr_size   = 4;

      lmo.l_name_offset = 4;
      lmo.l_name_size   = 4;

      lmo.l_next_offset = 12;
      lmo.l_next_size   = 4;

      lmo.l_prev_offset = 16;
      lmo.l_prev_size   = 4;
    }

  return lmp;
}

void
_initialize_mips_linux_tdep (void)
{
  add_core_fns (&regset_core_fns);
}
Commit	Line	Data
75c9abc6	1	/* Target-dependent code for GNU/Linux on MIPS processors.
2aa830e4 DJ	2	Copyright 2001 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	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.
	10
	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.
	15
	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. */
	20
	21	#include "defs.h"
	22	#include "gdbcore.h"
	23	#include "target.h"
	24	#include "solib-svr4.h"
	25
	26	/* Copied from <asm/elf.h>. */
	27	#define ELF_NGREG 45
	28	#define ELF_NFPREG 33
	29
	30	typedef unsigned char elf_greg_t[4];
	31	typedef elf_greg_t elf_gregset_t[ELF_NGREG];
	32
	33	typedef unsigned char elf_fpreg_t[8];
	34	typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
	35
	36	/* 0 - 31 are integer registers, 32 - 63 are fp registers. */
	37	#define FPR_BASE 32
	38	#define PC 64
	39	#define CAUSE 65
	40	#define BADVADDR 66
	41	#define MMHI 67
	42	#define MMLO 68
	43	#define FPC_CSR 69
	44	#define FPC_EIR 70
	45
	46	#define EF_REG0 6
	47	#define EF_REG31 37
	48	#define EF_LO 38
	49	#define EF_HI 39
	50	#define EF_CP0_EPC 40
	51	#define EF_CP0_BADVADDR 41
	52	#define EF_CP0_STATUS 42
	53	#define EF_CP0_CAUSE 43
	54
	55	#define EF_SIZE 180
	56
	57	/* Figure out where the longjmp will land.
	58	We expect the first arg to be a pointer to the jmp_buf structure from
bf072999 DJ	59	which we extract the pc (MIPS_LINUX_JB_PC) that we will land at. The pc
bf072999 DJ	60	is copied into PC. This routine returns 1 on success. */
2aa830e4 DJ	61
	62	int
	63	mips_linux_get_longjmp_target (CORE_ADDR *pc)
	64	{
	65	CORE_ADDR jb_addr;
	66	char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
	67
	68	jb_addr = read_register (A0_REGNUM);
	69
bf072999 DJ	70	if (target_read_memory (jb_addr
	71	+ MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
	72	buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
2aa830e4 DJ	73	return 0;
	74
	75	*pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
	76
	77	return 1;
	78	}
	79
	80	/* Unpack an elf_gregset_t into GDB's register cache. */
	81
	82	void
	83	supply_gregset (elf_gregset_t *gregsetp)
	84	{
	85	int regi;
	86	elf_greg_t regp = gregsetp;
bf072999 DJ	87	char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
	88
	89	memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
2aa830e4 DJ	90
	91	for (regi = EF_REG0; regi <= EF_REG31; regi++)
	92	supply_register ((regi - EF_REG0), (char *)(regp + regi));
	93
	94	supply_register (LO_REGNUM, (char *)(regp + EF_LO));
	95	supply_register (HI_REGNUM, (char *)(regp + EF_HI));
	96
	97	supply_register (PC_REGNUM, (char *)(regp + EF_CP0_EPC));
	98	supply_register (BADVADDR_REGNUM, (char *)(regp + EF_CP0_BADVADDR));
	99	supply_register (PS_REGNUM, (char *)(regp + EF_CP0_STATUS));
	100	supply_register (CAUSE_REGNUM, (char *)(regp + EF_CP0_CAUSE));
	101
	102	/* Fill inaccessible registers with zero. */
	103	supply_register (FP_REGNUM, zerobuf);
	104	supply_register (UNUSED_REGNUM, zerobuf);
	105	for (regi = FIRST_EMBED_REGNUM; regi < LAST_EMBED_REGNUM; regi++)
	106	supply_register (regi, zerobuf);
	107	}
	108
	109	/* Pack our registers (or one register) into an elf_gregset_t. */
	110
	111	void
	112	fill_gregset (elf_gregset_t *gregsetp, int regno)
	113	{
	114	int regaddr, regi;
	115	elf_greg_t regp = gregsetp;
	116	void src, dst;
	117
	118	if (regno == -1)
	119	{
	120	memset (regp, 0, sizeof (elf_gregset_t));
	121	for (regi = 0; regi < 32; regi++)
	122	fill_gregset (gregsetp, regi);
	123	fill_gregset (gregsetp, LO_REGNUM);
	124	fill_gregset (gregsetp, HI_REGNUM);
	125	fill_gregset (gregsetp, PC_REGNUM);
	126	fill_gregset (gregsetp, BADVADDR_REGNUM);
	127	fill_gregset (gregsetp, PS_REGNUM);
	128	fill_gregset (gregsetp, CAUSE_REGNUM);
	129
	130	return;
	131	}
	132
	133	if (regno < 32)
	134	{
	135	src = &registers[REGISTER_BYTE (regno)];
	136	dst = regp + regno + EF_REG0;
	137	memcpy (dst, src, sizeof (elf_greg_t));
	138	return;
	139	}
	140
	141	regaddr = -1;
	142	switch (regno)
	143	{
	144	case LO_REGNUM:
	145	regaddr = EF_LO;
	146	break;
	147	case HI_REGNUM:
	148	regaddr = EF_HI;
	149	break;
	150	case PC_REGNUM:
	151	regaddr = EF_CP0_EPC;
	152	break;
	153	case BADVADDR_REGNUM:
154	regaddr = EF_CP0_BADVADDR;
155	break;
156	case PS_REGNUM:
157	regaddr = EF_CP0_STATUS;
158	break;
159	case CAUSE_REGNUM:
160	regaddr = EF_CP0_CAUSE;
161	break;
162	}
163
164	if (regaddr != -1)
165	{
166	src = &registers[REGISTER_BYTE (regno)];
167	dst = regp + regaddr;
168	memcpy (dst, src, sizeof (elf_greg_t));
169	}
170	}
171
172	/* Likewise, unpack an elf_fpregset_t. */
173
174	void
175	supply_fpregset (elf_fpregset_t *fpregsetp)
176	{
177	register int regi;
bf072999 DJ	178	char *zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
	179
	180	memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
2aa830e4 DJ	181
	182	for (regi = 0; regi < 32; regi++)
	183	supply_register (FP0_REGNUM + regi,
	184	(char )(fpregsetp + regi));
	185
	186	supply_register (FCRCS_REGNUM, (char )(fpregsetp + 32));
	187
	188	/* FIXME: how can we supply FCRIR_REGNUM? The ABI doesn't tell us. */
	189	supply_register (FCRIR_REGNUM, zerobuf);
	190	}
	191
	192	/* Likewise, pack one or all floating point registers into an
	193	elf_fpregset_t. */
	194
	195	void
	196	fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
	197	{
	198	char from, to;
	199
	200	if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
	201	{
	202	from = (char *) &registers[REGISTER_BYTE (regno)];
	203	to = (char ) (fpregsetp + regno - FP0_REGNUM);
	204	memcpy (to, from, REGISTER_RAW_SIZE (regno - FP0_REGNUM));
	205	}
	206	else if (regno == FCRCS_REGNUM)
	207	{
	208	from = (char *) &registers[REGISTER_BYTE (regno)];
	209	to = (char ) (fpregsetp + 32);
	210	memcpy (to, from, REGISTER_RAW_SIZE (regno));
	211	}
	212	else if (regno == -1)
	213	{
	214	int regi;
	215
	216	for (regi = 0; regi < 32; regi++)
	217	fill_fpregset (fpregsetp, FP0_REGNUM + regi);
	218	fill_fpregset(fpregsetp, FCRCS_REGNUM);
	219	}
	220	}
	221
	222	/* Map gdb internal register number to ptrace ``address''.
	223	These ``addresses'' are normally defined in <asm/ptrace.h>. */
	224
	225	CORE_ADDR
	226	register_addr (int regno, CORE_ADDR blockend)
	227	{
	228	int regaddr;
	229
	230	if (regno < 0 \|\| regno >= NUM_REGS)
	231	error ("Bogon register number %d.", regno);
	232
	233	if (regno < 32)
	234	regaddr = regno;
	235	else if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32))
	236	regaddr = FPR_BASE + (regno - FP0_REGNUM);
	237	else if (regno == PC_REGNUM)
	238	regaddr = PC;
	239	else if (regno == CAUSE_REGNUM)
	240	regaddr = CAUSE;
	241	else if (regno == BADVADDR_REGNUM)
	242	regaddr = BADVADDR;
	243	else if (regno == LO_REGNUM)
	244	regaddr = MMLO;
245	else if (regno == HI_REGNUM)
246	regaddr = MMHI;
247	else if (regno == FCRCS_REGNUM)
248	regaddr = FPC_CSR;
249	else if (regno == FCRIR_REGNUM)
250	regaddr = FPC_EIR;
251	else
252	error ("Unknowable register number %d.", regno);
253
254	return regaddr;
255	}
256
257	/* Use a local version of this function to get the correct types for
258	regsets, until multi-arch core support is ready. */
259
260	static void
261	fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
262	int which, CORE_ADDR reg_addr)
263	{
264	elf_gregset_t gregset;
265	elf_fpregset_t fpregset;
266
267	if (which == 0)
268	{
269	if (core_reg_size != sizeof (gregset))
270	{
271	warning ("wrong size gregset struct in core file");
272	}
273	else
274	{
275	memcpy ((char *) &gregset, core_reg_sect, sizeof (gregset));
276	supply_gregset (&gregset);
277	}
278	}
279	else if (which == 2)
280	{
281	if (core_reg_size != sizeof (fpregset))
282	{
283	warning ("wrong size fpregset struct in core file");
284	}
285	else
286	{
287	memcpy ((char *) &fpregset, core_reg_sect, sizeof (fpregset));
288	supply_fpregset (&fpregset);
289	}
290	}
291	}
292
293	/* Register that we are able to handle ELF file formats using standard
294	procfs "regset" structures. */
295
296	static struct core_fns regset_core_fns =
297	{
298	bfd_target_elf_flavour, /* core_flavour */
299	default_check_format, /* check_format */
300	default_core_sniffer, /* core_sniffer */
301	fetch_core_registers, /* core_read_registers */
302	NULL /* next */
303	};
304
305	/* Fetch (and possibly build) an appropriate link_map_offsets
75c9abc6	306	structure for native GNU/Linux MIPS targets using the struct offsets
2aa830e4 DJ	307	defined in link.h (but without actual reference to that file).
2aa830e4 DJ	308
75c9abc6 DJ	309	This makes it possible to access GNU/Linux MIPS shared libraries from a
75c9abc6 DJ	310	GDB that was built on a different host platform (for cross debugging). */
2aa830e4 DJ	311
	312	struct link_map_offsets *
	313	mips_linux_svr4_fetch_link_map_offsets (void)
	314	{
	315	static struct link_map_offsets lmo;
	316	static struct link_map_offsets *lmp = NULL;
	317
	318	if (lmp == NULL)
	319	{
	320	lmp = &lmo;
	321
	322	lmo.r_debug_size = 8; /* The actual size is 20 bytes, but
	323	this is all we need. */
	324	lmo.r_map_offset = 4;
	325	lmo.r_map_size = 4;
	326
	327	lmo.link_map_size = 20;
	328
	329	lmo.l_addr_offset = 0;
	330	lmo.l_addr_size = 4;
	331
	332	lmo.l_name_offset = 4;
	333	lmo.l_name_size = 4;
	334
	335	lmo.l_next_offset = 12;
	336	lmo.l_next_size = 4;
	337
	338	lmo.l_prev_offset = 16;
	339	lmo.l_prev_size = 4;
	340	}
	341
	342	return lmp;
	343	}
	344
	345	void
d1bacddc	346	_initialize_mips_linux_tdep (void)
2aa830e4 DJ	347	{
	348	add_core_fns (&regset_core_fns);
	349	}