darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

2007-10-08 Markus Deuling <deuling@de.ibm.com>

Browse source 
* irix5-nat.c (supply_gregset, fill_gregset, supply_fpregset)
	(fill_fpregset, fetch_core_registers): Use get_regcache_arch or
	get_frame_arch to get at the current architecture by regcache or by
	frame, respectively.
This commit is contained in:
Ulrich Weigand 2007-10-08 12:53:07 +00:00
parent 088568da7d
commit d611717af8
2 changed files with 42 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
gdb/ChangeLog
View file

@ -1,3 +1,10 @@
2007-10-08 Markus Deuling <deuling@de.ibm.com>
* irix5-nat.c (supply_gregset, fill_gregset, supply_fpregset)
(fill_fpregset, fetch_core_registers): Use get_regcache_arch or
get_frame_arch to get at the current architecture by regcache or by
frame, respectively.
2007-10-08 Markus Deuling <deuling@de.ibm.com> 2007-10-08 Markus Deuling <deuling@de.ibm.com>
* ia64-tdep.c (ia64_pseudo_register_read, ia64_pseudo_register_write): * ia64-tdep.c (ia64_pseudo_register_read, ia64_pseudo_register_write):

67
gdb/irix5-nat.c
View file

@ -54,24 +54,25 @@ supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
{ {
int regi; int regi;
const greg_t *regp = &(*gregsetp)[0]; const greg_t *regp = &(*gregsetp)[0];
int gregoff = sizeof (greg_t) - mips_isa_regsize (current_gdbarch); struct gdbarch *gdbarch = get_regcache_arch (regcache);
int gregoff = sizeof (greg_t) - mips_isa_regsize (gdbarch);
static char zerobuf[32] = {0}; static char zerobuf[32] = {0};
for (regi = 0; regi <= CTX_RA; regi++) for (regi = 0; regi <= CTX_RA; regi++)
regcache_raw_supply (regcache, regi, regcache_raw_supply (regcache, regi,
(const char *) (regp + regi) + gregoff); (const char *) (regp + regi) + gregoff);
regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->pc, regcache_raw_supply (regcache, mips_regnum (gdbarch)->pc,
(const char *) (regp + CTX_EPC) + gregoff); (const char *) (regp + CTX_EPC) + gregoff);
regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->hi, regcache_raw_supply (regcache, mips_regnum (gdbarch)->hi,
(const char *) (regp + CTX_MDHI) + gregoff); (const char *) (regp + CTX_MDHI) + gregoff);
regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->lo, regcache_raw_supply (regcache, mips_regnum (gdbarch)->lo,
(const char *) (regp + CTX_MDLO) + gregoff); (const char *) (regp + CTX_MDLO) + gregoff);
regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->cause, regcache_raw_supply (regcache, mips_regnum (gdbarch)->cause,
(const char *) (regp + CTX_CAUSE) + gregoff); (const char *) (regp + CTX_CAUSE) + gregoff);
/* Fill inaccessible registers with zero. */ /* Fill inaccessible registers with zero. */
regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf); regcache_raw_supply (regcache, mips_regnum (gdbarch)->badvaddr, zerobuf);
} }
void void
@ -80,6 +81,7 @@ fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
int regi, size; int regi, size;
greg_t *regp = &(*gregsetp)[0]; greg_t *regp = &(*gregsetp)[0];
gdb_byte buf[MAX_REGISTER_SIZE]; gdb_byte buf[MAX_REGISTER_SIZE];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* Under Irix6, if GDB is built with N32 ABI and is debugging an O32 /* 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 executable, we have to sign extend the registers to 64 bits before
@ -88,39 +90,39 @@ fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
for (regi = 0; regi <= CTX_RA; regi++) for (regi = 0; regi <= CTX_RA; regi++)
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
size = register_size (current_gdbarch, regi); size = register_size (gdbarch, regi);
regcache_raw_collect (regcache, regi, buf); regcache_raw_collect (regcache, regi, buf);
*(regp + regi) = extract_signed_integer (buf, size); *(regp + regi) = extract_signed_integer (buf, size);
} }
if ((regno == -1) || (regno == gdbarch_pc_regnum (current_gdbarch))) if ((regno == -1) || (regno == gdbarch_pc_regnum (gdbarch)))
{ {
regi = mips_regnum (current_gdbarch)->pc; regi = mips_regnum (gdbarch)->pc;
size = register_size (current_gdbarch, regi); size = register_size (gdbarch, regi);
regcache_raw_collect (regcache, regi, buf); regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_EPC) = extract_signed_integer (buf, size); *(regp + CTX_EPC) = extract_signed_integer (buf, size);
} }
if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->cause)) if ((regno == -1) || (regno == mips_regnum (gdbarch)->cause))
{ {
regi = mips_regnum (current_gdbarch)->cause; regi = mips_regnum (gdbarch)->cause;
size = register_size (current_gdbarch, regi); size = register_size (gdbarch, regi);
regcache_raw_collect (regcache, regi, buf); regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_CAUSE) = extract_signed_integer (buf, size); *(regp + CTX_CAUSE) = extract_signed_integer (buf, size);
} }
if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->hi)) if ((regno == -1) || (regno == mips_regnum (gdbarch)->hi))
{ {
regi = mips_regnum (current_gdbarch)->hi; regi = mips_regnum (gdbarch)->hi;
size = register_size (current_gdbarch, regi); size = register_size (gdbarch, regi);
regcache_raw_collect (regcache, regi, buf); regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_MDHI) = extract_signed_integer (buf, size); *(regp + CTX_MDHI) = extract_signed_integer (buf, size);
} }
if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->lo)) if ((regno == -1) || (regno == mips_regnum (gdbarch)->lo))
{ {
regi = mips_regnum (current_gdbarch)->lo; regi = mips_regnum (gdbarch)->lo;
size = register_size (current_gdbarch, regi); size = register_size (gdbarch, regi);
regcache_raw_collect (regcache, regi, buf); regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_MDLO) = extract_signed_integer (buf, size); *(regp + CTX_MDLO) = extract_signed_integer (buf, size);
} }
@ -140,11 +142,12 @@ supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
int regi; int regi;
static char zerobuf[32] = {0}; static char zerobuf[32] = {0};
char fsrbuf[8]; char fsrbuf[8];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */ /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache, gdbarch_fp0_regnum (current_gdbarch) + regi, regcache_raw_supply (regcache, gdbarch_fp0_regnum (gdbarch) + regi,
(const char *) &fpregsetp->fp_r.fp_regs[regi]); (const char *) &fpregsetp->fp_r.fp_regs[regi]);
/* We can't supply the FSR register directly to the regcache, /* We can't supply the FSR register directly to the regcache,
@ -156,12 +159,11 @@ supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
memcpy (fsrbuf + 4, &fpregsetp->fp_csr, 4); memcpy (fsrbuf + 4, &fpregsetp->fp_csr, 4);
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_control_status, mips_regnum (gdbarch)->fp_control_status, fsrbuf);
fsrbuf);
/* FIXME: how can we supply FCRIR? SGI doesn't tell us. */ /* FIXME: how can we supply FCRIR? SGI doesn't tell us. */
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_implementation_revision, mips_regnum (gdbarch)->fp_implementation_revision,
zerobuf); zerobuf);
} }
@ -170,22 +172,23 @@ fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno
{ {
int regi; int regi;
char *from, *to; char *from, *to;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
/* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */ /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
for (regi = gdbarch_fp0_regnum (current_gdbarch); for (regi = gdbarch_fp0_regnum (gdbarch);
regi < gdbarch_fp0_regnum (current_gdbarch) + 32; regi++) regi < gdbarch_fp0_regnum (gdbarch) + 32; regi++)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - gdbarch_fp0_regnum to = (char *) &(fpregsetp->fp_r.fp_regs[regi - gdbarch_fp0_regnum
(current_gdbarch)]); (gdbarch)]);
regcache_raw_collect (regcache, regi, to); regcache_raw_collect (regcache, regi, to);
} }
} }
if (regno == -1 if (regno == -1
|| regno == mips_regnum (current_gdbarch)->fp_control_status) || regno == mips_regnum (gdbarch)->fp_control_status)
{ {
char fsrbuf[8]; char fsrbuf[8];
@ -195,8 +198,7 @@ fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno
So we use a buffer of the correct size and copy the register So we use a buffer of the correct size and copy the register
value from that buffer. */ value from that buffer. */
regcache_raw_collect (regcache, regcache_raw_collect (regcache,
mips_regnum (current_gdbarch)->fp_control_status, mips_regnum (gdbarch)->fp_control_status, fsrbuf);
fsrbuf);
memcpy (&fpregsetp->fp_csr, fsrbuf + 4, 4); memcpy (&fpregsetp->fp_csr, fsrbuf + 4, 4);
} }
@ -222,18 +224,19 @@ fetch_core_registers (struct regcache *regcache,
int which, CORE_ADDR reg_addr) int which, CORE_ADDR reg_addr)
{ {
char *srcp = core_reg_sect; 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; int regno;
/* If regsize is 8, this is a N32 or N64 core file. /* If regsize is 8, this is a N32 or N64 core file.
If regsize is 4, this is an O32 core file. */ If regsize is 4, this is an O32 core file. */
if (core_reg_size != regsize * gdbarch_num_regs (current_gdbarch)) if (core_reg_size != regsize * gdbarch_num_regs (gdbarch))
{ {
warning (_("wrong size gregset struct in core file")); warning (_("wrong size gregset struct in core file"));
return; return;
} }
for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++) for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
{ {
regcache_raw_supply (regcache, regno, srcp); regcache_raw_supply (regcache, regno, srcp);
srcp += regsize; srcp += regsize;