/* Dynamic architecture support for GDB, the GNU debugger.
- Copyright 1998-1999, Free Software Foundation, Inc.
+ Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GDB.
/* Just include everything in sight so that the every old definition
of macro is visible. */
#include "gdb_string.h"
-#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcore.h"
#include "gdbcmd.h"
#include "target.h"
-#include "gdbthread.h"
#include "annotate.h"
-#include "symfile.h" /* for overlay functions */
#endif
+#include "regcache.h"
+#include "gdb_assert.h"
#include "version.h"
#include "floatformat.h"
-/* Convenience macro for allocting typesafe memory. */
-
-#ifndef XMALLOC
-#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
-#endif
-
-
/* 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,
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;
+}
+
char *
legacy_register_name (int i)
{
else
return names[i];
#else
- internal_error ("legacy_register_name: called.");
+ internal_error (__FILE__, __LINE__,
+ "legacy_register_name: called.");
return NULL;
#endif
}
#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 LITTLE_ENDIAN:
return &floatformat_ieee_single_little;
default:
- internal_error ("default_float_format: bad byte order");
+ internal_error (__FILE__, __LINE__,
+ "default_float_format: bad byte order");
}
}
case LITTLE_ENDIAN:
return &floatformat_ieee_double_little;
default:
- internal_error ("default_double_format: bad byte order");
+ internal_error (__FILE__, __LINE__,
+ "default_double_format: bad byte order");
}
}
return num;
}
+
+CORE_ADDR
+core_addr_identity (CORE_ADDR addr)
+{
+ return addr;
+}
+
+int
+no_op_reg_to_regnum (int reg)
+{
+ 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)
+{
+ return 0;
+}
+
+/* Generic prepare_to_proceed(). This one should be suitable for most
+ targets that support threads. */
+int
+generic_prepare_to_proceed (int select_it)
+{
+ ptid_t wait_ptid;
+ struct target_waitstatus wait_status;
+
+ /* Get the last target status returned by target_wait(). */
+ get_last_target_status (&wait_ptid, &wait_status);
+
+ /* Make sure we were stopped either at a breakpoint, or because
+ of a Ctrl-C. */
+ if (wait_status.kind != TARGET_WAITKIND_STOPPED
+ || (wait_status.value.sig != TARGET_SIGNAL_TRAP &&
+ wait_status.value.sig != TARGET_SIGNAL_INT))
+ {
+ return 0;
+ }
+
+ if (!ptid_equal (wait_ptid, minus_one_ptid)
+ && !ptid_equal (inferior_ptid, wait_ptid))
+ {
+ /* Switched over from WAIT_PID. */
+ CORE_ADDR wait_pc = read_pc_pid (wait_ptid);
+
+ if (wait_pc != read_pc ())
+ {
+ if (select_it)
+ {
+ /* Switch back to WAIT_PID thread. */
+ inferior_ptid = wait_ptid;
+
+ /* FIXME: This stuff came from switch_to_thread() in
+ thread.c (which should probably be a public function). */
+ flush_cached_frames ();
+ registers_changed ();
+ stop_pc = wait_pc;
+ select_frame (get_current_frame (), 0);
+ }
+ /* We return 1 to indicate that there is a breakpoint here,
+ so we need to step over it before continuing to avoid
+ hitting it straight away. */
+ if (breakpoint_here_p (wait_pc))
+ {
+ return 1;
+ }
+ }
+ }
+ return 0;
+
+}
+
+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;
+}
+\f
/* Functions to manipulate the endianness of the target. */
#ifdef TARGET_BYTE_ORDER_SELECTABLE
}
}
else
- internal_error ("set_endian: bad value");
+ internal_error (__FILE__, __LINE__,
+ "set_endian: bad value");
show_endian (NULL, from_tty);
}
set_endian_from_file (bfd *abfd)
{
if (GDB_MULTI_ARCH)
- internal_error ("set_endian_from_file: not for multi-arch");
+ internal_error (__FILE__, __LINE__,
+ "set_endian_from_file: not for multi-arch");
if (TARGET_BYTE_ORDER_SELECTABLE_P)
{
int want;
arch_ok (const struct bfd_arch_info *arch)
{
if (GDB_MULTI_ARCH)
- internal_error ("arch_ok: not multi-arched");
+ internal_error (__FILE__, __LINE__,
+ "arch_ok: not multi-arched");
/* Should be performing the more basic check that the binary is
compatible with GDB. */
/* Check with the target that the architecture is valid. */
enum set_arch type)
{
if (GDB_MULTI_ARCH)
- internal_error ("set_arch: not multi-arched");
+ internal_error (__FILE__, __LINE__,
+ "set_arch: not multi-arched");
switch (type)
{
case set_arch_auto:
{
const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
if (GDB_MULTI_ARCH)
- internal_error ("set_architecture_from_arch_mach: not multi-arched");
+ internal_error (__FILE__, __LINE__,
+ "set_architecture_from_arch_mach: not multi-arched");
if (wanted != NULL)
set_arch (wanted, set_arch_manual);
else
- internal_error ("gdbarch: hardwired architecture/machine not reconized");
+ internal_error (__FILE__, __LINE__,
+ "gdbarch: hardwired architecture/machine not recognized");
}
/* Set the architecture from a BFD (deprecated) */
{
const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
if (GDB_MULTI_ARCH)
- internal_error ("set_architecture_from_file: not multi-arched");
+ internal_error (__FILE__, __LINE__,
+ "set_architecture_from_file: not multi-arched");
if (target_architecture_auto)
{
set_arch (wanted, set_arch_auto);
memset (&info, 0, sizeof info);
info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
if (info.bfd_arch_info == NULL)
- internal_error ("set_architecture: bfd_scan_arch failed");
+ internal_error (__FILE__, __LINE__,
+ "set_architecture: bfd_scan_arch failed");
if (gdbarch_update_p (info))
target_architecture_auto = 0;
else
- printf_unfiltered ("Architecture `%s' not reconized.\n",
+ printf_unfiltered ("Architecture `%s' not recognized.\n",
set_architecture_string);
}
else
const struct bfd_arch_info *arch
= bfd_scan_arch (set_architecture_string);
if (arch == NULL)
- internal_error ("set_architecture: bfd_scan_arch failed");
+ internal_error (__FILE__, __LINE__,
+ "set_architecture: bfd_scan_arch failed");
set_arch (arch, set_arch_manual);
}
show_architecture (NULL, from_tty);
}
-/* Called if the user enters ``info architecture'' without an argument. */
-
-static void
-info_architecture (char *args, int from_tty)
-{
- printf_filtered ("Available architectures are:\n");
- if (GDB_MULTI_ARCH)
- {
- const char **arches = gdbarch_printable_names ();
- const char **arch;
- for (arch = arches; *arch != NULL; arch++)
- {
- printf_filtered (" %s", *arch);
- }
- free (arches);
- }
- else
- {
- enum bfd_architecture a;
- for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
- {
- const struct bfd_arch_info *ap;
- for (ap = bfd_lookup_arch (a, 0);
- ap != NULL;
- ap = ap->next)
- {
- printf_filtered (" %s", ap->printable_name);
- ap = ap->next;
- }
- }
- }
- printf_filtered ("\n");
-}
-
/* Set the dynamic target-system-dependent parameters (architecture,
byte-order) using information found in the BFD */
memset (&info, 0, sizeof info);
info.abfd = abfd;
if (! gdbarch_update_p (info))
- error ("Architecture of file not reconized.\n");
+ error ("Architecture of file not recognized.\n");
}
else
{
chosen = *arch;
}
if (chosen == NULL)
- internal_error ("initialize_current_architecture: No arch");
+ internal_error (__FILE__, __LINE__,
+ "initialize_current_architecture: No arch");
info.bfd_arch_info = bfd_scan_arch (chosen);
if (info.bfd_arch_info == NULL)
- internal_error ("initialize_current_architecture: Arch not found");
+ internal_error (__FILE__, __LINE__,
+ "initialize_current_architecture: Arch not found");
}
/* take several guesses at a byte order. */
{
if (! gdbarch_update_p (info))
{
- internal_error ("initialize_current_architecture: Selection of initial architecture failed");
+ internal_error (__FILE__, __LINE__,
+ "initialize_current_architecture: Selection of initial architecture failed");
}
}
+ else
+ initialize_non_multiarch ();
/* Create the ``set architecture'' command appending ``auto'' to the
list of architectures. */
current setting. */
add_cmd ("architecture", class_support, show_architecture,
"Show the current target architecture", &showlist);
- c = add_cmd ("architecture", class_support, info_architecture,
- "List supported target architectures", &infolist);
- deprecate_cmd (c, "set architecture");
}
}
projects / deliverable / binutils-gdb.git / blobdiff