mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
ac7936dfd0
This patches removes get_regcache_arch, and use regache->arch () instead. The motivation of this change is that I am going to move some basic stuff into a base class of regcache. I don't need to update "client" code regcache->arch (). On the other hand, this patch shortens the code a little bit. gdb: 2017-10-25 Yao Qi <yao.qi@linaro.org> * aarch32-linux-nat.c (aarch32_gp_regcache_supply): Use regcache->arch () instead get_regcache_arch. * aarch64-fbsd-nat.c (aarch64_fbsd_fetch_inferior_registers): Likewise. (aarch64_fbsd_store_inferior_registers): Likewise. * aarch64-linux-nat.c (fetch_gregs_from_thread): Likewise. (store_gregs_to_thread): Likewise. (fetch_fpregs_from_thread): Likewise. (store_fpregs_to_thread): Likewise. * aarch64-tdep.c (aarch64_extract_return_value): Likewise. (aarch64_store_return_value): Likewise. (aarch64_software_single_step): Likewise. * aix-thread.c (aix_thread_wait): Likewise. (supply_reg32): Likewise. (supply_sprs64): Likewise. (supply_sprs32): Likewise. (fill_gprs64): Likewise. (fill_gprs32): Likewise. (fill_sprs64): Likewise. (fill_sprs32): Likewise. (store_regs_user_thread): Likewise. (store_regs_kernel_thread): Likewise. * alpha-bsd-nat.c (alphabsd_fetch_inferior_registers): Likewise. (alphabsd_store_inferior_registers): Likewise. * alpha-tdep.c (alpha_extract_return_value): Likewise. (alpha_store_return_value): Likewise. (alpha_deal_with_atomic_sequence): Likewise. (alpha_next_pc): Likewise. (alpha_software_single_step): Likewise. * amd64-bsd-nat.c (amd64bsd_fetch_inferior_registers): Likewise. (amd64bsd_store_inferior_registers): Likewise. * amd64-linux-nat.c (amd64_linux_fetch_inferior_registers): Likewise. (amd64_linux_store_inferior_registers): Likewise. * amd64-nat.c (amd64_supply_native_gregset): Likewise. (amd64_collect_native_gregset): Likewise. * amd64-obsd-tdep.c (amd64obsd_supply_uthread): Likewise. (amd64obsd_collect_uthread): Likewise. * amd64-tdep.c (amd64_supply_fpregset): Likewise. (amd64_collect_fpregset): Likewise. (amd64_supply_fxsave): Likewise. (amd64_supply_xsave): Likewise. (amd64_collect_fxsave): Likewise. (amd64_collect_xsave): Likewise. * arc-tdep.c (arc_write_pc): Likewise. * arch-utils.c (default_skip_permanent_breakpoint): Likewise. * arm-fbsd-nat.c (arm_fbsd_fetch_inferior_registers): Likewise. (arm_fbsd_store_inferior_registers): Likewise. * arm-linux-nat.c (fetch_vfp_regs): Likewise. (store_vfp_regs): Likewise. (arm_linux_fetch_inferior_registers): Likewise. (arm_linux_store_inferior_registers): Likewise. * arm-linux-tdep.c (arm_linux_supply_gregset): Likewise. (arm_linux_sigreturn_next_pc): Likewise. (arm_linux_get_next_pcs_syscall_next_pc): Likewise. * arm-nbsd-nat.c (arm_supply_gregset): Likewise. (fetch_register): Likewise. (store_register): Likewise. * arm-tdep.c (arm_is_thumb): Likewise. (displaced_in_arm_mode): Likewise. (bx_write_pc): Likewise. (arm_get_next_pcs_addr_bits_remove): Likewise. (arm_software_single_step): Likewise. (arm_extract_return_value): Likewise. (arm_store_return_value): Likewise. (arm_write_pc): Likewise. * bfin-tdep.c (bfin_extract_return_value): Likewise. * bsd-uthread.c (bsd_uthread_fetch_registers): Likewise. (bsd_uthread_store_registers): Likewise. * core-regset.c (fetch_core_registers): Likewise. * corelow.c (get_core_registers): Likewise. * cris-tdep.c (cris_store_return_value): Likewise. (cris_extract_return_value): Likewise. (find_step_target): Likewise. (find_step_target): Likewise. (cris_software_single_step): Likewise. * ctf.c (ctf_fetch_registers): Likewise. * darwin-nat.c (cancel_breakpoint): Likewise. * fbsd-tdep.c (fbsd_collect_thread_registers): Likewise. * frv-tdep.c (frv_extract_return_value): Likewise. * ft32-tdep.c (ft32_store_return_value): Likewise. (ft32_extract_return_value): Likewise. * go32-nat.c (fetch_register): Likewise. (go32_fetch_registers): Likewise. (go32_store_registers): Likewise. (store_register): Likewise. * h8300-tdep.c (h8300_extract_return_value): Likewise. (h8300_store_return_value): Likewise. * hppa-linux-nat.c (fetch_register): Likewise. (store_register): Likewise. (hppa_linux_fetch_inferior_registers): Likewise. (hppa_linux_store_inferior_registers): Likewise. * i386-darwin-nat.c (i386_darwin_fetch_inferior_registers): Likewise. (i386_darwin_store_inferior_registers): Likewise. * i386-gnu-nat.c (gnu_fetch_registers): Likewise. (gnu_store_registers): Likewise. * i386-linux-nat.c (fetch_register): Likewise. (store_register): Likewise. (supply_gregset): Likewise. (fill_gregset): Likewise. (i386_linux_fetch_inferior_registers): Likewise. (i386_linux_store_inferior_registers): Likewise. (i386_linux_resume): Likewise. * i386-linux-tdep.c (i386_linux_get_syscall_number_from_regcache): Likewise. * i386-nto-tdep.c (i386nto_supply_gregset): Likewise. * i386-obsd-nat.c (i386obsd_supply_pcb): Likewise. * i386-obsd-tdep.c (i386obsd_supply_uthread): Likewise. (i386obsd_collect_uthread): Likewise. * i386-tdep.c (i386_mmx_regnum_to_fp_regnum): Likewise. (i386_supply_gregset): Likewise. (i386_collect_gregset): Likewise. (i386_supply_fpregset): Likewise. (i386_collect_fpregset): Likewise. (i386_mpx_bd_base): Likewise. * i386-v4-nat.c (supply_fpregset): Likewise. (fill_fpregset): Likewise. * i387-tdep.c (i387_supply_fsave): Likewise. (i387_collect_fsave): Likewise. (i387_supply_fxsave): Likewise. (i387_collect_fxsave): Likewise. (i387_supply_xsave): Likewise. (i387_collect_xsave): Likewise. * ia64-linux-nat.c (ia64_linux_fetch_registers): Likewise. (ia64_linux_store_registers): Likewise. * ia64-tdep.c (ia64_access_rse_reg): Likewise. (ia64_extract_return_value): Likewise. (ia64_store_return_value): Likewise. (find_func_descr): Likewise. * inf-child.c (inf_child_fetch_inferior_registers): Likewise. * inf-ptrace.c (inf_ptrace_fetch_registers): Likewise. (inf_ptrace_store_registers): Likewise. * infrun.c (use_displaced_stepping): Likewise. (displaced_step_prepare_throw): Likewise. (resume): Likewise. (proceed): Likewise. (do_target_wait): Likewise. (adjust_pc_after_break): Likewise. (handle_inferior_event_1): Likewise. (handle_signal_stop): Likewise. (save_infcall_suspend_state): Likewise. (restore_infcall_suspend_state): Likewise. * iq2000-tdep.c (iq2000_extract_return_value): Likewise. * jit.c (jit_frame_prev_register): Likewise. * linux-nat.c (save_stop_reason): Likewise. (linux_nat_wait_1): Likewise. (resume_stopped_resumed_lwps): Likewise. * linux-record.c (record_linux_sockaddr): Likewise. (record_linux_msghdr): Likewise. (record_linux_system_call): Likewise. * linux-tdep.c (linux_collect_thread_registers): Likewise. * lm32-tdep.c (lm32_extract_return_value): Likewise. (lm32_store_return_value): Likewise. * m32c-tdep.c (m32c_read_flg): Likewise. (m32c_pseudo_register_read): Likewise. (m32c_pseudo_register_write): Likewise. * m32r-linux-tdep.c (m32r_linux_supply_gregset): Likewise. (m32r_linux_collect_gregset): Likewise. * m32r-tdep.c (m32r_store_return_value): Likewise. (m32r_extract_return_value): Likewise. * m68k-bsd-nat.c (m68kbsd_supply_fpregset): Likewise. (m68kbsd_collect_fpregset): Likewise. * m68k-bsd-tdep.c (m68kbsd_supply_fpregset): Likewise. * m68k-linux-nat.c (fetch_register): Likewise. (old_fetch_inferior_registers): Likewise. (old_store_inferior_registers): Likewise. (store_regs): Likewise. * m68k-tdep.c (m68k_svr4_extract_return_value): Likewise. (m68k_svr4_store_return_value): Likewise. * m88k-tdep.c (m88k_store_arguments): Likewise. * mi/mi-main.c (mi_cmd_data_list_changed_registers): Likewise. (mi_cmd_data_write_register_values): Likewise. * mips-fbsd-nat.c (mips_fbsd_fetch_inferior_registers): Likewise. (mips_fbsd_store_inferior_registers): Likewise. * mips-fbsd-tdep.c (mips_fbsd_supply_fpregs): Likewise. (mips_fbsd_supply_gregs): Likewise. (mips_fbsd_collect_fpregs): Likewise. (mips_fbsd_collect_gregs): Likewise. (mips_fbsd_supply_fpregset): Likewise. (mips_fbsd_collect_fpregset): Likewise. (mips_fbsd_supply_gregset): Likewise. (mips_fbsd_collect_gregset): Likewise. * mips-linux-nat.c (supply_gregset): Likewise. (fill_gregset): Likewise. (supply_fpregset): Likewise. (fill_fpregset): Likewise. * mips-linux-tdep.c (mips_supply_gregset): Likewise. (mips_fill_gregset): Likewise. (mips_supply_fpregset): Likewise. (mips_fill_fpregset): Likewise. (mips64_supply_gregset): Likewise. (micromips_linux_sigframe_validate): Likewise. * mips-nbsd-nat.c (mipsnbsd_fetch_inferior_registers): Likewise. (mipsnbsd_fetch_inferior_registers): Likewise. (mipsnbsd_store_inferior_registers): Likewise. * mips-nbsd-tdep.c (mipsnbsd_supply_fpregset): Likewise. (mipsnbsd_supply_gregset): Likewise. (mipsnbsd_iterate_over_regset_sections): Likewise. (mipsnbsd_supply_reg): Likewise. (mipsnbsd_supply_fpreg): Likewise. * mips-tdep.c (mips_in_frame_stub): Likewise. (mips_dummy_id): Likewise. (is_octeon_bbit_op): Likewise. (micromips_bc1_pc): Likewise. (extended_mips16_next_pc): Likewise. (mips16_next_pc): Likewise. (deal_with_atomic_sequence): Likewise. * moxie-tdep.c (moxie_process_readu): Likewise. * nios2-tdep.c (nios2_get_next_pc): Likewise. * nto-procfs.c (procfs_store_registers): Likewise. * ppc-fbsd-nat.c (ppcfbsd_fetch_inferior_registers): Likewise. (ppcfbsd_store_inferior_registers): Likewise. * ppc-linux-nat.c (fetch_vsx_register): Likewise. (fetch_altivec_register): Likewise. (get_spe_registers): Likewise. (fetch_spe_register): Likewise. (fetch_altivec_registers): Likewise. (fetch_all_gp_regs): Likewise. (fetch_all_fp_regs): Likewise. (store_vsx_register): Likewise. (store_altivec_register): Likewise. (set_spe_registers): Likewise. (store_spe_register): Likewise. (store_altivec_registers): Likewise. (store_all_gp_regs): Likewise. (store_all_fp_regs): Likewise. * ppc-linux-tdep.c (ppc_linux_supply_gregset): Likewise. (ppc_linux_collect_gregset): Likewise. (ppc_canonicalize_syscall): Likewise. (ppc_linux_record_signal): Likewise. (ppu2spu_prev_register): Likewise. * ppc-nbsd-nat.c (ppcnbsd_supply_pcb): Likewise. * ppc-obsd-nat.c (ppcobsd_fetch_registers): Likewise. (ppcobsd_store_registers): Likewise. * ppc-ravenscar-thread.c (ppc_ravenscar_generic_fetch_registers): Likewise. (ppc_ravenscar_generic_store_registers): Likewise. * procfs.c (procfs_fetch_registers): Likewise. (procfs_store_registers): Likewise. * ravenscar-thread.c (ravenscar_fetch_registers): Likewise. (ravenscar_store_registers): Likewise. (ravenscar_prepare_to_store): Likewise. * record-btrace.c (record_btrace_fetch_registers): Likewise. * record-full.c (record_full_wait_1): Likewise. (record_full_registers_change): Likewise. (record_full_store_registers): Likewise. (record_full_core_fetch_registers): Likewise. (record_full_save): Likewise. (record_full_goto_insn): Likewise. * regcache.c (regcache_register_size): Likewise. (get_regcache_arch): Remove. (regcache_read_pc): Likewise. * regcache.h (get_regcache_arch): Remove. * remote-sim.c (gdbsim_fetch_register): Likewise. (gdbsim_store_register): Likewise. * remote.c (fetch_register_using_p): Likewise. (send_g_packet): Likewise. (remote_prepare_to_store): Likewise. (store_registers_using_G): Likewise. * reverse.c (save_bookmark_command): Likewise. (goto_bookmark_command): Likewise. * rs6000-aix-tdep.c (branch_dest): Likewise. * rs6000-nat.c (rs6000_ptrace64): Likewise. (fetch_register): Likewise. * rs6000-tdep.c (ppc_supply_reg): Likewise. (ppc_collect_reg): Likewise. (ppc_collect_gregset): Likewise. (ppc_collect_fpregset): Likewise. (ppc_collect_vsxregset): Likewise. (ppc_collect_vrregset): Likewise. (ppc_displaced_step_hw_singlestep): Likewise. (rs6000_pseudo_register_read): Likewise. (rs6000_pseudo_register_write): Likewise. * s390-linux-nat.c (supply_gregset): Likewise. (fill_gregset): Likewise. (s390_linux_fetch_inferior_registers): Likewise. * s390-linux-tdep.c (s390_write_pc): Likewise. (s390_software_single_step): Likewise. (s390_all_but_pc_registers_record): Likewise. (s390_linux_syscall_record): Likewise. * sentinel-frame.c (sentinel_frame_prev_arch): Likewise. * sh-nbsd-nat.c (shnbsd_fetch_inferior_registers): Likewise. (shnbsd_store_inferior_registers): Likewise. * sh-tdep.c (sh_extract_return_value_nofpu): Likewise. (sh_extract_return_value_fpu): Likewise. (sh_store_return_value_nofpu): Likewise. (sh_corefile_supply_regset): Likewise. (sh_corefile_collect_regset): Likewise. * sh64-tdep.c (sh64_extract_return_value): Likewise. (sh64_store_return_value): Likewise. * sparc-linux-tdep.c (sparc32_linux_collect_core_fpregset): Likewise. * sparc-nat.c (sparc_fetch_inferior_registers): Likewise. (sparc_store_inferior_registers): Likewise. * sparc-ravenscar-thread.c (register_in_thread_descriptor_p): Likewise. (sparc_ravenscar_prepare_to_store): Likewise. * sparc-tdep.c (sparc32_store_arguments): Likewise. (sparc_analyze_control_transfer): Likewise. (sparc_step_trap): Likewise. (sparc_software_single_step): Likewise. (sparc32_gdbarch_init): Likewise. (sparc_supply_rwindow): Likewise. (sparc_collect_rwindow): Likewise. * sparc64-linux-tdep.c (sparc64_linux_collect_core_fpregset): Likewise. * sparc64-nbsd-nat.c (sparc64nbsd_supply_gregset): Likewise. (sparc64nbsd_collect_gregset): Likewise. (sparc64nbsd_supply_fpregset): Likewise. (sparc64nbsd_collect_fpregset): Likewise. * sparc64-tdep.c (sparc64_store_arguments): Likewise. (sparc64_supply_gregset): Likewise. (sparc64_collect_gregset): Likewise. (sparc64_supply_fpregset): Likewise. (sparc64_collect_fpregset): Likewise. * spu-linux-nat.c (spu_fetch_inferior_registers): Likewise. * spu-tdep.c (spu_unwind_sp): Likewise. (spu2ppu_prev_register): Likewise. (spu_memory_remove_breakpoint): Likewise. * stack.c (return_command): Likewise. * tic6x-tdep.c (tic6x_extract_signed_field): Likewise. * tracefile-tfile.c (tfile_fetch_registers): Likewise. * tracefile.c (trace_save_ctf): Likewise. * windows-nat.c (do_windows_fetch_inferior_registers): Likewise. (do_windows_store_inferior_registers): Likewise. (windows_resume): Likewise. * xtensa-linux-nat.c (fill_gregset): Likewise. (supply_gregset_reg): Likewise. * xtensa-tdep.c (xtensa_register_write_masked): Likewise. (xtensa_register_read_masked): Likewise. (xtensa_supply_gregset): Likewise. (xtensa_extract_return_value): Likewise. (xtensa_store_return_value): Likewise.
521 lines
15 KiB
C
521 lines
15 KiB
C
/* Target-dependent code for the VAX.
|
||
|
||
Copyright (C) 1986-2017 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "arch-utils.h"
|
||
#include "dis-asm.h"
|
||
#include "frame.h"
|
||
#include "frame-base.h"
|
||
#include "frame-unwind.h"
|
||
#include "gdbcore.h"
|
||
#include "gdbtypes.h"
|
||
#include "osabi.h"
|
||
#include "regcache.h"
|
||
#include "regset.h"
|
||
#include "trad-frame.h"
|
||
#include "value.h"
|
||
|
||
#include "vax-tdep.h"
|
||
|
||
/* Return the name of register REGNUM. */
|
||
|
||
static const char *
|
||
vax_register_name (struct gdbarch *gdbarch, int regnum)
|
||
{
|
||
static const char *register_names[] =
|
||
{
|
||
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
||
"r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
|
||
"ps",
|
||
};
|
||
|
||
if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
|
||
return register_names[regnum];
|
||
|
||
return NULL;
|
||
}
|
||
|
||
/* Return the GDB type object for the "standard" data type of data in
|
||
register REGNUM. */
|
||
|
||
static struct type *
|
||
vax_register_type (struct gdbarch *gdbarch, int regnum)
|
||
{
|
||
return builtin_type (gdbarch)->builtin_int;
|
||
}
|
||
|
||
/* Core file support. */
|
||
|
||
/* Supply register REGNUM from the buffer specified by GREGS and LEN
|
||
in the general-purpose register set REGSET to register cache
|
||
REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
|
||
|
||
static void
|
||
vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
|
||
int regnum, const void *gregs, size_t len)
|
||
{
|
||
const gdb_byte *regs = (const gdb_byte *) gregs;
|
||
int i;
|
||
|
||
for (i = 0; i < VAX_NUM_REGS; i++)
|
||
{
|
||
if (regnum == i || regnum == -1)
|
||
regcache_raw_supply (regcache, i, regs + i * 4);
|
||
}
|
||
}
|
||
|
||
/* VAX register set. */
|
||
|
||
static const struct regset vax_gregset =
|
||
{
|
||
NULL,
|
||
vax_supply_gregset
|
||
};
|
||
|
||
/* Iterate over core file register note sections. */
|
||
|
||
static void
|
||
vax_iterate_over_regset_sections (struct gdbarch *gdbarch,
|
||
iterate_over_regset_sections_cb *cb,
|
||
void *cb_data,
|
||
const struct regcache *regcache)
|
||
{
|
||
cb (".reg", VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
|
||
}
|
||
|
||
/* The VAX UNIX calling convention uses R1 to pass a structure return
|
||
value address instead of passing it as a first (hidden) argument as
|
||
the VMS calling convention suggests. */
|
||
|
||
static CORE_ADDR
|
||
vax_store_arguments (struct regcache *regcache, int nargs,
|
||
struct value **args, CORE_ADDR sp)
|
||
{
|
||
struct gdbarch *gdbarch = regcache->arch ();
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
gdb_byte buf[4];
|
||
int count = 0;
|
||
int i;
|
||
|
||
/* We create an argument list on the stack, and make the argument
|
||
pointer to it. */
|
||
|
||
/* Push arguments in reverse order. */
|
||
for (i = nargs - 1; i >= 0; i--)
|
||
{
|
||
int len = TYPE_LENGTH (value_enclosing_type (args[i]));
|
||
|
||
sp -= (len + 3) & ~3;
|
||
count += (len + 3) / 4;
|
||
write_memory (sp, value_contents_all (args[i]), len);
|
||
}
|
||
|
||
/* Push argument count. */
|
||
sp -= 4;
|
||
store_unsigned_integer (buf, 4, byte_order, count);
|
||
write_memory (sp, buf, 4);
|
||
|
||
/* Update the argument pointer. */
|
||
store_unsigned_integer (buf, 4, byte_order, sp);
|
||
regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
|
||
|
||
return sp;
|
||
}
|
||
|
||
static CORE_ADDR
|
||
vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||
struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
|
||
struct value **args, CORE_ADDR sp, int struct_return,
|
||
CORE_ADDR struct_addr)
|
||
{
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
CORE_ADDR fp = sp;
|
||
gdb_byte buf[4];
|
||
|
||
/* Set up the function arguments. */
|
||
sp = vax_store_arguments (regcache, nargs, args, sp);
|
||
|
||
/* Store return value address. */
|
||
if (struct_return)
|
||
regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
|
||
|
||
/* Store return address in the PC slot. */
|
||
sp -= 4;
|
||
store_unsigned_integer (buf, 4, byte_order, bp_addr);
|
||
write_memory (sp, buf, 4);
|
||
|
||
/* Store the (fake) frame pointer in the FP slot. */
|
||
sp -= 4;
|
||
store_unsigned_integer (buf, 4, byte_order, fp);
|
||
write_memory (sp, buf, 4);
|
||
|
||
/* Skip the AP slot. */
|
||
sp -= 4;
|
||
|
||
/* Store register save mask and control bits. */
|
||
sp -= 4;
|
||
store_unsigned_integer (buf, 4, byte_order, 0);
|
||
write_memory (sp, buf, 4);
|
||
|
||
/* Store condition handler. */
|
||
sp -= 4;
|
||
store_unsigned_integer (buf, 4, byte_order, 0);
|
||
write_memory (sp, buf, 4);
|
||
|
||
/* Update the stack pointer and frame pointer. */
|
||
store_unsigned_integer (buf, 4, byte_order, sp);
|
||
regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
|
||
regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
|
||
|
||
/* Return the saved (fake) frame pointer. */
|
||
return fp;
|
||
}
|
||
|
||
static struct frame_id
|
||
vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
|
||
{
|
||
CORE_ADDR fp;
|
||
|
||
fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
|
||
return frame_id_build (fp, get_frame_pc (this_frame));
|
||
}
|
||
|
||
|
||
static enum return_value_convention
|
||
vax_return_value (struct gdbarch *gdbarch, struct value *function,
|
||
struct type *type, struct regcache *regcache,
|
||
gdb_byte *readbuf, const gdb_byte *writebuf)
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_byte buf[8];
|
||
|
||
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
|
||
|| TYPE_CODE (type) == TYPE_CODE_UNION
|
||
|| TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||
{
|
||
/* The default on VAX is to return structures in static memory.
|
||
Consequently a function must return the address where we can
|
||
find the return value. */
|
||
|
||
if (readbuf)
|
||
{
|
||
ULONGEST addr;
|
||
|
||
regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
|
||
read_memory (addr, readbuf, len);
|
||
}
|
||
|
||
return RETURN_VALUE_ABI_RETURNS_ADDRESS;
|
||
}
|
||
|
||
if (readbuf)
|
||
{
|
||
/* Read the contents of R0 and (if necessary) R1. */
|
||
regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
|
||
if (len > 4)
|
||
regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
|
||
memcpy (readbuf, buf, len);
|
||
}
|
||
if (writebuf)
|
||
{
|
||
/* Read the contents to R0 and (if necessary) R1. */
|
||
memcpy (buf, writebuf, len);
|
||
regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
|
||
if (len > 4)
|
||
regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
|
||
}
|
||
|
||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||
}
|
||
|
||
|
||
/* Use the program counter to determine the contents and size of a
|
||
breakpoint instruction. Return a pointer to a string of bytes that
|
||
encode a breakpoint instruction, store the length of the string in
|
||
*LEN and optionally adjust *PC to point to the correct memory
|
||
location for inserting the breakpoint. */
|
||
|
||
constexpr gdb_byte vax_break_insn[] = { 3 };
|
||
|
||
typedef BP_MANIPULATION (vax_break_insn) vax_breakpoint;
|
||
|
||
/* Advance PC across any function entry prologue instructions
|
||
to reach some "real" code. */
|
||
|
||
static CORE_ADDR
|
||
vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
|
||
{
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
|
||
|
||
if (op == 0x11)
|
||
pc += 2; /* skip brb */
|
||
if (op == 0x31)
|
||
pc += 3; /* skip brw */
|
||
if (op == 0xC2
|
||
&& read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
|
||
pc += 3; /* skip subl2 */
|
||
if (op == 0x9E
|
||
&& read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
|
||
&& read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
|
||
pc += 4; /* skip movab */
|
||
if (op == 0x9E
|
||
&& read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
|
||
&& read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
|
||
pc += 5; /* skip movab */
|
||
if (op == 0x9E
|
||
&& read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
|
||
&& read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
|
||
pc += 7; /* skip movab */
|
||
|
||
return pc;
|
||
}
|
||
|
||
|
||
/* Unwinding the stack is relatively easy since the VAX has a
|
||
dedicated frame pointer, and frames are set up automatically as the
|
||
result of a function call. Most of the relevant information can be
|
||
inferred from the documentation of the Procedure Call Instructions
|
||
in the VAX MACRO and Instruction Set Reference Manual. */
|
||
|
||
struct vax_frame_cache
|
||
{
|
||
/* Base address. */
|
||
CORE_ADDR base;
|
||
|
||
/* Table of saved registers. */
|
||
struct trad_frame_saved_reg *saved_regs;
|
||
};
|
||
|
||
static struct vax_frame_cache *
|
||
vax_frame_cache (struct frame_info *this_frame, void **this_cache)
|
||
{
|
||
struct vax_frame_cache *cache;
|
||
CORE_ADDR addr;
|
||
ULONGEST mask;
|
||
int regnum;
|
||
|
||
if (*this_cache)
|
||
return (struct vax_frame_cache *) *this_cache;
|
||
|
||
/* Allocate a new cache. */
|
||
cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
|
||
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
|
||
|
||
/* The frame pointer is used as the base for the frame. */
|
||
cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
|
||
if (cache->base == 0)
|
||
return cache;
|
||
|
||
/* The register save mask and control bits determine the layout of
|
||
the stack frame. */
|
||
mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
|
||
|
||
/* These are always saved. */
|
||
cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
|
||
cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
|
||
cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
|
||
cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
|
||
|
||
/* Scan the register save mask and record the location of the saved
|
||
registers. */
|
||
addr = cache->base + 20;
|
||
for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
|
||
{
|
||
if (mask & (1 << regnum))
|
||
{
|
||
cache->saved_regs[regnum].addr = addr;
|
||
addr += 4;
|
||
}
|
||
}
|
||
|
||
/* The CALLS/CALLG flag determines whether this frame has a General
|
||
Argument List or a Stack Argument List. */
|
||
if (mask & (1 << 13))
|
||
{
|
||
ULONGEST numarg;
|
||
|
||
/* This is a procedure with Stack Argument List. Adjust the
|
||
stack address for the arguments that were pushed onto the
|
||
stack. The return instruction will automatically pop the
|
||
arguments from the stack. */
|
||
numarg = get_frame_memory_unsigned (this_frame, addr, 1);
|
||
addr += 4 + numarg * 4;
|
||
}
|
||
|
||
/* Bits 1:0 of the stack pointer were saved in the control bits. */
|
||
trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
|
||
|
||
return cache;
|
||
}
|
||
|
||
static void
|
||
vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
|
||
struct frame_id *this_id)
|
||
{
|
||
struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
|
||
|
||
/* This marks the outermost frame. */
|
||
if (cache->base == 0)
|
||
return;
|
||
|
||
(*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
|
||
}
|
||
|
||
static struct value *
|
||
vax_frame_prev_register (struct frame_info *this_frame,
|
||
void **this_cache, int regnum)
|
||
{
|
||
struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
|
||
|
||
return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
|
||
}
|
||
|
||
static const struct frame_unwind vax_frame_unwind =
|
||
{
|
||
NORMAL_FRAME,
|
||
default_frame_unwind_stop_reason,
|
||
vax_frame_this_id,
|
||
vax_frame_prev_register,
|
||
NULL,
|
||
default_frame_sniffer
|
||
};
|
||
|
||
|
||
static CORE_ADDR
|
||
vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
|
||
{
|
||
struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
|
||
|
||
return cache->base;
|
||
}
|
||
|
||
static CORE_ADDR
|
||
vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
|
||
{
|
||
return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
|
||
}
|
||
|
||
static const struct frame_base vax_frame_base =
|
||
{
|
||
&vax_frame_unwind,
|
||
vax_frame_base_address,
|
||
vax_frame_base_address,
|
||
vax_frame_args_address
|
||
};
|
||
|
||
/* Return number of arguments for FRAME. */
|
||
|
||
static int
|
||
vax_frame_num_args (struct frame_info *frame)
|
||
{
|
||
CORE_ADDR args;
|
||
|
||
/* Assume that the argument pointer for the outermost frame is
|
||
hosed, as is the case on NetBSD/vax ELF. */
|
||
if (get_frame_base_address (frame) == 0)
|
||
return 0;
|
||
|
||
args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
|
||
return get_frame_memory_unsigned (frame, args, 1);
|
||
}
|
||
|
||
static CORE_ADDR
|
||
vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||
{
|
||
return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
|
||
}
|
||
|
||
|
||
/* Initialize the current architecture based on INFO. If possible, re-use an
|
||
architecture from ARCHES, which is a list of architectures already created
|
||
during this debugging session.
|
||
|
||
Called e.g. at program startup, when reading a core file, and when reading
|
||
a binary file. */
|
||
|
||
static struct gdbarch *
|
||
vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||
{
|
||
struct gdbarch *gdbarch;
|
||
|
||
/* If there is already a candidate, use it. */
|
||
arches = gdbarch_list_lookup_by_info (arches, &info);
|
||
if (arches != NULL)
|
||
return arches->gdbarch;
|
||
|
||
gdbarch = gdbarch_alloc (&info, NULL);
|
||
|
||
set_gdbarch_float_format (gdbarch, floatformats_vax_f);
|
||
set_gdbarch_double_format (gdbarch, floatformats_vax_d);
|
||
set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
|
||
set_gdbarch_long_double_bit (gdbarch, 64);
|
||
|
||
/* Register info */
|
||
set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
|
||
set_gdbarch_register_name (gdbarch, vax_register_name);
|
||
set_gdbarch_register_type (gdbarch, vax_register_type);
|
||
set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
|
||
set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
|
||
set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
|
||
|
||
set_gdbarch_iterate_over_regset_sections
|
||
(gdbarch, vax_iterate_over_regset_sections);
|
||
|
||
/* Frame and stack info */
|
||
set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
|
||
set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
|
||
set_gdbarch_frame_args_skip (gdbarch, 4);
|
||
|
||
/* Stack grows downward. */
|
||
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
||
|
||
/* Return value info */
|
||
set_gdbarch_return_value (gdbarch, vax_return_value);
|
||
|
||
/* Call dummy code. */
|
||
set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
|
||
set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
|
||
|
||
/* Breakpoint info */
|
||
set_gdbarch_breakpoint_kind_from_pc (gdbarch, vax_breakpoint::kind_from_pc);
|
||
set_gdbarch_sw_breakpoint_from_kind (gdbarch, vax_breakpoint::bp_from_kind);
|
||
|
||
/* Misc info */
|
||
set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
|
||
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
|
||
|
||
set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
|
||
|
||
frame_base_set_default (gdbarch, &vax_frame_base);
|
||
|
||
/* Hook in ABI-specific overrides, if they have been registered. */
|
||
gdbarch_init_osabi (info, gdbarch);
|
||
|
||
frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
|
||
|
||
return (gdbarch);
|
||
}
|
||
|
||
void
|
||
_initialize_vax_tdep (void)
|
||
{
|
||
gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
|
||
}
|