#include "gdb_string.h"
#include "regcache.h"
#include "osabi.h"
+#include "dis-asm.h"
+
+#include "sparc-tdep.h"
#ifdef USE_PROC_FS
#include <sys/procfs.h>
* Some local macros that have multi-arch and non-multi-arch versions:
*/
-#if (GDB_MULTI_ARCH > 0)
-
#if 0
// OBSOLETE /* Does the target have Floating Point registers? */
// OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
/* Offset within the call dummy stack of the saved registers. */
#define DUMMY_REG_SAVE_OFFSET (gdbarch_tdep (current_gdbarch)->reg_save_offset)
-#else /* non-multi-arch */
-
-
-/* Does the target have Floating Point registers? */
-#if 0
-// OBSOLETE #if defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
-// OBSOLETE #define SPARC_HAS_FPU 0
-// OBSOLETE #else
-// OBSOLETE #define SPARC_HAS_FPU 1
-// OBSOLETE #endif
-#endif
-#define SPARC_HAS_FPU 1
-
-/* Number of bytes devoted to Floating Point registers: */
-#if (GDB_TARGET_IS_SPARC64)
-#define FP_REGISTER_BYTES (64 * 4)
-#else
-#if (SPARC_HAS_FPU)
-#define FP_REGISTER_BYTES (32 * 4)
-#else
-#define FP_REGISTER_BYTES 0
-#endif
-#endif
-
-/* Highest numbered Floating Point register. */
-#if (GDB_TARGET_IS_SPARC64)
-#define FP_MAX_REGNUM (FP0_REGNUM + 48)
-#else
-#define FP_MAX_REGNUM (FP0_REGNUM + 32)
-#endif
-
-/* Size of a general (integer) register: */
-#define SPARC_INTREG_SIZE (REGISTER_RAW_SIZE (G0_REGNUM))
-
-/* Offset within the call dummy stack of the saved registers. */
-#if (GDB_TARGET_IS_SPARC64)
-#define DUMMY_REG_SAVE_OFFSET (128 + 16)
-#else
-#define DUMMY_REG_SAVE_OFFSET 0x60
-#endif
-
-#endif /* GDB_MULTI_ARCH */
-
struct gdbarch_tdep
{
#if 0
* TARGET_ARCHITECTURE->mach == bfd_mach_sparc_v9a))
*/
-/* From infrun.c */
-extern int stop_after_trap;
-
/* We don't store all registers immediately when requested, since they
get sent over in large chunks anyway. Instead, we accumulate most
of the changes and send them over once. "deferred_stores" keeps
Beihl (beihl@mcc.com). */
/* npc4 and next_pc describe the situation at the time that the
- step-breakpoint was set, not necessary the current value of NPC_REGNUM. */
+ step-breakpoint was set, not necessary the current value of DEPRECATED_NPC_REGNUM. */
static CORE_ADDR next_pc, npc4, target;
static int brknpc4, brktrg;
typedef char binsn_quantum[BREAKPOINT_MAX];
if (insert_breakpoints_p)
{
/* Always set breakpoint for NPC. */
- next_pc = read_register (NPC_REGNUM);
+ next_pc = read_register (DEPRECATED_NPC_REGNUM);
npc4 = next_pc + 4; /* branch not taken */
target_insert_breakpoint (next_pc, break_mem[0]);
{
/* Should we adjust for stack bias here? */
ULONGEST tmp;
- frame_read_unsigned_register (fi, DEPRECATED_FP_REGNUM, &tmp);
+ tmp = get_frame_register_unsigned (fi, DEPRECATED_FP_REGNUM);
deprecated_update_frame_base_hack (fi, tmp);
if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
/* Overwrite the frame's address with the value in %i7. */
{
ULONGEST tmp;
- frame_read_unsigned_register (fi, I7_REGNUM, &tmp);
+ tmp = get_frame_register_unsigned (fi, I7_REGNUM);
deprecated_update_frame_base_hack (fi, tmp);
}
/* The sigcontext address is contained in register O2. */
{
ULONGEST tmp;
- frame_read_unsigned_register (frame, O0_REGNUM + 2, &tmp);
+ tmp = get_frame_register_unsigned (frame, O0_REGNUM + 2);
sigcontext_addr = tmp;
}
/* A frameless function interrupted by a signal did not save
the PC, it is still in %o7. */
ULONGEST tmp;
- frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
+ tmp = get_frame_register_unsigned (frame, O7_REGNUM);
return PC_ADJUST (tmp);
}
if (get_frame_extra_info (frame)->flat)
{
if (lval != NULL)
*lval = lval_register;
- addr = REGISTER_BYTE (regnum);
+ addr = DEPRECATED_REGISTER_BYTE (regnum);
if (raw_buffer != NULL)
deprecated_read_register_gen (regnum, raw_buffer);
}
if (GDB_TARGET_IS_SPARC64)
{
/* PC, NPC, CCR, FSR, FPRS, Y, ASI */
- deprecated_read_register_bytes (REGISTER_BYTE (PC_REGNUM),
+ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PC_REGNUM),
®ister_temp[0],
REGISTER_RAW_SIZE (PC_REGNUM) * 7);
- deprecated_read_register_bytes (REGISTER_BYTE (PSTATE_REGNUM),
+ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (PSTATE_REGNUM),
®ister_temp[7 * SPARC_INTREG_SIZE],
REGISTER_RAW_SIZE (PSTATE_REGNUM));
/* FIXME: not sure what needs to be saved here. */
else
{
/* Y, PS, WIM, TBR, PC, NPC, FPS, CPS regs */
- deprecated_read_register_bytes (REGISTER_BYTE (Y_REGNUM),
+ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (Y_REGNUM),
®ister_temp[0],
REGISTER_RAW_SIZE (Y_REGNUM) * 8);
}
- deprecated_read_register_bytes (REGISTER_BYTE (O0_REGNUM),
+ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM),
®ister_temp[8 * SPARC_INTREG_SIZE],
SPARC_INTREG_SIZE * 8);
- deprecated_read_register_bytes (REGISTER_BYTE (G0_REGNUM),
+ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (G0_REGNUM),
®ister_temp[16 * SPARC_INTREG_SIZE],
SPARC_INTREG_SIZE * 8);
if (SPARC_HAS_FPU)
- deprecated_read_register_bytes (REGISTER_BYTE (FP0_REGNUM),
+ deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM),
®ister_temp[24 * SPARC_INTREG_SIZE],
FP_REGISTER_BYTES);
static void
sparc_frame_find_saved_regs (struct frame_info *fi, CORE_ADDR *saved_regs_addr)
{
- register int regnum;
+ int regnum;
CORE_ADDR frame_addr = get_frame_base (fi);
gdb_assert (fi != NULL);
void
sparc_pop_frame (void)
{
- register struct frame_info *frame = get_current_frame ();
- register CORE_ADDR pc;
+ struct frame_info *frame = get_current_frame ();
+ CORE_ADDR pc;
CORE_ADDR *fsr;
char *raw_buffer;
int regnum;
if (fsr[FP0_REGNUM])
{
read_memory (fsr[FP0_REGNUM], raw_buffer, FP_REGISTER_BYTES);
- deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (FP0_REGNUM),
raw_buffer, FP_REGISTER_BYTES);
}
if (!(GDB_TARGET_IS_SPARC64))
if (fsr[G1_REGNUM])
{
read_memory (fsr[G1_REGNUM], raw_buffer, 7 * SPARC_INTREG_SIZE);
- deprecated_write_register_bytes (REGISTER_BYTE (G1_REGNUM), raw_buffer,
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (G1_REGNUM), raw_buffer,
7 * SPARC_INTREG_SIZE);
}
/* Restore the out registers.
Among other things this writes the new stack pointer. */
- deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), raw_buffer,
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (O0_REGNUM), raw_buffer,
SPARC_INTREG_SIZE * 8);
- deprecated_write_register_bytes (REGISTER_BYTE (L0_REGNUM), reg_temp,
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (L0_REGNUM), reg_temp,
SPARC_INTREG_SIZE * 16);
}
write_register (PC_REGNUM,
read_memory_integer (fsr[PC_REGNUM],
REGISTER_RAW_SIZE (PC_REGNUM)));
- if (fsr[NPC_REGNUM])
- write_register (NPC_REGNUM,
- read_memory_integer (fsr[NPC_REGNUM],
- REGISTER_RAW_SIZE (NPC_REGNUM)));
+ if (fsr[DEPRECATED_NPC_REGNUM])
+ write_register (DEPRECATED_NPC_REGNUM,
+ read_memory_integer (fsr[DEPRECATED_NPC_REGNUM],
+ REGISTER_RAW_SIZE (DEPRECATED_NPC_REGNUM)));
}
else if (get_frame_extra_info (frame)->flat)
{
it is a complicated way of saying
"pc = read_register (O7_REGNUM);". */
ULONGEST tmp;
- frame_read_unsigned_register (frame, O7_REGNUM, &tmp);
+ tmp = get_frame_register_unsigned (frame, O7_REGNUM);
pc = PC_ADJUST (tmp);
}
write_register (PC_REGNUM, pc);
- write_register (NPC_REGNUM, pc + 4);
+ write_register (DEPRECATED_NPC_REGNUM, pc + 4);
}
else if (fsr[I7_REGNUM])
{
pc = PC_ADJUST ((CORE_ADDR) read_memory_integer (fsr[I7_REGNUM],
SPARC_INTREG_SIZE));
write_register (PC_REGNUM, pc);
- write_register (NPC_REGNUM, pc + 4);
+ write_register (DEPRECATED_NPC_REGNUM, pc + 4);
}
flush_cached_frames ();
}
/* These require a bit more care. */
supply_register (PC_REGNUM, ((char *) (regp + R_PC)) + offset);
- supply_register (NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);
+ supply_register (DEPRECATED_NPC_REGNUM, ((char *) (regp + R_nPC)) + offset);
supply_register (Y_REGNUM, ((char *) (regp + R_Y)) + offset);
if (GDB_TARGET_IS_SPARC64)
if ((regno == -1) || (regno == PC_REGNUM))
deprecated_read_register_gen (PC_REGNUM, (char *) (regp + R_PC) + offset);
- if ((regno == -1) || (regno == NPC_REGNUM))
- deprecated_read_register_gen (NPC_REGNUM, (char *) (regp + R_nPC) + offset);
+ if ((regno == -1) || (regno == DEPRECATED_NPC_REGNUM))
+ deprecated_read_register_gen (DEPRECATED_NPC_REGNUM, (char *) (regp + R_nPC) + offset);
if ((regno == -1) || (regno == Y_REGNUM))
deprecated_read_register_gen (Y_REGNUM, (char *) (regp + R_Y) + offset);
void
supply_fpregset (gdb_fpregset_t *fpregsetp)
{
- register int regi;
+ int regi;
char *from;
if (!SPARC_HAS_FPU)
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
to = (char *) &fpregsetp->pr_fr.pr_regs[regi - FP0_REGNUM];
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
if (!(GDB_TARGET_IS_SPARC64)) /* FIXME: does Sparc64 have this register? */
if ((regno == -1) || (regno == FPS_REGNUM))
{
- from = (char *)&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)];
+ from = (char *)&deprecated_registers[DEPRECATED_REGISTER_BYTE (FPS_REGNUM)];
to = (char *) &fpregsetp->pr_fsr;
memcpy (to, from, REGISTER_RAW_SIZE (FPS_REGNUM));
}
continue;
}
- /* FIXME: cagney/2002-08-03: This code shouldn't be necessary.
- The function frame_register_read() should have returned the
- pre-cooked register so no conversion is necessary. */
- /* Convert raw data to virtual format if necessary. */
- if (REGISTER_CONVERTIBLE (i))
- {
- REGISTER_CONVERT_TO_VIRTUAL (i, REGISTER_VIRTUAL_TYPE (i),
- raw_buffer, virtual_buffer);
- }
- else
- {
- memcpy (virtual_buffer, raw_buffer,
- REGISTER_VIRTUAL_SIZE (i));
- }
+ memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (i));
/* If virtual format is floating, print it that way, and in raw
hex. */
// OBSOLETE }
#endif
-\f
-int
-gdb_print_insn_sparc (bfd_vma memaddr, disassemble_info *info)
-{
- /* It's necessary to override mach again because print_insn messes it up. */
- info->mach = TARGET_ARCHITECTURE->mach;
- return print_insn_sparc (memaddr, info);
-}
-\f
-
#define SPARC_F0_REGNUM FP0_REGNUM /* %f0 */
#define SPARC_F1_REGNUM (FP0_REGNUM + 1)/* %f1 */
#define SPARC_O0_REGNUM O0_REGNUM /* %o0 */
/* FIXME: kettenis/2003/05/24: Still used for sparc64. */
-void
+static void
sparc_store_return_value (struct type *type, char *valbuf)
{
int regno;
deprecated_write_register_gen (regno, buffer);
}
else
- deprecated_write_register_bytes (REGISTER_BYTE (regno), valbuf,
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regno), valbuf,
TYPE_LENGTH (type));
}
struct gdbarch_list *arches);
static void sparc_dump_tdep (struct gdbarch *, struct ui_file *);
+extern initialize_file_ftype _initialize_sparc_tdep; /* -Wmissing-prototypes */
+
void
_initialize_sparc_tdep (void)
{
/* Hook us into the gdbarch mechanism. */
gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);
- deprecated_tm_print_insn = gdb_print_insn_sparc;
- deprecated_tm_print_insn_info.mach = TM_PRINT_INSN_MACH; /* Selects sparc/sparclite */
/* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
}
/* Compensate for stack bias. Note that we currently don't handle
mixed 32/64 bit code. */
-CORE_ADDR
+static CORE_ADDR
sparc64_read_sp (void)
{
CORE_ADDR sp = read_register (SP_REGNUM);
return sp;
}
-CORE_ADDR
+static CORE_ADDR
sparc64_read_fp (void)
{
CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
return fp;
}
-void
+static void
sparc64_write_sp (CORE_ADDR val)
{
CORE_ADDR oldsp = read_register (SP_REGNUM);
for both; this means that if the arguments alternate between
int and float, we will waste every other register of both types. */
-CORE_ADDR
+static CORE_ADDR
sparc64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_retaddr)
{
default:
internal_error (__FILE__, __LINE__, "bad switch");
}
- deprecated_write_register_bytes (REGISTER_BYTE (fpreg),
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (fpreg),
VALUE_CONTENTS (args[i]),
len);
}
/* Values <= 32 bytes are returned in o0-o3 (floating-point values are
returned in f0-f3). */
-void
+static void
sp64_extract_return_value (struct type *type, char *regbuf, char *valbuf,
int bitoffset)
{
if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
{
- memcpy (valbuf, ®buf[REGISTER_BYTE (FP0_REGNUM)], typelen);
+ memcpy (valbuf, ®buf[DEPRECATED_REGISTER_BYTE (FP0_REGNUM)], typelen);
return;
}
}
}
-extern void
+static void
sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
{
sp64_extract_return_value (type, regbuf, valbuf, 0);
return ((addr + 7) & -8);
}
-extern CORE_ADDR
+static CORE_ADDR
sparc64_stack_align (CORE_ADDR addr)
{
return ((addr + 15) & -16);
paddr_nz (get_frame_extra_info (fi)->fp_addr));
}
-/* MULTI_ARCH support */
-
static const char *
sparc32_register_name (int regno)
{
// OBSOLETE }
#endif
-CORE_ADDR
+static CORE_ADDR
sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
{
if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
This address will actually be the program's entry point.
There will be a special call_dummy breakpoint there. */
- write_register (O7_REGNUM,
- CALL_DUMMY_ADDRESS () - 8);
+ if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
+ write_register (O7_REGNUM, DEPRECATED_CALL_DUMMY_ADDRESS () - 8);
+ else
+ write_register (O7_REGNUM, entry_point_address () - 8);
}
return sp;
return sparc_pc_adjust (read_register (RP_REGNUM));
}
-/* Convert registers between 'raw' and 'virtual' formats.
- They are the same on sparc, so there's nothing to do. */
-
-static void
-sparc_convert_to_virtual (int regnum, struct type *type, char *from, char *to)
-{ /* do nothing (should never be called) */
-}
-
-static void
-sparc_convert_to_raw (struct type *type, int regnum, char *from, char *to)
-{ /* do nothing (should never be called) */
-}
-
/* Init saved regs: nothing to do, just a place-holder function. */
static void
sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
}
-/* CALL_DUMMY_ADDRESS: fetch the breakpoint address for a call dummy. */
+/* DEPRECATED_CALL_DUMMY_ADDRESS: fetch the breakpoint address for a
+ call dummy. */
static CORE_ADDR
sparc_call_dummy_address (void)
}
/* Get the ith function argument for the current function. */
-CORE_ADDR
-sparc_fetch_pointer_argument (struct frame_info *frame, int argi, struct type *type)
+static CORE_ADDR
+sparc_fetch_pointer_argument (struct frame_info *frame, int argi,
+ struct type *type)
{
CORE_ADDR addr;
- frame_read_register (frame, O0_REGNUM + argi, &addr);
+ get_frame_register (frame, O0_REGNUM + argi, &addr);
return addr;
}
set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
- set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
set_gdbarch_frameless_function_invocation (gdbarch,
frameless_look_for_prologue);
set_gdbarch_deprecated_pop_frame (gdbarch, sparc_pop_frame);
set_gdbarch_deprecated_push_return_address (gdbarch, sparc_push_return_address);
set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
- set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
- set_gdbarch_register_convert_to_raw (gdbarch, sparc_convert_to_raw);
- set_gdbarch_register_convert_to_virtual (gdbarch,
- sparc_convert_to_virtual);
- set_gdbarch_register_convertible (gdbarch,
- generic_register_convertible_not);
- set_gdbarch_reg_struct_has_addr (gdbarch, sparc_reg_struct_has_addr);
+ set_gdbarch_deprecated_reg_struct_has_addr
+ (gdbarch, sparc_reg_struct_has_addr);
set_gdbarch_return_value_on_stack (gdbarch, sparc_return_value_on_stack);
set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);
#ifdef SPARC32_CALL_DUMMY_ON_STACK
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
- set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
+ set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);
set_gdbarch_frame_args_skip (gdbarch, 68);
set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
- set_gdbarch_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
+ set_gdbarch_deprecated_npc_regnum (gdbarch, SPARC32_NPC_REGNUM);
set_gdbarch_pc_regnum (gdbarch, SPARC32_PC_REGNUM);
set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_deprecated_push_arguments (gdbarch, sparc32_push_arguments);
- set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
- set_gdbarch_register_byte (gdbarch, sparc32_register_byte);
- set_gdbarch_register_raw_size (gdbarch, sparc32_register_size);
+ set_gdbarch_deprecated_register_byte (gdbarch, sparc32_register_byte);
+ set_gdbarch_deprecated_register_raw_size (gdbarch, sparc32_register_size);
set_gdbarch_deprecated_register_size (gdbarch, 4);
- set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
- set_gdbarch_register_virtual_type (gdbarch,
- sparc32_register_virtual_type);
+ set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc32_register_size);
+ set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc32_register_virtual_type);
#ifdef SPARC32_CALL_DUMMY_ON_STACK
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
#else
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif
- set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
+ set_gdbarch_deprecated_stack_align (gdbarch, sparc32_stack_align);
set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
set_gdbarch_use_struct_convention (gdbarch,
generic_use_struct_convention);
- set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
tdep->y_regnum = SPARC32_Y_REGNUM;
tdep->fp_max_regnum = SPARC_FP0_REGNUM + 32;
tdep->intreg_size = 4;
#ifdef SPARC64_CALL_DUMMY_ON_STACK
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
- set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
+ set_gdbarch_deprecated_call_dummy_address (gdbarch, sparc_call_dummy_address);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_frame_args_skip (gdbarch, 136);
set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
- set_gdbarch_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
+ set_gdbarch_deprecated_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM);
set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
set_gdbarch_read_sp (gdbarch, sparc64_read_sp);
/* Some of the registers aren't 64 bits, but it's a lot simpler just
to assume they all are (since most of them are). */
- set_gdbarch_register_byte (gdbarch, sparc64_register_byte);
- set_gdbarch_register_raw_size (gdbarch, sparc64_register_size);
+ set_gdbarch_deprecated_register_byte (gdbarch, sparc64_register_byte);
+ set_gdbarch_deprecated_register_raw_size (gdbarch, sparc64_register_size);
set_gdbarch_deprecated_register_size (gdbarch, 8);
- set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
- set_gdbarch_register_virtual_type (gdbarch,
- sparc64_register_virtual_type);
+ set_gdbarch_deprecated_register_virtual_size (gdbarch, sparc64_register_size);
+ set_gdbarch_deprecated_register_virtual_type (gdbarch, sparc64_register_virtual_type);
#ifdef SPARC64_CALL_DUMMY_ON_STACK
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
#else
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif
- set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
+ set_gdbarch_deprecated_stack_align (gdbarch, sparc64_stack_align);
set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
set_gdbarch_use_struct_convention (gdbarch,
break;
}
+ set_gdbarch_print_insn (gdbarch, print_insn_sparc);
+
/* Hook in OS ABI-specific overrides, if they have been registered. */
gdbarch_init_osabi (info, gdbarch);
projects / deliverable / binutils-gdb.git / blobdiff