#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>
#endif
#include "gdbcore.h"
+#include "gdb_assert.h"
#include "symfile.h" /* for 'entry_point_address' */
* Some local macros that have multi-arch and non-multi-arch versions:
*/
-#if (GDB_MULTI_ARCH > 0)
-
-/* Does the target have Floating Point registers? */
-#define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
+#if 0
+// OBSOLETE /* Does the target have Floating Point registers? */
+// OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
+#endif
+#define SPARC_HAS_FPU 1
/* Number of bytes devoted to Floating Point registers: */
#define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
/* Highest numbered Floating Point register. */
/* 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 defined(TARGET_SPARCLET) || defined(TARGET_SPARCLITE)
-#define SPARC_HAS_FPU 0
-#else
-#define SPARC_HAS_FPU 1
-#endif
-
-/* 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
{
- int has_fpu;
+#if 0
+ // OBSOLETE int has_fpu;
+#endif
int fp_register_bytes;
int y_regnum;
int fp_max_regnum;
* 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
int deferred_stores = 0; /* Accumulated stores we want to do eventually. */
-/* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
- where instructions are big-endian and data are little-endian.
- This flag is set when we detect that the target is of this type. */
+#if 0
+// OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
+// OBSOLETE where instructions are big-endian and data are little-endian.
+// OBSOLETE This flag is set when we detect that the target is of this type. */
+// OBSOLETE
+// OBSOLETE int bi_endian = 0;
+#endif
-int bi_endian = 0;
+const unsigned char *
+sparc_breakpoint_from_pc (CORE_ADDR *pc, int *len)
+{
+ static const char breakpoint[] = {0x91, 0xd0, 0x20, 0x01};
+ (*len) = sizeof (breakpoint);
+ return breakpoint;
+}
/* Fetch a single instruction. Even on bi-endian machines
such as sparc86x, instructions are always big-endian. */
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]);
: get_frame_base (get_next_frame (fi)))
: read_sp ());
- /* If fi->next is NULL, then we already set ->frame by passing read_fp()
- to create_new_frame. */
+ /* If fi->next is NULL, then we already set ->frame by passing
+ deprecated_read_fp() to create_new_frame. */
if (get_next_frame (fi))
{
- char *buf;
-
- buf = alloca (MAX_REGISTER_RAW_SIZE);
+ char buf[MAX_REGISTER_SIZE];
/* Compute ->frame as if not flat. If it is flat, we'll change
it later. */
else
{
/* Should we adjust for stack bias here? */
- get_saved_register (buf, 0, 0, fi, FP_REGNUM, 0);
- deprecated_update_frame_base_hack (fi, extract_address (buf, REGISTER_RAW_SIZE (FP_REGNUM)));
-
+ ULONGEST 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);
}
&& X_OP3 (insn) == 4
&& X_RS1 (insn) == 14)
{
- char *buf;
-
- buf = alloca (MAX_REGISTER_RAW_SIZE);
+ char buf[MAX_REGISTER_SIZE];
/* We definitely have a flat frame now. */
get_frame_extra_info (fi)->flat = 1;
get_frame_extra_info (fi)->sp_offset = offset;
/* Overwrite the frame's address with the value in %i7. */
- get_saved_register (buf, 0, 0, fi, I7_REGNUM, 0);
- deprecated_update_frame_base_hack (fi, extract_address (buf, REGISTER_RAW_SIZE (I7_REGNUM)));
+ {
+ ULONGEST tmp;
+ tmp = get_frame_register_unsigned (fi, I7_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);
CORE_ADDR
sparc_frame_chain (struct frame_info *frame)
{
- /* Value that will cause FRAME_CHAIN_VALID to not worry about the chain
- value. If it really is zero, we detect it later in
- sparc_init_prev_frame.
+ /* Value that will cause DEPRECATED_FRAME_CHAIN_VALID to not worry
+ about the chain value. If it really is zero, we detect it later
+ in sparc_init_prev_frame.
- Note: kevinb/2003-02-18: The constant 1 used to be returned
- here, but, after some recent changes to frame_chain_valid(),
- this value is no longer suitable for causing frame_chain_valid()
- to "not worry about the chain value." The constant ~0 (i.e,
- 0xfff...) causes the failing test in frame_chain_valid() to
- succeed thus preserving the "not worry" property. I had considered
- using something like ``get_frame_base (frame) + 1''. However, I think
- a constant value is better, because when debugging this problem,
- I knew that something funny was going on as soon as I saw the
- constant 1 being used as the frame chain elsewhere in GDB. */
+ Note: kevinb/2003-02-18: The constant 1 used to be returned here,
+ but, after some recent changes to legacy_frame_chain_valid(),
+ this value is no longer suitable for causing
+ legacy_frame_chain_valid() to "not worry about the chain value."
+ The constant ~0 (i.e, 0xfff...) causes the failing test in
+ legacy_frame_chain_valid() to succeed thus preserving the "not
+ worry" property. I had considered using something like
+ ``get_frame_base (frame) + 1''. However, I think a constant
+ value is better, because when debugging this problem, I knew that
+ something funny was going on as soon as I saw the constant 1
+ being used as the frame chain elsewhere in GDB. */
return ~ (CORE_ADDR) 0;
}
-CORE_ADDR
-sparc_extract_struct_value_address (char *regbuf)
-{
- return extract_address (regbuf + REGISTER_BYTE (O0_REGNUM),
- REGISTER_RAW_SIZE (O0_REGNUM));
-}
-
/* Find the pc saved in frame FRAME. */
CORE_ADDR
sparc_frame_saved_pc (struct frame_info *frame)
{
- char *buf;
+ char buf[MAX_REGISTER_SIZE];
CORE_ADDR addr;
- buf = alloca (MAX_REGISTER_RAW_SIZE);
if ((get_frame_type (frame) == SIGTRAMP_FRAME))
{
/* This is the signal trampoline frame.
saved_pc_offset = 12;
/* The sigcontext address is contained in register O2. */
- get_saved_register (buf, (int *) NULL, (CORE_ADDR *) NULL,
- frame, O0_REGNUM + 2, (enum lval_type *) NULL);
- sigcontext_addr = extract_address (buf, REGISTER_RAW_SIZE (O0_REGNUM + 2));
+ {
+ ULONGEST tmp;
+ tmp = get_frame_register_unsigned (frame, O0_REGNUM + 2);
+ sigcontext_addr = tmp;
+ }
/* Don't cause a memory_error when accessing sigcontext in case the
stack layout has changed or the stack is corrupt. */
target_read_memory (sigcontext_addr + saved_pc_offset,
scbuf, sizeof (scbuf));
- return extract_address (scbuf, sizeof (scbuf));
+ return extract_unsigned_integer (scbuf, sizeof (scbuf));
}
else if (get_frame_extra_info (frame)->in_prologue ||
(get_next_frame (frame) != NULL &&
{
/* A frameless function interrupted by a signal did not save
the PC, it is still in %o7. */
- get_saved_register (buf, (int *) NULL, (CORE_ADDR *) NULL,
- frame, O7_REGNUM, (enum lval_type *) NULL);
- return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
+ ULONGEST tmp;
+ tmp = get_frame_register_unsigned (frame, O7_REGNUM);
+ return PC_ADJUST (tmp);
}
if (get_frame_extra_info (frame)->flat)
addr = get_frame_extra_info (frame)->pc_addr;
return PC_ADJUST (read_register (O7_REGNUM));
read_memory (addr, buf, SPARC_INTREG_SIZE);
- return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
+ return PC_ADJUST (extract_unsigned_integer (buf, SPARC_INTREG_SIZE));
}
/* Since an individual frame in the frame cache is defined by two
if (raw_buffer != NULL)
{
/* Put it back in target format. */
- store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
+ store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), get_frame_pc (frame));
}
if (addrp != NULL)
*addrp = 0;
else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
{
/* Outs become ins. */
- get_saved_register (raw_buffer, optimized, addrp, frame1,
- (regnum - O0_REGNUM + I0_REGNUM), lval);
+ int realnum;
+ frame_register (frame1, (regnum - O0_REGNUM + I0_REGNUM),
+ optimized, lval, addrp, &realnum, raw_buffer);
return;
}
}
if (raw_buffer != NULL)
{
/* Put it back in target format. */
- store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
+ store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
}
if (addrp != NULL)
*addrp = 0;
{
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);
sp -= DUMMY_STACK_SIZE;
- write_sp (sp);
+ DEPRECATED_DUMMY_WRITE_SP (sp);
write_memory (sp + DUMMY_REG_SAVE_OFFSET, ®ister_temp[0],
DUMMY_STACK_REG_BUF_SIZE);
if (GDB_TARGET_IS_SPARC64)
{
/* Target is a 64 bit SPARC. */
- CORE_ADDR oldfp = read_register (FP_REGNUM);
+ CORE_ADDR oldfp = read_register (DEPRECATED_FP_REGNUM);
if (oldfp & 1)
- write_register (FP_REGNUM, old_sp - 2047);
+ write_register (DEPRECATED_FP_REGNUM, old_sp - 2047);
else
- write_register (FP_REGNUM, old_sp);
+ write_register (DEPRECATED_FP_REGNUM, old_sp);
}
else
{
/* Target is a 32 bit SPARC. */
- write_register (FP_REGNUM, old_sp);
+ write_register (DEPRECATED_FP_REGNUM, old_sp);
}
/* Set return address register for the call dummy to the current PC. */
write_register (I7_REGNUM, read_pc () - 8);
/* The call dummy will write this value to FP before executing
the 'save'. This ensures that register window flushes work
correctly in the simulator. */
- write_register (G0_REGNUM + 1, read_register (FP_REGNUM));
+ write_register (G0_REGNUM + 1, read_register (DEPRECATED_FP_REGNUM));
/* The call dummy will write this value to FP after executing
the 'save'. */
/* Set the FP that the call dummy will be using after the 'save'.
This makes backtraces from an inferior function call work properly. */
- write_register (FP_REGNUM, old_sp);
+ write_register (DEPRECATED_FP_REGNUM, old_sp);
}
}
I think few ports of GDB get right--if you are popping a frame
which does not save some register that *is* saved by a more inner
frame (such a frame will never be a dummy frame because dummy
- frames save all registers). Rewriting pop_frame to use
- get_saved_register would solve this problem and also get rid of the
- ugly duplication between sparc_frame_find_saved_regs and
- get_saved_register.
+ frames save all registers).
+
+ NOTE: cagney/2003-03-12: Since pop_frame has been rewritten to use
+ frame_unwind_register() the need for this function is questionable.
Stores, into an array of CORE_ADDR,
the addresses of the saved registers of frame described by FRAME_INFO.
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);
- if (!fi)
- internal_error (__FILE__, __LINE__,
- "Bad frame info struct in FRAME_FIND_SAVED_REGS");
+ gdb_assert (fi != NULL);
memset (saved_regs_addr, 0, NUM_REGS * sizeof (CORE_ADDR));
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;
fsr = alloca (NUM_REGS * sizeof (CORE_ADDR));
- raw_buffer = alloca (REGISTER_BYTES);
+ raw_buffer = alloca (DEPRECATED_REGISTER_BYTES);
sparc_frame_find_saved_regs (frame, &fsr[0]);
if (SPARC_HAS_FPU)
{
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);
}
read_memory_integer (fsr[O0_REGNUM + 7],
SPARC_INTREG_SIZE));
- write_sp (get_frame_base (frame));
+ DEPRECATED_DUMMY_WRITE_SP (get_frame_base (frame));
}
else if (fsr[I0_REGNUM])
{
/* 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)
{
/* I think this happens only in the innermost frame, if so then
it is a complicated way of saying
"pc = read_register (O7_REGNUM);". */
- char *buf;
-
- buf = alloca (MAX_REGISTER_RAW_SIZE);
- get_saved_register (buf, 0, 0, frame, O7_REGNUM, 0);
- pc = PC_ADJUST (extract_address
- (buf, REGISTER_RAW_SIZE (O7_REGNUM)));
+ ULONGEST 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));
}
LONGJMP_TARGET_SIZE))
return 0;
- *pc = extract_address (buf, LONGJMP_TARGET_SIZE);
+ *pc = extract_unsigned_integer (buf, LONGJMP_TARGET_SIZE);
return 1;
}
{
int i;
const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
- char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
- char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
+ char raw_buffer[MAX_REGISTER_SIZE];
+ char virtual_buffer[MAX_REGISTER_SIZE];
for (i = 0; i < numregs; i++)
{
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. */
regnum, all);
}
-static void
-sparclet_print_registers_info (struct gdbarch *gdbarch,
- struct ui_file *file,
- struct frame_info *frame,
- int regnum, int print_all)
-{
- sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
-}
+#if 0
+// OBSOLETE static void
+// OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
+// OBSOLETE struct ui_file *file,
+// OBSOLETE struct frame_info *frame,
+// OBSOLETE int regnum, int print_all)
+// OBSOLETE {
+// OBSOLETE sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
+// OBSOLETE }
+// OBSOLETE
+// OBSOLETE void
+// OBSOLETE sparclet_do_registers_info (int regnum, int all)
+// OBSOLETE {
+// OBSOLETE sparclet_print_registers_info (current_gdbarch, gdb_stdout,
+// OBSOLETE deprecated_selected_frame, regnum, all);
+// OBSOLETE }
+#endif
-void
-sparclet_do_registers_info (int regnum, int all)
-{
- sparclet_print_registers_info (current_gdbarch, gdb_stdout,
- deprecated_selected_frame, regnum, all);
-}
+#define SPARC_F0_REGNUM FP0_REGNUM /* %f0 */
+#define SPARC_F1_REGNUM (FP0_REGNUM + 1)/* %f1 */
+#define SPARC_O0_REGNUM O0_REGNUM /* %o0 */
+#define SPARC_O1_REGNUM O1_REGNUM /* %o1 */
-\f
-int
-gdb_print_insn_sparc (bfd_vma memaddr, disassemble_info *info)
+/* Push the arguments onto the stack and into the appropriate registers. */
+
+static CORE_ADDR
+sparc32_do_push_arguments (struct regcache *regcache, int nargs,
+ struct value **args, CORE_ADDR sp)
{
- /* It's necessary to override mach again because print_insn messes it up. */
- info->mach = TARGET_ARCHITECTURE->mach;
- return print_insn_sparc (memaddr, info);
+ CORE_ADDR *addr;
+ int size = 0;
+ int i;
+
+ /* Structure, union and quad-precision arguments are passed by
+ reference. We allocate space for these arguments on the stack
+ and record their addresses in an array. Array elements for
+ arguments that are passed by value will be set to zero.*/
+ addr = alloca (nargs * sizeof (CORE_ADDR));
+
+ for (i = nargs - 1; i >= 0; i--)
+ {
+ struct type *type = VALUE_ENCLOSING_TYPE (args[i]);
+ enum type_code code = TYPE_CODE (type);
+ int len = TYPE_LENGTH (type);
+
+ /* Push the contents of structure, union and quad-precision
+ arguments on the stack. */
+ if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION || len > 8)
+ {
+ /* Keep the stack doubleword aligned. */
+ sp -= (len + 7) & ~7;
+ write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
+ addr[i] = sp;
+ size += 4;
+ }
+ else
+ {
+ addr[i] = 0;
+ size += (len > 4) ? 8 : 4;
+ }
+ }
+
+ /* The needed space for outgoing arguments should be a multiple of 4. */
+ gdb_assert (size % 4 == 0);
+
+ /* Make sure we reserve space for the first six words of arguments
+ in the stack frame, even if we don't need them. */
+ if (size < 24)
+ sp -= (24 - size);
+
+ /* Make sure we end up with a doubleword aligned stack in the end.
+ Reserve an extra word if necessary in order to accomplish this. */
+ if ((sp - size) % 8 == 0)
+ sp -= 4;
+
+ /* Now push the arguments onto the stack. */
+ for (i = nargs - 1; i >=0; i--)
+ {
+ char buf[8];
+ int len;
+
+ if (addr[i])
+ {
+ store_unsigned_integer (buf, 4, addr[i]);
+ len = 4;
+ }
+ else
+ {
+ struct value *arg = args[i];
+
+ len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
+
+ /* Expand signed and unsigned bytes and halfwords as needed. */
+ if (len < 4)
+ {
+ arg = value_cast (builtin_type_long, arg);
+ len = 4;
+ }
+ else if (len > 4 && len < 8)
+ {
+ arg = value_cast (builtin_type_long_long, arg);
+ len = 4;
+ }
+
+ gdb_assert (len == 4 || len == 8);
+ memcpy (buf, VALUE_CONTENTS_ALL (arg), len);
+ }
+
+ /* We always write the argument word on the stack. */
+ sp -= len;
+ write_memory (sp, buf, len);
+
+ /* If this argument occupies one of the first 6 words, write it
+ into the appropriate register too. */
+ size -= len;
+ if (size < 24)
+ {
+ int regnum = SPARC_O0_REGNUM + (size / 4);
+
+ regcache_cooked_write (regcache, regnum, buf);
+ if (len == 8 && size < 20)
+ regcache_cooked_write (regcache, regnum + 1, buf + 4);
+ }
+ }
+
+ /* Reserve space for the struct/union return value pointer. */
+ sp -= 4;
+
+ /* Stack should be doubleword aligned at this point. */
+ gdb_assert (sp % 8 == 0);
+
+ /* Return the adjusted stack pointer. */
+ return sp;
}
-\f
+
/* The SPARC passes the arguments on the stack; arguments smaller
than an int are promoted to an int. The first 6 words worth of
args are also passed in registers o0 - o5. */
sparc32_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
- int i, j, oregnum;
- int accumulate_size = 0;
- struct sparc_arg
+ sp = sparc32_do_push_arguments (current_regcache, nargs, args, sp);
+
+ /* FIXME: kettenis/20030525: We don't let this function set the
+ struct/union return pointer just yet. */
+#if 0
+ if (struct_return)
{
- char *contents;
- int len;
- int offset;
- };
- struct sparc_arg *sparc_args =
- (struct sparc_arg *) alloca (nargs * sizeof (struct sparc_arg));
- struct sparc_arg *m_arg;
-
- /* Promote arguments if necessary, and calculate their stack offsets
- and sizes. */
- for (i = 0, m_arg = sparc_args; i < nargs; i++, m_arg++)
- {
- struct value *arg = args[i];
- struct type *arg_type = check_typedef (VALUE_TYPE (arg));
- /* Cast argument to long if necessary as the compiler does it too. */
- switch (TYPE_CODE (arg_type))
- {
- case TYPE_CODE_INT:
- case TYPE_CODE_BOOL:
- case TYPE_CODE_CHAR:
- case TYPE_CODE_RANGE:
- case TYPE_CODE_ENUM:
- if (TYPE_LENGTH (arg_type) < TYPE_LENGTH (builtin_type_long))
- {
- arg_type = builtin_type_long;
- arg = value_cast (arg_type, arg);
- }
- break;
- default:
- break;
- }
- m_arg->len = TYPE_LENGTH (arg_type);
- m_arg->offset = accumulate_size;
- accumulate_size = (accumulate_size + m_arg->len + 3) & ~3;
- m_arg->contents = VALUE_CONTENTS (arg);
+ char buf[4];
+
+ /* The space for the struct/union return value pointer has
+ already been reserved. */
+ store_unsigned_integer (buf, 4, struct_addr);
+ write (sp, buf, 4);
}
- /* Make room for the arguments on the stack. */
- accumulate_size += CALL_DUMMY_STACK_ADJUST;
- sp = ((sp - accumulate_size) & ~7) + CALL_DUMMY_STACK_ADJUST;
+ return sp;
+#else
+ return sp + 4;
+#endif
+}
- /* `Push' arguments on the stack. */
- for (i = 0, oregnum = 0, m_arg = sparc_args;
- i < nargs;
- i++, m_arg++)
+/* Extract from REGCACHE a function return value of type TYPE and copy
+ that into VALBUF.
+
+ Note that REGCACHE specifies the register values for the frame of
+ the calling function. This means that we need to fetch the value
+ form %o0 and %o1, which correspond to %i0 and %i1 in the frame of
+ the called function. */
+
+void
+sparc32_extract_return_value (struct type *type, struct regcache *regcache,
+ void *valbuf)
+{
+ int len = TYPE_LENGTH (type);
+ char buf[8];
+
+ if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
{
- write_memory (sp + m_arg->offset, m_arg->contents, m_arg->len);
- for (j = 0;
- j < m_arg->len && oregnum < 6;
- j += SPARC_INTREG_SIZE, oregnum++)
- deprecated_write_register_gen (O0_REGNUM + oregnum, m_arg->contents + j);
+ if (len == 4 || len == 8)
+ {
+ regcache_cooked_read (regcache, SPARC_F0_REGNUM, buf);
+ regcache_cooked_read (regcache, SPARC_F1_REGNUM, buf + 4);
+ memcpy (valbuf, buf, len);
+ return;
+ }
+ else
+ internal_error (__FILE__, __LINE__, "\
+Cannot extract floating-point return value of %d bytes long.", len);
}
- return sp;
+ if (len <= 4)
+ {
+ regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
+ memcpy (valbuf, buf + 4 - len, len);
+ }
+ else if (len <= 8)
+ {
+ regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
+ regcache_cooked_read (regcache, SPARC_O1_REGNUM, buf + 4);
+ memcpy (valbuf, buf + 8 - len, len);
+ }
+ else
+ internal_error (__FILE__, __LINE__,
+ "Cannot extract return value of %d bytes long.", len);
}
-
-/* Extract from an array REGBUF containing the (raw) register state
- a function return value of type TYPE, and copy that, in virtual format,
- into VALBUF. */
+/* Write into REGBUF a function return value VALBUF of type TYPE. */
void
-sparc32_extract_return_value (struct type *type, char *regbuf, char *valbuf)
+sparc32_store_return_value (struct type *type, struct regcache *regcache,
+ const void *valbuf)
{
- int typelen = TYPE_LENGTH (type);
- int regsize = REGISTER_RAW_SIZE (O0_REGNUM);
+ int len = TYPE_LENGTH (type);
+ char buf[8];
if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
- memcpy (valbuf, ®buf[REGISTER_BYTE (FP0_REGNUM)], typelen);
+ {
+ const char *buf = valbuf;
+
+ if (len == 4)
+ {
+ regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
+ return;
+ }
+ else if (len == 8)
+ {
+ regcache_cooked_write (regcache, SPARC_F0_REGNUM, buf);
+ regcache_cooked_write (regcache, SPARC_F1_REGNUM, buf + 4);
+ return;
+ }
+ else
+ internal_error (__FILE__, __LINE__, "\
+Cannot extract floating-point return value of %d bytes long.", len);
+ }
+
+ /* Add leading zeros to the value. */
+ memset (buf, 0, sizeof buf);
+
+ if (len <= 4)
+ {
+ memcpy (buf + 4 - len, valbuf, len);
+ regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
+ }
+ else if (len <= 8)
+ {
+ memcpy (buf + 8 - len, valbuf, len);
+ regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
+ regcache_cooked_write (regcache, SPARC_O1_REGNUM, buf);
+ }
else
- memcpy (valbuf,
- ®buf[O0_REGNUM * regsize +
- (typelen >= regsize
- || TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE ? 0
- : regsize - typelen)],
- typelen);
+ internal_error (__FILE__, __LINE__,
+ "Cannot extract return value of %d bytes long.", len);
}
+/* Extract from REGCACHE the address in which a function should return
+ its structure value. */
+
+CORE_ADDR
+sparc_extract_struct_value_address (struct regcache *regcache)
+{
+ ULONGEST addr;
-/* Write into appropriate registers a function return value
- of type TYPE, given in virtual format. On SPARCs with FPUs,
- float values are returned in %f0 (and %f1). In all other cases,
- values are returned in register %o0. */
+ regcache_cooked_read_unsigned (regcache, SPARC_O0_REGNUM, &addr);
+ return addr;
+}
-void
+/* FIXME: kettenis/2003/05/24: Still used for sparc64. */
+
+static void
sparc_store_return_value (struct type *type, char *valbuf)
{
int regno;
- char *buffer;
-
- buffer = alloca (MAX_REGISTER_RAW_SIZE);
+ char buffer[MAX_REGISTER_SIZE];
if (TYPE_CODE (type) == TYPE_CODE_FLT && SPARC_HAS_FPU)
/* Floating-point values are returned in the register pair */
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));
}
-extern void
-sparclet_store_return_value (struct type *type, char *valbuf)
-{
- /* Other values are returned in register %o0. */
- deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
- TYPE_LENGTH (type));
-}
+#if 0
+// OBSOLETE extern void
+// OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
+// OBSOLETE {
+// OBSOLETE /* Other values are returned in register %o0. */
+// OBSOLETE deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
+// OBSOLETE TYPE_LENGTH (type));
+// OBSOLETE }
+#endif
#ifndef CALL_DUMMY_CALL_OFFSET
For structs and unions, if the function was compiled with Sun cc,
it expects 'unimp' after the call. But gcc doesn't use that
- (twisted) convention. So leave a nop there for gcc (FIX_CALL_DUMMY
- can assume it is operating on a pristine CALL_DUMMY, not one that
- has already been customized for a different function). */
+ (twisted) convention. So leave a nop there for gcc
+ (DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
+ CALL_DUMMY, not one that has already been customized for a
+ different function). */
void
sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
Adjust the call_dummy_breakpoint_offset for the bp_call_dummy breakpoint
to the proper address in the call dummy, so that `finish' after a stop
in a call dummy works.
- Tweeking current_gdbarch is not an optimal solution, but the call to
- sparc_fix_call_dummy is immediately followed by a call to run_stack_dummy,
- which is the only function where dummy_breakpoint_offset is actually
- used, if it is non-zero. */
+
+ Tweeking current_gdbarch is not an optimal solution, but the call
+ to sparc_fix_call_dummy is immediately followed by a call to
+ call_function_by_hand, which is the only function where
+ dummy_breakpoint_offset is actually used, if it is non-zero. */
if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
|| TYPE_CODE (value_type) == TYPE_CODE_UNION)
{
store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
TYPE_LENGTH (value_type) & 0x1fff);
- set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
+ set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
}
else
- set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
+ set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
if (!(GDB_TARGET_IS_SPARC64))
{
}
}
- /* If this is a bi-endian target, GDB has written the call dummy
- in little-endian order. We must byte-swap it back to big-endian. */
- if (bi_endian)
- {
- for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
- {
- char tmp = dummy[i];
- dummy[i] = dummy[i + 3];
- dummy[i + 3] = tmp;
- tmp = dummy[i + 1];
- dummy[i + 1] = dummy[i + 2];
- dummy[i + 2] = tmp;
- }
- }
+#if 0
+// OBSOLETE /* If this is a bi-endian target, GDB has written the call dummy
+// OBSOLETE in little-endian order. We must byte-swap it back to big-endian. */
+// OBSOLETE if (bi_endian)
+// OBSOLETE {
+// OBSOLETE for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
+// OBSOLETE {
+// OBSOLETE char tmp = dummy[i];
+// OBSOLETE dummy[i] = dummy[i + 3];
+// OBSOLETE dummy[i + 3] = tmp;
+// OBSOLETE tmp = dummy[i + 1];
+// OBSOLETE dummy[i + 1] = dummy[i + 2];
+// OBSOLETE dummy[i + 2] = tmp;
+// OBSOLETE }
+// OBSOLETE }
+#endif
}
-/* Set target byte order based on machine type. */
-
-static int
-sparc_target_architecture_hook (const bfd_arch_info_type *ap)
-{
- int i, j;
-
- if (ap->mach == bfd_mach_sparc_sparclite_le)
- {
- target_byte_order = BFD_ENDIAN_LITTLE;
- bi_endian = 1;
- }
- else
- bi_endian = 0;
- return 1;
-}
-\f
+#if 0
+// OBSOLETE /* Set target byte order based on machine type. */
+// OBSOLETE
+// OBSOLETE static int
+// OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
+// OBSOLETE {
+// OBSOLETE int i, j;
+// OBSOLETE
+// OBSOLETE if (ap->mach == bfd_mach_sparc_sparclite_le)
+// OBSOLETE {
+// OBSOLETE target_byte_order = BFD_ENDIAN_LITTLE;
+// OBSOLETE bi_endian = 1;
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE bi_endian = 0;
+// OBSOLETE return 1;
+// OBSOLETE }
+#endif
/*
* Module "constructor" function.
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);
- tm_print_insn = gdb_print_insn_sparc;
- tm_print_insn_info.mach = TM_PRINT_INSN_MACH; /* Selects sparc/sparclite */
- target_architecture_hook = sparc_target_architecture_hook;
+ /* 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 (FP_REGNUM);
+ CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
if (fp & 1)
fp += 2047;
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);
}
-extern void
-sparclet_extract_return_value (struct type *type,
- char *regbuf,
- char *valbuf)
-{
- regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
- if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
- regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
-
- memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
-}
-
+#if 0
+// OBSOLETE extern void
+// OBSOLETE sparclet_extract_return_value (struct type *type,
+// OBSOLETE char *regbuf,
+// OBSOLETE char *valbuf)
+// OBSOLETE {
+// OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
+// OBSOLETE if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
+// OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
+// OBSOLETE
+// OBSOLETE memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
+// OBSOLETE }
+#endif
extern CORE_ADDR
sparc32_stack_align (CORE_ADDR addr)
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)
{
return register_names[regno];
}
-static const char *
-sparclite_register_name (int regno)
-{
- static char *register_names[] =
- { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
- "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
- "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
- "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
-
- "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
- "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
- "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
- "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
-
- "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
- "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
- };
-
- if (regno < 0 ||
- regno >= (sizeof (register_names) / sizeof (register_names[0])))
- return NULL;
- else
- return register_names[regno];
-}
-
-static const char *
-sparclet_register_name (int regno)
-{
- static char *register_names[] =
- { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
- "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
- "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
- "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
-
- "", "", "", "", "", "", "", "", /* no floating point registers */
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
-
- "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
- "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
-
- /* ASR15 ASR19 (don't display them) */
- "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
- /* None of the rest get displayed */
#if 0
- "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
- "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
- "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
- "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
- "apsr"
-#endif /* 0 */
- };
+// OBSOLETE static const char *
+// OBSOLETE sparclite_register_name (int regno)
+// OBSOLETE {
+// OBSOLETE static char *register_names[] =
+// OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
+// OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
+// OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
+// OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
+// OBSOLETE
+// OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
+// OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
+// OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
+// OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
+// OBSOLETE
+// OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
+// OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
+// OBSOLETE };
+// OBSOLETE
+// OBSOLETE if (regno < 0 ||
+// OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
+// OBSOLETE return NULL;
+// OBSOLETE else
+// OBSOLETE return register_names[regno];
+// OBSOLETE }
+#endif
- if (regno < 0 ||
- regno >= (sizeof (register_names) / sizeof (register_names[0])))
- return NULL;
- else
- return register_names[regno];
-}
+#if 0
+// OBSOLETE static const char *
+// OBSOLETE sparclet_register_name (int regno)
+// OBSOLETE {
+// OBSOLETE static char *register_names[] =
+// OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
+// OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
+// OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
+// OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
+// OBSOLETE
+// OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
+// OBSOLETE "", "", "", "", "", "", "", "",
+// OBSOLETE "", "", "", "", "", "", "", "",
+// OBSOLETE "", "", "", "", "", "", "", "",
+// OBSOLETE
+// OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
+// OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
+// OBSOLETE
+// OBSOLETE /* ASR15 ASR19 (don't display them) */
+// OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
+// OBSOLETE /* None of the rest get displayed */
+// OBSOLETE #if 0
+// OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
+// OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
+// OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
+// OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
+// OBSOLETE "apsr"
+// OBSOLETE #endif /* 0 */
+// OBSOLETE };
+// OBSOLETE
+// OBSOLETE if (regno < 0 ||
+// OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
+// OBSOLETE return NULL;
+// OBSOLETE else
+// OBSOLETE return register_names[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;
sparc32_register_virtual_type (int regno)
{
if (regno == PC_REGNUM ||
- regno == FP_REGNUM ||
+ regno == DEPRECATED_FP_REGNUM ||
regno == SP_REGNUM)
return builtin_type_unsigned_int;
if (regno < 32)
sparc64_register_virtual_type (int regno)
{
if (regno == PC_REGNUM ||
- regno == FP_REGNUM ||
+ regno == DEPRECATED_FP_REGNUM ||
regno == SP_REGNUM)
return builtin_type_unsigned_long_long;
if (regno < 32)
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)
{
- return (CALL_DUMMY_START_OFFSET) + CALL_DUMMY_BREAKPOINT_OFFSET;
+ return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
}
/* Supply the Y register number to those that need it. */
return 0;
}
+/* Get the ith function argument for the current function. */
+static CORE_ADDR
+sparc_fetch_pointer_argument (struct frame_info *frame, int argi,
+ struct type *type)
+{
+ CORE_ADDR addr;
+ get_frame_register (frame, O0_REGNUM + argi, &addr);
+ return addr;
+}
+
/*
* Gdbarch "constructor" function.
*/
/* First set settings that are common for all sparc architectures. */
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
- set_gdbarch_breakpoint_from_pc (gdbarch, memory_breakpoint_from_pc);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
- set_gdbarch_call_dummy_p (gdbarch, 1);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 1);
+ set_gdbarch_breakpoint_from_pc (gdbarch, sparc_breakpoint_from_pc);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
- set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sparc_extract_struct_value_address);
- set_gdbarch_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
+ set_gdbarch_extract_struct_value_address (gdbarch,
+ sparc_extract_struct_value_address);
+ set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
- set_gdbarch_fp_regnum (gdbarch, SPARC_FP_REGNUM);
+ set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
- set_gdbarch_frame_chain (gdbarch, sparc_frame_chain);
+ 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_get_saved_register (gdbarch, sparc_get_saved_register);
+ set_gdbarch_deprecated_get_saved_register (gdbarch, sparc_get_saved_register);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_deprecated_max_register_raw_size (gdbarch, 8);
set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
- set_gdbarch_pop_frame (gdbarch, sparc_pop_frame);
- set_gdbarch_push_return_address (gdbarch, sparc_push_return_address);
+ 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_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
+ set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sparc_saved_pc_after_call);
set_gdbarch_prologue_frameless_p (gdbarch, sparc_prologue_frameless_p);
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_skip_prologue (gdbarch, sparc_skip_prologue);
set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
+ /* Helper for function argument information. */
+ set_gdbarch_fetch_pointer_argument (gdbarch, sparc_fetch_pointer_argument);
+
/*
* Settings that depend only on 32/64 bit word size
*/
switch (info.bfd_arch_info->mach)
{
case bfd_mach_sparc:
- case bfd_mach_sparc_sparclet:
- case bfd_mach_sparc_sparclite:
+#if 0
+ // OBSOLETE case bfd_mach_sparc_sparclet:
+ // OBSOLETE case bfd_mach_sparc_sparclite:
+#endif
case bfd_mach_sparc_v8plus:
case bfd_mach_sparc_v8plusa:
- case bfd_mach_sparc_sparclite_le:
+#if 0
+ // OBSOLETE case bfd_mach_sparc_sparclite_le:
+#endif
/* 32-bit machine types: */
#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_call_dummy_breakpoint_offset (gdbarch, 0x30);
- set_gdbarch_call_dummy_length (gdbarch, 0x38);
-
- /* NOTE: cagney/2002-04-26: Based from info posted by Peter
+ 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);
+
+ /* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
+ architecture method, it is now possible to implement a
+ generic dummy frames based inferior function call that stores
+ the breakpoint (and struct info) on the stack. Further, by
+ treating a SIGSEG at a breakpoint as equivalent to a SIGTRAP
+ it is even possible to make this work when the stack is
+ no-execute.
+
+ NOTE: cagney/2002-04-26: Based from info posted by Peter
Schauer around Oct '99. Briefly, due to aspects of the SPARC
ABI, it isn't possible to use ON_STACK with a strictly
compliant compiler.
are explained in Appendix D.3. */
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
- set_gdbarch_call_dummy_words (gdbarch, call_dummy_32);
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);
#else
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
- set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
- set_gdbarch_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
#endif
- set_gdbarch_call_dummy_stack_adjust (gdbarch, 68);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
+ set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
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_push_arguments (gdbarch, sparc32_push_arguments);
- set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
- 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_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_push_arguments (gdbarch, sparc32_push_arguments);
+
+ 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_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_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
+ set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
#else
- set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+ set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif
- set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
- set_gdbarch_store_struct_return (gdbarch, sparc32_store_struct_return);
+ 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_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_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
- set_gdbarch_call_dummy_length (gdbarch, 192);
+ 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_call_dummy_start_offset (gdbarch, 148);
- set_gdbarch_call_dummy_words (gdbarch, call_dummy_64);
+ set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);
#else
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
- set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
- set_gdbarch_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
#endif
- set_gdbarch_call_dummy_stack_adjust (gdbarch, 128);
+ set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
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_push_arguments (gdbarch, sparc64_push_arguments);
+ set_gdbarch_deprecated_push_arguments (gdbarch, sparc64_push_arguments);
/* NOTE different for at_entry */
- set_gdbarch_read_fp (gdbarch, sparc64_read_fp);
+ set_gdbarch_deprecated_target_read_fp (gdbarch, sparc64_read_fp);
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_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_byte (gdbarch, sparc64_register_byte);
+ set_gdbarch_deprecated_register_raw_size (gdbarch, sparc64_register_size);
+ set_gdbarch_deprecated_register_size (gdbarch, 8);
+ 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_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
+ set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
#else
- set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+ set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif
- set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
- set_gdbarch_store_struct_return (gdbarch, sparc64_store_struct_return);
+ 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,
sparc64_use_struct_convention);
- set_gdbarch_write_sp (gdbarch, sparc64_write_sp);
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, sparc64_write_sp);
tdep->y_regnum = SPARC64_Y_REGNUM;
tdep->fp_max_regnum = SPARC_FP0_REGNUM + 48;
tdep->intreg_size = 8;
switch (info.bfd_arch_info->mach)
{
case bfd_mach_sparc:
- set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+ set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
+ set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
set_gdbarch_num_regs (gdbarch, 72);
- set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
+ set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
set_gdbarch_register_name (gdbarch, sparc32_register_name);
- set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
- tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#if 0
+ // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#endif
tdep->fp_register_bytes = 32 * 4;
tdep->print_insn_mach = bfd_mach_sparc;
break;
- case bfd_mach_sparc_sparclet:
- set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
- set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
- set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
- set_gdbarch_register_name (gdbarch, sparclet_register_name);
- set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
- tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
- tdep->fp_register_bytes = 0;
- tdep->print_insn_mach = bfd_mach_sparc_sparclet;
- break;
- case bfd_mach_sparc_sparclite:
- set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
- set_gdbarch_num_regs (gdbarch, 80);
- set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
- set_gdbarch_register_name (gdbarch, sparclite_register_name);
- set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
- tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
- tdep->fp_register_bytes = 0;
- tdep->print_insn_mach = bfd_mach_sparc_sparclite;
- break;
+#if 0
+ // OBSOLETE case bfd_mach_sparc_sparclet:
+ // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
+ // OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
+ // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
+ // OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
+ // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
+ // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
+ // OBSOLETE tdep->fp_register_bytes = 0;
+ // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
+ // OBSOLETE break;
+#endif
+#if 0
+ // OBSOLETE case bfd_mach_sparc_sparclite:
+ // OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+ // OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
+ // OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
+ // OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
+ // OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
+ // OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
+ // OBSOLETE tdep->fp_register_bytes = 0;
+ // OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
+ // OBSOLETE break;
+#endif
case bfd_mach_sparc_v8plus:
- set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+ set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
+ set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
set_gdbarch_num_regs (gdbarch, 72);
- set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
+ set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
set_gdbarch_register_name (gdbarch, sparc32_register_name);
- set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
tdep->print_insn_mach = bfd_mach_sparc;
tdep->fp_register_bytes = 32 * 4;
- tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#if 0
+ // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#endif
break;
case bfd_mach_sparc_v8plusa:
- set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+ set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
+ set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
set_gdbarch_num_regs (gdbarch, 72);
- set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
+ set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
set_gdbarch_register_name (gdbarch, sparc32_register_name);
- set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
- tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#if 0
+ // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#endif
tdep->fp_register_bytes = 32 * 4;
tdep->print_insn_mach = bfd_mach_sparc;
break;
- case bfd_mach_sparc_sparclite_le:
- set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
- set_gdbarch_num_regs (gdbarch, 80);
- set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
- set_gdbarch_register_name (gdbarch, sparclite_register_name);
- set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
- tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
- tdep->fp_register_bytes = 0;
- tdep->print_insn_mach = bfd_mach_sparc_sparclite;
- break;
+#if 0
+// OBSOLETE case bfd_mach_sparc_sparclite_le:
+// OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
+// OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
+// OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
+// OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
+// OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
+// OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
+// OBSOLETE tdep->fp_register_bytes = 0;
+// OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
+// OBSOLETE break;
+#endif
case bfd_mach_sparc_v9:
set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
set_gdbarch_num_regs (gdbarch, 125);
- set_gdbarch_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
+ set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
set_gdbarch_register_name (gdbarch, sparc64_register_name);
set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
- tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#if 0
+ // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#endif
tdep->fp_register_bytes = 64 * 4;
tdep->print_insn_mach = bfd_mach_sparc_v9a;
break;
case bfd_mach_sparc_v9a:
set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
set_gdbarch_num_regs (gdbarch, 125);
- set_gdbarch_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
+ set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
set_gdbarch_register_name (gdbarch, sparc64_register_name);
set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
- tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#if 0
+ // OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
+#endif
tdep->fp_register_bytes = 64 * 4;
tdep->print_insn_mach = bfd_mach_sparc_v9a;
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);
if (tdep == NULL)
return;
- fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
- tdep->has_fpu);
+#if 0
+ // OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
+ // OBSOLETE tdep->has_fpu);
+#endif
fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
tdep->fp_register_bytes);
fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",
projects / deliverable / binutils-gdb.git / blobdiff