X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Farch-utils.c;h=4ef616ae7110e2a3f7a8e2063f78283a56b8dd25;hb=c187492465e6fd60ebf2f4710944fa7b6a679a02;hp=1a38beca3aa685af5a7393e6376dc0ac62d051fc;hpb=22a44745e3c45871c3124196752c5b7bf0c593e3;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c index 1a38beca3a..4ef616ae71 100644 --- a/gdb/arch-utils.c +++ b/gdb/arch-utils.c @@ -1,13 +1,13 @@ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 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., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" @@ -32,93 +30,31 @@ #include "sim-regno.h" #include "gdbcore.h" #include "osabi.h" +#include "target-descriptions.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) -{ - gdb_byte *registers = deprecated_grub_regcache_for_registers (regcache); - gdb_byte *buf = valbuf; - DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */ -} - -/* 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) -{ - gdb_byte *b = alloca (TYPE_LENGTH (type)); - gdb_assert (regcache == current_regcache); - memcpy (b, buf, TYPE_LENGTH (type)); - DEPRECATED_STORE_RETURN_VALUE (type, b); -} - -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) -{ - /* 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)); - - 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); - } - - if (readbuf != NULL) - { - gdb_assert (!struct_return); - EXTRACT_RETURN_VALUE (valtype, regcache, readbuf); - } - - if (struct_return) - return RETURN_VALUE_STRUCT_CONVENTION; - else - return RETURN_VALUE_REGISTER_CONVENTION; -} int legacy_register_sim_regno (int regnum) { /* Only makes sense to supply raw registers. */ - gdb_assert (regnum >= 0 && regnum < NUM_REGS); + gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (current_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 (current_gdbarch, regnum) != NULL + && gdbarch_register_name (current_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; } @@ -141,17 +77,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,42 +91,6 @@ 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 @@ -241,7 +131,7 @@ cannot_register_not (int regnum) } /* 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 @@ -254,10 +144,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 (current_gdbarch) >= 0 + && gdbarch_deprecated_fp_regnum (current_gdbarch) + < gdbarch_num_regs (current_gdbarch)) + *frame_regnum = gdbarch_deprecated_fp_regnum (current_gdbarch); + else if (gdbarch_sp_regnum (current_gdbarch) >= 0 + && gdbarch_sp_regnum (current_gdbarch) + < gdbarch_num_regs (current_gdbarch)) + *frame_regnum = gdbarch_sp_regnum (current_gdbarch); else /* Should this be an internal error? I guess so, it is reflecting an architectural limitation in the current design. */ @@ -265,43 +159,7 @@ 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) { @@ -311,17 +169,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,27 +179,17 @@ 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. */ -/* ``target_byte_order'' is only used when non- multi-arch. - Multi-arch targets obtain the current byte order using the - TARGET_BYTE_ORDER gdbarch method. - - The choice of initial value is entirely arbitrary. During startup, - the function initialize_current_architecture() updates this value - based on default byte-order information extracted from BFD. */ -static int target_byte_order = BFD_ENDIAN_BIG; -static int target_byte_order_auto = 1; - -enum bfd_endian -selected_byte_order (void) -{ - if (target_byte_order_auto) - return BFD_ENDIAN_UNKNOWN; - else - return target_byte_order; -} +static int target_byte_order_user = BFD_ENDIAN_UNKNOWN; static const char endian_big[] = "big"; static const char endian_little[] = "little"; @@ -366,21 +203,30 @@ static const char *endian_enum[] = }; static const char *set_endian_string; +enum bfd_endian +selected_byte_order (void) +{ + if (target_byte_order_user != BFD_ENDIAN_UNKNOWN) + return gdbarch_byte_order (current_gdbarch); + else + return BFD_ENDIAN_UNKNOWN; +} + /* 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_auto) - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (target_byte_order_user == BFD_ENDIAN_UNKNOWN) + if (gdbarch_byte_order (current_gdbarch) == 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 (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) fprintf_unfiltered (file, _("The target is assumed to be big endian\n")); else @@ -391,46 +237,121 @@ show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c, 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_auto = 1; + 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) { - struct gdbarch_info info; - target_byte_order_auto = 0; - 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_user = BFD_ENDIAN_LITTLE; } else if (set_endian_string == endian_big) { - struct gdbarch_info info; - target_byte_order_auto = 0; - 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_user = BFD_ENDIAN_BIG; } else internal_error (__FILE__, __LINE__, _("set_endian: bad value")); + 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 }; -static int target_architecture_auto = 1; +static const struct bfd_arch_info *target_architecture_user; static const char *set_architecture_string; const char * selected_architecture_name (void) { - if (target_architecture_auto) + if (target_architecture_user == NULL) return NULL; else return set_architecture_string; @@ -444,8 +365,8 @@ 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_auto) + arch = gdbarch_bfd_arch_info (current_gdbarch)->printable_name; + if (target_architecture_user == NULL) fprintf_filtered (file, _("\ The target architecture is set automatically (currently %s)\n"), arch); else @@ -460,20 +381,25 @@ The target architecture is assumed to be %s\n"), arch); 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_auto = 1; + target_architecture_user = NULL; + if (!gdbarch_update_p (info)) + internal_error (__FILE__, __LINE__, + _("could not select an architecture automatically")); } else { - 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; + target_architecture_user = info.bfd_arch_info; else printf_unfiltered (_("Architecture `%s' not recognized.\n"), set_architecture_string); @@ -530,6 +456,13 @@ gdbarch_from_bfd (bfd *abfd) 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); @@ -567,6 +500,8 @@ static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC; static const bfd_target *default_bfd_vec; #endif +static int default_byte_order = BFD_ENDIAN_UNKNOWN; + void initialize_current_architecture (void) { @@ -577,10 +512,7 @@ initialize_current_architecture (void) 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) + if (default_bfd_arch == NULL) { /* Choose the architecture by taking the first one alphabetically. */ @@ -594,30 +526,32 @@ initialize_current_architecture (void) 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) + 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 (info.byte_order == BFD_ENDIAN_UNKNOWN + 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: - info.byte_order = BFD_ENDIAN_BIG; + default_byte_order = BFD_ENDIAN_BIG; break; case BFD_ENDIAN_LITTLE: - info.byte_order = BFD_ENDIAN_LITTLE; + default_byte_order = BFD_ENDIAN_LITTLE; break; default: break; } } - if (info.byte_order == BFD_ENDIAN_UNKNOWN) + if (default_byte_order == BFD_ENDIAN_UNKNOWN) { /* look for ``*el-*'' in the target name. */ const char *chp; @@ -625,14 +559,16 @@ initialize_current_architecture (void) if (chp != NULL && chp - 2 >= target_name && strncmp (chp - 2, "el", 2) == 0) - info.byte_order = BFD_ENDIAN_LITTLE; + default_byte_order = BFD_ENDIAN_LITTLE; } - if (info.byte_order == BFD_ENDIAN_UNKNOWN) + if (default_byte_order == BFD_ENDIAN_UNKNOWN) { /* Wire it to big-endian!!! */ - info.byte_order = BFD_ENDIAN_BIG; + default_byte_order = BFD_ENDIAN_BIG; } + info.byte_order = default_byte_order; + if (! gdbarch_update_p (info)) internal_error (__FILE__, __LINE__, _("initialize_current_architecture: Selection of " @@ -674,48 +610,57 @@ gdbarch_info_init (struct gdbarch_info *info) } /* Similar to init, but this time fill in the blanks. Information is - obtained from the specified architecture, global "set ..." options, - and explicitly initialized INFO fields. */ + obtained from the global "set ..." options and explicitly + initialized INFO fields. */ void -gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info) +gdbarch_info_fill (struct gdbarch_info *info) { + /* 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 (); + /* "(gdb) set architecture ...". */ if (info->bfd_arch_info == NULL - && !target_architecture_auto - && gdbarch != NULL) - info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch); + && 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); - if (info->bfd_arch_info == NULL - && gdbarch != NULL) - info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch); + /* 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; /* "(gdb) set byte-order ...". */ if (info->byte_order == BFD_ENDIAN_UNKNOWN - && !target_byte_order_auto - && gdbarch != NULL) - info->byte_order = gdbarch_byte_order (gdbarch); + && target_byte_order_user != BFD_ENDIAN_UNKNOWN) + info->byte_order = target_byte_order_user; /* From the INFO struct. */ if (info->byte_order == BFD_ENDIAN_UNKNOWN && info->abfd != NULL) info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG - : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE - : BFD_ENDIAN_UNKNOWN); - /* From the current target. */ - if (info->byte_order == BFD_ENDIAN_UNKNOWN - && gdbarch != NULL) - info->byte_order = gdbarch_byte_order (gdbarch); + : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE + : BFD_ENDIAN_UNKNOWN); + /* From the default. */ + if (info->byte_order == BFD_ENDIAN_UNKNOWN) + info->byte_order = default_byte_order; /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */ if (info->osabi == GDB_OSABI_UNINITIALIZED) info->osabi = gdbarch_lookup_osabi (info->abfd); - if (info->osabi == GDB_OSABI_UNINITIALIZED - && gdbarch != NULL) - info->osabi = gdbarch_osabi (gdbarch); /* Must have at least filled in the architecture. */ gdb_assert (info->bfd_arch_info != NULL);