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); } }