#include "defs.h"
#if GDB_MULTI_ARCH
+#include "arch-utils.h"
#include "gdbcmd.h"
#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
#else
#include "annotate.h"
#endif
#include "regcache.h"
+#include "gdb_assert.h"
#include "version.h"
return 0;
}
+CORE_ADDR
+generic_skip_trampoline_code (CORE_ADDR pc)
+{
+ return 0;
+}
+
+int
+generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
+{
+ return 0;
+}
+
+int
+generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+ return 0;
+}
+
char *
legacy_register_name (int i)
{
#endif
}
+/* New/multi-arched targets should use the correct gdbarch field
+ instead of using this global pointer. */
+int
+legacy_print_insn (bfd_vma vma, disassemble_info *info)
+{
+ return (*tm_print_insn) (vma, info);
+}
/* Helper functions for INNER_THAN */
{
case BIG_ENDIAN:
return &floatformat_ieee_single_big;
- case LITTLE_ENDIAN:
+ case BFD_ENDIAN_LITTLE:
return &floatformat_ieee_single_little;
default:
internal_error (__FILE__, __LINE__,
{
case BIG_ENDIAN:
return &floatformat_ieee_double_big;
- case LITTLE_ENDIAN:
+ case BFD_ENDIAN_LITTLE:
return &floatformat_ieee_double_little;
default:
internal_error (__FILE__, __LINE__,
}
+/* Under some ABI's that specify the `struct convention' for returning
+ structures by value, by the time we've returned from the function,
+ the return value is sitting there in the caller's buffer, but GDB
+ has no way to find the address of that buffer.
+
+ On such architectures, use this function as your
+ extract_struct_value_address method. When asked to a struct
+ returned by value in this fashion, GDB will print a nice error
+ message, instead of garbage. */
+CORE_ADDR
+generic_cannot_extract_struct_value_address (char *dummy)
+{
+ return 0;
+}
+
int
default_register_sim_regno (int num)
{
}
+void
+init_frame_pc_noop (int fromleaf, struct frame_info *prev)
+{
+ return;
+}
+
+void
+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);
+ else
+ prev->pc = read_pc ();
+}
+
+int
+cannot_register_not (int regnum)
+{
+ return 0;
+}
+
+/* Legacy version of target_virtual_frame_pointer(). Assumes that
+ there is an 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;
+ *frame_offset = 0;
+}
+
+/* Assume the world is flat. Every register is large enough to fit a
+ target integer. */
+
+int
+generic_register_raw_size (int regnum)
+{
+ gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
+ return TARGET_INT_BIT / HOST_CHAR_BIT;
+}
+
+/* Assume the virtual size corresponds to the virtual type. */
+
+int
+generic_register_virtual_size (int regnum)
+{
+ return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum));
+}
+
+\f
/* Functions to manipulate the endianness of the target. */
#ifdef TARGET_BYTE_ORDER_SELECTABLE
if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
- memset (&info, 0, sizeof info);
- info.byte_order = LITTLE_ENDIAN;
+ gdbarch_info_init (&info);
+ info.byte_order = BFD_ENDIAN_LITTLE;
if (! gdbarch_update_p (info))
{
printf_unfiltered ("Little endian target not supported by GDB\n");
}
else
{
- target_byte_order = LITTLE_ENDIAN;
+ target_byte_order = BFD_ENDIAN_LITTLE;
}
}
else if (set_endian_string == endian_big)
if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
- memset (&info, 0, sizeof info);
+ gdbarch_info_init (&info);
info.byte_order = BIG_ENDIAN;
if (! gdbarch_update_p (info))
{
if (bfd_big_endian (abfd))
want = BIG_ENDIAN;
else
- want = LITTLE_ENDIAN;
+ want = BFD_ENDIAN_LITTLE;
if (TARGET_BYTE_ORDER_AUTO)
target_byte_order = want;
else if (TARGET_BYTE_ORDER != want)
else if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
- memset (&info, 0, sizeof info);
+ gdbarch_info_init (&info);
info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
if (info.bfd_arch_info == NULL)
internal_error (__FILE__, __LINE__,
if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
- memset (&info, 0, sizeof info);
+ gdbarch_info_init (&info);
info.abfd = abfd;
if (! gdbarch_update_p (info))
error ("Architecture of file not recognized.\n");
/* determine a default architecture and byte order. */
struct gdbarch_info info;
- memset (&info, 0, sizeof (info));
+ gdbarch_info_init (&info);
/* Find a default architecture. */
if (info.bfd_arch_info == NULL
/* take several guesses at a byte order. */
/* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
forced above. */
- if (info.byte_order == 0
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN
&& default_bfd_vec != NULL)
{
/* Extract BFD's default vector's byte order. */
info.byte_order = BIG_ENDIAN;
break;
case BFD_ENDIAN_LITTLE:
- info.byte_order = LITTLE_ENDIAN;
+ info.byte_order = BFD_ENDIAN_LITTLE;
break;
default:
break;
}
}
- if (info.byte_order == 0)
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN)
{
/* look for ``*el-*'' in the target name. */
const char *chp;
if (chp != NULL
&& chp - 2 >= target_name
&& strncmp (chp - 2, "el", 2) == 0)
- info.byte_order = LITTLE_ENDIAN;
+ info.byte_order = BFD_ENDIAN_LITTLE;
}
- if (info.byte_order == 0)
+ if (info.byte_order == BFD_ENDIAN_UNKNOWN)
{
/* Wire it to big-endian!!! */
info.byte_order = BIG_ENDIAN;
}
+/* Initialize a gdbarch info to values that will be automatically
+ overridden. Note: Originally, this ``struct info'' was initialized
+ using memset(0). Unfortunatly, that ran into problems, namely
+ BFD_ENDIAN_BIG is zero. An explicit initialization function that
+ can explicitly set each field to a well defined value is used. */
+
+void
+gdbarch_info_init (struct gdbarch_info *info)
+{
+ memset (info, 0, sizeof (struct gdbarch_info));
+ info->byte_order = BFD_ENDIAN_UNKNOWN;
+}
+
/* */
extern initialize_file_ftype _initialize_gdbarch_utils;
projects / binutils-gdb.git / blobdiff