OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

* gdbarch.sh (SP_REGNUM): Replace by gdbarch_sp_regnum.
	* v850-tdep.c (v850_unwind_sp): Likewise.
	* std-regs.c (value_of_builtin_frame_sp_reg): Likewise.
	* stack.c (frame_info): Likewise.
	* stabsread.c (define_symbol): Likewise.
	* sh-tdep.c (sh_push_dummy_call_fpu, sh_push_dummy_call_nofpu)
	(sh_dwarf2_frame_init_reg, sh_frame_cache, sh_frame_prev_register)
	(sh_unwind_sp): Likewise.
	* sh64-tdep.c (sh64_push_dummy_call, sh64_frame_cache)
	(sh64_frame_prev_register, sh64_unwind_sp): Likewise.
	* rs6000-tdep.c (rs6000_push_dummy_call, rs6000_unwind_dummy_id)
	(rs6000_frame_cache): Likewise.
	* rs6000-nat.c (store_register): Likewise.
	* remote-mips.c (mips_wait): Likewise.
	* procfs.c (procfs_fetch_registers, procfs_store_registers): Likewise.
	* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call)
	(ppc64_sysv_abi_push_dummy_call): Likewise.
	* ppcobsd-tdep.c (ppcobsd_sigtramp_frame_cache): Likewise.
	* ppcobsd-nat.c (ppcobsd_supply_pcb): Likewise.
	* ppcnbsd-tdep.c (ppcnbsd_sigtramp_cache_init): Likewise.
	* ppc-linux-tdep.c (ppc_linux_sigtramp_cache): Likewise.
	* m32r-rom.c (m32r_supply_register): Likewise.
	* frame.c (frame_sp_unwind): Likewise.
	* mips-tdep.c (mips_insn16_frame_cache)
	(mips_insn32_frame_cache): Likewise (comment).
	* m68klinux-nat.c (supply_gregset): Likewise.
	* m68k-tdep.c (m68k_get_longjmp_target): Likewise.
	* ia64-tdep.c (ia64_frame_prev_register): Likewise.
	* i386-tdep.c (i386_get_longjmp_target): Likewise.
	* dwarf2-frame.c (dwarf2_frame_default_init_reg): Likewise.
	* cris-tdep.c (cris_regnums, cris_sigcontext_addr)
	(cris_sigtramp_frame_unwind_cache, cris_push_dummy_call)
	(cris_scan_prologue, crisv32_scan_prologue, cris_unwind_sp)
	(cris_register_type, crisv32_register_type)
	(cris_dwarf2_frame_init_reg): Likewise.
	* arch-utils.c (legacy_virtual_frame_pointer): Likewise.
	* amd64-tdep.c (amd64_frame_prev_register): Likewise.
	* amd64-linux-tdep.c (amd64_linux_sigcontext_addr): Likewise.
	* libunwind-frame.c (libunwind_frame_cache): Likewise.

	* gdbarch.sh (PC_REGNUM): Replace by gdbarch_pc_regnum.
	* regcache.c (read_pc_pid, generic_target_write_pc): Likewise.
	* xtensa-tdep.c (xtensa_register_type, xtensa_supply_gregset)
	(xtensa_unwind_pc, xtensa_frame_cache, xtensa_frame_prev_register)
	(xtensa_extract_return_value, xtensa_store_return_value): Likewise.
	* v850-tdep.c (v850_unwind_pc): Likewise.
	* stack.c (frame_info): Likewise.
	* sh-tdep.c (sh_generic_show_regs, sh3_show_regs, sh2e_show_regs)
	(sh2a_show_regs, sh2a_nofpu_show_regs, sh3e_show_regs)
	(sh3_dsp_show_regs, sh4_show_regs, sh4_nofpu_show_regs)
	(sh_dwarf2_frame_init_reg, sh_frame_prev_register, sh_unwind_pc)
	(sh_dsp_show_regs): Likewise.
	* shnbsd-tdep.c (shnbsd_supply_gregset)
	(shnbsd_collect_gregset): Likewise.
	* shnbsd-nat.c (GETREGS_SUPPLIES): Likewise.
	* sh64-tdep.c (sh64_compact_reg_base_num, sh64_show_media_regs)
	(sh64_frame_prev_register, sh64_unwind_pc): Likewise.
	* rs6000-tdep.c (ppc_supply_gregset, ppc_collect_gregset)
	(6000_register_reggroup_p, rs6000_unwind_pc)
	(rs6000_frame_cache): Likewise.
	* rs6000-nat.c (regmap, rs6000_fetch_inferior_registers)
	(rs6000_store_inferior_registers): Likewise.
	* remote-mips.c (mips_wait, mips_load): Likewise.
	* procfs.c (procfs_fetch_registers, procfs_store_registers): Likewise.
	* ppcobsd-tdep.c (ppcobsd_sigtramp_frame_cache): Likewise.
	* ppcobsd-nat.c (ppcobsd_supply_pcb): Likewise.
	* ppcnbsd-tdep.c (ppcnbsd_sigtramp_cache_init): Likewise.
	* ppcnbsd-nat.c (getregs_supplies, ppcnbsd_supply_pcb): Likewise.
	* ppc-linux-tdep.c (ppc_linux_sigtramp_cache): Likewise.
	* ppc-linux-nat.c (ppc_register_u_addr, fetch_ppc_registers)
	(store_ppc_registers, fill_gregset): Likewise.
	* mips-tdep.c (mips_stub_frame_cache, mips_gdbarch_init): Likewise.
	* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg): Likewise.
	* mipsnbsd-nat.c (getregs_supplies): Likewise.
	* m68k-tdep.c (m68k_register_type, m68k_unwind_pc): Likewise.
	* m68klinux-nat.c (supply_gregset): Likewise.
	* irix5-nat.c (fill_gregset): Likewise.
	* i386-tdep.c (i386_unwind_pc): Likewise.
	* i386-linux-nat.c (i386_linux_resume): Likewise.
	* frame.c (get_prev_frame_1): Likewise.
	* dwarf2-frame.c (dwarf2_frame_default_init_reg): Likewise.
	* dbug-rom.c (dbug_supply_register): Likewise.
	* cris-tdep.c (cris_sigtramp_frame_unwind_cache, cris_scan_prologue)
	(crisv32_scan_prologue, cris_unwind_pc, cris_register_size)
	(cris_register_type, crisv32_register_type, crisv32_register_name)
	(cris_dwarf2_frame_init_reg, find_step_target)
	(cris_software_single_step, cris_supply_gregset)
	(cris_regnums): Likewise.
	* alpha-linux-nat.c (alpha_linux_register_u_offset): Likewise.
	* aix-thread.c (special_register_p, supply_sprs64, supply_sprs32)
	(fill_sprs64, fill_sprs32, store_regs_user_thread): Likewise.
	* mips-linux-tdep.c (mips_linux_write_pc): Likewise.

	* gdbarch.sh (PS_REGNUM): Replace by gdbarch_ps_regnum.
	* dbug-rom.c (dbug_supply_register): Likewise.
	* xtensa-tdep.c (xtensa_supply_gregset, xtensa_frame_cache)
	(xtensa_frame_prev_register, xtensa_push_dummy_call): Likewise.
	* win32-nat.c (win32_resume): Likewise.
	* std-regs.c (value_of_builtin_frame_ps_reg)
	(value_of_builtin_frame_pc_reg): Likewise.
	* m68k-tdep.c (m68k_register_type): Likewise.
	* m68klinux-nat.c (supply_gregset): Likewise.

	* gdbarch.sh (FP0_REGNUM): Replace by gdbarch_fp0_regnum.
	* sh-tdep.c (sh_extract_return_value_fpu, sh_store_return_value_fpu)
	(sh2e_show_regs, sh2a_show_regs, sh3e_show_regs, sh4_show_regs)
	(sh_sh2a_register_type, sh_sh3e_register_type, sh_sh4_register_type)
	(fv_reg_base_num, dr_reg_base_num): Likewise.
	* sh64-tdep.c (sh64_fv_reg_base_num, sh64_dr_reg_base_num)
	(sh64_fpp_reg_base_num, sh64_compact_reg_base_num, sh64_push_dummy_call)
	(sh64_extract_return_value, sh64_store_return_value)
	(sh64_show_media_regs, sh64_show_compact_regs, sh64_register_type)
	(sh64_do_fp_register, sh64_media_print_registers_info): Likewise.
	* procfs.c (procfs_fetch_registers, procfs_store_registers)
	(invalidate_cache): Likewise.
	* ppc-linux-tdep.c (ppc_linux_sigtramp_cache): Likewise.
	* mipsnbsd-tdep.c (mipsnbsd_supply_fpreg)
	(mipsnbsd_fill_fpreg): Likewise.
	* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
	(mipsnbsd_store_inferior_registers): Likewise.
	* mips-linux-tdep.c (mips_supply_fpregset, mips_fill_fpregset)
	(mips64_supply_fpregset, mips64_fill_fpregset): Likewise.
	* mips-linux-nat.c (mips64_linux_register_addr): Likewise.
	* m68k-tdep.c (m68k_register_type, m68k_convert_register_p): Likewise.
	* m68klinux-nat.c (getfpregs_supplies, supply_fpregset)
	(fill_fpregset): Likewise.
	* irix5-nat.c (supply_fpregset, fill_fpregset): Likewise.
	* i386-tdep.h (struct_return): Likewise (comment).
	* i386-nto-tdep.c (i386nto_register_area): Likewise.
	* go32-nat.c (fetch_register, go32_fetch_registers, store_register)
	(go32_store_registers): Likewise.
	* alpha-tdep.c (alpha_next_pc): Likewise.
	* alpha-linux-nat.c (alpha_linux_register_u_offset): Likewise.
	* alphabsd-nat.c (alphabsd_fetch_inferior_registers)
	(alphabsd_store_inferior_registers): Likewise.
	* core-regset.c (fetch_core_registers): Likewise.
	* i386v4-nat.c (supply_fpregset, fill_fpregset): Likewise.

	* gdbarch.c, gdbarch.h: Regenerate.
This commit is contained in:
Ulrich Weigand 2007-06-18 17:45:26 +00:00
parent 0d823e126f
commit 3e8c568d4f
56 changed files with 741 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
gdb/ChangeLog
View File

@ -1,3 +1,145 @@
2007-06-18 Markus Deuling <deuling@de.ibm.com>
* gdbarch.sh (SP_REGNUM): Replace by gdbarch_sp_regnum.
* v850-tdep.c (v850_unwind_sp): Likewise.
* std-regs.c (value_of_builtin_frame_sp_reg): Likewise.
* stack.c (frame_info): Likewise.
* stabsread.c (define_symbol): Likewise.
* sh-tdep.c (sh_push_dummy_call_fpu, sh_push_dummy_call_nofpu)
(sh_dwarf2_frame_init_reg, sh_frame_cache, sh_frame_prev_register)
(sh_unwind_sp): Likewise.
* sh64-tdep.c (sh64_push_dummy_call, sh64_frame_cache)
(sh64_frame_prev_register, sh64_unwind_sp): Likewise.
* rs6000-tdep.c (rs6000_push_dummy_call, rs6000_unwind_dummy_id)
(rs6000_frame_cache): Likewise.
* rs6000-nat.c (store_register): Likewise.
* remote-mips.c (mips_wait): Likewise.
* procfs.c (procfs_fetch_registers, procfs_store_registers): Likewise.
* ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call)
(ppc64_sysv_abi_push_dummy_call): Likewise.
* ppcobsd-tdep.c (ppcobsd_sigtramp_frame_cache): Likewise.
* ppcobsd-nat.c (ppcobsd_supply_pcb): Likewise.
* ppcnbsd-tdep.c (ppcnbsd_sigtramp_cache_init): Likewise.
* ppc-linux-tdep.c (ppc_linux_sigtramp_cache): Likewise.
* m32r-rom.c (m32r_supply_register): Likewise.
* frame.c (frame_sp_unwind): Likewise.
* mips-tdep.c (mips_insn16_frame_cache)
(mips_insn32_frame_cache): Likewise (comment).
* m68klinux-nat.c (supply_gregset): Likewise.
* m68k-tdep.c (m68k_get_longjmp_target): Likewise.
* ia64-tdep.c (ia64_frame_prev_register): Likewise.
* i386-tdep.c (i386_get_longjmp_target): Likewise.
* dwarf2-frame.c (dwarf2_frame_default_init_reg): Likewise.
* cris-tdep.c (cris_regnums, cris_sigcontext_addr)
(cris_sigtramp_frame_unwind_cache, cris_push_dummy_call)
(cris_scan_prologue, crisv32_scan_prologue, cris_unwind_sp)
(cris_register_type, crisv32_register_type)
(cris_dwarf2_frame_init_reg): Likewise.
* arch-utils.c (legacy_virtual_frame_pointer): Likewise.
* amd64-tdep.c (amd64_frame_prev_register): Likewise.
* amd64-linux-tdep.c (amd64_linux_sigcontext_addr): Likewise.
* libunwind-frame.c (libunwind_frame_cache): Likewise.
* gdbarch.sh (PC_REGNUM): Replace by gdbarch_pc_regnum.
* regcache.c (read_pc_pid, generic_target_write_pc): Likewise.
* xtensa-tdep.c (xtensa_register_type, xtensa_supply_gregset)
(xtensa_unwind_pc, xtensa_frame_cache, xtensa_frame_prev_register)
(xtensa_extract_return_value, xtensa_store_return_value): Likewise.
* v850-tdep.c (v850_unwind_pc): Likewise.
* stack.c (frame_info): Likewise.
* sh-tdep.c (sh_generic_show_regs, sh3_show_regs, sh2e_show_regs)
(sh2a_show_regs, sh2a_nofpu_show_regs, sh3e_show_regs)
(sh3_dsp_show_regs, sh4_show_regs, sh4_nofpu_show_regs)
(sh_dwarf2_frame_init_reg, sh_frame_prev_register, sh_unwind_pc)
(sh_dsp_show_regs): Likewise.
* shnbsd-tdep.c (shnbsd_supply_gregset)
(shnbsd_collect_gregset): Likewise.
* shnbsd-nat.c (GETREGS_SUPPLIES): Likewise.
* sh64-tdep.c (sh64_compact_reg_base_num, sh64_show_media_regs)
(sh64_frame_prev_register, sh64_unwind_pc): Likewise.
* rs6000-tdep.c (ppc_supply_gregset, ppc_collect_gregset)
(6000_register_reggroup_p, rs6000_unwind_pc)
(rs6000_frame_cache): Likewise.
* rs6000-nat.c (regmap, rs6000_fetch_inferior_registers)
(rs6000_store_inferior_registers): Likewise.
* remote-mips.c (mips_wait, mips_load): Likewise.
* procfs.c (procfs_fetch_registers, procfs_store_registers): Likewise.
* ppcobsd-tdep.c (ppcobsd_sigtramp_frame_cache): Likewise.
* ppcobsd-nat.c (ppcobsd_supply_pcb): Likewise.
* ppcnbsd-tdep.c (ppcnbsd_sigtramp_cache_init): Likewise.
* ppcnbsd-nat.c (getregs_supplies, ppcnbsd_supply_pcb): Likewise.
* ppc-linux-tdep.c (ppc_linux_sigtramp_cache): Likewise.
* ppc-linux-nat.c (ppc_register_u_addr, fetch_ppc_registers)
(store_ppc_registers, fill_gregset): Likewise.
* mips-tdep.c (mips_stub_frame_cache, mips_gdbarch_init): Likewise.
* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg): Likewise.
* mipsnbsd-nat.c (getregs_supplies): Likewise.
* m68k-tdep.c (m68k_register_type, m68k_unwind_pc): Likewise.
* m68klinux-nat.c (supply_gregset): Likewise.
* irix5-nat.c (fill_gregset): Likewise.
* i386-tdep.c (i386_unwind_pc): Likewise.
* i386-linux-nat.c (i386_linux_resume): Likewise.
* frame.c (get_prev_frame_1): Likewise.
* dwarf2-frame.c (dwarf2_frame_default_init_reg): Likewise.
* dbug-rom.c (dbug_supply_register): Likewise.
* cris-tdep.c (cris_sigtramp_frame_unwind_cache, cris_scan_prologue)
(crisv32_scan_prologue, cris_unwind_pc, cris_register_size)
(cris_register_type, crisv32_register_type, crisv32_register_name)
(cris_dwarf2_frame_init_reg, find_step_target)
(cris_software_single_step, cris_supply_gregset)
(cris_regnums): Likewise.
* alpha-linux-nat.c (alpha_linux_register_u_offset): Likewise.
* aix-thread.c (special_register_p, supply_sprs64, supply_sprs32)
(fill_sprs64, fill_sprs32, store_regs_user_thread): Likewise.
* std-regs.c (value_of_builtin_frame_pc_reg): Likewise.
* mips-linux-tdep.c (mips_linux_write_pc): Likewise.
* gdbarch.sh (PS_REGNUM): Replace by gdbarch_ps_regnum.
* dbug-rom.c (dbug_supply_register): Likewise.
* xtensa-tdep.c (xtensa_supply_gregset, xtensa_frame_cache)
(xtensa_frame_prev_register, xtensa_push_dummy_call): Likewise.
* win32-nat.c (win32_resume): Likewise.
* std-regs.c (value_of_builtin_frame_ps_reg): Likewise.
* m68k-tdep.c (m68k_register_type): Likewise.
* m68klinux-nat.c (supply_gregset): Likewise.
* gdbarch.sh (FP0_REGNUM): Replace by gdbarch_fp0_regnum.
* sh-tdep.c (sh_extract_return_value_fpu, sh_store_return_value_fpu)
(sh2e_show_regs, sh2a_show_regs, sh3e_show_regs, sh4_show_regs)
(sh_sh2a_register_type, sh_sh3e_register_type, sh_sh4_register_type)
(fv_reg_base_num, dr_reg_base_num): Likewise.
* sh64-tdep.c (sh64_fv_reg_base_num, sh64_dr_reg_base_num)
(sh64_fpp_reg_base_num, sh64_compact_reg_base_num, sh64_push_dummy_call)
(sh64_extract_return_value, sh64_store_return_value)
(sh64_show_media_regs, sh64_show_compact_regs, sh64_register_type)
(sh64_do_fp_register, sh64_media_print_registers_info): Likewise.
* procfs.c (procfs_fetch_registers, procfs_store_registers)
(invalidate_cache): Likewise.
* ppc-linux-tdep.c (ppc_linux_sigtramp_cache): Likewise.
* mipsnbsd-tdep.c (mipsnbsd_supply_fpreg)
(mipsnbsd_fill_fpreg): Likewise.
* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
(mipsnbsd_store_inferior_registers): Likewise.
* mips-linux-tdep.c (mips_supply_fpregset, mips_fill_fpregset)
(mips64_supply_fpregset, mips64_fill_fpregset): Likewise.
* mips-linux-nat.c (mips64_linux_register_addr): Likewise.
* m68k-tdep.c (m68k_register_type, m68k_convert_register_p): Likewise.
* m68klinux-nat.c (getfpregs_supplies, supply_fpregset)
(fill_fpregset): Likewise.
* irix5-nat.c (supply_fpregset, fill_fpregset): Likewise.
* i386-tdep.h (struct_return): Likewise (comment).
* i386-nto-tdep.c (i386nto_register_area): Likewise.
* go32-nat.c (fetch_register, go32_fetch_registers, store_register)
(go32_store_registers): Likewise.
* alpha-tdep.c (alpha_next_pc): Likewise.
* alpha-linux-nat.c (alpha_linux_register_u_offset): Likewise.
* alphabsd-nat.c (alphabsd_fetch_inferior_registers)
(alphabsd_store_inferior_registers): Likewise.
* core-regset.c (fetch_core_registers): Likewise.
* i386v4-nat.c (supply_fpregset, fill_fpregset): Likewise.
* gdbarch.c, gdbarch.h: Regenerate.
2007-06-18 Daniel Jacobowitz <dan@codesourcery.com> 2007-06-18 Daniel Jacobowitz <dan@codesourcery.com>
* coffread.c (coff_sym_fns): Add default_symfile_segments. * coffread.c (coff_sym_fns): Add default_symfile_segments.

26
gdb/aix-thread.c
View File

@ -1065,7 +1065,7 @@ special_register_p (int regno)
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
return regno == PC_REGNUM return regno == gdbarch_pc_regnum (current_gdbarch)
|| regno == tdep->ppc_ps_regnum || regno == tdep->ppc_ps_regnum
|| regno == tdep->ppc_cr_regnum || regno == tdep->ppc_cr_regnum
|| regno == tdep->ppc_lr_regnum || regno == tdep->ppc_lr_regnum
@ -1087,7 +1087,8 @@ supply_sprs64 (struct regcache *regcache,
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
regcache_raw_supply (regcache, PC_REGNUM, (char *) &iar); regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch),
(char *) &iar);
regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr); regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr); regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr); regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
@ -1109,7 +1110,8 @@ supply_sprs32 (struct regcache *regcache,
{ {
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
regcache_raw_supply (regcache, PC_REGNUM, (char *) &iar); regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch),
(char *) &iar);
regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr); regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr); regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr); regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
@ -1343,10 +1345,12 @@ fill_sprs64 (const struct regcache *regcache,
they're not, then either GDB has been built incorrectly, or they're not, then either GDB has been built incorrectly, or
there's some other kind of internal error. To be really safe, there's some other kind of internal error. To be really safe,
we should check all of the sizes. */ we should check all of the sizes. */
gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM)); gdb_assert (sizeof (*iar) == register_size
(current_gdbarch,
gdbarch_pc_regnum (current_gdbarch)));
if (regcache_valid_p (regcache, PC_REGNUM)) if (regcache_valid_p (regcache, gdbarch_pc_regnum (current_gdbarch)))
regcache_raw_collect (regcache, PC_REGNUM, iar); regcache_raw_collect (regcache, gdbarch_pc_regnum (current_gdbarch), iar);
if (regcache_valid_p (regcache, tdep->ppc_ps_regnum)) if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr); regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
if (regcache_valid_p (regcache, tdep->ppc_cr_regnum)) if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
@ -1375,10 +1379,12 @@ fill_sprs32 (const struct regcache *regcache,
they're not, then either GDB has been built incorrectly, or they're not, then either GDB has been built incorrectly, or
there's some other kind of internal error. To be really safe, there's some other kind of internal error. To be really safe,
we should check all of the sizes. */ we should check all of the sizes. */
gdb_assert (sizeof (*iar) == register_size (current_gdbarch, PC_REGNUM)); gdb_assert (sizeof (*iar) == register_size (current_gdbarch,
gdbarch_pc_regnum
(current_gdbarch)));
if (regcache_valid_p (regcache, PC_REGNUM)) if (regcache_valid_p (regcache, gdbarch_pc_regnum (current_gdbarch)))
regcache_raw_collect (regcache, PC_REGNUM, iar); regcache_raw_collect (regcache, gdbarch_pc_regnum (current_gdbarch), iar);
if (regcache_valid_p (regcache, tdep->ppc_ps_regnum)) if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr); regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
if (regcache_valid_p (regcache, tdep->ppc_cr_regnum)) if (regcache_valid_p (regcache, tdep->ppc_cr_regnum))
@ -1459,7 +1465,7 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
&tmp_xer, &tmp_fpscr); &tmp_xer, &tmp_fpscr);
if (regcache_valid_p (regcache, PC_REGNUM)) if (regcache_valid_p (regcache, gdbarch_pc_regnum (current_gdbarch)))
ctx.iar = tmp_iar; ctx.iar = tmp_iar;
if (regcache_valid_p (regcache, tdep->ppc_ps_regnum)) if (regcache_valid_p (regcache, tdep->ppc_ps_regnum))
ctx.msr = tmp_msr; ctx.msr = tmp_msr;

6
gdb/alpha-linux-nat.c
View File

@ -86,14 +86,14 @@ fill_fpregset (const struct regcache *regcache,
static CORE_ADDR static CORE_ADDR
alpha_linux_register_u_offset (struct gdbarch *gdbarch, int regno, int store_p) alpha_linux_register_u_offset (struct gdbarch *gdbarch, int regno, int store_p)
{ {
if (regno == PC_REGNUM) if (regno == gdbarch_pc_regnum (current_gdbarch))
return PC; return PC;
if (regno == ALPHA_UNIQUE_REGNUM) if (regno == ALPHA_UNIQUE_REGNUM)
return ALPHA_UNIQUE_PTRACE_ADDR; return ALPHA_UNIQUE_PTRACE_ADDR;
if (regno < FP0_REGNUM) if (regno < gdbarch_fp0_regnum (current_gdbarch))
return GPR_BASE + regno; return GPR_BASE + regno;
else else
return FPR_BASE + regno - FP0_REGNUM; return FPR_BASE + regno - gdbarch_fp0_regnum (current_gdbarch);
} }
void _initialialize_alpha_linux_nat (void); void _initialialize_alpha_linux_nat (void);

2
gdb/alpha-tdep.c
View File

@ -1443,7 +1443,7 @@ alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
case 0x33: /* FBLE */ case 0x33: /* FBLE */
case 0x32: /* FBLT */ case 0x32: /* FBLT */
case 0x35: /* FBNE */ case 0x35: /* FBNE */
regno += FP0_REGNUM; regno += gdbarch_fp0_regnum (current_gdbarch);
} }
rav = get_frame_register_signed (frame, regno); rav = get_frame_register_signed (frame, regno);

4
gdb/alphabsd-nat.c
View File

@ -101,7 +101,7 @@ alphabsd_fetch_inferior_registers (struct regcache *regcache, int regno)
return; return;
} }
if (regno == -1 || regno >= FP0_REGNUM) if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
{ {
struct fpreg fpregs; struct fpreg fpregs;
@ -136,7 +136,7 @@ alphabsd_store_inferior_registers (struct regcache *regcache, int regno)
return; return;
} }
if (regno == -1 || regno >= FP0_REGNUM) if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
{ {
struct fpreg fpregs; struct fpreg fpregs;

2
gdb/amd64-linux-tdep.c
View File

@ -156,7 +156,7 @@ amd64_linux_sigcontext_addr (struct frame_info *next_frame)
CORE_ADDR sp; CORE_ADDR sp;
gdb_byte buf[8]; gdb_byte buf[8];
frame_unwind_register (next_frame, SP_REGNUM, buf); frame_unwind_register (next_frame, gdbarch_sp_regnum (current_gdbarch), buf);
sp = extract_unsigned_integer (buf, 8); sp = extract_unsigned_integer (buf, 8);
/* The sigcontext structure is part of the user context. A pointer /* The sigcontext structure is part of the user context. A pointer

2
gdb/amd64-tdep.c
View File

@ -870,7 +870,7 @@ amd64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
gdb_assert (regnum >= 0); gdb_assert (regnum >= 0);
if (regnum == SP_REGNUM && cache->saved_sp) if (regnum == gdbarch_sp_regnum (current_gdbarch) && cache->saved_sp)
{ {
*optimizedp = 0; *optimizedp = 0;
*lvalp = not_lval; *lvalp = not_lval;

6
gdb/arch-utils.c
View File

@ -189,8 +189,10 @@ legacy_virtual_frame_pointer (CORE_ADDR pc,
if (DEPRECATED_FP_REGNUM >= 0 if (DEPRECATED_FP_REGNUM >= 0
&& DEPRECATED_FP_REGNUM < gdbarch_num_regs (current_gdbarch)) && DEPRECATED_FP_REGNUM < gdbarch_num_regs (current_gdbarch))
*frame_regnum = DEPRECATED_FP_REGNUM; *frame_regnum = DEPRECATED_FP_REGNUM;
else if (SP_REGNUM >= 0 && SP_REGNUM < gdbarch_num_regs (current_gdbarch)) else if (gdbarch_sp_regnum (current_gdbarch) >= 0
*frame_regnum = SP_REGNUM; && gdbarch_sp_regnum (current_gdbarch)
< gdbarch_num_regs (current_gdbarch))
*frame_regnum = gdbarch_sp_regnum (current_gdbarch);
else else
/* Should this be an internal error? I guess so, it is reflecting /* Should this be an internal error? I guess so, it is reflecting
an architectural limitation in the current design. */ an architectural limitation in the current design. */

2
gdb/core-regset.c
View File

@ -85,7 +85,7 @@ fetch_core_registers (struct regcache *regcache,
else else
{ {
memcpy (&fpregset, core_reg_sect, sizeof (fpregset)); memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
if (FP0_REGNUM >= 0) if (gdbarch_fp0_regnum (current_gdbarch) >= 0)
supply_fpregset (regcache, (const gdb_fpregset_t *) &fpregset); supply_fpregset (regcache, (const gdb_fpregset_t *) &fpregset);
} }
break; break;

94
gdb/cris-tdep.c
View File

@ -74,8 +74,8 @@ enum cris_num_regs
ARG2_REGNUM Contains the second parameter to a function. ARG2_REGNUM Contains the second parameter to a function.
ARG3_REGNUM Contains the third parameter to a function. ARG3_REGNUM Contains the third parameter to a function.
ARG4_REGNUM Contains the fourth parameter to a function. Rest on stack. ARG4_REGNUM Contains the fourth parameter to a function. Rest on stack.
SP_REGNUM Contains address of top of stack. gdbarch_sp_regnum Contains address of top of stack.
PC_REGNUM Contains address of next instruction. gdbarch_pc_regnum Contains address of next instruction.
SRP_REGNUM Subroutine return pointer register. SRP_REGNUM Subroutine return pointer register.
BRP_REGNUM Breakpoint return pointer register. */ BRP_REGNUM Breakpoint return pointer register. */
@ -279,7 +279,7 @@ cris_sigcontext_addr (struct frame_info *next_frame)
CORE_ADDR sp; CORE_ADDR sp;
char buf[4]; char buf[4];
frame_unwind_register (next_frame, SP_REGNUM, buf); frame_unwind_register (next_frame, gdbarch_sp_regnum (current_gdbarch), buf);
sp = extract_unsigned_integer (buf, 4); sp = extract_unsigned_integer (buf, 4);
/* Look for normal sigtramp frame first. */ /* Look for normal sigtramp frame first. */
@ -359,7 +359,7 @@ cris_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
info->return_pc = 0; info->return_pc = 0;
info->leaf_function = 0; info->leaf_function = 0;
frame_unwind_register (next_frame, SP_REGNUM, buf); frame_unwind_register (next_frame, gdbarch_sp_regnum (current_gdbarch), buf);
info->base = extract_unsigned_integer (buf, 4); info->base = extract_unsigned_integer (buf, 4);
addr = cris_sigcontext_addr (next_frame); addr = cris_sigcontext_addr (next_frame);
@ -385,8 +385,10 @@ cris_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
it though since that will mean that the backtrace will show a PC it though since that will mean that the backtrace will show a PC
different from what is shown when stopped. */ different from what is shown when stopped. */
info->saved_regs[IRP_REGNUM].addr = addr + (19 * 4); info->saved_regs[IRP_REGNUM].addr = addr + (19 * 4);
info->saved_regs[PC_REGNUM] = info->saved_regs[IRP_REGNUM]; info->saved_regs[gdbarch_pc_regnum (current_gdbarch)]
info->saved_regs[SP_REGNUM].addr = addr + (24 * 4); = info->saved_regs[IRP_REGNUM];
info->saved_regs[gdbarch_sp_regnum (current_gdbarch)].addr
= addr + (24 * 4);
} }
else else
{ {
@ -413,9 +415,11 @@ cris_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
This could be solved by a couple of read_memory_unsigned_integer and a This could be solved by a couple of read_memory_unsigned_integer and a
trad_frame_set_value. */ trad_frame_set_value. */
info->saved_regs[PC_REGNUM] = info->saved_regs[ERP_REGNUM]; info->saved_regs[gdbarch_pc_regnum (current_gdbarch)]
= info->saved_regs[ERP_REGNUM];
info->saved_regs[SP_REGNUM].addr = addr + (25 * 4); info->saved_regs[gdbarch_sp_regnum (current_gdbarch)].addr
= addr + (25 * 4);
} }
return info; return info;
@ -986,7 +990,8 @@ cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
} }
/* Finally, update the SP register. */ /* Finally, update the SP register. */
regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp); regcache_cooked_write_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
return sp; return sp;
} }
@ -1180,7 +1185,7 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
} }
continue; continue;
} }
else if (cris_get_operand2 (insn) == SP_REGNUM else if (cris_get_operand2 (insn) == gdbarch_sp_regnum (current_gdbarch)
&& cris_get_mode (insn) == 0x0000 && cris_get_mode (insn) == 0x0000
&& cris_get_opcode (insn) == 0x000A) && cris_get_opcode (insn) == 0x000A)
{ {
@ -1193,12 +1198,13 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
else if (cris_get_mode (insn) == 0x0002 else if (cris_get_mode (insn) == 0x0002
&& cris_get_opcode (insn) == 0x000F && cris_get_opcode (insn) == 0x000F
&& cris_get_size (insn) == 0x0003 && cris_get_size (insn) == 0x0003
&& cris_get_operand1 (insn) == SP_REGNUM) && cris_get_operand1 (insn) == gdbarch_sp_regnum
(current_gdbarch))
{ {
/* movem r<regsave>,[sp] */ /* movem r<regsave>,[sp] */
regsave = cris_get_operand2 (insn); regsave = cris_get_operand2 (insn);
} }
else if (cris_get_operand2 (insn) == SP_REGNUM else if (cris_get_operand2 (insn) == gdbarch_sp_regnum (current_gdbarch)
&& ((insn & 0x0F00) >> 8) == 0x0001 && ((insn & 0x0F00) >> 8) == 0x0001
&& (cris_get_signed_offset (insn) < 0)) && (cris_get_signed_offset (insn) < 0))
{ {
@ -1215,7 +1221,8 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
if (cris_get_mode (insn_next) == PREFIX_ASSIGN_MODE if (cris_get_mode (insn_next) == PREFIX_ASSIGN_MODE
&& cris_get_opcode (insn_next) == 0x000F && cris_get_opcode (insn_next) == 0x000F
&& cris_get_size (insn_next) == 0x0003 && cris_get_size (insn_next) == 0x0003
&& cris_get_operand1 (insn_next) == SP_REGNUM) && cris_get_operand1 (insn_next) == gdbarch_sp_regnum
(current_gdbarch))
{ {
regsave = cris_get_operand2 (insn_next); regsave = cris_get_operand2 (insn_next);
} }
@ -1257,7 +1264,7 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
insn_next = read_memory_unsigned_integer (pc, 2); insn_next = read_memory_unsigned_integer (pc, 2);
pc += 2; pc += 2;
regno = cris_get_operand2 (insn_next); regno = cris_get_operand2 (insn_next);
if ((regno >= 0 && regno < SP_REGNUM) if ((regno >= 0 && regno < gdbarch_sp_regnum (current_gdbarch))
&& cris_get_mode (insn_next) == PREFIX_OFFSET_MODE && cris_get_mode (insn_next) == PREFIX_OFFSET_MODE
&& cris_get_opcode (insn_next) == 0x000F) && cris_get_opcode (insn_next) == 0x000F)
{ {
@ -1281,7 +1288,7 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
insn_next = read_memory_unsigned_integer (pc, 2); insn_next = read_memory_unsigned_integer (pc, 2);
pc += 2; pc += 2;
regno = cris_get_operand2 (insn_next); regno = cris_get_operand2 (insn_next);
if ((regno >= 0 && regno < SP_REGNUM) if ((regno >= 0 && regno < gdbarch_sp_regnum (current_gdbarch))
&& cris_get_mode (insn_next) == PREFIX_OFFSET_MODE && cris_get_mode (insn_next) == PREFIX_OFFSET_MODE
&& cris_get_opcode (insn_next) == 0x0009 && cris_get_opcode (insn_next) == 0x0009
&& cris_get_operand1 (insn_next) == regno) && cris_get_operand1 (insn_next) == regno)
@ -1335,7 +1342,9 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
ULONGEST this_base; ULONGEST this_base;
/* Assume that the FP is this frame's SP but with that pushed /* Assume that the FP is this frame's SP but with that pushed
stack space added back. */ stack space added back. */
frame_unwind_unsigned_register (next_frame, SP_REGNUM, &this_base); frame_unwind_unsigned_register (next_frame,
gdbarch_sp_regnum (current_gdbarch),
&this_base);
info->base = this_base; info->base = this_base;
info->prev_sp = info->base + info->size; info->prev_sp = info->base + info->size;
} }
@ -1354,7 +1363,8 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
/* The previous frame's SP needed to be computed. Save the computed /* The previous frame's SP needed to be computed. Save the computed
value. */ value. */
trad_frame_set_value (info->saved_regs, SP_REGNUM, info->prev_sp); trad_frame_set_value (info->saved_regs,
gdbarch_sp_regnum (current_gdbarch), info->prev_sp);
if (!info->leaf_function) if (!info->leaf_function)
{ {
@ -1372,7 +1382,8 @@ cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
} }
/* The PC is found in SRP (the actual register or located on the stack). */ /* The PC is found in SRP (the actual register or located on the stack). */
info->saved_regs[PC_REGNUM] = info->saved_regs[SRP_REGNUM]; info->saved_regs[gdbarch_pc_regnum (current_gdbarch)]
= info->saved_regs[SRP_REGNUM];
return pc; return pc;
} }
@ -1403,12 +1414,15 @@ crisv32_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
} }
/* The SP is assumed to be unaltered. */ /* The SP is assumed to be unaltered. */
frame_unwind_unsigned_register (next_frame, SP_REGNUM, &this_base); frame_unwind_unsigned_register (next_frame,
gdbarch_sp_regnum (current_gdbarch),
&this_base);
info->base = this_base; info->base = this_base;
info->prev_sp = this_base; info->prev_sp = this_base;
/* The PC is assumed to be found in SRP. */ /* The PC is assumed to be found in SRP. */
info->saved_regs[PC_REGNUM] = info->saved_regs[SRP_REGNUM]; info->saved_regs[gdbarch_pc_regnum (current_gdbarch)]
= info->saved_regs[SRP_REGNUM];
return pc; return pc;
} }
@ -1447,7 +1461,8 @@ static CORE_ADDR
cris_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) cris_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
ULONGEST pc; ULONGEST pc;
frame_unwind_unsigned_register (next_frame, PC_REGNUM, &pc); frame_unwind_unsigned_register (next_frame,
gdbarch_pc_regnum (current_gdbarch), &pc);
return pc; return pc;
} }
@ -1455,7 +1470,8 @@ static CORE_ADDR
cris_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) cris_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
ULONGEST sp; ULONGEST sp;
frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp); frame_unwind_unsigned_register (next_frame,
gdbarch_sp_regnum (current_gdbarch), &sp);
return sp; return sp;
} }
@ -1550,7 +1566,8 @@ cris_register_size (int regno)
/* Special register not applicable to this CRIS version. */ /* Special register not applicable to this CRIS version. */
return 0; return 0;
} }
else if (regno >= PC_REGNUM && regno < gdbarch_num_regs (current_gdbarch)) else if (regno >= gdbarch_pc_regnum (current_gdbarch)
&& regno < gdbarch_num_regs (current_gdbarch))
{ {
/* This will apply to CRISv32 only where there are additional registers /* This will apply to CRISv32 only where there are additional registers
after the special registers (pseudo PC and support registers). */ after the special registers (pseudo PC and support registers). */
@ -1651,11 +1668,12 @@ crisv32_cannot_store_register (int regno)
static struct type * static struct type *
cris_register_type (struct gdbarch *gdbarch, int regno) cris_register_type (struct gdbarch *gdbarch, int regno)
{ {
if (regno == PC_REGNUM) if (regno == gdbarch_pc_regnum (current_gdbarch))
return builtin_type_void_func_ptr; return builtin_type_void_func_ptr;
else if (regno == SP_REGNUM || regno == CRIS_FP_REGNUM) else if (regno == gdbarch_sp_regnum (current_gdbarch)
|| regno == CRIS_FP_REGNUM)
return builtin_type_void_data_ptr; return builtin_type_void_data_ptr;
else if ((regno >= 0 && regno < SP_REGNUM) else if ((regno >= 0 && regno < gdbarch_sp_regnum (current_gdbarch))
|| (regno >= MOF_REGNUM && regno <= USP_REGNUM)) || (regno >= MOF_REGNUM && regno <= USP_REGNUM))
/* Note: R8 taken care of previous clause. */ /* Note: R8 taken care of previous clause. */
return builtin_type_uint32; return builtin_type_uint32;
@ -1671,9 +1689,10 @@ cris_register_type (struct gdbarch *gdbarch, int regno)
static struct type * static struct type *
crisv32_register_type (struct gdbarch *gdbarch, int regno) crisv32_register_type (struct gdbarch *gdbarch, int regno)
{ {
if (regno == PC_REGNUM) if (regno == gdbarch_pc_regnum (current_gdbarch))
return builtin_type_void_func_ptr; return builtin_type_void_func_ptr;
else if (regno == SP_REGNUM || regno == CRIS_FP_REGNUM) else if (regno == gdbarch_sp_regnum (current_gdbarch)
|| regno == CRIS_FP_REGNUM)
return builtin_type_void_data_ptr; return builtin_type_void_data_ptr;
else if ((regno >= 0 && regno <= ACR_REGNUM) else if ((regno >= 0 && regno <= ACR_REGNUM)
|| (regno >= EXS_REGNUM && regno <= SPC_REGNUM) || (regno >= EXS_REGNUM && regno <= SPC_REGNUM)
@ -1801,7 +1820,7 @@ crisv32_register_name (int regno)
{ {
return cris_special_register_name (regno); return cris_special_register_name (regno);
} }
else if (regno == PC_REGNUM) else if (regno == gdbarch_pc_regnum (current_gdbarch))
{ {
return "pc"; return "pc";
} }
@ -1854,11 +1873,11 @@ cris_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct frame_info *next_frame) struct frame_info *next_frame)
{ {
/* The return address column. */ /* The return address column. */
if (regnum == PC_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch))
reg->how = DWARF2_FRAME_REG_RA; reg->how = DWARF2_FRAME_REG_RA;
/* The call frame address. */ /* The call frame address. */
else if (regnum == SP_REGNUM) else if (regnum == gdbarch_sp_regnum (current_gdbarch))
reg->how = DWARF2_FRAME_REG_CFA; reg->how = DWARF2_FRAME_REG_CFA;
} }
@ -2090,7 +2109,8 @@ find_step_target (struct frame_info *frame, inst_env_type *inst_env)
do do
{ {
/* Read an instruction from the client. */ /* Read an instruction from the client. */
insn = read_memory_unsigned_integer (inst_env->reg[PC_REGNUM], 2); insn = read_memory_unsigned_integer
(inst_env->reg[gdbarch_pc_regnum (current_gdbarch)], 2);
/* If the instruction is not in a delay slot the new content of the /* If the instruction is not in a delay slot the new content of the
PC is [PC] + 2. If the instruction is in a delay slot it is not PC is [PC] + 2. If the instruction is in a delay slot it is not
@ -2099,12 +2119,13 @@ find_step_target (struct frame_info *frame, inst_env_type *inst_env)
Just make sure it is a valid instruction. */ Just make sure it is a valid instruction. */
if (!inst_env->delay_slot_pc_active) if (!inst_env->delay_slot_pc_active)
{ {
inst_env->reg[PC_REGNUM] += 2; inst_env->reg[gdbarch_pc_regnum (current_gdbarch)] += 2;
} }
else else
{ {
inst_env->delay_slot_pc_active = 0; inst_env->delay_slot_pc_active = 0;
inst_env->reg[PC_REGNUM] = inst_env->delay_slot_pc; inst_env->reg[gdbarch_pc_regnum (current_gdbarch)]
= inst_env->delay_slot_pc;
} }
/* Analyse the present instruction. */ /* Analyse the present instruction. */
i = find_cris_op (insn, inst_env); i = find_cris_op (insn, inst_env);
@ -2144,7 +2165,8 @@ cris_software_single_step (struct frame_info *frame)
{ {
/* Insert at most two breakpoints. One for the next PC content /* Insert at most two breakpoints. One for the next PC content
and possibly another one for a branch, jump, etc. */ and possibly another one for a branch, jump, etc. */
CORE_ADDR next_pc = (CORE_ADDR) inst_env.reg[PC_REGNUM]; CORE_ADDR next_pc =
(CORE_ADDR) inst_env.reg[gdbarch_pc_regnum (current_gdbarch)];
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (next_pc);
if (inst_env.branch_found if (inst_env.branch_found
&& (CORE_ADDR) inst_env.branch_break_address != next_pc) && (CORE_ADDR) inst_env.branch_break_address != next_pc)
@ -3882,7 +3904,7 @@ cris_supply_gregset (struct regcache *regcache, elf_gregset_t *gregsetp)
/* Needed to set pseudo-register PC for CRISv32. */ /* Needed to set pseudo-register PC for CRISv32. */
/* FIXME: If ERP is in a delay slot at this point then the PC will /* FIXME: If ERP is in a delay slot at this point then the PC will
be wrong. Issue a warning to alert the user. */ be wrong. Issue a warning to alert the user. */
regcache_raw_supply (regcache, PC_REGNUM, regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch),
(char *)&regp[ERP_REGNUM]); (char *)&regp[ERP_REGNUM]);
if (*(char *)&regp[ERP_REGNUM] & 0x1) if (*(char *)&regp[ERP_REGNUM] & 0x1)

4
gdb/dbug-rom.c
View File

@ -51,12 +51,12 @@ dbug_supply_register (struct regcache *regcache, char *regname,
case 'S': case 'S':
if (regname[1] != 'R') if (regname[1] != 'R')
return; return;
regno = PS_REGNUM; regno = gdbarch_ps_regnum (current_gdbarch);
break; break;
case 'P': case 'P':
if (regname[1] != 'C') if (regname[1] != 'C')
return; return;
regno = PC_REGNUM; regno = gdbarch_pc_regnum (current_gdbarch);
break; break;
case 'D': case 'D':
if (regname[1] < '0' || regname[1] > '7') if (regname[1] < '0' || regname[1] > '7')

4
gdb/dwarf2-frame.c
View File

@ -649,9 +649,9 @@ dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
(e.g. IBM S/390 and zSeries). Those architectures should provide (e.g. IBM S/390 and zSeries). Those architectures should provide
their own architecture-specific initialization function. */ their own architecture-specific initialization function. */
if (regnum == PC_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch))
reg->how = DWARF2_FRAME_REG_RA; reg->how = DWARF2_FRAME_REG_RA;
else if (regnum == SP_REGNUM) else if (regnum == gdbarch_sp_regnum (current_gdbarch))
reg->how = DWARF2_FRAME_REG_CFA; reg->how = DWARF2_FRAME_REG_CFA;
} }

17
gdb/frame.c
View File

@ -1229,7 +1229,7 @@ get_prev_frame_1 (struct frame_info *this_frame)
method set the same lval and location information as method set the same lval and location information as
frame_register_unwind. */ frame_register_unwind. */
if (this_frame->level > 0 if (this_frame->level > 0
&& PC_REGNUM >= 0 && gdbarch_pc_regnum (current_gdbarch) >= 0
&& get_frame_type (this_frame) == NORMAL_FRAME && get_frame_type (this_frame) == NORMAL_FRAME
&& get_frame_type (this_frame->next) == NORMAL_FRAME) && get_frame_type (this_frame->next) == NORMAL_FRAME)
{ {
@ -1237,9 +1237,11 @@ get_prev_frame_1 (struct frame_info *this_frame)
enum lval_type lval, nlval; enum lval_type lval, nlval;
CORE_ADDR addr, naddr; CORE_ADDR addr, naddr;
frame_register_unwind_location (this_frame, PC_REGNUM, &optimized, frame_register_unwind_location (this_frame,
&lval, &addr, &realnum); gdbarch_pc_regnum (current_gdbarch),
frame_register_unwind_location (get_next_frame (this_frame), PC_REGNUM, &optimized, &lval, &addr, &realnum);
frame_register_unwind_location (get_next_frame (this_frame),
gdbarch_pc_regnum (current_gdbarch),
&optimized, &nlval, &naddr, &realnum); &optimized, &nlval, &naddr, &realnum);
if (lval == lval_memory && lval == nlval && addr == naddr) if (lval == lval_memory && lval == nlval && addr == naddr)
@ -1724,11 +1726,12 @@ frame_sp_unwind (struct frame_info *next_frame)
if (gdbarch_unwind_sp_p (current_gdbarch)) if (gdbarch_unwind_sp_p (current_gdbarch))
return gdbarch_unwind_sp (current_gdbarch, next_frame); return gdbarch_unwind_sp (current_gdbarch, next_frame);
/* Now things are really are grim. Hope that the value returned by /* Now things are really are grim. Hope that the value returned by
the SP_REGNUM register is meaningful. */ the gdbarch_sp_regnum register is meaningful. */
if (SP_REGNUM >= 0) if (gdbarch_sp_regnum (current_gdbarch) >= 0)
{ {
ULONGEST sp; ULONGEST sp;
frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp); frame_unwind_unsigned_register (next_frame,
gdbarch_sp_regnum (current_gdbarch), &sp);
return sp; return sp;
} }
internal_error (__FILE__, __LINE__, _("Missing unwind SP method")); internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));

20
gdb/gdbarch.c
View File

@ -839,11 +839,6 @@ gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: float_format = %s\n", "gdbarch_dump: float_format = %s\n",
pformat (current_gdbarch->float_format)); pformat (current_gdbarch->float_format));
#ifdef FP0_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: FP0_REGNUM # %s\n",
XSTRING (FP0_REGNUM));
#endif
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: fp0_regnum = %s\n", "gdbarch_dump: fp0_regnum = %s\n",
paddr_d (current_gdbarch->fp0_regnum)); paddr_d (current_gdbarch->fp0_regnum));
@ -928,11 +923,6 @@ gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: overlay_update = <0x%lx>\n", "gdbarch_dump: overlay_update = <0x%lx>\n",
(long) current_gdbarch->overlay_update); (long) current_gdbarch->overlay_update);
#ifdef PC_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: PC_REGNUM # %s\n",
XSTRING (PC_REGNUM));
#endif
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: pc_regnum = %s\n", "gdbarch_dump: pc_regnum = %s\n",
paddr_d (current_gdbarch->pc_regnum)); paddr_d (current_gdbarch->pc_regnum));
@ -963,11 +953,6 @@ gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: print_vector_info = <0x%lx>\n", "gdbarch_dump: print_vector_info = <0x%lx>\n",
(long) current_gdbarch->print_vector_info); (long) current_gdbarch->print_vector_info);
#ifdef PS_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: PS_REGNUM # %s\n",
XSTRING (PS_REGNUM));
#endif
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: ps_regnum = %s\n", "gdbarch_dump: ps_regnum = %s\n",
paddr_d (current_gdbarch->ps_regnum)); paddr_d (current_gdbarch->ps_regnum));
@ -1085,11 +1070,6 @@ gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: software_single_step = <0x%lx>\n", "gdbarch_dump: software_single_step = <0x%lx>\n",
(long) current_gdbarch->software_single_step); (long) current_gdbarch->software_single_step);
#ifdef SP_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: SP_REGNUM # %s\n",
XSTRING (SP_REGNUM));
#endif
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: sp_regnum = %s\n", "gdbarch_dump: sp_regnum = %s\n",
paddr_d (current_gdbarch->sp_regnum)); paddr_d (current_gdbarch->sp_regnum));

26
gdb/gdbarch.h
View File

@ -192,43 +192,19 @@ extern void set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch, int num_pseudo
/* GDB's standard (or well known) register numbers. These can map onto /* GDB's standard (or well known) register numbers. These can map onto
a real register or a pseudo (computed) register or not be defined at a real register or a pseudo (computed) register or not be defined at
all (-1). all (-1).
SP_REGNUM will hopefully be replaced by UNWIND_SP. */ gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP. */
extern int gdbarch_sp_regnum (struct gdbarch *gdbarch); extern int gdbarch_sp_regnum (struct gdbarch *gdbarch);
extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum); extern void set_gdbarch_sp_regnum (struct gdbarch *gdbarch, int sp_regnum);
#if !defined (GDB_TM_FILE) && defined (SP_REGNUM)
#error "Non multi-arch definition of SP_REGNUM"
#endif
#if !defined (SP_REGNUM)
#define SP_REGNUM (gdbarch_sp_regnum (current_gdbarch))
#endif
extern int gdbarch_pc_regnum (struct gdbarch *gdbarch); extern int gdbarch_pc_regnum (struct gdbarch *gdbarch);
extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum); extern void set_gdbarch_pc_regnum (struct gdbarch *gdbarch, int pc_regnum);
#if !defined (GDB_TM_FILE) && defined (PC_REGNUM)
#error "Non multi-arch definition of PC_REGNUM"
#endif
#if !defined (PC_REGNUM)
#define PC_REGNUM (gdbarch_pc_regnum (current_gdbarch))
#endif
extern int gdbarch_ps_regnum (struct gdbarch *gdbarch); extern int gdbarch_ps_regnum (struct gdbarch *gdbarch);
extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum); extern void set_gdbarch_ps_regnum (struct gdbarch *gdbarch, int ps_regnum);
#if !defined (GDB_TM_FILE) && defined (PS_REGNUM)
#error "Non multi-arch definition of PS_REGNUM"
#endif
#if !defined (PS_REGNUM)
#define PS_REGNUM (gdbarch_ps_regnum (current_gdbarch))
#endif
extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch); extern int gdbarch_fp0_regnum (struct gdbarch *gdbarch);
extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum); extern void set_gdbarch_fp0_regnum (struct gdbarch *gdbarch, int fp0_regnum);
#if !defined (GDB_TM_FILE) && defined (FP0_REGNUM)
#error "Non multi-arch definition of FP0_REGNUM"
#endif
#if !defined (FP0_REGNUM)
#define FP0_REGNUM (gdbarch_fp0_regnum (current_gdbarch))
#endif
/* Convert stab register number (from `r' declaration) to a gdb REGNUM. */ /* Convert stab register number (from `r' declaration) to a gdb REGNUM. */

10
gdb/gdbarch.sh
View File

@ -438,11 +438,11 @@ v::int:num_pseudo_regs:::0:0::0
# GDB's standard (or well known) register numbers. These can map onto # GDB's standard (or well known) register numbers. These can map onto
# a real register or a pseudo (computed) register or not be defined at # a real register or a pseudo (computed) register or not be defined at
# all (-1). # all (-1).
# SP_REGNUM will hopefully be replaced by UNWIND_SP. # gdbarch_sp_regnum will hopefully be replaced by UNWIND_SP.
v:=:int:sp_regnum:::-1:-1::0 v::int:sp_regnum:::-1:-1::0
v:=:int:pc_regnum:::-1:-1::0 v::int:pc_regnum:::-1:-1::0
v:=:int:ps_regnum:::-1:-1::0 v::int:ps_regnum:::-1:-1::0
v:=:int:fp0_regnum:::0:-1::0 v::int:fp0_regnum:::0:-1::0
# Convert stab register number (from \`r\' declaration) to a gdb REGNUM. # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
f::int:stab_reg_to_regnum:int stab_regnr:stab_regnr::no_op_reg_to_regnum::0 f::int:stab_reg_to_regnum:int stab_regnr:stab_regnr::no_op_reg_to_regnum::0
# Provide a default mapping from a ecoff register number to a gdb REGNUM. # Provide a default mapping from a ecoff register number to a gdb REGNUM.

8
gdb/go32-nat.c
View File

@ -467,7 +467,7 @@ go32_wait (ptid_t ptid, struct target_waitstatus *status)
static void static void
fetch_register (struct regcache *regcache, int regno) fetch_register (struct regcache *regcache, int regno)
{ {
if (regno < FP0_REGNUM) if (regno < gdbarch_fp0_regnum (current_gdbarch))
regcache_raw_supply (regcache, regno, regcache_raw_supply (regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs); (char *) &a_tss + regno_mapping[regno].tss_ofs);
else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno)) else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
@ -484,7 +484,7 @@ go32_fetch_registers (struct regcache *regcache, int regno)
fetch_register (regcache, regno); fetch_register (regcache, regno);
else else
{ {
for (regno = 0; regno < FP0_REGNUM; regno++) for (regno = 0; regno < gdbarch_fp0_regnum (current_gdbarch); regno++)
fetch_register (regcache, regno); fetch_register (regcache, regno);
i387_supply_fsave (regcache, -1, &npx); i387_supply_fsave (regcache, -1, &npx);
} }
@ -493,7 +493,7 @@ go32_fetch_registers (struct regcache *regcache, int regno)
static void static void
store_register (const struct regcache *regcache, int regno) store_register (const struct regcache *regcache, int regno)
{ {
if (regno < FP0_REGNUM) if (regno < gdbarch_fp0_regnum (current_gdbarch))
regcache_raw_collect (regcache, regno, regcache_raw_collect (regcache, regno,
(char *) &a_tss + regno_mapping[regno].tss_ofs); (char *) &a_tss + regno_mapping[regno].tss_ofs);
else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno)) else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
@ -512,7 +512,7 @@ go32_store_registers (struct regcache *regcache, int regno)
store_register (regcache, regno); store_register (regcache, regno);
else else
{ {
for (r = 0; r < FP0_REGNUM; r++) for (r = 0; r < gdbarch_fp0_regnum (current_gdbarch); r++)
store_register (regcache, r); store_register (regcache, r);
i387_collect_fsave (regcache, -1, &npx); i387_collect_fsave (regcache, -1, &npx);
} }

3
gdb/i386-linux-nat.c
View File

@ -744,7 +744,8 @@ i386_linux_resume (ptid_t ptid, int step, enum target_signal signal)
request = PTRACE_SINGLESTEP; request = PTRACE_SINGLESTEP;
regcache_cooked_read_unsigned (regcache, PC_REGNUM, &pc); regcache_cooked_read_unsigned (regcache,
gdbarch_pc_regnum (current_gdbarch), &pc);
/* Returning from a signal trampoline is done by calling a /* Returning from a signal trampoline is done by calling a
special system call (sigreturn or rt_sigreturn, see special system call (sigreturn or rt_sigreturn, see

3
gdb/i386-nto-tdep.c
View File

@ -166,7 +166,8 @@ i386nto_register_area (int regno, int regset, unsigned *off)
if (regno == -1) if (regno == -1)
return regset_size; return regset_size;
*off = (regno - FP0_REGNUM) * regsize + off_adjust; *off = (regno - gdbarch_fp0_regnum (current_gdbarch))
* regsize + off_adjust;
return 10; return 10;
/* Why 10 instead of regsize? GDB only stores 10 bytes per FP /* Why 10 instead of regsize? GDB only stores 10 bytes per FP
register so if we're sending a register back to the target, register so if we're sending a register back to the target,

4
gdb/i386-tdep.c
View File

@ -914,7 +914,7 @@ i386_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
gdb_byte buf[8]; gdb_byte buf[8];
frame_unwind_register (next_frame, PC_REGNUM, buf); frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf);
return extract_typed_address (buf, builtin_type_void_func_ptr); return extract_typed_address (buf, builtin_type_void_func_ptr);
} }
@ -1280,7 +1280,7 @@ i386_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
/* Don't use I386_ESP_REGNUM here, since this function is also used /* Don't use I386_ESP_REGNUM here, since this function is also used
for AMD64. */ for AMD64. */
get_frame_register (frame, SP_REGNUM, buf); get_frame_register (frame, gdbarch_sp_regnum (current_gdbarch), buf);
sp = extract_typed_address (buf, builtin_type_void_data_ptr); sp = extract_typed_address (buf, builtin_type_void_data_ptr);
if (target_read_memory (sp + len, buf, len)) if (target_read_memory (sp + len, buf, len))
return 0; return 0;

2
gdb/i386-tdep.h
View File

@ -40,7 +40,7 @@ struct regcache;
- SSE control register - SSE control register
The general purpose registers for the x86-64 architecture are quite The general purpose registers for the x86-64 architecture are quite
different from IA-32. Therefore, the FP0_REGNUM target macro different from IA-32. Therefore, gdbarch_fp0_regnum
determines the register number at which the FPU data registers determines the register number at which the FPU data registers
start. The number of FPU data and control registers is the same start. The number of FPU data and control registers is the same
for both architectures. The number of SSE registers however, for both architectures. The number of SSE registers however,

4
gdb/i386v4-nat.c
View File

@ -139,7 +139,7 @@ fill_gregset (const struct regcache *regcache,
void void
supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp) supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{ {
if (FP0_REGNUM == 0) if (gdbarch_fp0_regnum (current_gdbarch) == 0)
return; return;
i387_supply_fsave (regcache, -1, fpregsetp); i387_supply_fsave (regcache, -1, fpregsetp);
@ -153,7 +153,7 @@ void
fill_fpregset (const struct regcache *regcache, fill_fpregset (const struct regcache *regcache,
fpregset_t *fpregsetp, int regno) fpregset_t *fpregsetp, int regno)
{ {
if (FP0_REGNUM == 0) if (gdbarch_fp0_regnum (current_gdbarch) == 0)
return; return;
i387_collect_fsave (regcache, regno, fpregsetp); i387_collect_fsave (regcache, regno, fpregsetp);

2
gdb/ia64-tdep.c
View File

@ -1618,7 +1618,7 @@ ia64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
memset (valuep, 0, register_size (current_gdbarch, regnum)); memset (valuep, 0, register_size (current_gdbarch, regnum));
if (regnum == SP_REGNUM) if (regnum == gdbarch_sp_regnum (current_gdbarch))
{ {
/* Handle SP values for all frames but the topmost. */ /* Handle SP values for all frames but the topmost. */
store_unsigned_integer (valuep, register_size (current_gdbarch, regnum), store_unsigned_integer (valuep, register_size (current_gdbarch, regnum),

12
gdb/irix5-nat.c
View File

@ -95,7 +95,7 @@ fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
*(regp + regi) = extract_signed_integer (buf, size); *(regp + regi) = extract_signed_integer (buf, size);
} }
if ((regno == -1) || (regno == PC_REGNUM)) if ((regno == -1) || (regno == gdbarch_pc_regnum (current_gdbarch)))
{ {
regi = mips_regnum (current_gdbarch)->pc; regi = mips_regnum (current_gdbarch)->pc;
size = register_size (current_gdbarch, regi); size = register_size (current_gdbarch, regi);
@ -130,7 +130,7 @@ fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
/* /*
* Now we do the same thing for floating-point registers. * 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. * reasonable MIPS configuration has an R3010 in it.
* *
* Again, see the comments in m68k-tdep.c. * Again, see the comments in m68k-tdep.c.
@ -146,7 +146,7 @@ supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
/* 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, FP0_REGNUM + regi, regcache_raw_supply (regcache, gdbarch_fp0_regnum (current_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,
@ -175,11 +175,13 @@ fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno
/* 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 = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++) for (regi = gdbarch_fp0_regnum (current_gdbarch);
regi < gdbarch_fp0_regnum (current_gdbarch) + 32; regi++)
{ {
if ((regno == -1) || (regno == regi)) if ((regno == -1) || (regno == regi))
{ {
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]); to = (char *) &(fpregsetp->fp_r.fp_regs[regi - gdbarch_fp0_regnum
(current_gdbarch)]);
regcache_raw_collect (regcache, regi, to); regcache_raw_collect (regcache, regi, to);
} }
} }

2
gdb/libunwind-frame.c
View File

@ -179,7 +179,7 @@ libunwind_frame_cache (struct frame_info *next_frame, void **this_cache)
} }
/* To get base address, get sp from previous frame. */ /* To get base address, get sp from previous frame. */
uw_sp_regnum = descr->gdb2uw (SP_REGNUM); uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (current_gdbarch));
ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp); ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
if (ret < 0) if (ret < 0)
{ {

6
gdb/m32r-rom.c
View File

@ -276,9 +276,11 @@ m32r_supply_register (struct regcache *regcache, char *regname,
stackmode = psw & 0x80; stackmode = psw & 0x80;
if (regno == SPI_REGNUM && !stackmode) /* SP == SPI */ if (regno == SPI_REGNUM && !stackmode) /* SP == SPI */
monitor_supply_register (regcache, SP_REGNUM, val); monitor_supply_register (regcache,
gdbarch_sp_regnum (current_gdbarch), val);
else if (regno == SPU_REGNUM && stackmode) /* SP == SPU */ else if (regno == SPU_REGNUM && stackmode) /* SP == SPU */
monitor_supply_register (regcache, SP_REGNUM, val); monitor_supply_register (regcache,
gdbarch_sp_regnum (current_gdbarch), val);
} }
} }
} }

9
gdb/m68k-tdep.c
View File

@ -85,7 +85,8 @@ m68k_register_type (struct gdbarch *gdbarch, int regnum)
if (tdep->fpregs_present) if (tdep->fpregs_present)
{ {
if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7) if (regnum >= gdbarch_fp0_regnum (current_gdbarch)
&& regnum <= gdbarch_fp0_regnum (current_gdbarch) + 7)
{ {
if (tdep->flavour == m68k_coldfire_flavour) if (tdep->flavour == m68k_coldfire_flavour)
return builtin_type (gdbarch)->builtin_double; return builtin_type (gdbarch)->builtin_double;
@ -105,7 +106,7 @@ m68k_register_type (struct gdbarch *gdbarch, int regnum)
return builtin_type_int0; return builtin_type_int0;
} }
if (regnum == PC_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch))
return builtin_type_void_func_ptr; return builtin_type_void_func_ptr;
if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7) if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
@ -801,7 +802,7 @@ m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
gdb_byte buf[8]; gdb_byte buf[8];
frame_unwind_register (next_frame, PC_REGNUM, buf); frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf);
return extract_typed_address (buf, builtin_type_void_func_ptr); return extract_typed_address (buf, builtin_type_void_func_ptr);
} }
@ -992,7 +993,7 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
} }
buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT); buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
sp = get_frame_register_unsigned (frame, SP_REGNUM); sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (current_gdbarch));
if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */ if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
buf, buf,

27
gdb/m68klinux-nat.c
View File

@ -81,7 +81,8 @@ getregs_supplies (int regno)
int int
getfpregs_supplies (int regno) getfpregs_supplies (int regno)
{ {
return FP0_REGNUM <= regno && regno <= M68K_FPI_REGNUM; return gdbarch_fp0_regnum (current_gdbarch) <= regno
&& regno <= M68K_FPI_REGNUM;
} }
/* Does the current host support the GETREGS request? */ /* Does the current host support the GETREGS request? */
@ -245,10 +246,14 @@ supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
const elf_greg_t *regp = (const elf_greg_t *) gregsetp; const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
int regi; int regi;
for (regi = M68K_D0_REGNUM; regi <= SP_REGNUM; regi++) for (regi = M68K_D0_REGNUM;
regi <= gdbarch_sp_regnum (current_gdbarch);
regi++)
regcache_raw_supply (regcache, regi, &regp[regmap[regi]]); regcache_raw_supply (regcache, regi, &regp[regmap[regi]]);
regcache_raw_supply (regcache, PS_REGNUM, &regp[PT_SR]); regcache_raw_supply (regcache, gdbarch_ps_regnum (current_gdbarch),
regcache_raw_supply (regcache, PC_REGNUM, &regp[PT_PC]); &regp[PT_SR]);
regcache_raw_supply (regcache,
gdbarch_pc_regnum (current_gdbarch), &regp[PT_PC]);
} }
/* Fill register REGNO (if it is a general-purpose register) in /* Fill register REGNO (if it is a general-purpose register) in
@ -330,9 +335,12 @@ supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
{ {
int regi; int regi;
for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++) for (regi = gdbarch_fp0_regnum (current_gdbarch);
regi < gdbarch_fp0_regnum (current_gdbarch) + 8; regi++)
regcache_raw_supply (regcache, regi, regcache_raw_supply (regcache, regi,
FPREG_ADDR (fpregsetp, regi - FP0_REGNUM)); FPREG_ADDR (fpregsetp,
regi - gdbarch_fp0_regnum
(current_gdbarch)));
regcache_raw_supply (regcache, M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]); regcache_raw_supply (regcache, M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]);
regcache_raw_supply (regcache, M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]); regcache_raw_supply (regcache, M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]);
regcache_raw_supply (regcache, M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]); regcache_raw_supply (regcache, M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]);
@ -349,10 +357,13 @@ fill_fpregset (const struct regcache *regcache,
int i; int i;
/* Fill in the floating-point registers. */ /* Fill in the floating-point registers. */
for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++) for (i = gdbarch_fp0_regnum (current_gdbarch);
i < gdbarch_fp0_regnum (current_gdbarch) + 8; i++)
if (regno == -1 || regno == i) if (regno == -1 || regno == i)
regcache_raw_collect (regcache, i, regcache_raw_collect (regcache, i,
FPREG_ADDR (fpregsetp, i - FP0_REGNUM)); FPREG_ADDR (fpregsetp,
i - gdbarch_fp0_regnum
(current_gdbarch)));
/* Fill in the floating-point control registers. */ /* Fill in the floating-point control registers. */
for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++) for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)

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

@ -104,7 +104,7 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
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 - FP0_REGNUM); regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (current_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)

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

@ -199,7 +199,9 @@ mips_supply_fpregset (struct regcache *regcache,
memset (zerobuf, 0, MAX_REGISTER_SIZE); memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache, FP0_REGNUM + regi, *fpregsetp + regi); regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi,
*fpregsetp + regi);
regcache_raw_supply (regcache, regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_control_status, mips_regnum (current_gdbarch)->fp_control_status,
@ -220,9 +222,10 @@ mips_fill_fpregset (const struct regcache *regcache,
{ {
char *from, *to; char *from, *to;
if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32)) if ((regno >= gdbarch_fp0_regnum (current_gdbarch))
&& (regno < gdbarch_fp0_regnum (current_gdbarch) + 32))
{ {
to = (char *) (*fpregsetp + regno - FP0_REGNUM); to = (char *) (*fpregsetp + regno - 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 (current_gdbarch)->fp_control_status)
@ -235,7 +238,8 @@ mips_fill_fpregset (const struct regcache *regcache,
int regi; int regi;
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
mips_fill_fpregset (regcache, fpregsetp, FP0_REGNUM + regi); mips_fill_fpregset (regcache, fpregsetp,
gdbarch_fp0_regnum (current_gdbarch) + regi);
mips_fill_fpregset (regcache, fpregsetp, mips_fill_fpregset (regcache, fpregsetp,
mips_regnum (current_gdbarch)->fp_control_status); mips_regnum (current_gdbarch)->fp_control_status);
} }
@ -407,18 +411,22 @@ mips64_supply_fpregset (struct regcache *regcache,
/* 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, FP0_REGNUM) == 4) if (register_size (current_gdbarch,
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 (current_gdbarch)
== BFD_ENDIAN_BIG) != (regi & 1)) == BFD_ENDIAN_BIG) != (regi & 1))
reg_ptr += 4; reg_ptr += 4;
regcache_raw_supply (regcache, FP0_REGNUM + regi, reg_ptr); regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi,
reg_ptr);
} }
else else
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache, FP0_REGNUM + regi, regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_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 (current_gdbarch)->fp_control_status,
@ -441,13 +449,14 @@ mips64_fill_fpregset (const struct regcache *regcache,
{ {
gdb_byte *to; gdb_byte *to;
if ((regno >= FP0_REGNUM) && (regno < FP0_REGNUM + 32)) if ((regno >= gdbarch_fp0_regnum (current_gdbarch))
&& (regno < gdbarch_fp0_regnum (current_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 (current_gdbarch, regno) == 4)
{ {
int regi = regno - FP0_REGNUM; int regi = regno - gdbarch_fp0_regnum (current_gdbarch);
to = (gdb_byte *) (*fpregsetp + (regi & ~1)); to = (gdb_byte *) (*fpregsetp + (regi & ~1));
if ((gdbarch_byte_order (current_gdbarch) if ((gdbarch_byte_order (current_gdbarch)
@ -457,7 +466,8 @@ mips64_fill_fpregset (const struct regcache *regcache,
} }
else else
{ {
to = (gdb_byte *) (*fpregsetp + regno - FP0_REGNUM); to = (gdb_byte *) (*fpregsetp + regno
- gdbarch_fp0_regnum (current_gdbarch));
regcache_raw_collect (regcache, regno, to); regcache_raw_collect (regcache, regno, to);
} }
} }
@ -488,7 +498,8 @@ mips64_fill_fpregset (const struct regcache *regcache,
int regi; int regi;
for (regi = 0; regi < 32; regi++) for (regi = 0; regi < 32; regi++)
mips64_fill_fpregset (regcache, fpregsetp, FP0_REGNUM + regi); mips64_fill_fpregset (regcache, fpregsetp,
gdbarch_fp0_regnum (current_gdbarch) + regi);
mips64_fill_fpregset (regcache, fpregsetp, mips64_fill_fpregset (regcache, fpregsetp,
mips_regnum (current_gdbarch)->fp_control_status); mips_regnum (current_gdbarch)->fp_control_status);
mips64_fill_fpregset (regcache, fpregsetp, mips64_fill_fpregset (regcache, fpregsetp,
@ -1056,7 +1067,8 @@ 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, PC_REGNUM, pc); regcache_cooked_write_unsigned (regcache,
gdbarch_pc_regnum (current_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 (current_gdbarch))

10
gdb/mips-tdep.c
View File

@ -1751,7 +1751,7 @@ mips_insn16_frame_cache (struct frame_info *next_frame, void **this_cache)
mips16_scan_prologue (start_addr, pc, next_frame, *this_cache); mips16_scan_prologue (start_addr, pc, next_frame, *this_cache);
} }
/* SP_REGNUM, contains the value and not the address. */ /* gdbarch_sp_regnum contains the value and not the address. */
trad_frame_set_value (cache->saved_regs, gdbarch_num_regs (current_gdbarch) trad_frame_set_value (cache->saved_regs, gdbarch_num_regs (current_gdbarch)
+ MIPS_SP_REGNUM, cache->base); + MIPS_SP_REGNUM, cache->base);
@ -2086,7 +2086,7 @@ mips_insn32_frame_cache (struct frame_info *next_frame, void **this_cache)
mips32_scan_prologue (start_addr, pc, next_frame, *this_cache); mips32_scan_prologue (start_addr, pc, next_frame, *this_cache);
} }
/* SP_REGNUM, contains the value and not the address. */ /* gdbarch_sp_regnum contains the value and not the address. */
trad_frame_set_value (cache->saved_regs, trad_frame_set_value (cache->saved_regs,
gdbarch_num_regs (current_gdbarch) + MIPS_SP_REGNUM, gdbarch_num_regs (current_gdbarch) + MIPS_SP_REGNUM,
cache->base); cache->base);
@ -2173,7 +2173,9 @@ mips_stub_frame_cache (struct frame_info *next_frame, void **this_cache)
(*this_cache) = this_trad_cache; (*this_cache) = this_trad_cache;
/* The return address is in the link register. */ /* The return address is in the link register. */
trad_frame_set_reg_realreg (this_trad_cache, PC_REGNUM, MIPS_RA_REGNUM); trad_frame_set_reg_realreg (this_trad_cache,
gdbarch_pc_regnum (current_gdbarch),
MIPS_RA_REGNUM);
/* Frame ID, since it's a frameless / stackless function, no stack /* Frame ID, since it's a frameless / stackless function, no stack
space is allocated and SP on entry is the current SP. */ space is allocated and SP on entry is the current SP. */
@ -5195,7 +5197,7 @@ mips_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
else else
reg_names = mips_generic_reg_names; reg_names = mips_generic_reg_names;
} }
/* FIXME: cagney/2003-11-15: For MIPS, hasn't PC_REGNUM been /* FIXME: cagney/2003-11-15: For MIPS, hasn't gdbarch_pc_regnum been
replaced by read_pc? */ replaced by read_pc? */
set_gdbarch_pc_regnum (gdbarch, regnum->pc + num_regs); set_gdbarch_pc_regnum (gdbarch, regnum->pc + num_regs);
set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs); set_gdbarch_sp_regnum (gdbarch, MIPS_SP_REGNUM + num_regs);

7
gdb/mipsnbsd-nat.c
View File

@ -36,7 +36,8 @@
static int static int
getregs_supplies (int regno) getregs_supplies (int regno)
{ {
return ((regno) >= MIPS_ZERO_REGNUM && (regno) <= PC_REGNUM); return ((regno) >= MIPS_ZERO_REGNUM
&& (regno) <= gdbarch_pc_regnum (current_gdbarch));
} }
static void static void
@ -55,7 +56,7 @@ mipsnbsd_fetch_inferior_registers (struct regcache *regcache, int regno)
return; return;
} }
if (regno == -1 || regno >= FP0_REGNUM) if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
{ {
struct fpreg fpregs; struct fpreg fpregs;
@ -88,7 +89,7 @@ mipsnbsd_store_inferior_registers (struct regcache *regcache, int regno)
return; return;
} }
if (regno == -1 || regno >= FP0_REGNUM) if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
{ {
struct fpreg fpregs; struct fpreg fpregs;

17
gdb/mipsnbsd-tdep.c
View File

@ -146,7 +146,7 @@ mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
{ {
int i; int i;
for (i = 0; i <= PC_REGNUM; i++) for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
{ {
if (regno == i || regno == -1) if (regno == i || regno == -1)
{ {
@ -164,7 +164,7 @@ mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno)
{ {
int i; int i;
for (i = 0; i <= PC_REGNUM; i++) for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
if ((regno == i || regno == -1) if ((regno == i || regno == -1)
&& ! gdbarch_cannot_store_register (current_gdbarch, i)) && ! gdbarch_cannot_store_register (current_gdbarch, i))
regcache_raw_collect (regcache, i, regcache_raw_collect (regcache, i,
@ -176,7 +176,7 @@ mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
{ {
int i; int i;
for (i = FP0_REGNUM; for (i = gdbarch_fp0_regnum (current_gdbarch);
i <= mips_regnum (current_gdbarch)->fp_implementation_revision; i <= mips_regnum (current_gdbarch)->fp_implementation_revision;
i++) i++)
{ {
@ -186,7 +186,9 @@ mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
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 + ((i - FP0_REGNUM) * mips_isa_regsize (current_gdbarch))); fpregs
+ ((i - gdbarch_fp0_regnum (current_gdbarch))
* mips_isa_regsize (current_gdbarch)));
} }
} }
} }
@ -196,12 +198,15 @@ mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno)
{ {
int i; int i;
for (i = FP0_REGNUM; i <= mips_regnum (current_gdbarch)->fp_control_status; for (i = gdbarch_fp0_regnum (current_gdbarch);
i <= mips_regnum (current_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 (current_gdbarch, i))
regcache_raw_collect (regcache, i, regcache_raw_collect (regcache, i,
fpregs + ((i - FP0_REGNUM) * mips_isa_regsize (current_gdbarch))); fpregs + ((i - gdbarch_fp0_regnum
(current_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

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

@ -188,7 +188,7 @@ ppc_register_u_addr (int regno)
u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->ppc_fp0_regnum) * 8); u_addr = (PT_FPR0 * wordsize) + ((regno - tdep->ppc_fp0_regnum) * 8);
/* UISA special purpose registers: 1 slot each */ /* UISA special purpose registers: 1 slot each */
if (regno == PC_REGNUM) if (regno == gdbarch_pc_regnum (current_gdbarch))
u_addr = PT_NIP * wordsize; u_addr = PT_NIP * wordsize;
if (regno == tdep->ppc_lr_regnum) if (regno == tdep->ppc_lr_regnum)
u_addr = PT_LNK * wordsize; u_addr = PT_LNK * wordsize;
@ -463,7 +463,7 @@ fetch_ppc_registers (struct regcache *regcache, int tid)
if (tdep->ppc_fp0_regnum >= 0) if (tdep->ppc_fp0_regnum >= 0)
for (i = 0; i < ppc_num_fprs; i++) for (i = 0; i < ppc_num_fprs; i++)
fetch_register (regcache, tid, tdep->ppc_fp0_regnum + i); fetch_register (regcache, tid, tdep->ppc_fp0_regnum + i);
fetch_register (regcache, tid, PC_REGNUM); fetch_register (regcache, tid, gdbarch_pc_regnum (current_gdbarch));
if (tdep->ppc_ps_regnum != -1) if (tdep->ppc_ps_regnum != -1)
fetch_register (regcache, tid, tdep->ppc_ps_regnum); fetch_register (regcache, tid, tdep->ppc_ps_regnum);
if (tdep->ppc_cr_regnum != -1) if (tdep->ppc_cr_regnum != -1)
@ -747,7 +747,7 @@ store_ppc_registers (const struct regcache *regcache, int tid)
if (tdep->ppc_fp0_regnum >= 0) if (tdep->ppc_fp0_regnum >= 0)
for (i = 0; i < ppc_num_fprs; i++) for (i = 0; i < ppc_num_fprs; i++)
store_register (regcache, tid, tdep->ppc_fp0_regnum + i); store_register (regcache, tid, tdep->ppc_fp0_regnum + i);
store_register (regcache, tid, PC_REGNUM); store_register (regcache, tid, gdbarch_pc_regnum (current_gdbarch));
if (tdep->ppc_ps_regnum != -1) if (tdep->ppc_ps_regnum != -1)
store_register (regcache, tid, tdep->ppc_ps_regnum); store_register (regcache, tid, tdep->ppc_ps_regnum);
if (tdep->ppc_cr_regnum != -1) if (tdep->ppc_cr_regnum != -1)
@ -946,8 +946,9 @@ fill_gregset (const struct regcache *regcache,
(regp + PT_R0 + regi)); (regp + PT_R0 + regi));
} }
if ((regno == -1) || regno == PC_REGNUM) if ((regno == -1) || regno == gdbarch_pc_regnum (current_gdbarch))
right_fill_reg (regcache, PC_REGNUM, regp + PT_NIP); right_fill_reg (regcache, gdbarch_pc_regnum (current_gdbarch),
regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum) if ((regno == -1) || regno == tdep->ppc_lr_regnum)
right_fill_reg (regcache, tdep->ppc_lr_regnum, regp + PT_LNK); right_fill_reg (regcache, tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum) if ((regno == -1) || regno == tdep->ppc_cr_regnum)

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

@ -753,7 +753,8 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
struct gdbarch *gdbarch = get_frame_arch (next_frame); struct gdbarch *gdbarch = get_frame_arch (next_frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); base = frame_unwind_register_unsigned (next_frame,
gdbarch_sp_regnum (current_gdbarch));
if (bias > 0 && frame_pc_unwind (next_frame) != func) if (bias > 0 && frame_pc_unwind (next_frame) != func)
/* See below, some signal trampolines increment the stack as their /* See below, some signal trampolines increment the stack as their
first instruction, need to compensate for that. */ first instruction, need to compensate for that. */
@ -772,7 +773,9 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
int regnum = i + tdep->ppc_gp0_regnum; int regnum = i + tdep->ppc_gp0_regnum;
trad_frame_set_reg_addr (this_cache, regnum, gpregs + i * tdep->wordsize); trad_frame_set_reg_addr (this_cache, regnum, gpregs + i * tdep->wordsize);
} }
trad_frame_set_reg_addr (this_cache, PC_REGNUM, gpregs + 32 * tdep->wordsize); trad_frame_set_reg_addr (this_cache,
gdbarch_pc_regnum (current_gdbarch),
gpregs + 32 * tdep->wordsize);
trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum, trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum,
gpregs + 35 * tdep->wordsize); gpregs + 35 * tdep->wordsize);
trad_frame_set_reg_addr (this_cache, tdep->ppc_lr_regnum, trad_frame_set_reg_addr (this_cache, tdep->ppc_lr_regnum,
@ -787,7 +790,7 @@ ppc_linux_sigtramp_cache (struct frame_info *next_frame,
/* Floating point registers. */ /* Floating point registers. */
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
{ {
int regnum = i + FP0_REGNUM; int regnum = i + gdbarch_fp0_regnum (current_gdbarch);
trad_frame_set_reg_addr (this_cache, regnum, trad_frame_set_reg_addr (this_cache, regnum,
fpregs + i * tdep->wordsize); fpregs + i * tdep->wordsize);
} }

14
gdb/ppc-sysv-tdep.c
View File

@ -55,7 +55,9 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int argspace = 0; /* 0 is an initial wrong guess. */ int argspace = 0; /* 0 is an initial wrong guess. */
int write_pass; int write_pass;
regcache_cooked_read_unsigned (regcache, SP_REGNUM, &saved_sp); regcache_cooked_read_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch),
&saved_sp);
/* Go through the argument list twice. /* Go through the argument list twice.
@ -307,7 +309,8 @@ ppc_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
} }
/* Update %sp. */ /* Update %sp. */
regcache_cooked_write_signed (regcache, SP_REGNUM, sp); regcache_cooked_write_signed (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
/* Write the backchain (it occupies WORDSIZED bytes). */ /* Write the backchain (it occupies WORDSIZED bytes). */
write_memory_signed_integer (sp, tdep->wordsize, saved_sp); write_memory_signed_integer (sp, tdep->wordsize, saved_sp);
@ -601,7 +604,9 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* By this stage in the proceedings, SP has been decremented by "red /* By this stage in the proceedings, SP has been decremented by "red
zone size" + "struct return size". Fetch the stack-pointer from zone size" + "struct return size". Fetch the stack-pointer from
before this and use that as the BACK_CHAIN. */ before this and use that as the BACK_CHAIN. */
regcache_cooked_read_unsigned (regcache, SP_REGNUM, &back_chain); regcache_cooked_read_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch),
&back_chain);
/* Go through the argument list twice. /* Go through the argument list twice.
@ -832,7 +837,8 @@ ppc64_sysv_abi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
} }
/* Update %sp. */ /* Update %sp. */
regcache_cooked_write_signed (regcache, SP_REGNUM, sp); regcache_cooked_write_signed (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
/* Write the backchain (it occupies WORDSIZED bytes). */ /* Write the backchain (it occupies WORDSIZED bytes). */
write_memory_signed_integer (sp, tdep->wordsize, back_chain); write_memory_signed_integer (sp, tdep->wordsize, back_chain);

4
gdb/ppcnbsd-nat.c
View File

@ -52,7 +52,7 @@ getregs_supplies (int regnum)
|| regnum == tdep->ppc_cr_regnum || regnum == tdep->ppc_cr_regnum
|| regnum == tdep->ppc_xer_regnum || regnum == tdep->ppc_xer_regnum
|| regnum == tdep->ppc_ctr_regnum || regnum == tdep->ppc_ctr_regnum
|| regnum == PC_REGNUM); || regnum == gdbarch_pc_regnum (current_gdbarch));
} }
/* Like above, but for PT_GETFPREGS. */ /* Like above, but for PT_GETFPREGS. */
@ -169,7 +169,7 @@ ppcnbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
read_memory(cf.sp, (gdb_byte *)&cf, sizeof(cf)); read_memory(cf.sp, (gdb_byte *)&cf, sizeof(cf));
regcache_raw_supply (regcache, tdep->ppc_lr_regnum, &cf.lr); regcache_raw_supply (regcache, tdep->ppc_lr_regnum, &cf.lr);
regcache_raw_supply (regcache, PC_REGNUM, &cf.lr); regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch), &cf.lr);
return 1; return 1;
} }

7
gdb/ppcnbsd-tdep.c
View File

@ -115,7 +115,8 @@ ppcnbsd_sigtramp_cache_init (const struct tramp_frame *self,
CORE_ADDR addr, base; CORE_ADDR addr, base;
int i; int i;
base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); base = frame_unwind_register_unsigned (next_frame,
gdbarch_sp_regnum (current_gdbarch));
if (self == &ppcnbsd2_sigtramp) if (self == &ppcnbsd2_sigtramp)
addr = base + 0x10 + 2 * tdep->wordsize; addr = base + 0x10 + 2 * tdep->wordsize;
else else
@ -133,7 +134,9 @@ ppcnbsd_sigtramp_cache_init (const struct tramp_frame *self,
addr += tdep->wordsize; addr += tdep->wordsize;
trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum, addr); trad_frame_set_reg_addr (this_cache, tdep->ppc_ctr_regnum, addr);
addr += tdep->wordsize; addr += tdep->wordsize;
trad_frame_set_reg_addr (this_cache, PC_REGNUM, addr); /* SRR0? */ trad_frame_set_reg_addr (this_cache,
gdbarch_pc_regnum (current_gdbarch),
addr); /* SRR0? */
addr += tdep->wordsize; addr += tdep->wordsize;
/* Construct the frame ID using the function start. */ /* Construct the frame ID using the function start. */

4
gdb/ppcobsd-nat.c
View File

@ -169,14 +169,14 @@ ppcobsd_supply_pcb (struct regcache *regcache, struct pcb *pcb)
return 0; return 0;
read_memory (pcb->pcb_sp, (gdb_byte *)&sf, sizeof sf); read_memory (pcb->pcb_sp, (gdb_byte *)&sf, sizeof sf);
regcache_raw_supply (regcache, SP_REGNUM, &sf.sp); regcache_raw_supply (regcache, gdbarch_sp_regnum (current_gdbarch), &sf.sp);
regcache_raw_supply (regcache, tdep->ppc_cr_regnum, &sf.cr); regcache_raw_supply (regcache, tdep->ppc_cr_regnum, &sf.cr);
regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 2, &sf.fixreg2); regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 2, &sf.fixreg2);
for (i = 0, regnum = tdep->ppc_gp0_regnum + 13; i < 19; i++, regnum++) for (i = 0, regnum = tdep->ppc_gp0_regnum + 13; i < 19; i++, regnum++)
regcache_raw_supply (regcache, regnum, &sf.fixreg[i]); regcache_raw_supply (regcache, regnum, &sf.fixreg[i]);
read_memory (sf.sp, (gdb_byte *)&cf, sizeof cf); read_memory (sf.sp, (gdb_byte *)&cf, sizeof cf);
regcache_raw_supply (regcache, PC_REGNUM, &cf.lr); regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch), &cf.lr);
regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 30, &cf.r30); regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 30, &cf.r30);
regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 31, &cf.r31); regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + 31, &cf.r31);

6
gdb/ppcobsd-tdep.c
View File

@ -211,7 +211,8 @@ ppcobsd_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache)
insn = extract_unsigned_integer (buf, PPC_INSN_SIZE); insn = extract_unsigned_integer (buf, PPC_INSN_SIZE);
sigcontext_offset = (0x10000 - (insn & 0x0000ffff)) + 8; sigcontext_offset = (0x10000 - (insn & 0x0000ffff)) + 8;
base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); base = frame_unwind_register_unsigned (next_frame,
gdbarch_sp_regnum (current_gdbarch));
addr = base + sigcontext_offset + 2 * tdep->wordsize; addr = base + sigcontext_offset + 2 * tdep->wordsize;
for (i = 0; i < ppc_num_gprs; i++, addr += tdep->wordsize) for (i = 0; i < ppc_num_gprs; i++, addr += tdep->wordsize)
{ {
@ -226,7 +227,8 @@ ppcobsd_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache)
addr += tdep->wordsize; addr += tdep->wordsize;
trad_frame_set_reg_addr (cache, tdep->ppc_ctr_regnum, addr); trad_frame_set_reg_addr (cache, tdep->ppc_ctr_regnum, addr);
addr += tdep->wordsize; addr += tdep->wordsize;
trad_frame_set_reg_addr (cache, PC_REGNUM, addr); /* SRR0? */ trad_frame_set_reg_addr (cache, gdbarch_pc_regnum (current_gdbarch), addr);
/* SRR0? */
addr += tdep->wordsize; addr += tdep->wordsize;
/* Construct the frame ID using the function start. */ /* Construct the frame ID using the function start. */

18
gdb/procfs.c
View File

@ -3709,13 +3709,13 @@ procfs_fetch_registers (struct regcache *regcache, int regnum)
supply_gregset (regcache, (const gdb_gregset_t *) gregs); supply_gregset (regcache, (const gdb_gregset_t *) gregs);
if (FP0_REGNUM >= 0) /* Do we have an FPU? */ if (gdbarch_fp0_regnum (current_gdbarch) >= 0) /* Do we have an FPU? */
{ {
gdb_fpregset_t *fpregs; gdb_fpregset_t *fpregs;
if ((regnum >= 0 && regnum < FP0_REGNUM) if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (current_gdbarch))
|| regnum == PC_REGNUM || regnum == gdbarch_pc_regnum (current_gdbarch)
|| regnum == SP_REGNUM) || regnum == gdbarch_sp_regnum (current_gdbarch))
return; /* Not a floating point register. */ return; /* Not a floating point register. */
fpregs = proc_get_fpregs (pi); fpregs = proc_get_fpregs (pi);
@ -3776,13 +3776,13 @@ procfs_store_registers (struct regcache *regcache, int regnum)
if (!proc_set_gregs (pi)) if (!proc_set_gregs (pi))
proc_error (pi, "store_registers, set_gregs", __LINE__); proc_error (pi, "store_registers, set_gregs", __LINE__);
if (FP0_REGNUM >= 0) /* Do we have an FPU? */ if (gdbarch_fp0_regnum (current_gdbarch) >= 0) /* Do we have an FPU? */
{ {
gdb_fpregset_t *fpregs; gdb_fpregset_t *fpregs;
if ((regnum >= 0 && regnum < FP0_REGNUM) if ((regnum >= 0 && regnum < gdbarch_fp0_regnum (current_gdbarch))
|| regnum == PC_REGNUM || regnum == gdbarch_pc_regnum (current_gdbarch)
|| regnum == SP_REGNUM) || regnum == gdbarch_sp_regnum (current_gdbarch))
return; /* Not a floating point register. */ return; /* Not a floating point register. */
fpregs = proc_get_fpregs (pi); fpregs = proc_get_fpregs (pi);
@ -4413,7 +4413,7 @@ invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
if (!proc_set_gregs (pi)) /* flush gregs cache */ if (!proc_set_gregs (pi)) /* flush gregs cache */
proc_warn (pi, "target_resume, set_gregs", proc_warn (pi, "target_resume, set_gregs",
__LINE__); __LINE__);
if (FP0_REGNUM >= 0) if (gdbarch_fp0_regnum (current_gdbarch) >= 0)
if (pi->fpregs_dirty) if (pi->fpregs_dirty)
if (parent == NULL || if (parent == NULL ||
proc_get_current_thread (parent) != pi->tid) proc_get_current_thread (parent) != pi->tid)

11
gdb/regcache.c
View File

@ -839,10 +839,12 @@ read_pc_pid (ptid_t ptid)
if (gdbarch_read_pc_p (gdbarch)) if (gdbarch_read_pc_p (gdbarch))
pc_val = gdbarch_read_pc (gdbarch, regcache); pc_val = gdbarch_read_pc (gdbarch, regcache);
/* Else use per-frame method on get_current_frame. */ /* Else use per-frame method on get_current_frame. */
else if (PC_REGNUM >= 0) else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
{ {
ULONGEST raw_val; ULONGEST raw_val;
regcache_cooked_read_unsigned (regcache, PC_REGNUM, &raw_val); regcache_cooked_read_unsigned (regcache,
gdbarch_pc_regnum (current_gdbarch),
&raw_val);
pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val); pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
} }
else else
@ -865,8 +867,9 @@ write_pc_pid (CORE_ADDR pc, ptid_t ptid)
if (gdbarch_write_pc_p (gdbarch)) if (gdbarch_write_pc_p (gdbarch))
gdbarch_write_pc (gdbarch, regcache, pc); gdbarch_write_pc (gdbarch, regcache, pc);
else if (PC_REGNUM >= 0) if (gdbarch_pc_regnum (current_gdbarch) >= 0)
regcache_cooked_write_unsigned (regcache, PC_REGNUM, pc); regcache_cooked_write_unsigned (regcache,
gdbarch_pc_regnum (current_gdbarch), pc);
else else
internal_error (__FILE__, __LINE__, internal_error (__FILE__, __LINE__,
_("write_pc_pid: Unable to update PC")); _("write_pc_pid: Unable to update PC"));

18
gdb/remote-mips.c
View File

@ -1758,14 +1758,20 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
struct regcache *regcache = get_current_regcache (); struct regcache *regcache = get_current_regcache ();
char buf[MAX_REGISTER_SIZE]; char buf[MAX_REGISTER_SIZE];
store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rpc); store_unsigned_integer (buf,
regcache_raw_supply (regcache, PC_REGNUM, buf); register_size
(current_gdbarch, gdbarch_pc_regnum
(current_gdbarch)), rpc);
regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch), buf);
store_unsigned_integer (buf, register_size (current_gdbarch, PC_REGNUM), rfp); store_unsigned_integer
(buf, register_size (current_gdbarch,
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, SP_REGNUM), rsp); store_unsigned_integer (buf, register_size (current_gdbarch,
regcache_raw_supply (regcache, SP_REGNUM, buf); gdbarch_sp_regnum (current_gdbarch)), rsp);
regcache_raw_supply (regcache, gdbarch_sp_regnum (current_gdbarch), buf);
store_unsigned_integer (buf, register_size (current_gdbarch, DEPRECATED_FP_REGNUM), 0); store_unsigned_integer (buf, register_size (current_gdbarch, DEPRECATED_FP_REGNUM), 0);
regcache_raw_supply (regcache, DEPRECATED_FP_REGNUM, buf); regcache_raw_supply (regcache, DEPRECATED_FP_REGNUM, buf);
@ -3263,7 +3269,7 @@ mips_load (char *file, int from_tty)
/* Work around problem where PMON monitor updates the PC after a load /* Work around problem where PMON monitor updates the PC after a load
to a different value than GDB thinks it has. The following ensures to a different value than GDB thinks it has. The following ensures
that the write_pc() WILL update the PC value: */ that the write_pc() WILL update the PC value: */
deprecated_register_valid[PC_REGNUM] = 0; deprecated_register_valid[gdbarch_pc_regnum (current_gdbarch)] = 0;
} }
if (exec_bfd) if (exec_bfd)
write_pc (bfd_get_start_address (exec_bfd)); write_pc (bfd_get_start_address (exec_bfd));

8
gdb/rs6000-nat.c
View File

@ -157,7 +157,7 @@ regmap (int regno, int *isfloat)
*isfloat = 1; *isfloat = 1;
return regno - tdep->ppc_fp0_regnum + FPR0; return regno - tdep->ppc_fp0_regnum + FPR0;
} }
else if (regno == PC_REGNUM) else if (regno == gdbarch_pc_regnum (current_gdbarch))
return IAR; return IAR;
else if (regno == tdep->ppc_ps_regnum) else if (regno == tdep->ppc_ps_regnum)
return MSR; return MSR;
@ -297,7 +297,7 @@ store_register (const struct regcache *regcache, int regno)
/* Fixed-point registers. */ /* Fixed-point registers. */
else else
{ {
if (regno == SP_REGNUM) if (regno == gdbarch_sp_regnum (current_gdbarch))
/* Execute one dummy instruction (which is a breakpoint) in inferior /* Execute one dummy instruction (which is a breakpoint) in inferior
process to give kernel a chance to do internal housekeeping. process to give kernel a chance to do internal housekeeping.
Otherwise the following ptrace(2) calls will mess up user stack Otherwise the following ptrace(2) calls will mess up user stack
@ -357,7 +357,7 @@ rs6000_fetch_inferior_registers (struct regcache *regcache, int regno)
fetch_register (regcache, tdep->ppc_fp0_regnum + regno); fetch_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Read special registers. */ /* Read special registers. */
fetch_register (regcache, PC_REGNUM); fetch_register (regcache, gdbarch_pc_regnum (current_gdbarch));
fetch_register (regcache, tdep->ppc_ps_regnum); fetch_register (regcache, tdep->ppc_ps_regnum);
fetch_register (regcache, tdep->ppc_cr_regnum); fetch_register (regcache, tdep->ppc_cr_regnum);
fetch_register (regcache, tdep->ppc_lr_regnum); fetch_register (regcache, tdep->ppc_lr_regnum);
@ -398,7 +398,7 @@ rs6000_store_inferior_registers (struct regcache *regcache, int regno)
store_register (regcache, tdep->ppc_fp0_regnum + regno); store_register (regcache, tdep->ppc_fp0_regnum + regno);
/* Write special registers. */ /* Write special registers. */
store_register (regcache, PC_REGNUM); store_register (regcache, gdbarch_pc_regnum (current_gdbarch));
store_register (regcache, tdep->ppc_ps_regnum); store_register (regcache, tdep->ppc_ps_regnum);
store_register (regcache, tdep->ppc_cr_regnum); store_register (regcache, tdep->ppc_cr_regnum);
store_register (regcache, tdep->ppc_lr_regnum); store_register (regcache, tdep->ppc_lr_regnum);

42
gdb/rs6000-tdep.c
View File

@ -342,8 +342,9 @@ ppc_supply_gregset (const struct regset *regset, struct regcache *regcache,
ppc_supply_reg (regcache, i, gregs, offset); ppc_supply_reg (regcache, i, gregs, offset);
} }
if (regnum == -1 || regnum == PC_REGNUM) if (regnum == -1 || regnum == gdbarch_pc_regnum (current_gdbarch))
ppc_supply_reg (regcache, PC_REGNUM, gregs, offsets->pc_offset); ppc_supply_reg (regcache, gdbarch_pc_regnum (current_gdbarch),
gregs, offsets->pc_offset);
if (regnum == -1 || regnum == tdep->ppc_ps_regnum) if (regnum == -1 || regnum == tdep->ppc_ps_regnum)
ppc_supply_reg (regcache, tdep->ppc_ps_regnum, ppc_supply_reg (regcache, tdep->ppc_ps_regnum,
gregs, offsets->ps_offset); gregs, offsets->ps_offset);
@ -418,8 +419,9 @@ ppc_collect_gregset (const struct regset *regset,
ppc_collect_reg (regcache, i, gregs, offset); ppc_collect_reg (regcache, i, gregs, offset);
} }
if (regnum == -1 || regnum == PC_REGNUM) if (regnum == -1 || regnum == gdbarch_pc_regnum (current_gdbarch))
ppc_collect_reg (regcache, PC_REGNUM, gregs, offsets->pc_offset); ppc_collect_reg (regcache, gdbarch_pc_regnum (current_gdbarch),
gregs, offsets->pc_offset);
if (regnum == -1 || regnum == tdep->ppc_ps_regnum) if (regnum == -1 || regnum == tdep->ppc_ps_regnum)
ppc_collect_reg (regcache, tdep->ppc_ps_regnum, ppc_collect_reg (regcache, tdep->ppc_ps_regnum,
gregs, offsets->ps_offset); gregs, offsets->ps_offset);
@ -1697,7 +1699,9 @@ rs6000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
ran_out_of_registers_for_arguments: ran_out_of_registers_for_arguments:
regcache_cooked_read_unsigned (regcache, SP_REGNUM, &saved_sp); regcache_cooked_read_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch),
&saved_sp);
/* Location for 8 parameters are always reserved. */ /* Location for 8 parameters are always reserved. */
sp -= wordsize * 8; sp -= wordsize * 8;
@ -1739,7 +1743,8 @@ ran_out_of_registers_for_arguments:
to use this area. So, update %sp first before doing anything to use this area. So, update %sp first before doing anything
else. */ else. */
regcache_raw_write_signed (regcache, SP_REGNUM, sp); regcache_raw_write_signed (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
/* If the last argument copied into the registers didn't fit there /* If the last argument copied into the registers didn't fit there
completely, push the rest of it into stack. */ completely, push the rest of it into stack. */
@ -1786,7 +1791,7 @@ ran_out_of_registers_for_arguments:
Not doing this can lead to conflicts with the kernel which thinks Not doing this can lead to conflicts with the kernel which thinks
that it still has control over this not-yet-allocated stack that it still has control over this not-yet-allocated stack
region. */ region. */
regcache_raw_write_signed (regcache, SP_REGNUM, sp); regcache_raw_write_signed (regcache, gdbarch_sp_regnum (current_gdbarch), sp);
/* Set back chain properly. */ /* Set back chain properly. */
store_unsigned_integer (tmp_buffer, wordsize, saved_sp); store_unsigned_integer (tmp_buffer, wordsize, saved_sp);
@ -2210,7 +2215,7 @@ rs6000_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
|| regnum == tdep->ppc_lr_regnum || regnum == tdep->ppc_lr_regnum
|| regnum == tdep->ppc_ctr_regnum || regnum == tdep->ppc_ctr_regnum
|| regnum == tdep->ppc_xer_regnum || regnum == tdep->ppc_xer_regnum
|| regnum == PC_REGNUM); || regnum == gdbarch_pc_regnum (current_gdbarch));
if (group == general_reggroup) if (group == general_reggroup)
return general_p; return general_p;
@ -3119,15 +3124,16 @@ gdb_print_insn_powerpc (bfd_vma memaddr, disassemble_info *info)
static CORE_ADDR static CORE_ADDR
rs6000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) rs6000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, PC_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_pc_regnum (current_gdbarch));
} }
static struct frame_id static struct frame_id
rs6000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) rs6000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_id_build (frame_unwind_register_unsigned (next_frame, return frame_id_build (frame_unwind_register_unsigned
SP_REGNUM), (next_frame, gdbarch_sp_regnum (current_gdbarch)),
frame_pc_unwind (next_frame)); frame_pc_unwind (next_frame));
} }
struct rs6000_frame_cache struct rs6000_frame_cache
@ -3164,7 +3170,8 @@ rs6000_frame_cache (struct frame_info *next_frame, void **this_cache)
->frame pointed to the outer-most address of the frame. In ->frame pointed to the outer-most address of the frame. In
the mean time, the address of the prev frame is used as the the mean time, the address of the prev frame is used as the
base address of this frame. */ base address of this frame. */
cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); cache->base = frame_unwind_register_unsigned
(next_frame, gdbarch_sp_regnum (current_gdbarch));
/* If the function appears to be frameless, check a couple of likely /* If the function appears to be frameless, check a couple of likely
indicators that we have simply failed to find the frame setup. indicators that we have simply failed to find the frame setup.
@ -3202,7 +3209,8 @@ rs6000_frame_cache (struct frame_info *next_frame, void **this_cache)
/* Frameless really means stackless. */ /* Frameless really means stackless. */
cache->base = read_memory_addr (cache->base, wordsize); cache->base = read_memory_addr (cache->base, wordsize);
trad_frame_set_value (cache->saved_regs, SP_REGNUM, cache->base); trad_frame_set_value (cache->saved_regs,
gdbarch_sp_regnum (current_gdbarch), cache->base);
/* if != -1, fdata.saved_fpr is the smallest number of saved_fpr. /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr.
All fpr's from saved_fpr to fp31 are saved. */ All fpr's from saved_fpr to fp31 are saved. */
@ -3281,7 +3289,8 @@ rs6000_frame_cache (struct frame_info *next_frame, void **this_cache)
if (fdata.lr_offset != 0) if (fdata.lr_offset != 0)
cache->saved_regs[tdep->ppc_lr_regnum].addr = cache->base + fdata.lr_offset; cache->saved_regs[tdep->ppc_lr_regnum].addr = cache->base + fdata.lr_offset;
/* The PC is found in the link register. */ /* The PC is found in the link register. */
cache->saved_regs[PC_REGNUM] = cache->saved_regs[tdep->ppc_lr_regnum]; cache->saved_regs[gdbarch_pc_regnum (current_gdbarch)] =
cache->saved_regs[tdep->ppc_lr_regnum];
/* If != 0, fdata.vrsave_offset is the offset from the frame that /* If != 0, fdata.vrsave_offset is the offset from the frame that
holds the VRSAVE. */ holds the VRSAVE. */
@ -3291,7 +3300,8 @@ rs6000_frame_cache (struct frame_info *next_frame, void **this_cache)
if (fdata.alloca_reg < 0) if (fdata.alloca_reg < 0)
/* If no alloca register used, then fi->frame is the value of the /* If no alloca register used, then fi->frame is the value of the
%sp for this frame, and it is good enough. */ %sp for this frame, and it is good enough. */
cache->initial_sp = frame_unwind_register_unsigned (next_frame, SP_REGNUM); cache->initial_sp = frame_unwind_register_unsigned
(next_frame, gdbarch_sp_regnum (current_gdbarch));
else else
cache->initial_sp = frame_unwind_register_unsigned (next_frame, cache->initial_sp = frame_unwind_register_unsigned (next_frame,
fdata.alloca_reg); fdata.alloca_reg);

261
gdb/sh-tdep.c
View File

@ -1134,7 +1134,8 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr); regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
/* Update stack pointer. */ /* Update stack pointer. */
regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp); regcache_cooked_write_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
return sp; return sp;
} }
@ -1204,7 +1205,8 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr); regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
/* Update stack pointer. */ /* Update stack pointer. */
regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp); regcache_cooked_write_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
return sp; return sp;
} }
@ -1245,7 +1247,7 @@ sh_extract_return_value_fpu (struct type *type, struct regcache *regcache,
if (sh_treat_as_flt_p (type)) if (sh_treat_as_flt_p (type))
{ {
int len = TYPE_LENGTH (type); int len = TYPE_LENGTH (type);
int i, regnum = FP0_REGNUM; int i, regnum = gdbarch_fp0_regnum (current_gdbarch);
for (i = 0; i < len; i += 4) for (i = 0; i < len; i += 4)
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE) if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
regcache_raw_read (regcache, regnum++, (char *) valbuf + len - 4 - i); regcache_raw_read (regcache, regnum++, (char *) valbuf + len - 4 - i);
@ -1289,7 +1291,7 @@ sh_store_return_value_fpu (struct type *type, struct regcache *regcache,
if (sh_treat_as_flt_p (type)) if (sh_treat_as_flt_p (type))
{ {
int len = TYPE_LENGTH (type); int len = TYPE_LENGTH (type);
int i, regnum = FP0_REGNUM; int i, regnum = gdbarch_fp0_regnum (current_gdbarch);
for (i = 0; i < len; i += 4) for (i = 0; i < len; i += 4)
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE) if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
regcache_raw_write (regcache, regnum++, regcache_raw_write (regcache, regnum++,
@ -1336,7 +1338,8 @@ sh_generic_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1374,7 +1377,8 @@ sh3_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1416,7 +1420,8 @@ sh2e_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1456,24 +1461,40 @@ sh2e_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", ("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 0), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 1), (frame, gdbarch_fp0_regnum (current_gdbarch) + 0),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 2), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 3), (frame, gdbarch_fp0_regnum (current_gdbarch) + 1),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 4), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 5), (frame, gdbarch_fp0_regnum (current_gdbarch) + 2),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 6), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 7)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 3),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 4),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 5),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 6),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 7));
printf_filtered printf_filtered
("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", ("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 8), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 9), (frame, gdbarch_fp0_regnum (current_gdbarch) + 8),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 10), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 11), (frame, gdbarch_fp0_regnum (current_gdbarch) + 9),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 12), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 13), (frame, gdbarch_fp0_regnum (current_gdbarch) + 10),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 14), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 15)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 11),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 12),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 13),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 14),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 15));
} }
static void static void
@ -1483,7 +1504,8 @@ sh2a_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1525,25 +1547,41 @@ sh2a_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
(pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" (pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
: "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 0), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 1), (frame, gdbarch_fp0_regnum (current_gdbarch) + 0),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 2), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 3), (frame, gdbarch_fp0_regnum (current_gdbarch) + 1),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 4), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 5), (frame, gdbarch_fp0_regnum (current_gdbarch) + 2),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 6), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 7)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 3),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 4),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 5),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 6),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 7));
printf_filtered printf_filtered
(pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" (pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
: "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 8), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 9), (frame, gdbarch_fp0_regnum (current_gdbarch) + 8),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 10), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 11), (frame, gdbarch_fp0_regnum (current_gdbarch) + 9),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 12), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 13), (frame, gdbarch_fp0_regnum (current_gdbarch) + 10),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 14), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 15)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 11),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 12),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 13),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 14),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 15));
printf_filtered printf_filtered
("BANK=%-3d\n", (int) get_frame_register_unsigned (frame, BANK_REGNUM)); ("BANK=%-3d\n", (int) get_frame_register_unsigned (frame, BANK_REGNUM));
printf_filtered printf_filtered
@ -1581,7 +1619,8 @@ sh2a_nofpu_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1655,7 +1694,8 @@ sh3e_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1695,24 +1735,40 @@ sh3e_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", ("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 0), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 1), (frame, gdbarch_fp0_regnum (current_gdbarch) + 0),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 2), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 3), (frame, gdbarch_fp0_regnum (current_gdbarch) + 1),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 4), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 5), (frame, gdbarch_fp0_regnum (current_gdbarch) + 2),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 6), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 7)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 3),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 4),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 5),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 6),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 7));
printf_filtered printf_filtered
("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", ("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 8), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 9), (frame, gdbarch_fp0_regnum (current_gdbarch) + 8),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 10), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 11), (frame, gdbarch_fp0_regnum (current_gdbarch) + 9),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 12), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 13), (frame, gdbarch_fp0_regnum (current_gdbarch) + 10),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 14), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 15)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 11),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 12),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 13),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 14),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 15));
} }
static void static void
@ -1720,7 +1776,8 @@ sh3_dsp_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1784,7 +1841,8 @@ sh4_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1825,25 +1883,41 @@ sh4_show_regs (struct frame_info *frame)
printf_filtered printf_filtered
(pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" (pr ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
: "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 0), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 1), (frame, gdbarch_fp0_regnum (current_gdbarch) + 0),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 2), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 3), (frame, gdbarch_fp0_regnum (current_gdbarch) + 1),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 4), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 5), (frame, gdbarch_fp0_regnum (current_gdbarch) + 2),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 6), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 7)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 3),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 4),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 5),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 6),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 7));
printf_filtered printf_filtered
(pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" (pr ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
: "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 8), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 9), (frame, gdbarch_fp0_regnum (current_gdbarch) + 8),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 10), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 11), (frame, gdbarch_fp0_regnum (current_gdbarch) + 9),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 12), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 13), (frame, gdbarch_fp0_regnum (current_gdbarch) + 10),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 14), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + 15)); (frame, gdbarch_fp0_regnum (current_gdbarch) + 11),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 12),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 13),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 14),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + 15));
} }
static void static void
@ -1851,7 +1925,8 @@ sh4_nofpu_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1895,7 +1970,8 @@ sh_dsp_show_regs (struct frame_info *frame)
{ {
printf_filtered printf_filtered
(" PC %s SR %08lx PR %08lx MACH %08lx\n", (" PC %s SR %08lx PR %08lx MACH %08lx\n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long) get_frame_register_unsigned (frame, SR_REGNUM), (long) get_frame_register_unsigned (frame, SR_REGNUM),
(long) get_frame_register_unsigned (frame, PR_REGNUM), (long) get_frame_register_unsigned (frame, PR_REGNUM),
(long) get_frame_register_unsigned (frame, MACH_REGNUM)); (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@ -1956,7 +2032,7 @@ sh_show_regs_command (char *args, int from_tty)
static struct type * static struct type *
sh_sh2a_register_type (struct gdbarch *gdbarch, int reg_nr) sh_sh2a_register_type (struct gdbarch *gdbarch, int reg_nr)
{ {
if ((reg_nr >= FP0_REGNUM if ((reg_nr >= gdbarch_fp0_regnum (current_gdbarch)
&& (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM)) && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
return builtin_type_float; return builtin_type_float;
else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM) else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
@ -1970,7 +2046,7 @@ sh_sh2a_register_type (struct gdbarch *gdbarch, int reg_nr)
static struct type * static struct type *
sh_sh3e_register_type (struct gdbarch *gdbarch, int reg_nr) sh_sh3e_register_type (struct gdbarch *gdbarch, int reg_nr)
{ {
if ((reg_nr >= FP0_REGNUM if ((reg_nr >= gdbarch_fp0_regnum (current_gdbarch)
&& (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM)) && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
return builtin_type_float; return builtin_type_float;
else else
@ -1989,7 +2065,7 @@ sh_sh4_build_float_register_type (int high)
static struct type * static struct type *
sh_sh4_register_type (struct gdbarch *gdbarch, int reg_nr) sh_sh4_register_type (struct gdbarch *gdbarch, int reg_nr)
{ {
if ((reg_nr >= FP0_REGNUM if ((reg_nr >= gdbarch_fp0_regnum (current_gdbarch)
&& (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM)) && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
return builtin_type_float; return builtin_type_float;
else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM) else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
@ -2109,7 +2185,8 @@ fv_reg_base_num (int fv_regnum)
{ {
int fp_regnum; int fp_regnum;
fp_regnum = FP0_REGNUM + (fv_regnum - FV0_REGNUM) * 4; fp_regnum = gdbarch_fp0_regnum (current_gdbarch)
+ (fv_regnum - FV0_REGNUM) * 4;
return fp_regnum; return fp_regnum;
} }
@ -2119,7 +2196,8 @@ dr_reg_base_num (int dr_regnum)
{ {
int fp_regnum; int fp_regnum;
fp_regnum = FP0_REGNUM + (dr_regnum - DR0_REGNUM) * 2; fp_regnum = gdbarch_fp0_regnum (current_gdbarch)
+ (dr_regnum - DR0_REGNUM) * 2;
return fp_regnum; return fp_regnum;
} }
@ -2269,11 +2347,11 @@ sh_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
struct frame_info *next_frame) struct frame_info *next_frame)
{ {
/* Mark the PC as the destination for the return address. */ /* Mark the PC as the destination for the return address. */
if (regnum == PC_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch))
reg->how = DWARF2_FRAME_REG_RA; reg->how = DWARF2_FRAME_REG_RA;
/* Mark the stack pointer as the call frame address. */ /* Mark the stack pointer as the call frame address. */
else if (regnum == SP_REGNUM) else if (regnum == gdbarch_sp_regnum (current_gdbarch))
reg->how = DWARF2_FRAME_REG_CFA; reg->how = DWARF2_FRAME_REG_CFA;
/* The above was taken from the default init_reg in dwarf2-frame.c /* The above was taken from the default init_reg in dwarf2-frame.c
@ -2375,7 +2453,8 @@ sh_frame_cache (struct frame_info *next_frame, void **this_cache)
setup yet. Try to reconstruct the base address for the stack setup yet. Try to reconstruct the base address for the stack
frame by looking at the stack pointer. For truly "frameless" frame by looking at the stack pointer. For truly "frameless"
functions this might work too. */ functions this might work too. */
cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); cache->base = frame_unwind_register_unsigned
(next_frame, gdbarch_sp_regnum (current_gdbarch));
} }
/* Now that we have the base address for the stack frame we can /* Now that we have the base address for the stack frame we can
@ -2401,7 +2480,7 @@ sh_frame_prev_register (struct frame_info *next_frame, void **this_cache,
gdb_assert (regnum >= 0); gdb_assert (regnum >= 0);
if (regnum == SP_REGNUM && cache->saved_sp) if (regnum == gdbarch_sp_regnum (current_gdbarch) && cache->saved_sp)
{ {
*optimizedp = 0; *optimizedp = 0;
*lvalp = not_lval; *lvalp = not_lval;
@ -2418,7 +2497,7 @@ sh_frame_prev_register (struct frame_info *next_frame, void **this_cache,
/* The PC of the previous frame is stored in the PR register of /* The PC of the previous frame is stored in the PR register of
the current frame. Frob regnum so that we pull the value from the current frame. Frob regnum so that we pull the value from
the correct place. */ the correct place. */
if (regnum == PC_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch))
regnum = PR_REGNUM; regnum = PR_REGNUM;
if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1) if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1)
@ -2472,13 +2551,15 @@ sh_frame_sniffer (struct frame_info *next_frame)
static CORE_ADDR static CORE_ADDR
sh_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) sh_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, SP_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_sp_regnum (current_gdbarch));
} }
static CORE_ADDR static CORE_ADDR
sh_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) sh_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, PC_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_pc_regnum (current_gdbarch));
} }
static struct frame_id static struct frame_id

106
gdb/sh64-tdep.c
View File

@ -95,7 +95,7 @@ enum
DR0_REGNUM = 141, DR0_REGNUM = 141,
DR_LAST_REGNUM = 172, DR_LAST_REGNUM = 172,
/* FPP stands for Floating Point Pair, to avoid confusion with /* FPP stands for Floating Point Pair, to avoid confusion with
GDB's FP0_REGNUM, which is the number of the first Floating GDB's gdbarch_fp0_regnum, which is the number of the first Floating
point register. Unfortunately on the sh5, the floating point point register. Unfortunately on the sh5, the floating point
registers are called FR, and the floating point pairs are called FP. */ registers are called FR, and the floating point pairs are called FP. */
FPP0_REGNUM = 173, FPP0_REGNUM = 173,
@ -691,7 +691,7 @@ sh64_fv_reg_base_num (int fv_regnum)
{ {
int fp_regnum; int fp_regnum;
fp_regnum = FP0_REGNUM + fp_regnum = gdbarch_fp0_regnum (current_gdbarch) +
(fv_regnum - FV0_REGNUM) * 4; (fv_regnum - FV0_REGNUM) * 4;
return fp_regnum; return fp_regnum;
} }
@ -702,7 +702,7 @@ sh64_dr_reg_base_num (int dr_regnum)
{ {
int fp_regnum; int fp_regnum;
fp_regnum = FP0_REGNUM + fp_regnum = gdbarch_fp0_regnum (current_gdbarch) +
(dr_regnum - DR0_REGNUM) * 2; (dr_regnum - DR0_REGNUM) * 2;
return fp_regnum; return fp_regnum;
} }
@ -713,7 +713,7 @@ sh64_fpp_reg_base_num (int fpp_regnum)
{ {
int fp_regnum; int fp_regnum;
fp_regnum = FP0_REGNUM + fp_regnum = gdbarch_fp0_regnum (current_gdbarch) +
(fpp_regnum - FPP0_REGNUM) * 2; (fpp_regnum - FPP0_REGNUM) * 2;
return fp_regnum; return fp_regnum;
} }
@ -793,7 +793,7 @@ sh64_compact_reg_base_num (int reg_nr)
/* floating point register N maps to floating point register N */ /* floating point register N maps to floating point register N */
else if (reg_nr >= FP0_C_REGNUM else if (reg_nr >= FP0_C_REGNUM
&& reg_nr <= FP_LAST_C_REGNUM) && reg_nr <= FP_LAST_C_REGNUM)
base_regnum = reg_nr - FP0_C_REGNUM + FP0_REGNUM; base_regnum = reg_nr - FP0_C_REGNUM + gdbarch_fp0_regnum (current_gdbarch);
/* double prec register N maps to base regnum for double prec register N */ /* double prec register N maps to base regnum for double prec register N */
else if (reg_nr >= DR0_C_REGNUM else if (reg_nr >= DR0_C_REGNUM
@ -806,7 +806,7 @@ sh64_compact_reg_base_num (int reg_nr)
base_regnum = sh64_fv_reg_base_num (FV0_REGNUM + reg_nr - FV0_C_REGNUM); base_regnum = sh64_fv_reg_base_num (FV0_REGNUM + reg_nr - FV0_C_REGNUM);
else if (reg_nr == PC_C_REGNUM) else if (reg_nr == PC_C_REGNUM)
base_regnum = PC_REGNUM; base_regnum = gdbarch_pc_regnum (current_gdbarch);
else if (reg_nr == GBR_C_REGNUM) else if (reg_nr == GBR_C_REGNUM)
base_regnum = 16; base_regnum = 16;
@ -825,7 +825,7 @@ sh64_compact_reg_base_num (int reg_nr)
base_regnum = FPSCR_REGNUM; /*???? this register is a mess. */ base_regnum = FPSCR_REGNUM; /*???? this register is a mess. */
else if (reg_nr == FPUL_C_REGNUM) else if (reg_nr == FPUL_C_REGNUM)
base_regnum = FP0_REGNUM + 32; base_regnum = gdbarch_fp0_regnum (current_gdbarch) + 32;
return base_regnum; return base_regnum;
} }
@ -1087,7 +1087,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
in eight registers available. Loop thru args from first to last. */ in eight registers available. Loop thru args from first to last. */
int_argreg = ARG0_REGNUM; int_argreg = ARG0_REGNUM;
float_argreg = FP0_REGNUM; float_argreg = gdbarch_fp0_regnum (current_gdbarch);
double_argreg = DR0_REGNUM; double_argreg = DR0_REGNUM;
for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++) for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
@ -1157,7 +1157,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
{ {
/* Goes in FR0...FR11 */ /* Goes in FR0...FR11 */
regcache_cooked_write (regcache, regcache_cooked_write (regcache,
FP0_REGNUM + float_arg_index, gdbarch_fp0_regnum (current_gdbarch)
+ float_arg_index,
val); val);
fp_args[float_arg_index] = 1; fp_args[float_arg_index] = 1;
/* Skip the corresponding general argument register. */ /* Skip the corresponding general argument register. */
@ -1201,7 +1202,8 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr); regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
/* Update stack pointer. */ /* Update stack pointer. */
regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp); regcache_cooked_write_unsigned (regcache,
gdbarch_sp_regnum (current_gdbarch), sp);
return sp; return sp;
} }
@ -1220,8 +1222,9 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
{ {
if (len == 4) if (len == 4)
{ {
/* Return value stored in FP0_REGNUM */ /* Return value stored in gdbarch_fp0_regnum */
regcache_raw_read (regcache, FP0_REGNUM, valbuf); regcache_raw_read (regcache,
gdbarch_fp0_regnum (current_gdbarch), valbuf);
} }
else if (len == 8) else if (len == 8)
{ {
@ -1278,7 +1281,7 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
if (TYPE_CODE (type) == TYPE_CODE_FLT) if (TYPE_CODE (type) == TYPE_CODE_FLT)
{ {
int i, regnum = FP0_REGNUM; int i, regnum = gdbarch_fp0_regnum (current_gdbarch);
for (i = 0; i < len; i += 4) for (i = 0; i < len; i += 4)
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE) if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
regcache_raw_write (regcache, regnum++, regcache_raw_write (regcache, regnum++,
@ -1330,7 +1333,8 @@ sh64_show_media_regs (struct frame_info *frame)
printf_filtered printf_filtered
("PC=%s SR=%016llx \n", ("PC=%s SR=%016llx \n",
paddr (get_frame_register_unsigned (frame, PC_REGNUM)), paddr (get_frame_register_unsigned (frame,
gdbarch_pc_regnum (current_gdbarch))),
(long long) get_frame_register_unsigned (frame, SR_REGNUM)); (long long) get_frame_register_unsigned (frame, SR_REGNUM));
printf_filtered printf_filtered
@ -1356,14 +1360,22 @@ sh64_show_media_regs (struct frame_info *frame)
printf_filtered printf_filtered
("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
i, i + 7, i, i + 7,
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 0), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 1), (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 0),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 2), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 3), (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 1),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 4), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 5), (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 2),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 6), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 7)); (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 3),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 4),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 5),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 6),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 7));
} }
static void static void
@ -1402,14 +1414,22 @@ sh64_show_compact_regs (struct frame_info *frame)
printf_filtered printf_filtered
("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", ("FR%d-FR%d %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
i, i + 7, i, i + 7,
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 0), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 1), (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 0),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 2), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 3), (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 1),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 4), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 5), (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 2),
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 6), (long) get_frame_register_unsigned
(long) get_frame_register_unsigned (frame, FP0_REGNUM + i + 7)); (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 3),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 4),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 5),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 6),
(long) get_frame_register_unsigned
(frame, gdbarch_fp0_regnum (current_gdbarch) + i + 7));
} }
/* FIXME!!! This only shows the registers for shmedia, excluding the /* FIXME!!! This only shows the registers for shmedia, excluding the
@ -1505,7 +1525,7 @@ sh64_build_float_register_type (int high)
static struct type * static struct type *
sh64_register_type (struct gdbarch *gdbarch, int reg_nr) sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
{ {
if ((reg_nr >= FP0_REGNUM if ((reg_nr >= gdbarch_fp0_regnum (current_gdbarch)
&& reg_nr <= FP_LAST_REGNUM) && reg_nr <= FP_LAST_REGNUM)
|| (reg_nr >= FP0_C_REGNUM || (reg_nr >= FP0_C_REGNUM
&& reg_nr <= FP_LAST_C_REGNUM)) && reg_nr <= FP_LAST_C_REGNUM))
@ -1974,7 +1994,10 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file,
int j; int j;
/* Allocate space for the float. */ /* Allocate space for the float. */
raw_buffer = (unsigned char *) alloca (register_size (gdbarch, FP0_REGNUM)); raw_buffer = (unsigned char *) alloca
(register_size (gdbarch,
gdbarch_fp0_regnum
(current_gdbarch)));
/* Get the data in raw format. */ /* Get the data in raw format. */
if (!frame_register_read (frame, regnum, raw_buffer)) if (!frame_register_read (frame, regnum, raw_buffer))
@ -2161,7 +2184,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
regnum ++; regnum ++;
} }
else else
regnum += FP_LAST_REGNUM - FP0_REGNUM; /* skip FP regs */ regnum += FP_LAST_REGNUM - gdbarch_fp0_regnum (current_gdbarch);
/* skip FP regs */
} }
else else
{ {
@ -2284,7 +2308,8 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
setup yet. Try to reconstruct the base address for the stack setup yet. Try to reconstruct the base address for the stack
frame by looking at the stack pointer. For truly "frameless" frame by looking at the stack pointer. For truly "frameless"
functions this might work too. */ functions this might work too. */
cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM); cache->base = frame_unwind_register_unsigned
(next_frame, gdbarch_sp_regnum (current_gdbarch));
} }
/* Now that we have the base address for the stack frame we can /* Now that we have the base address for the stack frame we can
@ -2310,7 +2335,7 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
gdb_assert (regnum >= 0); gdb_assert (regnum >= 0);
if (regnum == SP_REGNUM && cache->saved_sp) if (regnum == gdbarch_sp_regnum (current_gdbarch) && cache->saved_sp)
{ {
*optimizedp = 0; *optimizedp = 0;
*lvalp = not_lval; *lvalp = not_lval;
@ -2320,7 +2345,8 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
{ {
/* Store the value. */ /* Store the value. */
store_unsigned_integer (valuep, store_unsigned_integer (valuep,
register_size (current_gdbarch, SP_REGNUM), register_size (current_gdbarch,
gdbarch_sp_regnum (current_gdbarch)),
cache->saved_sp); cache->saved_sp);
} }
return; return;
@ -2329,7 +2355,7 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
/* The PC of the previous frame is stored in the PR register of /* The PC of the previous frame is stored in the PR register of
the current frame. Frob regnum so that we pull the value from the current frame. Frob regnum so that we pull the value from
the correct place. */ the correct place. */
if (regnum == PC_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch))
regnum = PR_REGNUM; regnum = PR_REGNUM;
if (regnum < SIM_SH64_NR_REGS && cache->saved_regs[regnum] != -1) if (regnum < SIM_SH64_NR_REGS && cache->saved_regs[regnum] != -1)
@ -2393,13 +2419,15 @@ sh64_frame_sniffer (struct frame_info *next_frame)
static CORE_ADDR static CORE_ADDR
sh64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) sh64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, SP_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_sp_regnum (current_gdbarch));
} }
static CORE_ADDR static CORE_ADDR
sh64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) sh64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, PC_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_pc_regnum (current_gdbarch));
} }
static struct frame_id static struct frame_id

2
gdb/shnbsd-nat.c
View File

@ -37,7 +37,7 @@
/* Determine if PT_GETREGS fetches this register. */ /* Determine if PT_GETREGS fetches this register. */
#define GETREGS_SUPPLIES(regno) \ #define GETREGS_SUPPLIES(regno) \
(((regno) >= R0_REGNUM && (regno) <= (R0_REGNUM + 15)) \ (((regno) >= R0_REGNUM && (regno) <= (R0_REGNUM + 15)) \
|| (regno) == PC_REGNUM || (regno) == PR_REGNUM \ || (regno) == gdbarch_pc_regnum (current_gdbarch) || (regno) == PR_REGNUM \
|| (regno) == MACH_REGNUM || (regno) == MACL_REGNUM \ || (regno) == MACH_REGNUM || (regno) == MACL_REGNUM \
|| (regno) == SR_REGNUM) || (regno) == SR_REGNUM)

11
gdb/shnbsd-tdep.c
View File

@ -74,8 +74,10 @@ shnbsd_supply_gregset (const struct regset *regset,
gdb_assert (len >= SHNBSD_SIZEOF_GREGS); gdb_assert (len >= SHNBSD_SIZEOF_GREGS);
if (regnum == PC_REGNUM || regnum == -1) if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == -1)
regcache_raw_supply (regcache, PC_REGNUM, regs + (0 * 4)); regcache_raw_supply (regcache,
gdbarch_pc_regnum (current_gdbarch),
regs + (0 * 4));
if (regnum == SR_REGNUM || regnum == -1) if (regnum == SR_REGNUM || regnum == -1)
regcache_raw_supply (regcache, SR_REGNUM, regs + (1 * 4)); regcache_raw_supply (regcache, SR_REGNUM, regs + (1 * 4));
@ -111,8 +113,9 @@ shnbsd_collect_gregset (const struct regset *regset,
gdb_assert (len >= SHNBSD_SIZEOF_GREGS); gdb_assert (len >= SHNBSD_SIZEOF_GREGS);
if (regnum == PC_REGNUM || regnum == -1) if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == -1)
regcache_raw_collect (regcache, PC_REGNUM, regs + (0 * 4)); regcache_raw_collect (regcache, gdbarch_pc_regnum (current_gdbarch),
regs + (0 * 4));
if (regnum == SR_REGNUM || regnum == -1) if (regnum == SR_REGNUM || regnum == -1)
regcache_raw_collect (regcache, SR_REGNUM, regs + (1 * 4)); regcache_raw_collect (regcache, SR_REGNUM, regs + (1 * 4));

9
gdb/stabsread.c
View File

@ -1030,7 +1030,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
gdbarch_num_regs (current_gdbarch) gdbarch_num_regs (current_gdbarch)
+ gdbarch_num_pseudo_regs (current_gdbarch), + gdbarch_num_pseudo_regs (current_gdbarch),
SYMBOL_PRINT_NAME (sym)); SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */ SYMBOL_VALUE (sym) = gdbarch_sp_regnum (current_gdbarch);
/* Known safe, though useless */
} }
SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols); add_symbol_to_list (sym, &local_symbols);
@ -1048,7 +1049,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
gdbarch_num_regs (current_gdbarch) gdbarch_num_regs (current_gdbarch)
+ gdbarch_num_pseudo_regs (current_gdbarch), + gdbarch_num_pseudo_regs (current_gdbarch),
SYMBOL_PRINT_NAME (sym)); SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */ SYMBOL_VALUE (sym) = gdbarch_sp_regnum (current_gdbarch);
/* Known safe, though useless */
} }
SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
if (within_function) if (within_function)
@ -1322,7 +1324,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
gdbarch_num_regs (current_gdbarch) gdbarch_num_regs (current_gdbarch)
+ gdbarch_num_pseudo_regs (current_gdbarch), + gdbarch_num_pseudo_regs (current_gdbarch),
SYMBOL_PRINT_NAME (sym)); SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */ SYMBOL_VALUE (sym) = gdbarch_sp_regnum (current_gdbarch);
/* Known safe, though useless */
} }
SYMBOL_DOMAIN (sym) = VAR_DOMAIN; SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols); add_symbol_to_list (sym, &local_symbols);

23
gdb/stack.c
View File

@ -840,13 +840,14 @@ frame_info (char *addr_exp, int from_tty)
/* Name of the value returned by get_frame_pc(). Per comments, "pc" /* Name of the value returned by get_frame_pc(). Per comments, "pc"
is not a good name. */ is not a good name. */
if (PC_REGNUM >= 0) if (gdbarch_pc_regnum (current_gdbarch) >= 0)
/* OK, this is weird. The PC_REGNUM hardware register's value can /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
easily not match that of the internal value returned by easily not match that of the internal value returned by
get_frame_pc(). */ get_frame_pc(). */
pc_regname = gdbarch_register_name (current_gdbarch, PC_REGNUM); pc_regname = gdbarch_register_name (current_gdbarch,
gdbarch_pc_regnum (current_gdbarch));
else else
/* But then, this is weird to. Even without PC_REGNUM, an /* But then, this is weird to. Even without gdbarch_pc_regnum, an
architectures will often have a hardware register called "pc", architectures will often have a hardware register called "pc",
and that register's value, again, can easily not match and that register's value, again, can easily not match
get_frame_pc(). */ get_frame_pc(). */
@ -1021,22 +1022,26 @@ frame_info (char *addr_exp, int from_tty)
at one stage the frame cached the previous frame's SP instead at one stage the frame cached the previous frame's SP instead
of its address, hence it was easiest to just display the cached of its address, hence it was easiest to just display the cached
value. */ value. */
if (SP_REGNUM >= 0) if (gdbarch_sp_regnum (current_gdbarch) >= 0)
{ {
/* Find out the location of the saved stack pointer with out /* Find out the location of the saved stack pointer with out
actually evaluating it. */ actually evaluating it. */
frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr, frame_register_unwind (fi, gdbarch_sp_regnum (current_gdbarch),
&optimized, &lval, &addr,
&realnum, NULL); &realnum, NULL);
if (!optimized && lval == not_lval) if (!optimized && lval == not_lval)
{ {
gdb_byte value[MAX_REGISTER_SIZE]; gdb_byte value[MAX_REGISTER_SIZE];
CORE_ADDR sp; CORE_ADDR sp;
frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr, frame_register_unwind (fi, gdbarch_sp_regnum (current_gdbarch),
&optimized, &lval, &addr,
&realnum, value); &realnum, value);
/* NOTE: cagney/2003-05-22: This is assuming that the /* NOTE: cagney/2003-05-22: This is assuming that the
stack pointer was packed as an unsigned integer. That stack pointer was packed as an unsigned integer. That
may or may not be valid. */ may or may not be valid. */
sp = extract_unsigned_integer (value, register_size (current_gdbarch, SP_REGNUM)); sp = extract_unsigned_integer (value,
register_size (current_gdbarch,
gdbarch_sp_regnum (current_gdbarch)));
printf_filtered (" Previous frame's sp is "); printf_filtered (" Previous frame's sp is ");
deprecated_print_address_numeric (sp, 1, gdb_stdout); deprecated_print_address_numeric (sp, 1, gdb_stdout);
printf_filtered ("\n"); printf_filtered ("\n");
@ -1062,7 +1067,7 @@ frame_info (char *addr_exp, int from_tty)
numregs = gdbarch_num_regs (current_gdbarch) numregs = gdbarch_num_regs (current_gdbarch)
+ gdbarch_num_pseudo_regs (current_gdbarch); + gdbarch_num_pseudo_regs (current_gdbarch);
for (i = 0; i < numregs; i++) for (i = 0; i < numregs; i++)
if (i != SP_REGNUM if (i != gdbarch_sp_regnum (current_gdbarch)
&& gdbarch_register_reggroup_p (current_gdbarch, i, all_reggroup)) && gdbarch_register_reggroup_p (current_gdbarch, i, all_reggroup))
{ {
/* Find out the location of the saved register without /* Find out the location of the saved register without

16
gdb/std-regs.c
View File

@ -56,8 +56,8 @@ value_of_builtin_frame_fp_reg (struct frame_info *frame, const void *baton)
static struct value * static struct value *
value_of_builtin_frame_pc_reg (struct frame_info *frame, const void *baton) value_of_builtin_frame_pc_reg (struct frame_info *frame, const void *baton)
{ {
if (PC_REGNUM >= 0) if (gdbarch_pc_regnum (current_gdbarch) >= 0)
return value_of_register (PC_REGNUM, frame); return value_of_register (gdbarch_pc_regnum (current_gdbarch), frame);
else else
{ {
struct value *val = allocate_value (builtin_type_void_data_ptr); struct value *val = allocate_value (builtin_type_void_data_ptr);
@ -74,20 +74,16 @@ value_of_builtin_frame_pc_reg (struct frame_info *frame, const void *baton)
static struct value * static struct value *
value_of_builtin_frame_sp_reg (struct frame_info *frame, const void *baton) value_of_builtin_frame_sp_reg (struct frame_info *frame, const void *baton)
{ {
#ifdef SP_REGNUM if (gdbarch_sp_regnum (current_gdbarch) >= 0)
if (SP_REGNUM >= 0) return value_of_register (gdbarch_sp_regnum (current_gdbarch), frame);
return value_of_register (SP_REGNUM, frame);
#endif
error (_("Standard register ``$sp'' is not available for this target")); error (_("Standard register ``$sp'' is not available for this target"));
} }
static struct value * static struct value *
value_of_builtin_frame_ps_reg (struct frame_info *frame, const void *baton) value_of_builtin_frame_ps_reg (struct frame_info *frame, const void *baton)
{ {
#ifdef PS_REGNUM if (gdbarch_ps_regnum (current_gdbarch) >= 0)
if (PS_REGNUM >= 0) return value_of_register (gdbarch_ps_regnum (current_gdbarch), frame);
return value_of_register (PS_REGNUM, frame);
#endif
error (_("Standard register ``$ps'' is not available for this target")); error (_("Standard register ``$ps'' is not available for this target"));
} }

6
gdb/v850-tdep.c
View File

@ -940,13 +940,15 @@ v850_frame_sniffer (struct frame_info *next_frame)
static CORE_ADDR static CORE_ADDR
v850_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) v850_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, SP_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_sp_regnum (current_gdbarch));
} }
static CORE_ADDR static CORE_ADDR
v850_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) v850_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{ {
return frame_unwind_register_unsigned (next_frame, PC_REGNUM); return frame_unwind_register_unsigned (next_frame,
gdbarch_pc_regnum (current_gdbarch));
} }
static struct frame_id static struct frame_id

3
gdb/win32-nat.c
View File

@ -1318,7 +1318,8 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig)
if (step) if (step)
{ {
/* Single step by setting t bit */ /* Single step by setting t bit */
win32_fetch_inferior_registers (get_current_regcache (), PS_REGNUM); win32_fetch_inferior_registers (get_current_regcache (),
gdbarch_ps_regnum (current_gdbarch));
th->context.EFlags |= FLAG_TRACE_BIT; th->context.EFlags |= FLAG_TRACE_BIT;
} }

3
gdb/windows-nat.c
View File

@ -1318,7 +1318,8 @@ win32_resume (ptid_t ptid, int step, enum target_signal sig)
if (step) if (step)
{ {
/* Single step by setting t bit */ /* Single step by setting t bit */
win32_fetch_inferior_registers (get_current_regcache (), PS_REGNUM); win32_fetch_inferior_registers (get_current_regcache (),
gdbarch_ps_regnum (current_gdbarch));
th->context.EFlags |= FLAG_TRACE_BIT; th->context.EFlags |= FLAG_TRACE_BIT;
} }

37
gdb/xtensa-tdep.c
View File

@ -209,7 +209,7 @@ xtensa_register_type (struct gdbarch *gdbarch, int regnum)
|| (regnum >= A0_BASE && regnum < A0_BASE + 16)) || (regnum >= A0_BASE && regnum < A0_BASE + 16))
return builtin_type_int; return builtin_type_int;
if (regnum == PC_REGNUM || regnum == A1_REGNUM) if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == A1_REGNUM)
return lookup_pointer_type (builtin_type_void); return lookup_pointer_type (builtin_type_void);
/* Return the stored type for all other registers. */ /* Return the stored type for all other registers. */
@ -748,10 +748,13 @@ xtensa_supply_gregset (const struct regset *regset,
DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...) \n", regnum); DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...) \n", regnum);
if (regnum == PC_REGNUM || regnum == -1) if (regnum == gdbarch_pc_regnum (current_gdbarch) || regnum == -1)
regcache_raw_supply (rc, PC_REGNUM, (char *) &regs->pc); regcache_raw_supply (rc,
if (regnum == PS_REGNUM || regnum == -1) gdbarch_pc_regnum (current_gdbarch),
regcache_raw_supply (rc, PS_REGNUM, (char *) &regs->ps); (char *) &regs->pc);
if (regnum == gdbarch_ps_regnum (current_gdbarch) || regnum == -1)
regcache_raw_supply (rc, gdbarch_ps_regnum (current_gdbarch),
(char *) &regs->ps);
if (regnum == WB_REGNUM || regnum == -1) if (regnum == WB_REGNUM || regnum == -1)
regcache_raw_supply (rc, WB_REGNUM, (char *) &regs->windowbase); regcache_raw_supply (rc, WB_REGNUM, (char *) &regs->windowbase);
if (regnum == WS_REGNUM || regnum == -1) if (regnum == WS_REGNUM || regnum == -1)
@ -868,7 +871,7 @@ xtensa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame); DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame);
frame_unwind_register (next_frame, PC_REGNUM, buf); frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf);
DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int) DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int)
extract_typed_address (buf, builtin_type_void_func_ptr)); extract_typed_address (buf, builtin_type_void_func_ptr));
@ -918,8 +921,10 @@ xtensa_frame_cache (struct frame_info *next_frame, void **this_cache)
/* Get windowbase, windowstart, ps, and pc. */ /* Get windowbase, windowstart, ps, and pc. */
wb = frame_unwind_register_unsigned (next_frame, WB_REGNUM); wb = frame_unwind_register_unsigned (next_frame, WB_REGNUM);
ws = frame_unwind_register_unsigned (next_frame, WS_REGNUM); ws = frame_unwind_register_unsigned (next_frame, WS_REGNUM);
ps = frame_unwind_register_unsigned (next_frame, PS_REGNUM); ps = frame_unwind_register_unsigned (next_frame,
pc = frame_unwind_register_unsigned (next_frame, PC_REGNUM); gdbarch_ps_regnum (current_gdbarch));
pc = frame_unwind_register_unsigned (next_frame,
gdbarch_pc_regnum (current_gdbarch));
op1 = read_memory_integer (pc, 1); op1 = read_memory_integer (pc, 1);
if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (ps)) if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (ps))
@ -1062,9 +1067,9 @@ xtensa_frame_prev_register (struct frame_info *next_frame,
} }
else if (regnum == WB_REGNUM) else if (regnum == WB_REGNUM)
saved_reg = cache->wb; saved_reg = cache->wb;
else if (regnum == PC_REGNUM) else if (regnum == gdbarch_pc_regnum (current_gdbarch))
saved_reg = cache->pc; saved_reg = cache->pc;
else if (regnum == PS_REGNUM) else if (regnum == gdbarch_ps_regnum (current_gdbarch))
saved_reg = cache->ps; saved_reg = cache->ps;
else else
done = 0; done = 0;
@ -1169,7 +1174,8 @@ xtensa_extract_return_value (struct type *type,
gdb_assert(len > 0); gdb_assert(len > 0);
/* First, we have to find the caller window in the register file. */ /* First, we have to find the caller window in the register file. */
regcache_raw_read_unsigned (regcache, PC_REGNUM, &pc); regcache_raw_read_unsigned (regcache,
gdbarch_pc_regnum (current_gdbarch), &pc);
callsize = extract_call_winsize (pc); callsize = extract_call_winsize (pc);
/* On Xtensa, we can return up to 4 words (or 2 when called by call12). */ /* On Xtensa, we can return up to 4 words (or 2 when called by call12). */
@ -1212,7 +1218,8 @@ xtensa_store_return_value (struct type *type,
DEBUGTRACE ("xtensa_store_return_value (...)\n"); DEBUGTRACE ("xtensa_store_return_value (...)\n");
regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb); regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb);
regcache_raw_read_unsigned (regcache, PC_REGNUM, &pc); regcache_raw_read_unsigned (regcache,
gdbarch_pc_regnum (current_gdbarch), &pc);
callsize = extract_call_winsize (pc); callsize = extract_call_winsize (pc);
if (len > (callsize > 8 ? 8 : 16)) if (len > (callsize > 8 ? 8 : 16))
@ -1492,10 +1499,12 @@ xtensa_push_dummy_call (struct gdbarch *gdbarch,
saved in the dummy frame, so we can savely overwrite A0 here. */ saved in the dummy frame, so we can savely overwrite A0 here. */
ra = (bp_addr & 0x3fffffff) | 0x40000000; ra = (bp_addr & 0x3fffffff) | 0x40000000;
regcache_raw_read (regcache, PS_REGNUM, buf); regcache_raw_read (regcache, gdbarch_ps_regnum (current_gdbarch), buf);
ps = extract_unsigned_integer (buf, 4) & ~0x00030000; ps = extract_unsigned_integer (buf, 4) & ~0x00030000;
regcache_cooked_write_unsigned (regcache, A4_REGNUM, ra); regcache_cooked_write_unsigned (regcache, A4_REGNUM, ra);
regcache_cooked_write_unsigned (regcache, PS_REGNUM, ps | 0x00010000); regcache_cooked_write_unsigned (regcache,
gdbarch_ps_regnum (current_gdbarch),
ps | 0x00010000);
/* Set new stack pointer and return it. */ /* Set new stack pointer and return it. */
regcache_cooked_write_unsigned (regcache, A1_REGNUM, sp); regcache_cooked_write_unsigned (regcache, A1_REGNUM, sp);