X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Firix5-nat.c;h=f7454dc4558006f19c497371f7f9597bb2355b7f;hb=3c0ee1a46468d89b8865cd70616af4558c499b16;hp=ff23a9a8a6089ca8aa77056f33033b2a6e9d007e;hpb=8bb42077f294696bb97d9b047239b32b4ccf5d49;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/irix5-nat.c b/gdb/irix5-nat.c
index ff23a9a8a6..f7454dc455 100644
--- a/gdb/irix5-nat.c
+++ b/gdb/irix5-nat.c
@@ -1,7 +1,8 @@
/* Native support for the SGI Iris running IRIX version 5, for GDB.
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
- 1999, 2000, 2001, 2002, 2004, 2006, 2007 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2004, 2006, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
@@ -12,7 +13,7 @@
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
+ 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,
@@ -21,15 +22,14 @@
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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see . */
#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "target.h"
#include "regcache.h"
+#include "procfs.h"
#include "gdb_string.h"
#include
@@ -40,11 +40,9 @@
#include "gregset.h"
#include "mips-tdep.h"
-static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
+static void fetch_core_registers (struct regcache *, char *,
+ unsigned int, int, CORE_ADDR);
-/* Size of elements in jmpbuf */
-
-#define JB_ELEMENT_SIZE 4
/*
* See the comment in m68k-tdep.c regarding the utility of these functions.
@@ -54,36 +52,39 @@ static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
*/
void
-supply_gregset (gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
{
int regi;
- greg_t *regp = &(*gregsetp)[0];
- int gregoff = sizeof (greg_t) - mips_isa_regsize (current_gdbarch);
+ const greg_t *regp = &(*gregsetp)[0];
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ int gregoff = sizeof (greg_t) - mips_isa_regsize (gdbarch);
static char zerobuf[32] = {0};
for (regi = 0; regi <= CTX_RA; regi++)
- regcache_raw_supply (current_regcache, regi,
- (char *) (regp + regi) + gregoff);
-
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
- (char *) (regp + CTX_EPC) + gregoff);
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
- (char *) (regp + CTX_MDHI) + gregoff);
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
- (char *) (regp + CTX_MDLO) + gregoff);
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
- (char *) (regp + CTX_CAUSE) + gregoff);
+ regcache_raw_supply (regcache, regi,
+ (const char *) (regp + regi) + gregoff);
+
+ regcache_raw_supply (regcache, mips_regnum (gdbarch)->pc,
+ (const char *) (regp + CTX_EPC) + gregoff);
+ regcache_raw_supply (regcache, mips_regnum (gdbarch)->hi,
+ (const char *) (regp + CTX_MDHI) + gregoff);
+ regcache_raw_supply (regcache, mips_regnum (gdbarch)->lo,
+ (const char *) (regp + CTX_MDLO) + gregoff);
+ regcache_raw_supply (regcache, mips_regnum (gdbarch)->cause,
+ (const char *) (regp + CTX_CAUSE) + gregoff);
/* Fill inaccessible registers with zero. */
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf);
+ regcache_raw_supply (regcache, mips_regnum (gdbarch)->badvaddr, zerobuf);
}
void
-fill_gregset (gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
{
- int regi;
+ int regi, size;
greg_t *regp = &(*gregsetp)[0];
- LONGEST regval;
+ gdb_byte buf[MAX_REGISTER_SIZE];
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* Under Irix6, if GDB is built with N32 ABI and is debugging an O32
executable, we have to sign extend the registers to 64 bits before
@@ -92,60 +93,65 @@ fill_gregset (gregset_t *gregsetp, int regno)
for (regi = 0; regi <= CTX_RA; regi++)
if ((regno == -1) || (regno == regi))
{
- regcache_raw_read_signed (current_regcache, regi, ®val);
- *(regp + regi) = regval;
+ size = register_size (gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + regi) = extract_signed_integer (buf, size, byte_order);
}
- if ((regno == -1) || (regno == PC_REGNUM))
+ if ((regno == -1) || (regno == mips_regnum (gdbarch)->pc))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->pc, ®val);
- *(regp + CTX_EPC) = regval;
+ regi = mips_regnum (gdbarch)->pc;
+ size = register_size (gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_EPC) = extract_signed_integer (buf, size, byte_order);
}
- if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->cause))
+ if ((regno == -1) || (regno == mips_regnum (gdbarch)->cause))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->cause, ®val);
- *(regp + CTX_CAUSE) = regval;
+ regi = mips_regnum (gdbarch)->cause;
+ size = register_size (gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_CAUSE) = extract_signed_integer (buf, size, byte_order);
}
- if ((regno == -1)
- || (regno == mips_regnum (current_gdbarch)->hi))
+ if ((regno == -1) || (regno == mips_regnum (gdbarch)->hi))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->hi, ®val);
- *(regp + CTX_MDHI) = regval;
+ regi = mips_regnum (gdbarch)->hi;
+ size = register_size (gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_MDHI) = extract_signed_integer (buf, size, byte_order);
}
- if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->lo))
+ if ((regno == -1) || (regno == mips_regnum (gdbarch)->lo))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->lo, ®val);
- *(regp + CTX_MDLO) = regval;
+ regi = mips_regnum (gdbarch)->lo;
+ size = register_size (gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_MDLO) = extract_signed_integer (buf, size, byte_order);
}
}
/*
* Now we do the same thing for floating-point registers.
- * We don't bother to condition on FP0_REGNUM since any
+ * We don't bother to condition on gdbarch_fp0_regnum since any
* reasonable MIPS configuration has an R3010 in it.
*
* Again, see the comments in m68k-tdep.c.
*/
void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{
int regi;
static char zerobuf[32] = {0};
char fsrbuf[8];
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
for (regi = 0; regi < 32; regi++)
- regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
- (char *) &fpregsetp->fp_r.fp_regs[regi]);
+ regcache_raw_supply (regcache, gdbarch_fp0_regnum (gdbarch) + regi,
+ (const char *) &fpregsetp->fp_r.fp_regs[regi]);
/* We can't supply the FSR register directly to the regcache,
because there is a size issue: On one hand, fpregsetp->fp_csr
@@ -155,35 +161,37 @@ supply_fpregset (fpregset_t *fpregsetp)
memset (fsrbuf, 0, 4);
memcpy (fsrbuf + 4, &fpregsetp->fp_csr, 4);
- regcache_raw_supply (current_regcache,
- mips_regnum (current_gdbarch)->fp_control_status,
- fsrbuf);
+ regcache_raw_supply (regcache,
+ mips_regnum (gdbarch)->fp_control_status, fsrbuf);
/* FIXME: how can we supply FCRIR? SGI doesn't tell us. */
- regcache_raw_supply (current_regcache,
- mips_regnum (current_gdbarch)->fp_implementation_revision,
+ regcache_raw_supply (regcache,
+ mips_regnum (gdbarch)->fp_implementation_revision,
zerobuf);
}
void
-fill_fpregset (fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno)
{
int regi;
char *from, *to;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
- for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
+ for (regi = gdbarch_fp0_regnum (gdbarch);
+ regi < gdbarch_fp0_regnum (gdbarch) + 32; regi++)
{
if ((regno == -1) || (regno == regi))
{
- to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
- regcache_raw_read (current_regcache, regi, to);
+ to = (char *) &(fpregsetp->fp_r.fp_regs[regi - gdbarch_fp0_regnum
+ (gdbarch)]);
+ regcache_raw_collect (regcache, regi, to);
}
}
if (regno == -1
- || regno == mips_regnum (current_gdbarch)->fp_control_status)
+ || regno == mips_regnum (gdbarch)->fp_control_status)
{
char fsrbuf[8];
@@ -192,38 +200,14 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
is 32bits long, while the regcache expects a 64bits long buffer.
So we use a buffer of the correct size and copy the register
value from that buffer. */
- regcache_raw_read (current_regcache,
- mips_regnum (current_gdbarch)->fp_control_status,
- fsrbuf);
+ regcache_raw_collect (regcache,
+ mips_regnum (gdbarch)->fp_control_status, fsrbuf);
memcpy (&fpregsetp->fp_csr, fsrbuf + 4, 4);
}
}
-/* 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 (CORE_ADDR *pc)
-{
- char *buf;
- CORE_ADDR jb_addr;
-
- buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
- jb_addr = read_register (MIPS_A0_REGNUM);
-
- if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
- TARGET_PTR_BIT / TARGET_CHAR_BIT))
- return 0;
-
- *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-
- return 1;
-}
-
/* Provide registers to GDB from a core file.
CORE_REG_SECT points to an array of bytes, which were obtained from
@@ -238,24 +222,26 @@ get_longjmp_target (CORE_ADDR *pc)
REG_ADDR is also unused. */
static void
-fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
+fetch_core_registers (struct regcache *regcache,
+ char *core_reg_sect, unsigned core_reg_size,
int which, CORE_ADDR reg_addr)
{
char *srcp = core_reg_sect;
- int regsize = mips_isa_regsize (current_gdbarch);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ int regsize = mips_isa_regsize (gdbarch);
int regno;
/* If regsize is 8, this is a N32 or N64 core file.
If regsize is 4, this is an O32 core file. */
- if (core_reg_size != regsize * NUM_REGS)
+ if (core_reg_size != regsize * gdbarch_num_regs (gdbarch))
{
warning (_("wrong size gregset struct in core file"));
return;
}
- for (regno = 0; regno < NUM_REGS; regno++)
+ for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
{
- regcache_raw_supply (current_regcache, regno, srcp);
+ regcache_raw_supply (regcache, regno, srcp);
srcp += regsize;
}
}
@@ -272,8 +258,17 @@ static struct core_fns irix5_core_fns =
NULL /* next */
};
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_irix5_nat;
+
void
-_initialize_core_irix5 (void)
+_initialize_irix5_nat (void)
{
+ struct target_ops *t;
+
+ t = procfs_target ();
+ procfs_use_watchpoints (t);
+ add_target (t);
+
deprecated_add_core_fns (&irix5_core_fns);
}