/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
Inc.
This file is part of GDB.
#include "floatformat.h"
-/* Use the program counter to determine the contents and size
- of a breakpoint instruction. If no target-dependent macro
- BREAKPOINT_FROM_PC has been defined to implement this function,
- assume that the breakpoint doesn't depend on the PC, and
- use the values of the BIG_BREAKPOINT and LITTLE_BREAKPOINT macros.
- Return a pointer to a string of bytes that encode a breakpoint
- instruction, stores the length of the string to *lenptr,
- and optionally adjust the pc to point to the correct memory location
- for inserting the breakpoint. */
-
-const unsigned char *
-legacy_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
-{
- /* {BIG_,LITTLE_}BREAKPOINT is the sequence of bytes we insert for a
- breakpoint. On some machines, breakpoints are handled by the
- target environment and we don't have to worry about them here. */
-#ifdef BIG_BREAKPOINT
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- {
- static unsigned char big_break_insn[] = BIG_BREAKPOINT;
- *lenptr = sizeof (big_break_insn);
- return big_break_insn;
- }
-#endif
-#ifdef LITTLE_BREAKPOINT
- if (TARGET_BYTE_ORDER != BFD_ENDIAN_BIG)
- {
- static unsigned char little_break_insn[] = LITTLE_BREAKPOINT;
- *lenptr = sizeof (little_break_insn);
- return little_break_insn;
- }
-#endif
-#ifdef BREAKPOINT
- {
- static unsigned char break_insn[] = BREAKPOINT;
- *lenptr = sizeof (break_insn);
- return break_insn;
- }
-#endif
- *lenptr = 0;
- return NULL;
-}
-
/* Implementation of extract return value that grubs around in the
register cache. */
void
legacy_extract_return_value (struct type *type, struct regcache *regcache,
- char *valbuf)
+ void *valbuf)
{
char *registers = deprecated_grub_regcache_for_registers (regcache);
- DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, valbuf);
+ bfd_byte *buf = valbuf;
+ DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
}
+/* Implementation of store return value that grubs the register cache.
+ Takes a local copy of the buffer to avoid const problems. */
+void
+legacy_store_return_value (struct type *type, struct regcache *regcache,
+ const void *buf)
+{
+ bfd_byte *b = alloca (TYPE_LENGTH (type));
+ gdb_assert (regcache == current_regcache);
+ memcpy (b, buf, TYPE_LENGTH (type));
+ DEPRECATED_STORE_RETURN_VALUE (type, b);
+}
+
+
int
legacy_register_sim_regno (int regnum)
{
int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
void
-generic_remote_translate_xfer_address (CORE_ADDR gdb_addr, int gdb_len,
+generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
+ struct regcache *regcache,
+ CORE_ADDR gdb_addr, int gdb_len,
CORE_ADDR * rem_addr, int *rem_len)
{
*rem_addr = gdb_addr;
int
legacy_print_insn (bfd_vma vma, disassemble_info *info)
{
- return (*tm_print_insn) (vma, info);
+ return (*deprecated_tm_print_insn) (vma, info);
}
/* Helper functions for INNER_THAN */
return reg;
}
-/* For use by frame_args_address and frame_locals_address. */
-CORE_ADDR
-default_frame_address (struct frame_info *fi)
-{
- return fi->frame;
-}
-
/* Default prepare_to_procced(). */
int
default_prepare_to_proceed (int select_it)
}
-void
+CORE_ADDR
init_frame_pc_noop (int fromleaf, struct frame_info *prev)
{
- return;
+ /* Do nothing, implies return the same PC value. */
+ return get_frame_pc (prev);
}
-void
+CORE_ADDR
init_frame_pc_default (int fromleaf, struct frame_info *prev)
{
- if (fromleaf)
- prev->pc = SAVED_PC_AFTER_CALL (prev->next);
- else if (prev->next != NULL)
- prev->pc = FRAME_SAVED_PC (prev->next);
+ if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
+ return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
+ else if (get_next_frame (prev) != NULL)
+ return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
else
- prev->pc = read_pc ();
+ return read_pc ();
}
void
}
/* Legacy version of target_virtual_frame_pointer(). Assumes that
- there is an FP_REGNUM and that it is the same, cooked or raw. */
+ there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
+ raw. */
void
legacy_virtual_frame_pointer (CORE_ADDR pc,
int *frame_regnum,
LONGEST *frame_offset)
{
- gdb_assert (FP_REGNUM >= 0);
- *frame_regnum = FP_REGNUM;
+ /* FIXME: cagney/2002-09-13: This code is used when identifying the
+ frame pointer of the current PC. It is assuming that a single
+ register and an offset can determine this. I think it should
+ instead generate a byte code expression as that would work better
+ with things like Dwarf2's CFI. */
+ if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
+ *frame_regnum = DEPRECATED_FP_REGNUM;
+ else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
+ *frame_regnum = SP_REGNUM;
+ else
+ /* Should this be an internal error? I guess so, it is reflecting
+ an architectural limitation in the current design. */
+ internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
*frame_offset = 0;
}
generic_register_size (int regnum)
{
gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
- return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum));
+ if (gdbarch_register_type_p (current_gdbarch))
+ return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
+ else
+ /* FIXME: cagney/2003-03-01: Once all architectures implement
+ gdbarch_register_type(), this entire function can go away. It
+ is made obsolete by register_size(). */
+ return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
}
-#if !defined (IN_SIGTRAMP)
-#if defined (SIGTRAMP_START)
-#define IN_SIGTRAMP(pc, name) \
- ((pc) >= SIGTRAMP_START(pc) \
- && (pc) < SIGTRAMP_END(pc) \
- )
-#else
-#define IN_SIGTRAMP(pc, name) \
- (name && STREQ ("_sigtramp", name))
-#endif
-#endif
-
/* Assume all registers are adjacent. */
int
byte = 0;
for (i = 0; i < regnum; i++)
{
- byte += TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i));
+ byte += generic_register_size (i);
}
return byte;
}
int
legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
{
- return IN_SIGTRAMP(pc, name);
+#if !defined (IN_SIGTRAMP)
+ if (SIGTRAMP_START_P ())
+ return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
+ else
+ return name && strcmp ("_sigtramp", name) == 0;
+#else
+ return IN_SIGTRAMP (pc, name);
+#endif
}
int
{
memset (info, 0, sizeof (struct gdbarch_info));
info->byte_order = BFD_ENDIAN_UNKNOWN;
+ info->osabi = GDB_OSABI_UNINITIALIZED;
}
/* */