X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Farch-utils.c;h=188dc9b6f7766934845246e99b56d8a61de44d8d;hb=59837fe086d095b2ce147ac6e3539f6843007f4f;hp=c1801c9a0f7fbad23c15e8e17d771396b05fd951;hpb=7a10774786f11bc9608da206f79d7d546d5685bb;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c index c1801c9a0f..188dc9b6f7 100644 --- a/gdb/arch-utils.c +++ b/gdb/arch-utils.c @@ -1,13 +1,13 @@ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 - Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, + 2008, 2009 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,9 +16,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" @@ -32,93 +30,83 @@ #include "sim-regno.h" #include "gdbcore.h" #include "osabi.h" +#include "target-descriptions.h" +#include "objfiles.h" #include "version.h" #include "floatformat.h" -/* Implementation of extract return value that grubs around in the - register cache. */ -void -legacy_extract_return_value (struct type *type, struct regcache *regcache, - gdb_byte *valbuf) + +struct displaced_step_closure * +simple_displaced_step_copy_insn (struct gdbarch *gdbarch, + CORE_ADDR from, CORE_ADDR to, + struct regcache *regs) { - gdb_byte *registers = deprecated_grub_regcache_for_registers (regcache); - gdb_byte *buf = valbuf; - DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */ + size_t len = gdbarch_max_insn_length (gdbarch); + gdb_byte *buf = xmalloc (len); + + read_memory (from, buf, len); + write_memory (to, buf, len); + + if (debug_displaced) + { + fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ", + paddress (gdbarch, from), paddress (gdbarch, to)); + displaced_step_dump_bytes (gdb_stdlog, buf, len); + } + + return (struct displaced_step_closure *) buf; } -/* 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 gdb_byte *buf) +simple_displaced_step_free_closure (struct gdbarch *gdbarch, + struct displaced_step_closure *closure) { - gdb_byte *b = alloca (TYPE_LENGTH (type)); - gdb_assert (regcache == current_regcache); - memcpy (b, buf, TYPE_LENGTH (type)); - DEPRECATED_STORE_RETURN_VALUE (type, b); + xfree (closure); } -int -always_use_struct_convention (int gcc_p, struct type *value_type) -{ - return 1; -} -enum return_value_convention -legacy_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, gdb_byte *readbuf, - const gdb_byte *writebuf) +CORE_ADDR +displaced_step_at_entry_point (struct gdbarch *gdbarch) { - /* NOTE: cagney/2004-06-13: The gcc_p parameter to - USE_STRUCT_CONVENTION isn't used. */ - int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT - || TYPE_CODE (valtype) == TYPE_CODE_UNION - || TYPE_CODE (valtype) == TYPE_CODE_ARRAY) - && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype)); + CORE_ADDR addr; + int bp_len; - if (writebuf != NULL) - { - gdb_assert (!struct_return); - /* NOTE: cagney/2004-06-13: See stack.c:return_command. Old - architectures don't expect STORE_RETURN_VALUE to handle small - structures. Should not be called with such types. */ - gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT - && TYPE_CODE (valtype) != TYPE_CODE_UNION); - STORE_RETURN_VALUE (valtype, regcache, writebuf); - } + addr = entry_point_address (); - if (readbuf != NULL) - { - gdb_assert (!struct_return); - EXTRACT_RETURN_VALUE (valtype, regcache, readbuf); - } + /* Make certain that the address points at real code, and not a + function descriptor. */ + addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target); - if (struct_return) - return RETURN_VALUE_STRUCT_CONVENTION; - else - return RETURN_VALUE_REGISTER_CONVENTION; + /* Inferior calls also use the entry point as a breakpoint location. + We don't want displaced stepping to interfere with those + breakpoints, so leave space. */ + gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len); + addr += bp_len * 2; + + return addr; } int -legacy_register_sim_regno (int regnum) +legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum) { /* Only makes sense to supply raw registers. */ - gdb_assert (regnum >= 0 && regnum < NUM_REGS); + gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)); /* NOTE: cagney/2002-05-13: The old code did it this way and it is suspected that some GDB/SIM combinations may rely on this behavour. The default should be one2one_register_sim_regno (below). */ - if (REGISTER_NAME (regnum) != NULL - && REGISTER_NAME (regnum)[0] != '\0') + if (gdbarch_register_name (gdbarch, regnum) != NULL + && gdbarch_register_name (gdbarch, regnum)[0] != '\0') return regnum; else return LEGACY_SIM_REGNO_IGNORE; } CORE_ADDR -generic_skip_trampoline_code (CORE_ADDR pc) +generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { return 0; } @@ -130,7 +118,8 @@ generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) } int -generic_in_solib_return_trampoline (CORE_ADDR pc, char *name) +generic_in_solib_return_trampoline (struct gdbarch *gdbarch, + CORE_ADDR pc, char *name) { return 0; } @@ -141,17 +130,7 @@ generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) return 0; } -void -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; - *rem_len = gdb_len; -} - -/* Helper functions for INNER_THAN */ +/* Helper functions for gdbarch_inner_than */ int core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs) @@ -165,46 +144,10 @@ core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs) return (lhs > rhs); } - -/* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */ - -const struct floatformat * -default_float_format (struct gdbarch *gdbarch) -{ - int byte_order = gdbarch_byte_order (gdbarch); - switch (byte_order) - { - case BFD_ENDIAN_BIG: - return &floatformat_ieee_single_big; - case BFD_ENDIAN_LITTLE: - return &floatformat_ieee_single_little; - default: - internal_error (__FILE__, __LINE__, - _("default_float_format: bad byte order")); - } -} - - -const struct floatformat * -default_double_format (struct gdbarch *gdbarch) -{ - int byte_order = gdbarch_byte_order (gdbarch); - switch (byte_order) - { - case BFD_ENDIAN_BIG: - return &floatformat_ieee_double_big; - case BFD_ENDIAN_LITTLE: - return &floatformat_ieee_double_little; - default: - internal_error (__FILE__, __LINE__, - _("default_double_format: bad byte order")); - } -} - /* Misc helper functions for targets. */ CORE_ADDR -core_addr_identity (CORE_ADDR addr) +core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr) { return addr; } @@ -217,7 +160,7 @@ convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr, } int -no_op_reg_to_regnum (int reg) +no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg) { return reg; } @@ -235,17 +178,18 @@ default_coff_make_msymbol_special (int val, struct minimal_symbol *msym) } int -cannot_register_not (int regnum) +cannot_register_not (struct gdbarch *gdbarch, int regnum) { return 0; } /* Legacy version of target_virtual_frame_pointer(). Assumes that - there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or + there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or raw. */ void -legacy_virtual_frame_pointer (CORE_ADDR pc, +legacy_virtual_frame_pointer (struct gdbarch *gdbarch, + CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset) { @@ -254,10 +198,14 @@ legacy_virtual_frame_pointer (CORE_ADDR pc, 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; + if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0 + && gdbarch_deprecated_fp_regnum (gdbarch) + < gdbarch_num_regs (gdbarch)) + *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch); + else if (gdbarch_sp_regnum (gdbarch) >= 0 + && gdbarch_sp_regnum (gdbarch) + < gdbarch_num_regs (gdbarch)) + *frame_regnum = gdbarch_sp_regnum (gdbarch); else /* Should this be an internal error? I guess so, it is reflecting an architectural limitation in the current design. */ @@ -265,45 +213,10 @@ legacy_virtual_frame_pointer (CORE_ADDR pc, *frame_offset = 0; } -/* Assume the world is sane, every register's virtual and real size - is identical. */ - -int -generic_register_size (int regnum) -{ - gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS); - return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum)); -} - -/* Assume all registers are adjacent. */ - -int -generic_register_byte (int regnum) -{ - int byte; - int i; - gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS); - byte = 0; - for (i = 0; i < regnum; i++) - { - byte += generic_register_size (i); - } - return byte; -} - int -legacy_pc_in_sigtramp (CORE_ADDR pc, char *name) -{ -#if defined (DEPRECATED_IN_SIGTRAMP) - return DEPRECATED_IN_SIGTRAMP (pc, name); -#else - return name && strcmp ("_sigtramp", name) == 0; -#endif -} - -int -generic_convert_register_p (int regnum, struct type *type) +generic_convert_register_p (struct gdbarch *gdbarch, int regnum, + struct type *type) { return 0; } @@ -311,17 +224,6 @@ generic_convert_register_p (int regnum, struct type *type) int default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) { - if (DEPRECATED_REG_STRUCT_HAS_ADDR_P () - && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type)) - { - CHECK_TYPEDEF (type); - - return (TYPE_CODE (type) == TYPE_CODE_STRUCT - || TYPE_CODE (type) == TYPE_CODE_UNION - || TYPE_CODE (type) == TYPE_CODE_SET - || TYPE_CODE (type) == TYPE_CODE_BITSTRING); - } - return 0; } @@ -332,6 +234,13 @@ generic_instruction_nullified (struct gdbarch *gdbarch, return 0; } +int +default_remote_register_number (struct gdbarch *gdbarch, + int regno) +{ + return regno; +} + /* Functions to manipulate the endianness of the target. */ @@ -349,21 +258,27 @@ static const char *endian_enum[] = }; static const char *set_endian_string; +enum bfd_endian +selected_byte_order (void) +{ + return target_byte_order_user; +} + /* Called by ``show endian''. */ static void show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - if (target_byte_order_user != BFD_ENDIAN_UNKNOWN) - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (target_byte_order_user == BFD_ENDIAN_UNKNOWN) + if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG) fprintf_unfiltered (file, _("The target endianness is set automatically " "(currently big endian)\n")); else fprintf_unfiltered (file, _("The target endianness is set automatically " "(currently little endian)\n")); else - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (target_byte_order_user == BFD_ENDIAN_BIG) fprintf_unfiltered (file, _("The target is assumed to be big endian\n")); else @@ -408,6 +323,75 @@ set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) show_endian (gdb_stdout, from_tty, NULL, NULL); } +/* Given SELECTED, a currently selected BFD architecture, and + FROM_TARGET, a BFD architecture reported by the target description, + return what architecture to use. Either may be NULL; if both are + specified, we use the more specific. If the two are obviously + incompatible, warn the user. */ + +static const struct bfd_arch_info * +choose_architecture_for_target (const struct bfd_arch_info *selected, + const struct bfd_arch_info *from_target) +{ + const struct bfd_arch_info *compat1, *compat2; + + if (selected == NULL) + return from_target; + + if (from_target == NULL) + return selected; + + /* struct bfd_arch_info objects are singletons: that is, there's + supposed to be exactly one instance for a given machine. So you + can tell whether two are equivalent by comparing pointers. */ + if (from_target == selected) + return selected; + + /* BFD's 'A->compatible (A, B)' functions return zero if A and B are + incompatible. But if they are compatible, it returns the 'more + featureful' of the two arches. That is, if A can run code + written for B, but B can't run code written for A, then it'll + return A. + + Some targets (e.g. MIPS as of 2006-12-04) don't fully + implement this, instead always returning NULL or the first + argument. We detect that case by checking both directions. */ + + compat1 = selected->compatible (selected, from_target); + compat2 = from_target->compatible (from_target, selected); + + if (compat1 == NULL && compat2 == NULL) + { + warning (_("Selected architecture %s is not compatible " + "with reported target architecture %s"), + selected->printable_name, from_target->printable_name); + return selected; + } + + if (compat1 == NULL) + return compat2; + if (compat2 == NULL) + return compat1; + if (compat1 == compat2) + return compat1; + + /* If the two didn't match, but one of them was a default architecture, + assume the more specific one is correct. This handles the case + where an executable or target description just says "mips", but + the other knows which MIPS variant. */ + if (compat1->the_default) + return compat2; + if (compat2->the_default) + return compat1; + + /* We have no idea which one is better. This is a bug, but not + a critical problem; warn the user. */ + warning (_("Selected architecture %s is ambiguous with " + "reported target architecture %s"), + selected->printable_name, from_target->printable_name); + return selected; +} + /* Functions to manipulate the architecture of the target */ enum set_arch { set_arch_auto, set_arch_manual }; @@ -432,14 +416,13 @@ static void show_architecture (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - const char *arch; - arch = TARGET_ARCHITECTURE->printable_name; if (target_architecture_user == NULL) fprintf_filtered (file, _("\ -The target architecture is set automatically (currently %s)\n"), arch); +The target architecture is set automatically (currently %s)\n"), + gdbarch_bfd_arch_info (get_current_arch ())->printable_name); else fprintf_filtered (file, _("\ -The target architecture is assumed to be %s\n"), arch); +The target architecture is assumed to be %s\n"), set_architecture_string); } @@ -480,7 +463,19 @@ set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c) int gdbarch_update_p (struct gdbarch_info info) { - struct gdbarch *new_gdbarch = gdbarch_find_by_info (info); + struct gdbarch *new_gdbarch; + + /* Check for the current file. */ + if (info.abfd == NULL) + info.abfd = exec_bfd; + if (info.abfd == NULL) + info.abfd = core_bfd; + + /* Check for the current target description. */ + if (info.target_desc == NULL) + info.target_desc = target_current_description (); + + new_gdbarch = gdbarch_find_by_info (info); /* If there no architecture by that name, reject the request. */ if (new_gdbarch == NULL) @@ -493,12 +488,12 @@ gdbarch_update_p (struct gdbarch_info info) /* If it is the same old architecture, accept the request (but don't swap anything). */ - if (new_gdbarch == current_gdbarch) + if (new_gdbarch == target_gdbarch) { if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " - "Architecture 0x%08lx (%s) unchanged\n", - (long) new_gdbarch, + "Architecture %s (%s) unchanged\n", + host_address_to_string (new_gdbarch), gdbarch_bfd_arch_info (new_gdbarch)->printable_name); return 1; } @@ -506,10 +501,10 @@ gdbarch_update_p (struct gdbarch_info info) /* It's a new architecture, swap it in. */ if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " - "New architecture 0x%08lx (%s) selected\n", - (long) new_gdbarch, + "New architecture %s (%s) selected\n", + host_address_to_string (new_gdbarch), gdbarch_bfd_arch_info (new_gdbarch)->printable_name); - deprecated_current_gdbarch_select_hack (new_gdbarch); + deprecated_target_gdbarch_select_hack (new_gdbarch); return 1; } @@ -520,17 +515,7 @@ gdbarch_update_p (struct gdbarch_info info) struct gdbarch * gdbarch_from_bfd (bfd *abfd) { - struct gdbarch *old_gdbarch = current_gdbarch; - struct gdbarch *new_gdbarch; struct gdbarch_info info; - - /* If we call gdbarch_find_by_info without filling in info.abfd, - then it will use the global exec_bfd. That's fine if we don't - have one of those either. And that's the only time we should - reach here with a NULL ABFD argument - when we are discarding - the executable. */ - gdb_assert (abfd != NULL || exec_bfd == NULL); - gdbarch_info_init (&info); info.abfd = abfd; return gdbarch_find_by_info (info); @@ -542,12 +527,17 @@ gdbarch_from_bfd (bfd *abfd) void set_gdbarch_from_file (bfd *abfd) { + struct gdbarch_info info; struct gdbarch *gdbarch; - gdbarch = gdbarch_from_bfd (abfd); + 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.")); - deprecated_current_gdbarch_select_hack (gdbarch); + deprecated_target_gdbarch_select_hack (gdbarch); } /* Initialize the current architecture. Update the ``set @@ -636,6 +626,7 @@ initialize_current_architecture (void) } info.byte_order = default_byte_order; + info.byte_order_for_code = info.byte_order; if (! gdbarch_update_p (info)) internal_error (__FILE__, __LINE__, @@ -674,6 +665,7 @@ gdbarch_info_init (struct gdbarch_info *info) { memset (info, 0, sizeof (struct gdbarch_info)); info->byte_order = BFD_ENDIAN_UNKNOWN; + info->byte_order_for_code = info->byte_order; info->osabi = GDB_OSABI_UNINITIALIZED; } @@ -684,19 +676,20 @@ gdbarch_info_init (struct gdbarch_info *info) void gdbarch_info_fill (struct gdbarch_info *info) { - /* Check for the current file. */ - if (info->abfd == NULL) - info->abfd = exec_bfd; - /* "(gdb) set architecture ...". */ if (info->bfd_arch_info == NULL && target_architecture_user) info->bfd_arch_info = target_architecture_user; + /* From the file. */ if (info->bfd_arch_info == NULL && info->abfd != NULL && bfd_get_arch (info->abfd) != bfd_arch_unknown && bfd_get_arch (info->abfd) != bfd_arch_obscure) info->bfd_arch_info = bfd_get_arch_info (info->abfd); + /* From the target. */ + if (info->target_desc != NULL) + info->bfd_arch_info = choose_architecture_for_target + (info->bfd_arch_info, tdesc_architecture (info->target_desc)); /* From the default. */ if (info->bfd_arch_info == NULL) info->bfd_arch_info = default_bfd_arch; @@ -714,6 +707,7 @@ gdbarch_info_fill (struct gdbarch_info *info) /* From the default. */ if (info->byte_order == BFD_ENDIAN_UNKNOWN) info->byte_order = default_byte_order; + info->byte_order_for_code = info->byte_order; /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */ if (info->osabi == GDB_OSABI_UNINITIALIZED) @@ -723,6 +717,21 @@ gdbarch_info_fill (struct gdbarch_info *info) gdb_assert (info->bfd_arch_info != NULL); } +/* Return "current" architecture. If the target is running, this is the + architecture of the selected frame. Otherwise, the "current" architecture + defaults to the target architecture. + + This function should normally be called solely by the command interpreter + routines to determine the architecture to execute a command in. */ +struct gdbarch * +get_current_arch (void) +{ + if (has_stack_frames ()) + return get_frame_arch (get_selected_frame (NULL)); + else + return target_gdbarch; +} + /* */ extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */