static void
set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
{
if (set_endian_string == endian_auto)
{
target_byte_order_auto = 1;
}
else if (set_endian_string == endian_little)
{
target_byte_order_auto = 0;
if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
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 = BFD_ENDIAN_LITTLE;
}
}
else if (set_endian_string == endian_big)
{
target_byte_order_auto = 0;
if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
info.byte_order = BFD_ENDIAN_BIG;
if (! gdbarch_update_p (info))
{
printf_unfiltered ("Big endian target not supported by GDB\n");
}
}
else
{
target_byte_order = BFD_ENDIAN_BIG;
}
}
else
internal_error (__FILE__, __LINE__,
"set_endian: bad value");
show_endian (NULL, from_tty);
}
void
darwin_check_osabi (darwin_inferior *inf, thread_t thread)
{
if (gdbarch_osabi (target_gdbarch) == GDB_OSABI_UNKNOWN)
{
/* Attaching to a process. Let's figure out what kind it is. */
x86_thread_state_t gp_regs;
struct gdbarch_info info;
unsigned int gp_count = x86_THREAD_STATE_COUNT;
kern_return_t ret;
ret = thread_get_state (thread, x86_THREAD_STATE,
(thread_state_t) &gp_regs, &gp_count);
if (ret != KERN_SUCCESS)
{
MACH_CHECK_ERROR (ret);
return;
}
gdbarch_info_init (&info);
gdbarch_info_fill (&info);
info.byte_order = gdbarch_byte_order (target_gdbarch);
info.osabi = GDB_OSABI_DARWIN;
if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_x86_64);
else
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_i386_i386);
gdbarch_update_p (info);
}
}
static void
set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
if (strcmp (set_architecture_string, "auto") == 0)
{
target_architecture_user = NULL;
if (!gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
_("could not select an architecture automatically"));
}
else
{
info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
if (info.bfd_arch_info == NULL)
internal_error (__FILE__, __LINE__,
_("set_architecture: bfd_scan_arch failed"));
if (gdbarch_update_p (info))
target_architecture_user = info.bfd_arch_info;
else
printf_unfiltered (_("Architecture `%s' not recognized.\n"),
set_architecture_string);
}
show_architecture (gdb_stdout, from_tty, NULL, NULL);
}
static void
set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
{
if (strcmp (set_architecture_string, "auto") == 0)
{
target_architecture_auto = 1;
}
else if (GDB_MULTI_ARCH)
{
struct gdbarch_info 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__,
"set_architecture: bfd_scan_arch failed");
if (gdbarch_update_p (info))
target_architecture_auto = 0;
else
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 (__FILE__, __LINE__,
"set_architecture: bfd_scan_arch failed");
set_arch (arch, set_arch_manual);
}
show_architecture (NULL, from_tty);
}
struct gdbarch *
gdbarch_from_bfd (bfd *abfd)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
info.abfd = abfd;
return gdbarch_find_by_info (info);
}
/* Find gdbarch for SPU context SPUFS_FD. */
static struct gdbarch *
spu_gdbarch (int spufs_fd)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_spu, bfd_mach_spu);
info.byte_order = BFD_ENDIAN_BIG;
info.osabi = GDB_OSABI_LINUX;
info.tdep_info = (struct gdbarch_tdep_info *)&spufs_fd;
return gdbarch_find_by_info (info);
}
void
rs6000_nat_target::create_inferior (const char *exec_file,
const std::string &allargs,
char **env, int from_tty)
{
enum bfd_architecture arch;
unsigned long mach;
bfd abfd;
struct gdbarch_info info;
inf_ptrace_target::create_inferior (exec_file, allargs, env, from_tty);
if (__power_rs ())
{
arch = bfd_arch_rs6000;
mach = bfd_mach_rs6k;
}
else
{
arch = bfd_arch_powerpc;
mach = bfd_mach_ppc;
}
/* FIXME: schauer/2002-02-25:
We don't know if we are executing a 32 or 64 bit executable,
and have no way to pass the proper word size to rs6000_gdbarch_init.
So we have to avoid switching to a new architecture, if the architecture
matches already.
Blindly calling rs6000_gdbarch_init used to work in older versions of
GDB, as rs6000_gdbarch_init incorrectly used the previous tdep to
determine the wordsize. */
if (exec_bfd)
{
const struct bfd_arch_info *exec_bfd_arch_info;
exec_bfd_arch_info = bfd_get_arch_info (exec_bfd);
if (arch == exec_bfd_arch_info->arch)
return;
}
bfd_default_set_arch_mach (&abfd, arch, mach);
gdbarch_info_init (&info);
info.bfd_arch_info = bfd_get_arch_info (&abfd);
info.abfd = exec_bfd;
if (!gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
_("rs6000_create_inferior: failed "
"to select architecture"));
}
static void
sh3e_open (char *args, int from_tty)
{
char *serial_port_name = args;
char *parallel_port_name = 0;
if (args)
{
char *cursor = serial_port_name = xstrdup (args);
while (*cursor && *cursor != ' ')
cursor++;
if (*cursor)
*cursor++ = 0;
while (*cursor == ' ')
cursor++;
if (*cursor)
parallel_port_name = cursor;
}
/* Set up the SH-3E monitor commands structure. */
memcpy (&sh3e_cmds, &sh3_cmds, sizeof (struct monitor_ops));
sh3e_cmds.target = &sh3e_ops;
sh3e_cmds.regnames = sh3e_regnames;
monitor_open (serial_port_name, &sh3e_cmds, from_tty);
if (parallel_port_name)
{
parallel = serial_open (parallel_port_name);
if (!parallel)
perror_with_name (_("Unable to open parallel port."));
parallel_in_use = 1;
}
/* If we connected successfully, we know the processor is an SH3E. */
{
struct gdbarch_info info;
gdbarch_info_init (&info);
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_sh, bfd_mach_sh3);
if (!gdbarch_update_p (info))
error (_("Target is not an SH3"));
}
}
void
set_gdbarch_from_file (bfd *abfd)
{
struct gdbarch_info info;
struct gdbarch *gdbarch;
gdbarch_info_init (&info);
info.abfd = abfd;
info.target_desc = target_current_description ();
gdbarch = gdbarch_find_by_info (info);
if (gdbarch == NULL)
error (_("Architecture of file not recognized."));
set_target_gdbarch (gdbarch);
}
void
set_gdbarch_from_file (bfd *abfd)
{
if (GDB_MULTI_ARCH)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
info.abfd = abfd;
if (! gdbarch_update_p (info))
error ("Architecture of file not recognized.\n");
}
else
{
set_architecture_from_file (abfd);
set_endian_from_file (abfd);
}
}
static void
set_osabi (char *args, int from_tty, struct cmd_list_element *c)
{
struct gdbarch_info info;
if (strcmp (set_osabi_string, "auto") == 0)
user_osabi_state = osabi_auto;
else if (strcmp (set_osabi_string, "default") == 0)
{
user_selected_osabi = GDB_OSABI_DEFAULT;
user_osabi_state = osabi_user;
}
else if (strcmp (set_osabi_string, "none") == 0)
{
user_selected_osabi = GDB_OSABI_UNKNOWN;
user_osabi_state = osabi_user;
}
else
{
int i;
for (i = 1; i < GDB_OSABI_INVALID; i++)
if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
{
user_selected_osabi = i;
user_osabi_state = osabi_user;
break;
}
if (i == GDB_OSABI_INVALID)
internal_error (__FILE__, __LINE__,
_("Invalid OS ABI \"%s\" passed to command handler."),
set_osabi_string);
}
/* NOTE: At some point (true multiple architectures) we'll need to be more
graceful here. */
gdbarch_info_init (&info);
if (! gdbarch_update_p (info))
internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
}
static void
set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
{
struct gdbarch_info info;
gdbarch_info_init (&info);
if (set_endian_string == endian_auto)
{
target_byte_order_user = BFD_ENDIAN_UNKNOWN;
if (! gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
_("set_endian: architecture update failed"));
}
else if (set_endian_string == endian_little)
{
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_user = BFD_ENDIAN_LITTLE;
}
else if (set_endian_string == endian_big)
{
info.byte_order = BFD_ENDIAN_BIG;
if (! gdbarch_update_p (info))
printf_unfiltered (_("Big endian target not supported by GDB\n"));
else
target_byte_order_user = BFD_ENDIAN_BIG;
}
else
internal_error (__FILE__, __LINE__,
_("set_endian: bad value"));
show_endian (gdb_stdout, from_tty, NULL, NULL);
}
void
initialize_current_architecture (void)
{
const char **arches = gdbarch_printable_names ();
struct gdbarch_info info;
/* determine a default architecture and byte order. */
gdbarch_info_init (&info);
/* Find a default architecture. */
if (default_bfd_arch == NULL)
{
/* Choose the architecture by taking the first one
alphabetically. */
const char *chosen = arches[0];
const char **arch;
for (arch = arches; *arch != NULL; arch++)
{
if (strcmp (*arch, chosen) < 0)
chosen = *arch;
}
if (chosen == NULL)
internal_error (__FILE__, __LINE__,
_("initialize_current_architecture: No arch"));
default_bfd_arch = bfd_scan_arch (chosen);
if (default_bfd_arch == NULL)
internal_error (__FILE__, __LINE__,
_("initialize_current_architecture: Arch not found"));
}
info.bfd_arch_info = default_bfd_arch;
/* Take several guesses at a byte order. */
if (default_byte_order == BFD_ENDIAN_UNKNOWN
&& default_bfd_vec != NULL)
{
/* Extract BFD's default vector's byte order. */
switch (default_bfd_vec->byteorder)
{
case BFD_ENDIAN_BIG:
default_byte_order = BFD_ENDIAN_BIG;
break;
case BFD_ENDIAN_LITTLE:
default_byte_order = BFD_ENDIAN_LITTLE;
break;
default:
break;
}
}
if (default_byte_order == BFD_ENDIAN_UNKNOWN)
{
/* look for ``*el-*'' in the target name. */
const char *chp;
chp = strchr (target_name, '-');
if (chp != NULL
&& chp - 2 >= target_name
&& startswith (chp - 2, "el"))
default_byte_order = BFD_ENDIAN_LITTLE;
}
if (default_byte_order == BFD_ENDIAN_UNKNOWN)
{
/* Wire it to big-endian!!! */
default_byte_order = BFD_ENDIAN_BIG;
}
info.byte_order = default_byte_order;
info.byte_order_for_code = info.byte_order;
if (! gdbarch_update_p (info))
internal_error (__FILE__, __LINE__,
_("initialize_current_architecture: Selection of "
"initial architecture failed"));
/* Create the ``set architecture'' command appending ``auto'' to the
list of architectures. */
{
/* Append ``auto''. */
int nr;
for (nr = 0; arches[nr] != NULL; nr++);
arches = xrealloc (arches, sizeof (char*) * (nr + 2));
arches[nr + 0] = "auto";
arches[nr + 1] = NULL;
add_setshow_enum_cmd ("architecture", class_support,
arches, &set_architecture_string,
_("Set architecture of target."),
_("Show architecture of target."), NULL,
set_architecture, show_architecture,
&setlist, &showlist);
add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
}
}
void
fetch_inferior_registers (int regno)
{
int current_pid;
thread_t current_thread;
int fetched = 0;
current_pid = ptid_get_pid (inferior_ptid);
current_thread = ptid_get_tid (inferior_ptid);
/* ifdef the following code so that gdb doesn't send the new
GDB_x86_THREAD_STATE constant when built on an older x86 MacOS X 10.4
system that won't recognize it. In Leopard this is unnecessary. */
if (TARGET_OSABI == GDB_OSABI_UNKNOWN)
{
/* Attaching to a process. Let's figure out what kind it is. */
gdb_x86_thread_state_t gp_regs;
struct gdbarch_info info;
unsigned int gp_count = GDB_x86_THREAD_STATE_COUNT;
kern_return_t ret = thread_get_state
(current_thread, GDB_x86_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered ("Error calling thread_get_state for GP registers for thread 0x%x\n", (int) current_thread);
MACH_CHECK_ERROR (ret);
}
gdbarch_info_init (&info);
gdbarch_info_fill (current_gdbarch, &info);
info.byte_order = gdbarch_byte_order (current_gdbarch);
if (gp_regs.tsh.flavor == GDB_x86_THREAD_STATE64)
{
info.osabi = GDB_OSABI_DARWIN64;
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386, bfd_mach_x86_64);
}
else
{
info.osabi = GDB_OSABI_DARWIN;
info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
bfd_mach_i386_i386);
}
gdbarch_update_p (info);
}
if (TARGET_OSABI == GDB_OSABI_DARWIN64)
{
if ((regno == -1) || IS_GP_REGNUM_64 (regno))
{
gdb_x86_thread_state_t gp_regs;
unsigned int gp_count = GDB_x86_THREAD_STATE_COUNT;
kern_return_t ret = thread_get_state
(current_thread, GDB_x86_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered ("Error calling thread_get_state for GP registers for thread 0x%x\n", (int) current_thread);
MACH_CHECK_ERROR (ret);
}
x86_64_macosx_fetch_gp_registers (&gp_regs.uts.ts64);
fetched++;
}
if ((regno == -1)
|| IS_FP_REGNUM_64 (regno)
|| IS_VP_REGNUM_64 (regno)
|| regno == REGS_64_MXCSR)
{
gdb_x86_float_state_t fp_regs;
unsigned int fp_count = GDB_x86_FLOAT_STATE_COUNT;
kern_return_t ret = thread_get_state
(current_thread, GDB_x86_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered ("Error calling thread_get_state for float registers for thread 0x%x\n", (int) current_thread);
MACH_CHECK_ERROR (ret);
}
x86_64_macosx_fetch_fp_registers (&fp_regs.ufs.fs64);
fetched++;
}
}
else
{
if ((regno == -1) || IS_GP_REGNUM (regno))
{
gdb_x86_thread_state_t gp_regs;
unsigned int gp_count = GDB_x86_THREAD_STATE_COUNT;
kern_return_t ret = thread_get_state
(current_thread, GDB_x86_THREAD_STATE, (thread_state_t) & gp_regs,
&gp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered ("Error calling thread_get_state for GP registers for thread 0x%x\n", (int) current_thread);
MACH_CHECK_ERROR (ret);
}
i386_macosx_fetch_gp_registers (&(gp_regs.uts.ts32));
fetched++;
}
if ((regno == -1)
|| IS_FP_REGNUM (regno)
|| i386_sse_regnum_p (current_gdbarch, regno)
|| i386_mxcsr_regnum_p (current_gdbarch, regno))
{
gdb_i386_float_state_t fp_regs;
unsigned int fp_count = GDB_i386_FLOAT_STATE_COUNT;
kern_return_t ret = thread_get_state
(current_thread, GDB_i386_FLOAT_STATE, (thread_state_t) & fp_regs,
&fp_count);
if (ret != KERN_SUCCESS)
{
printf_unfiltered ("Error calling thread_get_state for float registers for thread 0x%x\n", (int) current_thread);
MACH_CHECK_ERROR (ret);
}
i386_macosx_fetch_fp_registers (&fp_regs);
fetched++;
}
}
if (! fetched)
{
warning ("unknown register %d", regno);
regcache_raw_supply (current_regcache, regno, NULL);
}
}
void
initialize_current_architecture (void)
{
const char **arches = gdbarch_printable_names ();
/* determine a default architecture and byte order. */
struct gdbarch_info info;
gdbarch_info_init (&info);
/* Find a default architecture. */
if (info.bfd_arch_info == NULL
&& default_bfd_arch != NULL)
info.bfd_arch_info = default_bfd_arch;
if (info.bfd_arch_info == NULL)
{
/* Choose the architecture by taking the first one
alphabetically. */
const char *chosen = arches[0];
const char **arch;
for (arch = arches; *arch != NULL; arch++)
{
if (strcmp (*arch, chosen) < 0)
chosen = *arch;
}
if (chosen == NULL)
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 (__FILE__, __LINE__,
"initialize_current_architecture: Arch not found");
}
/* Take several guesses at a byte order. */
if (info.byte_order == BFD_ENDIAN_UNKNOWN
&& default_bfd_vec != NULL)
{
/* Extract BFD's default vector's byte order. */
switch (default_bfd_vec->byteorder)
{
case BFD_ENDIAN_BIG:
info.byte_order = BFD_ENDIAN_BIG;
break;
case BFD_ENDIAN_LITTLE:
info.byte_order = BFD_ENDIAN_LITTLE;
break;
default:
break;
}
}
if (info.byte_order == BFD_ENDIAN_UNKNOWN)
{
/* look for ``*el-*'' in the target name. */
const char *chp;
chp = strchr (target_name, '-');
if (chp != NULL
&& chp - 2 >= target_name
&& strncmp (chp - 2, "el", 2) == 0)
info.byte_order = BFD_ENDIAN_LITTLE;
}
if (info.byte_order == BFD_ENDIAN_UNKNOWN)
{
/* Wire it to big-endian!!! */
info.byte_order = BFD_ENDIAN_BIG;
}
if (GDB_MULTI_ARCH)
{
if (! gdbarch_update_p (info))
{
internal_error (__FILE__, __LINE__,
"initialize_current_architecture: Selection of initial architecture failed");
}
}
else
{
/* If the multi-arch logic comes up with a byte-order (from BFD)
use it for the non-multi-arch case. */
if (info.byte_order != BFD_ENDIAN_UNKNOWN)
target_byte_order = info.byte_order;
initialize_non_multiarch ();
}
/* Create the ``set architecture'' command appending ``auto'' to the
list of architectures. */
{
struct cmd_list_element *c;
/* Append ``auto''. */
int nr;
for (nr = 0; arches[nr] != NULL; nr++);
arches = xrealloc (arches, sizeof (char*) * (nr + 2));
arches[nr + 0] = "auto";
arches[nr + 1] = NULL;
/* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
of ``const char *''. We just happen to know that the casts are
safe. */
c = add_set_enum_cmd ("architecture", class_support,
arches, &set_architecture_string,
"Set architecture of target.",
&setlist);
set_cmd_sfunc (c, set_architecture);
add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
/* Don't use set_from_show - need to print both auto/manual and
current setting. */
add_cmd ("architecture", class_support, show_architecture,
"Show the current target architecture", &showlist);
}
}