MatCat.OpenSource/8sa1-binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

2001-12-09 Elena Zannoni <ezannoni@redhat.com>

Browse Source 
* config/rs6000/tm-rs6000.h (STAB_REG_TO_REGNUM): Remove
	definition, it is now multiarched.
	* ppc-tdep.h (struct gdbarch_tdep): Move from rs6000-tdep.c.  Add
	fields for special register numbers.
	* rs6000-tdep.c (rs6000_gdbarch_init): Initialize new tdep special
	regnum fields.
	(rs6000_saved_pc_after_call): Use gdbarch_tdep registers fields
	instead of hardcoded macros.
	(branch_dest, rs6000_pop_frame, rs6000_fix_call_dummy,
	ppc_push_return_address, rs6000_frame_saved_pc,
	frame_get_saved_regs, rs6000_frame_chain,
	rs6000_store_return_value): Ditto.
	(rs6000_stab_reg_to_regnum): New function.
	* ppcnbsd-nat.c (fetch_inferior_registers,
	store_inferior_registers, fetch_core_registers): Ditto.
	* ppc-linux-tdep.c (ppc_linux_in_sigtramp,
	ppc_linux_frame_init_saved_regs): Ditto.
	* ppc-linux-nat.c (ppc_register_u_addr, supply_gregset,
	fill_gregset): Ditto.
	* ppc-bdm.c (bdm_ppc_fetch_registers, bdm_ppc_store_registers):
	Ditto.
This commit is contained in:
Elena Zannoni 2001-12-09 21:39:53 +00:00
parent 6edc140fcf
commit 2188cbdd51
8 changed files with 175 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
gdb/ChangeLog
View File

@ -1,3 +1,27 @@
2001-12-09 Elena Zannoni <ezannoni@redhat.com>
* config/rs6000/tm-rs6000.h (STAB_REG_TO_REGNUM): Remove
definition, it is now multiarched.
* ppc-tdep.h (struct gdbarch_tdep): Move from rs6000-tdep.c. Add
fields for special register numbers.
* rs6000-tdep.c (rs6000_gdbarch_init): Initialize new tdep special
regnum fields.
(rs6000_saved_pc_after_call): Use gdbarch_tdep registers fields
instead of hardcoded macros.
(branch_dest, rs6000_pop_frame, rs6000_fix_call_dummy,
ppc_push_return_address, rs6000_frame_saved_pc,
frame_get_saved_regs, rs6000_frame_chain,
rs6000_store_return_value): Ditto.
(rs6000_stab_reg_to_regnum): New function.
* ppcnbsd-nat.c (fetch_inferior_registers,
store_inferior_registers, fetch_core_registers): Ditto.
* ppc-linux-tdep.c (ppc_linux_in_sigtramp,
ppc_linux_frame_init_saved_regs): Ditto.
* ppc-linux-nat.c (ppc_register_u_addr, supply_gregset,
fill_gregset): Ditto.
* ppc-bdm.c (bdm_ppc_fetch_registers, bdm_ppc_store_registers):
Ditto.
2001-12-08 Fred Fish <fnf@redhat.com> 2001-12-08 Fred Fish <fnf@redhat.com>
* c-lang.c (c_create_fundamental_type): For FT_CHAR, pass * c-lang.c (c_create_fundamental_type): For FT_CHAR, pass

4
gdb/config/rs6000/tm-rs6000.h
View File

@ -86,10 +86,6 @@ extern void aix_process_linenos (void);
#define FIRST_UISA_SP_REGNUM 64 /* first special register number */ #define FIRST_UISA_SP_REGNUM 64 /* first special register number */
#define LAST_UISA_SP_REGNUM 70 /* last special register number */ #define LAST_UISA_SP_REGNUM 70 /* last special register number */
/* convert a dbx stab register number (from `r' declaration) to a gdb REGNUM */
#define STAB_REG_TO_REGNUM(value) (value)
/* Define other aspects of the stack frame. */ /* Define other aspects of the stack frame. */
#define INIT_FRAME_PC_FIRST(fromleaf, prev) \ #define INIT_FRAME_PC_FIRST(fromleaf, prev) \

8
gdb/ppc-bdm.c
View File

@ -200,8 +200,8 @@ bdm_ppc_fetch_registers (int regno)
/* printf("Asking for register %d\n", first_regno); */ /* printf("Asking for register %d\n", first_regno); */
/* if asking for an invalid register */ /* if asking for an invalid register */
if ((first_regno == PPC_MQ_REGNUM) || if ((first_regno == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
((first_regno >= FP0_REGNUM) && (first_regno <= FPLAST_REGNUM))) || ((first_regno >= FP0_REGNUM) && (first_regno <= FPLAST_REGNUM)))
{ {
/* printf("invalid reg request!\n"); */ /* printf("invalid reg request!\n"); */
supply_register (first_regno, NULL); supply_register (first_regno, NULL);
@ -289,13 +289,13 @@ bdm_ppc_store_registers (int regno)
/* only attempt to write if it's a valid ppc 8xx register */ /* only attempt to write if it's a valid ppc 8xx register */
/* (need to avoid FP regs and MQ reg) */ /* (need to avoid FP regs and MQ reg) */
if ((i != PPC_MQ_REGNUM) && ((i < FP0_REGNUM) || (i > FPLAST_REGNUM))) if ((i != gdbarch_tdep (current_gdbarch)->ppc_mq_regnum) && ((i < FP0_REGNUM) || (i > FPLAST_REGNUM)))
{ {
/* printf("write valid reg %d\n", bdm_regno); */ /* printf("write valid reg %d\n", bdm_regno); */
ocd_write_bdm_registers (bdm_regno, registers + REGISTER_BYTE (i), 4); ocd_write_bdm_registers (bdm_regno, registers + REGISTER_BYTE (i), 4);
} }
/* /*
else if (i == PPC_MQ_REGNUM) else if (i == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
printf("don't write invalid reg %d (PPC_MQ_REGNUM)\n", bdm_regno); printf("don't write invalid reg %d (PPC_MQ_REGNUM)\n", bdm_regno);
else else
printf("don't write invalid reg %d\n", bdm_regno); printf("don't write invalid reg %d\n", bdm_regno);

70
gdb/ppc-linux-nat.c
View File

@ -62,7 +62,8 @@ ppc_register_u_addr (int ustart, int regno)
int u_addr = -1; int u_addr = -1;
/* General purpose registers occupy 1 slot each in the buffer */ /* General purpose registers occupy 1 slot each in the buffer */
if (regno >= PPC_GP0_REGNUM && regno <= PPC_GPLAST_REGNUM ) if (regno >= gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum
&& regno <= gdbarch_tdep (current_gdbarch)->ppc_gplast_regnum )
u_addr = (ustart + (PT_R0 + regno) * 4); u_addr = (ustart + (PT_R0 + regno) * 4);
/* Floating point regs: 2 slots each */ /* Floating point regs: 2 slots each */
@ -72,17 +73,17 @@ ppc_register_u_addr (int ustart, int regno)
/* UISA special purpose registers: 1 slot each */ /* UISA special purpose registers: 1 slot each */
if (regno == PC_REGNUM) if (regno == PC_REGNUM)
u_addr = ustart + PT_NIP * 4; u_addr = ustart + PT_NIP * 4;
if (regno == PPC_LR_REGNUM) if (regno == gdbarch_tdep (current_gdbarch)->ppc_lr_regnum)
u_addr = ustart + PT_LNK * 4; u_addr = ustart + PT_LNK * 4;
if (regno == PPC_CR_REGNUM) if (regno == gdbarch_tdep (current_gdbarch)->ppc_cr_regnum)
u_addr = ustart + PT_CCR * 4; u_addr = ustart + PT_CCR * 4;
if (regno == PPC_XER_REGNUM) if (regno == gdbarch_tdep (current_gdbarch)->ppc_xer_regnum)
u_addr = ustart + PT_XER * 4; u_addr = ustart + PT_XER * 4;
if (regno == PPC_CTR_REGNUM) if (regno == gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum)
u_addr = ustart + PT_CTR * 4; u_addr = ustart + PT_CTR * 4;
if (regno == PPC_MQ_REGNUM) if (regno == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
u_addr = ustart + PT_MQ * 4; u_addr = ustart + PT_MQ * 4;
if (regno == PPC_PS_REGNUM) if (regno == gdbarch_tdep (current_gdbarch)->ppc_ps_regnum)
u_addr = ustart + PT_MSR * 4; u_addr = ustart + PT_MSR * 4;
return u_addr; return u_addr;
@ -98,12 +99,19 @@ supply_gregset (gdb_gregset_t *gregsetp)
supply_register (regi, (char *) (regp + regi)); supply_register (regi, (char *) (regp + regi));
supply_register (PC_REGNUM, (char *) (regp + PT_NIP)); supply_register (PC_REGNUM, (char *) (regp + PT_NIP));
supply_register (PPC_LR_REGNUM, (char *) (regp + PT_LNK)); supply_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum,
supply_register (PPC_CR_REGNUM, (char *) (regp + PT_CCR)); (char *) (regp + PT_LNK));
supply_register (PPC_XER_REGNUM, (char *) (regp + PT_XER)); supply_register (gdbarch_tdep (current_gdbarch)->ppc_cr_regnum,
supply_register (PPC_CTR_REGNUM, (char *) (regp + PT_CTR)); (char *) (regp + PT_CCR));
supply_register (PPC_MQ_REGNUM, (char *) (regp + PT_MQ)); supply_register (gdbarch_tdep (current_gdbarch)->ppc_xer_regnum,
supply_register (PPC_PS_REGNUM, (char *) (regp + PT_MSR)); (char *) (regp + PT_XER));
supply_register (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum,
(char *) (regp + PT_CTR));
supply_register (gdbarch_tdep (current_gdbarch)->ppc_mq_regnum,
(char *) (regp + PT_MQ));
supply_register (gdbarch_tdep (current_gdbarch)->ppc_ps_regnum,
(char *) (regp + PT_MSR));
} }
void void
@ -120,18 +128,30 @@ fill_gregset (gdb_gregset_t *gregsetp, int regno)
if ((regno == -1) || regno == PC_REGNUM) if ((regno == -1) || regno == PC_REGNUM)
regcache_collect (PC_REGNUM, regp + PT_NIP); regcache_collect (PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == PPC_LR_REGNUM) if ((regno == -1)
regcache_collect (PPC_LR_REGNUM, regp + PT_LNK); || regno == gdbarch_tdep (current_gdbarch)->ppc_lr_regnum)
if ((regno == -1) || regno == PPC_CR_REGNUM) regcache_collect (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum,
regcache_collect (PPC_CR_REGNUM, regp + PT_CCR); regp + PT_LNK);
if ((regno == -1) || regno == PPC_XER_REGNUM) if ((regno == -1)
regcache_collect (PPC_XER_REGNUM, regp + PT_XER); || regno == gdbarch_tdep (current_gdbarch)->ppc_cr_regnum)
if ((regno == -1) || regno == PPC_CTR_REGNUM) regcache_collect (gdbarch_tdep (current_gdbarch)->ppc_cr_regnum,
regcache_collect (PPC_CTR_REGNUM, regp + PT_CTR); regp + PT_CCR);
if ((regno == -1) || regno == PPC_MQ_REGNUM) if ((regno == -1)
regcache_collect (PPC_MQ_REGNUM, regp + PT_MQ); || regno == gdbarch_tdep (current_gdbarch)->ppc_xer_regnum)
if ((regno == -1) || regno == PPC_PS_REGNUM) regcache_collect (gdbarch_tdep (current_gdbarch)->ppc_xer_regnum,
regcache_collect (PPC_PS_REGNUM, regp + PT_MSR); regp + PT_XER);
if ((regno == -1)
|| regno == gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum)
regcache_collect (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum,
regp + PT_CTR);
if ((regno == -1)
|| regno == gdbarch_tdep (current_gdbarch)->ppc_mq_regnum)
regcache_collect (gdbarch_tdep (current_gdbarch)->ppc_mq_regnum,
regp + PT_MQ);
if ((regno == -1)
|| regno == gdbarch_tdep (current_gdbarch)->ppc_ps_regnum)
regcache_collect (gdbarch_tdep (current_gdbarch)->ppc_ps_regnum,
regp + PT_MSR);
} }
void void

23
gdb/ppc-linux-tdep.c
View File

@ -156,7 +156,7 @@ ppc_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
char buf[4]; char buf[4];
CORE_ADDR handler; CORE_ADDR handler;
lr = read_register (PPC_LR_REGNUM); lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
if (!ppc_linux_at_sigtramp_return_path (lr)) if (!ppc_linux_at_sigtramp_return_path (lr))
return 0; return 0;
@ -378,14 +378,21 @@ ppc_linux_frame_init_saved_regs (struct frame_info *fi)
regs_addr = regs_addr =
read_memory_integer (fi->frame + PPC_LINUX_REGS_PTR_OFFSET, 4); read_memory_integer (fi->frame + PPC_LINUX_REGS_PTR_OFFSET, 4);
fi->saved_regs[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP; fi->saved_regs[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
fi->saved_regs[PPC_PS_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_MSR; fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] =
fi->saved_regs[PPC_CR_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_CCR; regs_addr + 4 * PPC_LINUX_PT_MSR;
fi->saved_regs[PPC_LR_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_LNK; fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
fi->saved_regs[PPC_CTR_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_CTR; regs_addr + 4 * PPC_LINUX_PT_CCR;
fi->saved_regs[PPC_XER_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_XER; fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
fi->saved_regs[PPC_MQ_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_MQ; regs_addr + 4 * PPC_LINUX_PT_LNK;
fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] =
regs_addr + 4 * PPC_LINUX_PT_CTR;
fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] =
regs_addr + 4 * PPC_LINUX_PT_XER;
fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] =
regs_addr + 4 * PPC_LINUX_PT_MQ;
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
fi->saved_regs[PPC_GP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i; fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] =
regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i;
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
fi->saved_regs[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i; fi->saved_regs[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
} }

27
gdb/ppc-tdep.h
View File

@ -44,16 +44,23 @@ int rs6000_frameless_function_invocation (struct frame_info *);
void rs6000_frame_init_saved_regs (struct frame_info *); void rs6000_frame_init_saved_regs (struct frame_info *);
CORE_ADDR rs6000_frame_chain (struct frame_info *); CORE_ADDR rs6000_frame_chain (struct frame_info *);
/* Some important register numbers. */ /* Private data that this module attaches to struct gdbarch. */
#define PPC_GP0_REGNUM 0 /* GPR register 0 */ struct gdbarch_tdep
#define PPC_GPLAST_REGNUM 31 /* GPR register 31 */ {
#define PPC_TOC_REGNUM 2 /* TOC register */ int wordsize; /* size in bytes of fixed-point word */
#define PPC_PS_REGNUM 65 /* Processor (or machine) status (%msr) */ int osabi; /* OS / ABI from ELF header */
#define PPC_CR_REGNUM 66 /* Condition register */ int *regoff; /* byte offsets in register arrays */
#define PPC_LR_REGNUM 67 /* Link register */ const struct reg *regs; /* from current variant */
#define PPC_CTR_REGNUM 68 /* Count register */ int ppc_gp0_regnum; /* GPR register 0 */
#define PPC_XER_REGNUM 69 /* Integer exception register */ int ppc_gplast_regnum; /* GPR register 31 */
#define PPC_MQ_REGNUM 70 /* Multiply/Divide extension register */ int ppc_toc_regnum; /* TOC register */
int ppc_ps_regnum; /* Processor (or machine) status (%msr) */
int ppc_cr_regnum; /* Condition register */
int ppc_lr_regnum; /* Link register */
int ppc_ctr_regnum; /* Count register */
int ppc_xer_regnum; /* Integer exception register */
int ppc_mq_regnum; /* Multiply/Divide extension register */
};
#endif #endif

24
gdb/ppcnbsd-nat.c
View File

@ -49,10 +49,10 @@ fetch_inferior_registers (int regno)
(PTRACE_ARG3_TYPE) & inferior_registers, 0); (PTRACE_ARG3_TYPE) & inferior_registers, 0);
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
RF (i, inferior_registers.fixreg[i]); RF (i, inferior_registers.fixreg[i]);
RF (PPC_LR_REGNUM, inferior_registers.lr); RF (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum, inferior_registers.lr);
RF (PPC_CR_REGNUM, inferior_registers.cr); RF (gdbarch_tdep (current_gdbarch)->ppc_cr_regnum, inferior_registers.cr);
RF (PPC_XER_REGNUM, inferior_registers.xer); RF (gdbarch_tdep (current_gdbarch)->ppc_xer_regnum, inferior_registers.xer);
RF (PPC_CTR_REGNUM, inferior_registers.ctr); RF (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum, inferior_registers.ctr);
RF (PC_REGNUM, inferior_registers.pc); RF (PC_REGNUM, inferior_registers.pc);
#ifdef PT_GETFPREGS #ifdef PT_GETFPREGS
@ -76,10 +76,10 @@ store_inferior_registers (int regno)
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
RS (i, inferior_registers.fixreg[i]); RS (i, inferior_registers.fixreg[i]);
RS (PPC_LR_REGNUM, inferior_registers.lr); RS (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum, inferior_registers.lr);
RS (PPC_CR_REGNUM, inferior_registers.cr); RS (gdbarch_tdep (current_gdbarch)->ppc_cr_regnum, inferior_registers.cr);
RS (PPC_XER_REGNUM, inferior_registers.xer); RS (gdbarch_tdep (current_gdbarch)->ppc_xer_regnum, inferior_registers.xer);
RS (PPC_CTR_REGNUM, inferior_registers.ctr); RS (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum, inferior_registers.ctr);
RS (PC_REGNUM, inferior_registers.pc); RS (PC_REGNUM, inferior_registers.pc);
ptrace (PT_SETREGS, PIDGET (inferior_ptid), ptrace (PT_SETREGS, PIDGET (inferior_ptid),
@ -111,10 +111,10 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
/* Integer registers */ /* Integer registers */
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
RF (i, core_reg->intreg.fixreg[i]); RF (i, core_reg->intreg.fixreg[i]);
RF (PPC_LR_REGNUM, core_reg->intreg.lr); RF (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum, core_reg->intreg.lr);
RF (PPC_CR_REGNUM, core_reg->intreg.cr); RF (gdbarch_tdep (current_gdbarch)->ppc_cr_regnum, core_reg->intreg.cr);
RF (PPC_XER_REGNUM, core_reg->intreg.xer); RF (gdbarch_tdep (current_gdbarch)->ppc_xer_regnum, core_reg->intreg.xer);
RF (PPC_CTR_REGNUM, core_reg->intreg.ctr); RF (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum, core_reg->intreg.ctr);
RF (PC_REGNUM, core_reg->intreg.pc); RF (PC_REGNUM, core_reg->intreg.pc);
#ifdef PT_FPGETREGS #ifdef PT_FPGETREGS

81
gdb/rs6000-tdep.c
View File

@ -82,16 +82,6 @@ struct reg
unsigned char fpr; /* whether register is floating-point */ unsigned char fpr; /* whether register is floating-point */
}; };
/* Private data that this module attaches to struct gdbarch. */
struct gdbarch_tdep
{
int wordsize; /* size in bytes of fixed-point word */
int osabi; /* OS / ABI from ELF header */
int *regoff; /* byte offsets in register arrays */
const struct reg *regs; /* from current variant */
};
/* Return the current architecture's gdbarch_tdep structure. */ /* Return the current architecture's gdbarch_tdep structure. */
#define TDEP gdbarch_tdep (current_gdbarch) #define TDEP gdbarch_tdep (current_gdbarch)
@ -205,7 +195,7 @@ rs6000_frame_args_address (struct frame_info *fi)
static CORE_ADDR static CORE_ADDR
rs6000_saved_pc_after_call (struct frame_info *fi) rs6000_saved_pc_after_call (struct frame_info *fi)
{ {
return read_register (PPC_LR_REGNUM); return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
} }
/* Calculate the destination of a branch/jump. Return -1 if not a branch. */ /* Calculate the destination of a branch/jump. Return -1 if not a branch. */
@ -243,7 +233,7 @@ branch_dest (int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety)
if (ext_op == 16) /* br conditional register */ if (ext_op == 16) /* br conditional register */
{ {
dest = read_register (PPC_LR_REGNUM) & ~3; dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3;
/* If we are about to return from a signal handler, dest is /* If we are about to return from a signal handler, dest is
something like 0x3c90. The current frame is a signal handler something like 0x3c90. The current frame is a signal handler
@ -262,13 +252,13 @@ branch_dest (int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety)
else if (ext_op == 528) /* br cond to count reg */ else if (ext_op == 528) /* br cond to count reg */
{ {
dest = read_register (PPC_CTR_REGNUM) & ~3; dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum) & ~3;
/* If we are about to execute a system call, dest is something /* If we are about to execute a system call, dest is something
like 0x22fc or 0x3b00. Upon completion the system call like 0x22fc or 0x3b00. Upon completion the system call
will return to the address in the link register. */ will return to the address in the link register. */
if (dest < TEXT_SEGMENT_BASE) if (dest < TEXT_SEGMENT_BASE)
dest = read_register (PPC_LR_REGNUM) & ~3; dest = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum) & ~3;
} }
else else
return -1; return -1;
@ -809,7 +799,7 @@ rs6000_pop_frame (void)
else else
prev_sp = read_memory_addr (sp, wordsize); prev_sp = read_memory_addr (sp, wordsize);
if (fdata.lr_offset == 0) if (fdata.lr_offset == 0)
lr = read_register (PPC_LR_REGNUM); lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
else else
lr = read_memory_addr (prev_sp + fdata.lr_offset, wordsize); lr = read_memory_addr (prev_sp + fdata.lr_offset, wordsize);
@ -860,7 +850,8 @@ rs6000_fix_call_dummy (char *dummyname, CORE_ADDR pc, CORE_ADDR fun,
if (rs6000_find_toc_address_hook != NULL) if (rs6000_find_toc_address_hook != NULL)
{ {
CORE_ADDR tocvalue = (*rs6000_find_toc_address_hook) (fun); CORE_ADDR tocvalue = (*rs6000_find_toc_address_hook) (fun);
write_register (PPC_TOC_REGNUM, tocvalue); write_register (gdbarch_tdep (current_gdbarch)->ppc_toc_regnum,
tocvalue);
} }
} }
@ -1083,7 +1074,8 @@ ran_out_of_registers_for_arguments:
static CORE_ADDR static CORE_ADDR
ppc_push_return_address (CORE_ADDR pc, CORE_ADDR sp) ppc_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
{ {
write_register (PPC_LR_REGNUM, CALL_DUMMY_ADDRESS ()); write_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum,
CALL_DUMMY_ADDRESS ());
return sp; return sp;
} }
@ -1297,7 +1289,7 @@ rs6000_frame_saved_pc (struct frame_info *fi)
} }
if (fdata.lr_offset == 0) if (fdata.lr_offset == 0)
return read_register (PPC_LR_REGNUM); return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
return read_memory_addr (FRAME_CHAIN (fi) + fdata.lr_offset, wordsize); return read_memory_addr (FRAME_CHAIN (fi) + fdata.lr_offset, wordsize);
} }
@ -1368,12 +1360,14 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
/* If != 0, fdatap->cr_offset is the offset from the frame that holds /* If != 0, fdatap->cr_offset is the offset from the frame that holds
the CR. */ the CR. */
if (fdatap->cr_offset != 0) if (fdatap->cr_offset != 0)
fi->saved_regs[PPC_CR_REGNUM] = frame_addr + fdatap->cr_offset; fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
frame_addr + fdatap->cr_offset;
/* If != 0, fdatap->lr_offset is the offset from the frame that holds /* If != 0, fdatap->lr_offset is the offset from the frame that holds
the LR. */ the LR. */
if (fdatap->lr_offset != 0) if (fdatap->lr_offset != 0)
fi->saved_regs[PPC_LR_REGNUM] = frame_addr + fdatap->lr_offset; fi->saved_regs[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
frame_addr + fdatap->lr_offset;
} }
/* Return the address of a frame. This is the inital %sp value when the frame /* Return the address of a frame. This is the inital %sp value when the frame
@ -1483,7 +1477,7 @@ rs6000_frame_chain (struct frame_info *thisframe)
else else
fp = read_memory_addr ((thisframe)->frame, wordsize); fp = read_memory_addr ((thisframe)->frame, wordsize);
lr = read_register (PPC_LR_REGNUM); lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
if (lr == entry_point_address ()) if (lr == entry_point_address ())
if (fp != 0 && (fpp = read_memory_addr (fp, wordsize)) != 0) if (fp != 0 && (fpp = read_memory_addr (fp, wordsize)) != 0)
if (PC_IN_CALL_DUMMY (lr, fpp, fpp)) if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
@ -1614,6 +1608,33 @@ rs6000_register_convert_to_raw (struct type *type, int n,
memcpy (to, from, REGISTER_RAW_SIZE (n)); memcpy (to, from, REGISTER_RAW_SIZE (n));
} }
/* Convert a dbx stab register number (from `r' declaration) to a gdb
REGNUM. */
static int
rs6000_stab_reg_to_regnum (int num)
{
int regnum;
switch (num)
{
case 64:
regnum = gdbarch_tdep (current_gdbarch)->ppc_mq_regnum;
break;
case 65:
regnum = gdbarch_tdep (current_gdbarch)->ppc_lr_regnum;
break;
case 66:
regnum = gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum;
break;
case 76:
regnum = gdbarch_tdep (current_gdbarch)->ppc_xer_regnum;
break;
default:
regnum = num;
break;
}
return regnum;
}
/* Store the address of the place in which to copy the structure the /* Store the address of the place in which to copy the structure the
subroutine will return. This is called from call_function. subroutine will return. This is called from call_function.
@ -1645,8 +1666,8 @@ rs6000_store_return_value (struct type *type, char *valbuf)
TYPE_LENGTH (type)); TYPE_LENGTH (type));
else else
/* Everything else is returned in GPR3 and up. */ /* Everything else is returned in GPR3 and up. */
write_register_bytes (REGISTER_BYTE (PPC_GP0_REGNUM + 3), valbuf, write_register_bytes (REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3),
TYPE_LENGTH (type)); valbuf, TYPE_LENGTH (type));
} }
/* Extract from an array REGBUF containing the (raw) register state /* Extract from an array REGBUF containing the (raw) register state
@ -2236,6 +2257,19 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
v = find_variant_by_name (power ? "power" : "powerpc"); v = find_variant_by_name (power ? "power" : "powerpc");
tdep->regs = v->regs; tdep->regs = v->regs;
tdep->ppc_gp0_regnum = 0;
tdep->ppc_gplast_regnum = 31;
tdep->ppc_toc_regnum = 2;
tdep->ppc_ps_regnum = 65;
tdep->ppc_cr_regnum = 66;
tdep->ppc_lr_regnum = 67;
tdep->ppc_ctr_regnum = 68;
tdep->ppc_xer_regnum = 69;
if (v->mach == bfd_mach_ppc_601)
tdep->ppc_mq_regnum = 124;
else
tdep->ppc_mq_regnum = 70;
/* Calculate byte offsets in raw register array. */ /* Calculate byte offsets in raw register array. */
tdep->regoff = xmalloc (v->nregs * sizeof (int)); tdep->regoff = xmalloc (v->nregs * sizeof (int));
for (i = off = 0; i < v->nregs; i++) for (i = off = 0; i < v->nregs; i++)
@ -2295,6 +2329,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_register_convertible (gdbarch, rs6000_register_convertible); set_gdbarch_register_convertible (gdbarch, rs6000_register_convertible);
set_gdbarch_register_convert_to_virtual (gdbarch, rs6000_register_convert_to_virtual); set_gdbarch_register_convert_to_virtual (gdbarch, rs6000_register_convert_to_virtual);
set_gdbarch_register_convert_to_raw (gdbarch, rs6000_register_convert_to_raw); set_gdbarch_register_convert_to_raw (gdbarch, rs6000_register_convert_to_raw);
set_gdbarch_stab_reg_to_regnum (gdbarch, rs6000_stab_reg_to_regnum);
set_gdbarch_extract_return_value (gdbarch, rs6000_extract_return_value); set_gdbarch_extract_return_value (gdbarch, rs6000_extract_return_value);