espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-10-19 05:42:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* remote-mips.c (mips_wait, mips_fetch_registers)
	(mips_store_registers): Use get_regcache_arch to get at the
	current architecture by regcache.

	* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg)
	(mipsnbsd_supply_fpreg, mipsnbsd_fill_fpreg): Use get_regcache_arch to
	get at the current architecture by regcache.
	(mipsnbsd_sigtramp_offset): Use get_frame_arch to get at the current
	architecture by frame_info.

	* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
	(mipsnbsd_store_inferior_registers): Use get_regcache_arch to get at
	the current architecture by regcache.

	* mips-linux-tdep.c (mips_linux_get_longjmp_target)
	(mips64_linux_get_longjmp_target, mips_linux_o32_sigframe_init)
	(mips_linux_n32n64_sigframe_init): Use get_frame_arch to get at the
	current architecture by frame_info.
	(supply_32bit_reg, mips_supply_gregset, mips_fill_gregset)
	(mips_supply_fpregset, mips_fill_fpregset, supply_64bit_reg)
	(mips64_supply_gregset, mips64_fill_gregset, mips64_supply_fpregset)
	(mips64_fill_fpregset, mips_linux_write_pc): Use get_regcache_arch to
	get at the current architecture by regcache.

	* mips-linux-nat.c (mips_linux_register_addr)
	(mips64_linux_register_addr): Replace current_gdbarch by gdbarch.
	(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset)
	(mips64_linux_regsets_fetch_registers)
	(mips64_linux_regsets_store_registers): Use get_regcache_arch to get at
	the current architecture by regcache.

	* mips64obsd-tdep.c (mips64obsd_sigframe_init): Use get_frame_arch to
	get at the current architecture by frame_info.
This commit is contained in:
Ulrich Weigand
2007-10-10 17:04:38 +00:00
parent 72a155b44d
commit 2eb4d78bfd
7 changed files with 214 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
gdb/ChangeLog
View File

@ -1,3 +1,39 @@
2007-10-10 Markus Deuling <deuling@de.ibm.com>
* remote-mips.c (mips_wait, mips_fetch_registers)
(mips_store_registers): Use get_regcache_arch to get at the
current architecture by regcache.
* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg)
(mipsnbsd_supply_fpreg, mipsnbsd_fill_fpreg): Use get_regcache_arch to
get at the current architecture by regcache.
(mipsnbsd_sigtramp_offset): Use get_frame_arch to get at the current
architecture by frame_info.
* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
(mipsnbsd_store_inferior_registers): Use get_regcache_arch to get at
the current architecture by regcache.
* mips-linux-tdep.c (mips_linux_get_longjmp_target)
(mips64_linux_get_longjmp_target, mips_linux_o32_sigframe_init)
(mips_linux_n32n64_sigframe_init): Use get_frame_arch to get at the
current architecture by frame_info.
(supply_32bit_reg, mips_supply_gregset, mips_fill_gregset)
(mips_supply_fpregset, mips_fill_fpregset, supply_64bit_reg)
(mips64_supply_gregset, mips64_fill_gregset, mips64_supply_fpregset)
(mips64_fill_fpregset, mips_linux_write_pc): Use get_regcache_arch to
get at the current architecture by regcache.
* mips-linux-nat.c (mips_linux_register_addr)
(mips64_linux_register_addr): Replace current_gdbarch by gdbarch.
(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset)
(mips64_linux_regsets_fetch_registers)
(mips64_linux_regsets_store_registers): Use get_regcache_arch to get at
the current architecture by regcache.
* mips64obsd-tdep.c (mips64obsd_sigframe_init): Use get_frame_arch to
get at the current architecture by frame_info.
2007-10-10 Markus Deuling <deuling@de.ibm.com> 2007-10-10 Markus Deuling <deuling@de.ibm.com>
* mips-tdep.c (mips_xfer_register): Use get_regcache_arch to get at the * mips-tdep.c (mips_xfer_register): Use get_regcache_arch to get at the

32
gdb/mips-linux-nat.c
View File

@ -60,7 +60,7 @@ mips_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
{ {
CORE_ADDR regaddr; CORE_ADDR regaddr;
if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch)) if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
error (_("Bogon register number %d."), regno); error (_("Bogon register number %d."), regno);
if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32) if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
@ -95,14 +95,14 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
{ {
CORE_ADDR regaddr; CORE_ADDR regaddr;
if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch)) if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
error (_("Bogon register number %d."), regno); error (_("Bogon register number %d."), regno);
if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32) if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
regaddr = regno; regaddr = regno;
else if ((regno >= mips_regnum (gdbarch)->fp0) else if ((regno >= mips_regnum (gdbarch)->fp0)
&& (regno < mips_regnum (gdbarch)->fp0 + 32)) && (regno < mips_regnum (gdbarch)->fp0 + 32))
regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (current_gdbarch)); regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (gdbarch));
else if (regno == mips_regnum (gdbarch)->pc) else if (regno == mips_regnum (gdbarch)->pc)
regaddr = MIPS64_PC; regaddr = MIPS64_PC;
else if (regno == mips_regnum (gdbarch)->cause) else if (regno == mips_regnum (gdbarch)->cause)
@ -147,7 +147,7 @@ ps_get_thread_area (const struct ps_prochandle *ph,
void void
supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{ {
if (mips_isa_regsize (current_gdbarch) == 4) if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp); mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp);
else else
mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp); mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp);
@ -157,7 +157,7 @@ void
fill_gregset (const struct regcache *regcache, fill_gregset (const struct regcache *regcache,
gdb_gregset_t *gregsetp, int regno) gdb_gregset_t *gregsetp, int regno)
{ {
if (mips_isa_regsize (current_gdbarch) == 4) if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno); mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno);
else else
mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno); mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno);
@ -166,7 +166,7 @@ fill_gregset (const struct regcache *regcache,
void void
supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp) supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{ {
if (mips_isa_regsize (current_gdbarch) == 4) if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp); mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp);
else else
mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *) fpregsetp); mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *) fpregsetp);
@ -176,7 +176,7 @@ void
fill_fpregset (const struct regcache *regcache, fill_fpregset (const struct regcache *regcache,
gdb_fpregset_t *fpregsetp, int regno) gdb_fpregset_t *fpregsetp, int regno)
{ {
if (mips_isa_regsize (current_gdbarch) == 4) if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno); mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno);
else else
mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *) fpregsetp, regno); mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *) fpregsetp, regno);
@ -189,15 +189,16 @@ fill_fpregset (const struct regcache *regcache,
static void static void
mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno) mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int is_fp; int is_fp;
int tid; int tid;
if (regno >= mips_regnum (current_gdbarch)->fp0 if (regno >= mips_regnum (gdbarch)->fp0
&& regno <= mips_regnum (current_gdbarch)->fp0 + 32) && regno <= mips_regnum (gdbarch)->fp0 + 32)
is_fp = 1; is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_control_status) else if (regno == mips_regnum (gdbarch)->fp_control_status)
is_fp = 1; is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision) else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
is_fp = 1; is_fp = 1;
else else
is_fp = 0; is_fp = 0;
@ -250,15 +251,16 @@ mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
static void static void
mips64_linux_regsets_store_registers (const struct regcache *regcache, int regno) mips64_linux_regsets_store_registers (const struct regcache *regcache, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int is_fp; int is_fp;
int tid; int tid;
if (regno >= mips_regnum (current_gdbarch)->fp0 if (regno >= mips_regnum (gdbarch)->fp0
&& regno <= mips_regnum (current_gdbarch)->fp0 + 32) && regno <= mips_regnum (gdbarch)->fp0 + 32)
is_fp = 1; is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_control_status) else if (regno == mips_regnum (gdbarch)->fp_control_status)
is_fp = 1; is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision) else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
is_fp = 1; is_fp = 1;
else else
is_fp = 0; is_fp = 0;

238
gdb/mips-linux-tdep.c
View File

@ -53,19 +53,18 @@ static int
mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{ {
CORE_ADDR jb_addr; CORE_ADDR jb_addr;
char buf[gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT]; struct gdbarch *gdbarch = get_frame_arch (frame);
char buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM); jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr if (target_read_memory (jb_addr
+ MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE, + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
buf, buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
return 0; return 0;
*pc = extract_unsigned_integer (buf, *pc = extract_unsigned_integer (buf,
gdbarch_ptr_bit (current_gdbarch) gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
/ TARGET_CHAR_BIT);
return 1; return 1;
} }
@ -78,7 +77,8 @@ static void
supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr) supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr)
{ {
gdb_byte buf[MAX_REGISTER_SIZE]; gdb_byte buf[MAX_REGISTER_SIZE];
store_signed_integer (buf, register_size (current_gdbarch, regnum), store_signed_integer (buf,
register_size (get_regcache_arch (regcache), regnum),
extract_signed_integer (addr, 4)); extract_signed_integer (addr, 4));
regcache_raw_supply (regcache, regnum, buf); regcache_raw_supply (regcache, regnum, buf);
} }
@ -92,26 +92,25 @@ mips_supply_gregset (struct regcache *regcache,
int regi; int regi;
const mips_elf_greg_t *regp = *gregsetp; const mips_elf_greg_t *regp = *gregsetp;
char zerobuf[MAX_REGISTER_SIZE]; char zerobuf[MAX_REGISTER_SIZE];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
memset (zerobuf, 0, MAX_REGISTER_SIZE); memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = EF_REG0 + 1; regi <= EF_REG31; regi++) for (regi = EF_REG0 + 1; regi <= EF_REG31; regi++)
supply_32bit_reg (regcache, regi - EF_REG0, regp + regi); supply_32bit_reg (regcache, regi - EF_REG0, regp + regi);
if (mips_linux_restart_reg_p (current_gdbarch)) if (mips_linux_restart_reg_p (gdbarch))
supply_32bit_reg (regcache, MIPS_RESTART_REGNUM, regp + EF_REG0); supply_32bit_reg (regcache, MIPS_RESTART_REGNUM, regp + EF_REG0);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->lo, supply_32bit_reg (regcache, mips_regnum (gdbarch)->lo, regp + EF_LO);
regp + EF_LO); supply_32bit_reg (regcache, mips_regnum (gdbarch)->hi, regp + EF_HI);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->hi,
regp + EF_HI);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->pc, supply_32bit_reg (regcache, mips_regnum (gdbarch)->pc,
regp + EF_CP0_EPC); regp + EF_CP0_EPC);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->badvaddr, supply_32bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
regp + EF_CP0_BADVADDR); regp + EF_CP0_BADVADDR);
supply_32bit_reg (regcache, MIPS_PS_REGNUM, regp + EF_CP0_STATUS); supply_32bit_reg (regcache, MIPS_PS_REGNUM, regp + EF_CP0_STATUS);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->cause, supply_32bit_reg (regcache, mips_regnum (gdbarch)->cause,
regp + EF_CP0_CAUSE); regp + EF_CP0_CAUSE);
/* Fill inaccessible registers with zero. */ /* Fill inaccessible registers with zero. */
@ -129,6 +128,7 @@ void
mips_fill_gregset (const struct regcache *regcache, mips_fill_gregset (const struct regcache *regcache,
mips_elf_gregset_t *gregsetp, int regno) mips_elf_gregset_t *gregsetp, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regaddr, regi; int regaddr, regi;
mips_elf_greg_t *regp = *gregsetp; mips_elf_greg_t *regp = *gregsetp;
void *dst; void *dst;
@ -138,17 +138,12 @@ mips_fill_gregset (const struct regcache *regcache,
memset (regp, 0, sizeof (mips_elf_gregset_t)); memset (regp, 0, sizeof (mips_elf_gregset_t));
for (regi = 1; regi < 32; regi++) for (regi = 1; regi < 32; regi++)
mips_fill_gregset (regcache, gregsetp, regi); mips_fill_gregset (regcache, gregsetp, regi);
mips_fill_gregset (regcache, gregsetp, mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
mips_regnum (current_gdbarch)->lo); mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
mips_fill_gregset (regcache, gregsetp, mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
mips_regnum (current_gdbarch)->hi); mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->pc);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->badvaddr);
mips_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM); mips_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
mips_fill_gregset (regcache, gregsetp, mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
mips_regnum (current_gdbarch)->cause);
mips_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM); mips_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
return; return;
} }
@ -160,19 +155,19 @@ mips_fill_gregset (const struct regcache *regcache,
return; return;
} }
if (regno == mips_regnum (current_gdbarch)->lo) if (regno == mips_regnum (gdbarch)->lo)
regaddr = EF_LO; regaddr = EF_LO;
else if (regno == mips_regnum (current_gdbarch)->hi) else if (regno == mips_regnum (gdbarch)->hi)
regaddr = EF_HI; regaddr = EF_HI;
else if (regno == mips_regnum (current_gdbarch)->pc) else if (regno == mips_regnum (gdbarch)->pc)
regaddr = EF_CP0_EPC; regaddr = EF_CP0_EPC;
else if (regno == mips_regnum (current_gdbarch)->badvaddr) else if (regno == mips_regnum (gdbarch)->badvaddr)
regaddr = EF_CP0_BADVADDR; regaddr = EF_CP0_BADVADDR;
else if (regno == MIPS_PS_REGNUM) else if (regno == MIPS_PS_REGNUM)
regaddr = EF_CP0_STATUS; regaddr = EF_CP0_STATUS;
else if (regno == mips_regnum (current_gdbarch)->cause) else if (regno == mips_regnum (gdbarch)->cause)
regaddr = EF_CP0_CAUSE; regaddr = EF_CP0_CAUSE;
else if (mips_linux_restart_reg_p (current_gdbarch) else if (mips_linux_restart_reg_p (gdbarch)
&& regno == MIPS_RESTART_REGNUM) && regno == MIPS_RESTART_REGNUM)
regaddr = EF_REG0; regaddr = EF_REG0;
else else
@ -191,6 +186,7 @@ void
mips_supply_fpregset (struct regcache *regcache, mips_supply_fpregset (struct regcache *regcache,
const mips_elf_fpregset_t *fpregsetp) const mips_elf_fpregset_t *fpregsetp)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regi; int regi;
char zerobuf[MAX_REGISTER_SIZE]; char zerobuf[MAX_REGISTER_SIZE];
@ -198,16 +194,16 @@ mips_supply_fpregset (struct regcache *regcache,
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi, gdbarch_fp0_regnum (gdbarch) + regi,
*fpregsetp + regi); *fpregsetp + regi);
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_control_status, mips_regnum (gdbarch)->fp_control_status,
*fpregsetp + 32); *fpregsetp + 32);
/* FIXME: how can we supply FCRIR? The ABI doesn't tell us. */ /* FIXME: how can we supply FCRIR? The ABI 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);
} }
@ -218,15 +214,16 @@ void
mips_fill_fpregset (const struct regcache *regcache, mips_fill_fpregset (const struct regcache *regcache,
mips_elf_fpregset_t *fpregsetp, int regno) mips_elf_fpregset_t *fpregsetp, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
char *from, *to; char *from, *to;
if ((regno >= gdbarch_fp0_regnum (current_gdbarch)) if ((regno >= gdbarch_fp0_regnum (gdbarch))
&& (regno < gdbarch_fp0_regnum (current_gdbarch) + 32)) && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
{ {
to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (current_gdbarch)); to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
regcache_raw_collect (regcache, regno, to); regcache_raw_collect (regcache, regno, to);
} }
else if (regno == mips_regnum (current_gdbarch)->fp_control_status) else if (regno == mips_regnum (gdbarch)->fp_control_status)
{ {
to = (char *) (*fpregsetp + 32); to = (char *) (*fpregsetp + 32);
regcache_raw_collect (regcache, regno, to); regcache_raw_collect (regcache, regno, to);
@ -237,9 +234,9 @@ mips_fill_fpregset (const struct regcache *regcache,
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
mips_fill_fpregset (regcache, fpregsetp, mips_fill_fpregset (regcache, fpregsetp,
gdbarch_fp0_regnum (current_gdbarch) + regi); gdbarch_fp0_regnum (gdbarch) + regi);
mips_fill_fpregset (regcache, fpregsetp, mips_fill_fpregset (regcache, fpregsetp,
mips_regnum (current_gdbarch)->fp_control_status); mips_regnum (gdbarch)->fp_control_status);
} }
} }
@ -259,19 +256,19 @@ static int
mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{ {
CORE_ADDR jb_addr; CORE_ADDR jb_addr;
void *buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT); struct gdbarch *gdbarch = get_frame_arch (frame);
int element_size = gdbarch_ptr_bit (current_gdbarch) == 32 ? 4 : 8; void *buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
int element_size = gdbarch_ptr_bit (gdbarch) == 32 ? 4 : 8;
jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM); jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size, if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
buf, buf,
gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT)) gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
return 0; return 0;
*pc = extract_unsigned_integer (buf, *pc = extract_unsigned_integer (buf,
gdbarch_ptr_bit (current_gdbarch) gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
/ TARGET_CHAR_BIT);
return 1; return 1;
} }
@ -286,8 +283,9 @@ void
supply_64bit_reg (struct regcache *regcache, int regnum, supply_64bit_reg (struct regcache *regcache, int regnum,
const gdb_byte *buf) const gdb_byte *buf)
{ {
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG struct gdbarch *gdbarch = get_regcache_arch (regcache);
&& register_size (current_gdbarch, regnum) == 4) if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
&& register_size (gdbarch, regnum) == 4)
regcache_raw_supply (regcache, regnum, buf + 4); regcache_raw_supply (regcache, regnum, buf + 4);
else else
regcache_raw_supply (regcache, regnum, buf); regcache_raw_supply (regcache, regnum, buf);
@ -302,6 +300,7 @@ mips64_supply_gregset (struct regcache *regcache,
int regi; int regi;
const mips64_elf_greg_t *regp = *gregsetp; const mips64_elf_greg_t *regp = *gregsetp;
gdb_byte zerobuf[MAX_REGISTER_SIZE]; gdb_byte zerobuf[MAX_REGISTER_SIZE];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
memset (zerobuf, 0, MAX_REGISTER_SIZE); memset (zerobuf, 0, MAX_REGISTER_SIZE);
@ -309,22 +308,22 @@ mips64_supply_gregset (struct regcache *regcache,
supply_64bit_reg (regcache, regi - MIPS64_EF_REG0, supply_64bit_reg (regcache, regi - MIPS64_EF_REG0,
(const gdb_byte *)(regp + regi)); (const gdb_byte *)(regp + regi));
if (mips_linux_restart_reg_p (current_gdbarch)) if (mips_linux_restart_reg_p (gdbarch))
supply_64bit_reg (regcache, MIPS_RESTART_REGNUM, supply_64bit_reg (regcache, MIPS_RESTART_REGNUM,
(const gdb_byte *)(regp + MIPS64_EF_REG0)); (const gdb_byte *)(regp + MIPS64_EF_REG0));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->lo, supply_64bit_reg (regcache, mips_regnum (gdbarch)->lo,
(const gdb_byte *) (regp + MIPS64_EF_LO)); (const gdb_byte *) (regp + MIPS64_EF_LO));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->hi, supply_64bit_reg (regcache, mips_regnum (gdbarch)->hi,
(const gdb_byte *) (regp + MIPS64_EF_HI)); (const gdb_byte *) (regp + MIPS64_EF_HI));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->pc, supply_64bit_reg (regcache, mips_regnum (gdbarch)->pc,
(const gdb_byte *) (regp + MIPS64_EF_CP0_EPC)); (const gdb_byte *) (regp + MIPS64_EF_CP0_EPC));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->badvaddr, supply_64bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
(const gdb_byte *) (regp + MIPS64_EF_CP0_BADVADDR)); (const gdb_byte *) (regp + MIPS64_EF_CP0_BADVADDR));
supply_64bit_reg (regcache, MIPS_PS_REGNUM, supply_64bit_reg (regcache, MIPS_PS_REGNUM,
(const gdb_byte *) (regp + MIPS64_EF_CP0_STATUS)); (const gdb_byte *) (regp + MIPS64_EF_CP0_STATUS));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->cause, supply_64bit_reg (regcache, mips_regnum (gdbarch)->cause,
(const gdb_byte *) (regp + MIPS64_EF_CP0_CAUSE)); (const gdb_byte *) (regp + MIPS64_EF_CP0_CAUSE));
/* Fill inaccessible registers with zero. */ /* Fill inaccessible registers with zero. */
@ -342,6 +341,7 @@ void
mips64_fill_gregset (const struct regcache *regcache, mips64_fill_gregset (const struct regcache *regcache,
mips64_elf_gregset_t *gregsetp, int regno) mips64_elf_gregset_t *gregsetp, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regaddr, regi; int regaddr, regi;
mips64_elf_greg_t *regp = *gregsetp; mips64_elf_greg_t *regp = *gregsetp;
void *src, *dst; void *src, *dst;
@ -351,36 +351,31 @@ mips64_fill_gregset (const struct regcache *regcache,
memset (regp, 0, sizeof (mips64_elf_gregset_t)); memset (regp, 0, sizeof (mips64_elf_gregset_t));
for (regi = 1; regi < 32; regi++) for (regi = 1; regi < 32; regi++)
mips64_fill_gregset (regcache, gregsetp, regi); mips64_fill_gregset (regcache, gregsetp, regi);
mips64_fill_gregset (regcache, gregsetp, mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
mips_regnum (current_gdbarch)->lo); mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
mips64_fill_gregset (regcache, gregsetp, mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
mips_regnum (current_gdbarch)->hi); mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->pc);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->badvaddr);
mips64_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM); mips64_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
mips64_fill_gregset (regcache, gregsetp, mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
mips_regnum (current_gdbarch)->cause);
mips64_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM); mips64_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
return; return;
} }
if (regno > 0 && regno < 32) if (regno > 0 && regno < 32)
regaddr = regno + MIPS64_EF_REG0; regaddr = regno + MIPS64_EF_REG0;
else if (regno == mips_regnum (current_gdbarch)->lo) else if (regno == mips_regnum (gdbarch)->lo)
regaddr = MIPS64_EF_LO; regaddr = MIPS64_EF_LO;
else if (regno == mips_regnum (current_gdbarch)->hi) else if (regno == mips_regnum (gdbarch)->hi)
regaddr = MIPS64_EF_HI; regaddr = MIPS64_EF_HI;
else if (regno == mips_regnum (current_gdbarch)->pc) else if (regno == mips_regnum (gdbarch)->pc)
regaddr = MIPS64_EF_CP0_EPC; regaddr = MIPS64_EF_CP0_EPC;
else if (regno == mips_regnum (current_gdbarch)->badvaddr) else if (regno == mips_regnum (gdbarch)->badvaddr)
regaddr = MIPS64_EF_CP0_BADVADDR; regaddr = MIPS64_EF_CP0_BADVADDR;
else if (regno == MIPS_PS_REGNUM) else if (regno == MIPS_PS_REGNUM)
regaddr = MIPS64_EF_CP0_STATUS; regaddr = MIPS64_EF_CP0_STATUS;
else if (regno == mips_regnum (current_gdbarch)->cause) else if (regno == mips_regnum (gdbarch)->cause)
regaddr = MIPS64_EF_CP0_CAUSE; regaddr = MIPS64_EF_CP0_CAUSE;
else if (mips_linux_restart_reg_p (current_gdbarch) else if (mips_linux_restart_reg_p (gdbarch)
&& regno == MIPS_RESTART_REGNUM) && regno == MIPS_RESTART_REGNUM)
regaddr = MIPS64_EF_REG0; regaddr = MIPS64_EF_REG0;
else else
@ -392,8 +387,7 @@ mips64_fill_gregset (const struct regcache *regcache,
LONGEST val; LONGEST val;
regcache_raw_collect (regcache, regno, buf); regcache_raw_collect (regcache, regno, buf);
val = extract_signed_integer (buf, val = extract_signed_integer (buf, register_size (gdbarch, regno));
register_size (current_gdbarch, regno));
dst = regp + regaddr; dst = regp + regaddr;
store_signed_integer (dst, 8, val); store_signed_integer (dst, 8, val);
} }
@ -405,36 +399,35 @@ void
mips64_supply_fpregset (struct regcache *regcache, mips64_supply_fpregset (struct regcache *regcache,
const mips64_elf_fpregset_t *fpregsetp) const mips64_elf_fpregset_t *fpregsetp)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regi; int regi;
/* See mips_linux_o32_sigframe_init for a description of the /* See mips_linux_o32_sigframe_init for a description of the
peculiar FP register layout. */ peculiar FP register layout. */
if (register_size (current_gdbarch, if (register_size (gdbarch, gdbarch_fp0_regnum (gdbarch)) == 4)
gdbarch_fp0_regnum (current_gdbarch)) == 4)
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
{ {
const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1)); const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1));
if ((gdbarch_byte_order (current_gdbarch) if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
== BFD_ENDIAN_BIG) != (regi & 1))
reg_ptr += 4; reg_ptr += 4;
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi, gdbarch_fp0_regnum (gdbarch) + regi,
reg_ptr); reg_ptr);
} }
else else
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi, gdbarch_fp0_regnum (gdbarch) + regi,
(const char *)(*fpregsetp + regi)); (const char *)(*fpregsetp + regi));
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->fp_control_status, supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status,
(const gdb_byte *)(*fpregsetp + 32)); (const gdb_byte *)(*fpregsetp + 32));
/* The ABI doesn't tell us how to supply FCRIR, and core dumps don't /* The ABI doesn't tell us how to supply FCRIR, and core dumps don't
include it - but the result of PTRACE_GETFPREGS does. The best we include it - but the result of PTRACE_GETFPREGS does. The best we
can do is to assume that its value is present. */ can do is to assume that its value is present. */
supply_32bit_reg (regcache, supply_32bit_reg (regcache,
mips_regnum (current_gdbarch)->fp_implementation_revision, mips_regnum (gdbarch)->fp_implementation_revision,
(const gdb_byte *)(*fpregsetp + 32) + 4); (const gdb_byte *)(*fpregsetp + 32) + 4);
} }
@ -445,49 +438,46 @@ void
mips64_fill_fpregset (const struct regcache *regcache, mips64_fill_fpregset (const struct regcache *regcache,
mips64_elf_fpregset_t *fpregsetp, int regno) mips64_elf_fpregset_t *fpregsetp, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
gdb_byte *to; gdb_byte *to;
if ((regno >= gdbarch_fp0_regnum (current_gdbarch)) if ((regno >= gdbarch_fp0_regnum (gdbarch))
&& (regno < gdbarch_fp0_regnum (current_gdbarch) + 32)) && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
{ {
/* See mips_linux_o32_sigframe_init for a description of the /* See mips_linux_o32_sigframe_init for a description of the
peculiar FP register layout. */ peculiar FP register layout. */
if (register_size (current_gdbarch, regno) == 4) if (register_size (gdbarch, regno) == 4)
{ {
int regi = regno - gdbarch_fp0_regnum (current_gdbarch); int regi = regno - gdbarch_fp0_regnum (gdbarch);
to = (gdb_byte *) (*fpregsetp + (regi & ~1)); to = (gdb_byte *) (*fpregsetp + (regi & ~1));
if ((gdbarch_byte_order (current_gdbarch) if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
== BFD_ENDIAN_BIG) != (regi & 1))
to += 4; to += 4;
regcache_raw_collect (regcache, regno, to); regcache_raw_collect (regcache, regno, to);
} }
else else
{ {
to = (gdb_byte *) (*fpregsetp + regno to = (gdb_byte *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
- gdbarch_fp0_regnum (current_gdbarch));
regcache_raw_collect (regcache, regno, to); regcache_raw_collect (regcache, regno, to);
} }
} }
else if (regno == mips_regnum (current_gdbarch)->fp_control_status) else if (regno == mips_regnum (gdbarch)->fp_control_status)
{ {
gdb_byte buf[MAX_REGISTER_SIZE]; gdb_byte buf[MAX_REGISTER_SIZE];
LONGEST val; LONGEST val;
regcache_raw_collect (regcache, regno, buf); regcache_raw_collect (regcache, regno, buf);
val = extract_signed_integer (buf, val = extract_signed_integer (buf, register_size (gdbarch, regno));
register_size (current_gdbarch, regno));
to = (gdb_byte *) (*fpregsetp + 32); to = (gdb_byte *) (*fpregsetp + 32);
store_signed_integer (to, 4, val); store_signed_integer (to, 4, val);
} }
else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision) else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
{ {
gdb_byte buf[MAX_REGISTER_SIZE]; gdb_byte buf[MAX_REGISTER_SIZE];
LONGEST val; LONGEST val;
regcache_raw_collect (regcache, regno, buf); regcache_raw_collect (regcache, regno, buf);
val = extract_signed_integer (buf, val = extract_signed_integer (buf, register_size (gdbarch, regno));
register_size (current_gdbarch, regno));
to = (gdb_byte *) (*fpregsetp + 32) + 4; to = (gdb_byte *) (*fpregsetp + 32) + 4;
store_signed_integer (to, 4, val); store_signed_integer (to, 4, val);
} }
@ -497,11 +487,11 @@ mips64_fill_fpregset (const struct regcache *regcache,
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
mips64_fill_fpregset (regcache, fpregsetp, mips64_fill_fpregset (regcache, fpregsetp,
gdbarch_fp0_regnum (current_gdbarch) + regi); gdbarch_fp0_regnum (gdbarch) + regi);
mips64_fill_fpregset (regcache, fpregsetp, mips64_fill_fpregset (regcache, fpregsetp,
mips_regnum (current_gdbarch)->fp_control_status); mips_regnum (gdbarch)->fp_control_status);
mips64_fill_fpregset (regcache, fpregsetp, mips64_fill_fpregset (regcache, fpregsetp,
(mips_regnum (current_gdbarch) (mips_regnum (gdbarch)
->fp_implementation_revision)); ->fp_implementation_revision));
} }
} }
@ -867,9 +857,10 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
struct trad_frame_cache *this_cache, struct trad_frame_cache *this_cache,
CORE_ADDR func) CORE_ADDR func)
{ {
struct gdbarch *gdbarch = get_frame_arch (next_frame);
int ireg, reg_position; int ireg, reg_position;
CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET; CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
const struct mips_regnum *regs = mips_regnum (current_gdbarch); const struct mips_regnum *regs = mips_regnum (gdbarch);
CORE_ADDR regs_base; CORE_ADDR regs_base;
if (self == &mips_linux_o32_sigframe) if (self == &mips_linux_o32_sigframe)
@ -882,21 +873,21 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
per-frame basis, but right now we don't; the kernel saves eight per-frame basis, but right now we don't; the kernel saves eight
bytes but we only want four. Use regs_base to access any bytes but we only want four. Use regs_base to access any
64-bit fields. */ 64-bit fields. */
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
regs_base = sigcontext_base + 4; regs_base = sigcontext_base + 4;
else else
regs_base = sigcontext_base; regs_base = sigcontext_base;
if (mips_linux_restart_reg_p (current_gdbarch)) if (mips_linux_restart_reg_p (gdbarch))
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
(MIPS_RESTART_REGNUM (MIPS_RESTART_REGNUM
+ gdbarch_num_regs (current_gdbarch)), + gdbarch_num_regs (gdbarch)),
regs_base + SIGCONTEXT_REGS); regs_base + SIGCONTEXT_REGS);
for (ireg = 1; ireg < 32; ireg++) for (ireg = 1; ireg < 32; ireg++)
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
ireg + MIPS_ZERO_REGNUM ireg + MIPS_ZERO_REGNUM
+ gdbarch_num_regs (current_gdbarch), + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_REGS regs_base + SIGCONTEXT_REGS
+ ireg * SIGCONTEXT_REG_SIZE); + ireg * SIGCONTEXT_REG_SIZE);
@ -909,38 +900,38 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
layout, since we can't tell, and it's much more common. Which bits are layout, since we can't tell, and it's much more common. Which bits are
the "high" bits depends on endianness. */ the "high" bits depends on endianness. */
for (ireg = 0; ireg < 32; ireg++) for (ireg = 0; ireg < 32; ireg++)
if ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1)) if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
ireg + regs->fp0 + ireg + regs->fp0 +
gdbarch_num_regs (current_gdbarch), gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_FPREGS + 4 sigcontext_base + SIGCONTEXT_FPREGS + 4
+ (ireg & ~1) * SIGCONTEXT_REG_SIZE); + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
else else
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
ireg + regs->fp0 ireg + regs->fp0
+ gdbarch_num_regs (current_gdbarch), + gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_FPREGS sigcontext_base + SIGCONTEXT_FPREGS
+ (ireg & ~1) * SIGCONTEXT_REG_SIZE); + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->pc + gdbarch_num_regs (current_gdbarch), regs->pc + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_PC); regs_base + SIGCONTEXT_PC);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->fp_control_status regs->fp_control_status
+ gdbarch_num_regs (current_gdbarch), + gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_FPCSR); sigcontext_base + SIGCONTEXT_FPCSR);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->hi + gdbarch_num_regs (current_gdbarch), regs->hi + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_HI); regs_base + SIGCONTEXT_HI);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->lo + gdbarch_num_regs (current_gdbarch), regs->lo + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_LO); regs_base + SIGCONTEXT_LO);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->cause + gdbarch_num_regs (current_gdbarch), regs->cause + gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_CAUSE); sigcontext_base + SIGCONTEXT_CAUSE);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->badvaddr + gdbarch_num_regs (current_gdbarch), regs->badvaddr + gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_BADVADDR); sigcontext_base + SIGCONTEXT_BADVADDR);
/* Choice of the bottom of the sigframe is somewhat arbitrary. */ /* Choice of the bottom of the sigframe is somewhat arbitrary. */
@ -1028,54 +1019,55 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
struct trad_frame_cache *this_cache, struct trad_frame_cache *this_cache,
CORE_ADDR func) CORE_ADDR func)
{ {
struct gdbarch *gdbarch = get_frame_arch (next_frame);
int ireg, reg_position; int ireg, reg_position;
CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET; CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
const struct mips_regnum *regs = mips_regnum (current_gdbarch); const struct mips_regnum *regs = mips_regnum (gdbarch);
if (self == &mips_linux_n32_rt_sigframe) if (self == &mips_linux_n32_rt_sigframe)
sigcontext_base += N32_SIGFRAME_SIGCONTEXT_OFFSET; sigcontext_base += N32_SIGFRAME_SIGCONTEXT_OFFSET;
else else
sigcontext_base += N64_SIGFRAME_SIGCONTEXT_OFFSET; sigcontext_base += N64_SIGFRAME_SIGCONTEXT_OFFSET;
if (mips_linux_restart_reg_p (current_gdbarch)) if (mips_linux_restart_reg_p (gdbarch))
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
(MIPS_RESTART_REGNUM (MIPS_RESTART_REGNUM
+ gdbarch_num_regs (current_gdbarch)), + gdbarch_num_regs (gdbarch)),
sigcontext_base + N64_SIGCONTEXT_REGS); sigcontext_base + N64_SIGCONTEXT_REGS);
for (ireg = 1; ireg < 32; ireg++) for (ireg = 1; ireg < 32; ireg++)
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
ireg + MIPS_ZERO_REGNUM ireg + MIPS_ZERO_REGNUM
+ gdbarch_num_regs (current_gdbarch), + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_REGS sigcontext_base + N64_SIGCONTEXT_REGS
+ ireg * N64_SIGCONTEXT_REG_SIZE); + ireg * N64_SIGCONTEXT_REG_SIZE);
for (ireg = 0; ireg < 32; ireg++) for (ireg = 0; ireg < 32; ireg++)
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
ireg + regs->fp0 ireg + regs->fp0
+ gdbarch_num_regs (current_gdbarch), + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_FPREGS sigcontext_base + N64_SIGCONTEXT_FPREGS
+ ireg * N64_SIGCONTEXT_REG_SIZE); + ireg * N64_SIGCONTEXT_REG_SIZE);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->pc + gdbarch_num_regs (current_gdbarch), regs->pc + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_PC); sigcontext_base + N64_SIGCONTEXT_PC);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->fp_control_status regs->fp_control_status
+ gdbarch_num_regs (current_gdbarch), + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_FPCSR); sigcontext_base + N64_SIGCONTEXT_FPCSR);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->hi + gdbarch_num_regs (current_gdbarch), regs->hi + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_HI); sigcontext_base + N64_SIGCONTEXT_HI);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->lo + gdbarch_num_regs (current_gdbarch), regs->lo + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_LO); sigcontext_base + N64_SIGCONTEXT_LO);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->cause + gdbarch_num_regs (current_gdbarch), regs->cause + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_CAUSE); sigcontext_base + N64_SIGCONTEXT_CAUSE);
trad_frame_set_reg_addr (this_cache, trad_frame_set_reg_addr (this_cache,
regs->badvaddr + gdbarch_num_regs (current_gdbarch), regs->badvaddr + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_BADVADDR); sigcontext_base + N64_SIGCONTEXT_BADVADDR);
/* Choice of the bottom of the sigframe is somewhat arbitrary. */ /* Choice of the bottom of the sigframe is somewhat arbitrary. */
@ -1087,11 +1079,11 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
static void static void
mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{ {
regcache_cooked_write_unsigned (regcache, struct gdbarch *gdbarch = get_regcache_arch (regcache);
gdbarch_pc_regnum (current_gdbarch), pc); regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc);
/* Clear the syscall restart flag. */ /* Clear the syscall restart flag. */
if (mips_linux_restart_reg_p (current_gdbarch)) if (mips_linux_restart_reg_p (gdbarch))
regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0); regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0);
} }

10
gdb/mips64obsd-tdep.c
View File

@ -91,30 +91,30 @@ mips64obsd_sigframe_init (const struct tramp_frame *self,
fixed offset in the signal frame. */ fixed offset in the signal frame. */
sp = frame_unwind_register_signed (next_frame, sp = frame_unwind_register_signed (next_frame,
MIPS_SP_REGNUM MIPS_SP_REGNUM
+ gdbarch_num_regs (current_gdbarch)); + gdbarch_num_regs (gdbarch));
sigcontext_addr = sp + 32; sigcontext_addr = sp + 32;
/* PC. */ /* PC. */
regnum = mips_regnum (gdbarch)->pc; regnum = mips_regnum (gdbarch)->pc;
trad_frame_set_reg_addr (cache, trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch), regnum + gdbarch_num_regs (gdbarch),
sigcontext_addr + 16); sigcontext_addr + 16);
/* GPRs. */ /* GPRs. */
for (regnum = MIPS_AT_REGNUM, addr = sigcontext_addr + 32; for (regnum = MIPS_AT_REGNUM, addr = sigcontext_addr + 32;
regnum <= MIPS_RA_REGNUM; regnum++, addr += 8) regnum <= MIPS_RA_REGNUM; regnum++, addr += 8)
trad_frame_set_reg_addr (cache, trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch), regnum + gdbarch_num_regs (gdbarch),
addr); addr);
/* HI and LO. */ /* HI and LO. */
regnum = mips_regnum (gdbarch)->lo; regnum = mips_regnum (gdbarch)->lo;
trad_frame_set_reg_addr (cache, trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch), regnum + gdbarch_num_regs (gdbarch),
sigcontext_addr + 280); sigcontext_addr + 280);
regnum = mips_regnum (gdbarch)->hi; regnum = mips_regnum (gdbarch)->hi;
trad_frame_set_reg_addr (cache, trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch), regnum + gdbarch_num_regs (gdbarch),
sigcontext_addr + 288); sigcontext_addr + 288);
/* TODO: Handle the floating-point registers. */ /* TODO: Handle the floating-point registers. */

4
gdb/mipsnbsd-nat.c
View File

@ -54,7 +54,7 @@ mipsnbsd_fetch_inferior_registers (struct regcache *regcache, int regno)
return; return;
} }
if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch)) if (regno == -1 || regno >= gdbarch_fp0_regnum (get_regcache_arch (regcache)))
{ {
struct fpreg fpregs; struct fpreg fpregs;
@ -87,7 +87,7 @@ mipsnbsd_store_inferior_registers (struct regcache *regcache, int regno)
return; return;
} }
if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch)) if (regno == -1 || regno >= gdbarch_fp0_regnum (get_regcache_arch (regcache)))
{ {
struct fpreg fpregs; struct fpreg fpregs;

39
gdb/mipsnbsd-tdep.c
View File

@ -142,17 +142,18 @@ mipsnbsd_regset_from_core_section (struct gdbarch *gdbarch,
void void
mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno) mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i; int i;
for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++) for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
{ {
if (regno == i || regno == -1) if (regno == i || regno == -1)
{ {
if (gdbarch_cannot_fetch_register (current_gdbarch, i)) if (gdbarch_cannot_fetch_register (gdbarch, i))
regcache_raw_supply (regcache, i, NULL); regcache_raw_supply (regcache, i, NULL);
else else
regcache_raw_supply (regcache, i, regcache_raw_supply (regcache, i,
regs + (i * mips_isa_regsize (current_gdbarch))); regs + (i * mips_isa_regsize (gdbarch)));
} }
} }
} }
@ -160,33 +161,35 @@ mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
void void
mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno) mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i; int i;
for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++) for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
if ((regno == i || regno == -1) if ((regno == i || regno == -1)
&& ! gdbarch_cannot_store_register (current_gdbarch, i)) && ! gdbarch_cannot_store_register (gdbarch, i))
regcache_raw_collect (regcache, i, regcache_raw_collect (regcache, i,
regs + (i * mips_isa_regsize (current_gdbarch))); regs + (i * mips_isa_regsize (gdbarch)));
} }
void void
mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno) mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i; int i;
for (i = gdbarch_fp0_regnum (current_gdbarch); for (i = gdbarch_fp0_regnum (gdbarch);
i <= mips_regnum (current_gdbarch)->fp_implementation_revision; i <= mips_regnum (gdbarch)->fp_implementation_revision;
i++) i++)
{ {
if (regno == i || regno == -1) if (regno == i || regno == -1)
{ {
if (gdbarch_cannot_fetch_register (current_gdbarch, i)) if (gdbarch_cannot_fetch_register (gdbarch, i))
regcache_raw_supply (regcache, i, NULL); regcache_raw_supply (regcache, i, NULL);
else else
regcache_raw_supply (regcache, i, regcache_raw_supply (regcache, i,
fpregs fpregs
+ ((i - gdbarch_fp0_regnum (current_gdbarch)) + ((i - gdbarch_fp0_regnum (gdbarch))
* mips_isa_regsize (current_gdbarch))); * mips_isa_regsize (gdbarch)));
} }
} }
} }
@ -194,17 +197,17 @@ mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
void void
mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno) mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i; int i;
for (i = gdbarch_fp0_regnum (current_gdbarch); for (i = gdbarch_fp0_regnum (gdbarch);
i <= mips_regnum (current_gdbarch)->fp_control_status; i <= mips_regnum (gdbarch)->fp_control_status;
i++) i++)
if ((regno == i || regno == -1) if ((regno == i || regno == -1)
&& ! gdbarch_cannot_store_register (current_gdbarch, i)) && ! gdbarch_cannot_store_register (gdbarch, i))
regcache_raw_collect (regcache, i, regcache_raw_collect (regcache, i,
fpregs + ((i - gdbarch_fp0_regnum fpregs + ((i - gdbarch_fp0_regnum (gdbarch))
(current_gdbarch)) * mips_isa_regsize (gdbarch)));
* mips_isa_regsize (current_gdbarch)));
} }
/* Under NetBSD/mips, signal handler invocations can be identified by the /* Under NetBSD/mips, signal handler invocations can be identified by the
@ -244,7 +247,7 @@ static LONGEST
mipsnbsd_sigtramp_offset (struct frame_info *next_frame) mipsnbsd_sigtramp_offset (struct frame_info *next_frame)
{ {
CORE_ADDR pc = frame_pc_unwind (next_frame); CORE_ADDR pc = frame_pc_unwind (next_frame);
const char *retcode = gdbarch_byte_order (current_gdbarch) const char *retcode = gdbarch_byte_order (get_frame_arch (next_frame))
== BFD_ENDIAN_BIG ? sigtramp_retcode_mipseb : == BFD_ENDIAN_BIG ? sigtramp_retcode_mipseb :
sigtramp_retcode_mipsel; sigtramp_retcode_mipsel;
unsigned char ret[RETCODE_SIZE], w[4]; unsigned char ret[RETCODE_SIZE], w[4];

31
gdb/remote-mips.c
View File

@ -1754,30 +1754,29 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
if (nfields >= 3) if (nfields >= 3)
{ {
struct regcache *regcache = get_current_regcache (); struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = get_regcache_arch (regcache);
char buf[MAX_REGISTER_SIZE]; char buf[MAX_REGISTER_SIZE];
store_unsigned_integer (buf, store_unsigned_integer (buf,
register_size register_size
(current_gdbarch, gdbarch_pc_regnum (gdbarch, gdbarch_pc_regnum (gdbarch)), rpc);
(current_gdbarch)), rpc); regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), buf);
regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch), buf);
store_unsigned_integer store_unsigned_integer
(buf, register_size (current_gdbarch, (buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)), rfp);
gdbarch_pc_regnum (current_gdbarch)), rfp);
regcache_raw_supply (regcache, 30, buf); /* This register they are avoiding and so it is unnamed */ regcache_raw_supply (regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
store_unsigned_integer (buf, register_size (current_gdbarch, store_unsigned_integer (buf, register_size (gdbarch,
gdbarch_sp_regnum (current_gdbarch)), rsp); gdbarch_sp_regnum (gdbarch)), rsp);
regcache_raw_supply (regcache, gdbarch_sp_regnum (current_gdbarch), buf); regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
store_unsigned_integer (buf, store_unsigned_integer (buf,
register_size (current_gdbarch, register_size (gdbarch,
gdbarch_deprecated_fp_regnum gdbarch_deprecated_fp_regnum
(current_gdbarch)), (gdbarch)),
0); 0);
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
gdbarch_deprecated_fp_regnum (current_gdbarch), buf); gdbarch_deprecated_fp_regnum (gdbarch), buf);
if (nfields == 9) if (nfields == 9)
{ {
@ -1904,17 +1903,18 @@ mips_map_regno (int regno)
static void static void
mips_fetch_registers (struct regcache *regcache, int regno) mips_fetch_registers (struct regcache *regcache, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
unsigned LONGEST val; unsigned LONGEST val;
int err; int err;
if (regno == -1) if (regno == -1)
{ {
for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++) for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
mips_fetch_registers (regcache, regno); mips_fetch_registers (regcache, regno);
return; return;
} }
if (regno == gdbarch_deprecated_fp_regnum (current_gdbarch) if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
|| regno == MIPS_ZERO_REGNUM) || regno == MIPS_ZERO_REGNUM)
/* gdbarch_deprecated_fp_regnum on the mips is a hack which is just /* gdbarch_deprecated_fp_regnum on the mips is a hack which is just
supposed to read zero (see also mips-nat.c). */ supposed to read zero (see also mips-nat.c). */
@ -1948,7 +1948,7 @@ mips_fetch_registers (struct regcache *regcache, int regno)
/* We got the number the register holds, but gdb expects to see a /* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */ value in the target byte ordering. */
store_unsigned_integer (buf, register_size (current_gdbarch, regno), val); store_unsigned_integer (buf, register_size (gdbarch, regno), val);
regcache_raw_supply (regcache, regno, buf); regcache_raw_supply (regcache, regno, buf);
} }
} }
@ -1966,12 +1966,13 @@ mips_prepare_to_store (struct regcache *regcache)
static void static void
mips_store_registers (struct regcache *regcache, int regno) mips_store_registers (struct regcache *regcache, int regno)
{ {
struct gdbarch *gdbarch = get_regcache_arch (regcache);
ULONGEST val; ULONGEST val;
int err; int err;
if (regno == -1) if (regno == -1)
{ {
for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++) for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
mips_store_registers (regcache, regno); mips_store_registers (regcache, regno);
return; return;
} }