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

/* Target-dependent code for GNU/Linux on MIPS processors.

   Copyright 2001, 2002 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"
#include "osabi.h"
#include "gdb_string.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.  */

#define MIPS_LINUX_JB_ELEMENT_SIZE 4
#define MIPS_LINUX_JB_PC 0

static 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 (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 = &deprecated_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 = &deprecated_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 *) &deprecated_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 *) &deprecated_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).  */

static 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;
}

static void
mips_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  set_gdbarch_get_longjmp_target (gdbarch, mips_linux_get_longjmp_target);
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, mips_linux_svr4_fetch_link_map_offsets);
}

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