X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Farch-utils.c;h=5a5963740492a81d2eef099c3616cbf436d8132d;hb=3be60c3d274d8a95d1e3c579c26140177b711d74;hp=38ad4862dd1a3cbeec7103d81212316bf65afcaf;hpb=2b0266504ed1d2f24c3ec40d12b4a3dcf0f8f184;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c index 38ad4862dd..5a59637404 100644 --- a/gdb/arch-utils.c +++ b/gdb/arch-utils.c @@ -1,7 +1,7 @@ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, - Inc. + Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software + Foundation, Inc. This file is part of GDB. @@ -30,6 +30,8 @@ #include "regcache.h" #include "gdb_assert.h" #include "sim-regno.h" +#include "gdbcore.h" +#include "osabi.h" #include "version.h" @@ -39,10 +41,10 @@ register cache. */ void legacy_extract_return_value (struct type *type, struct regcache *regcache, - void *valbuf) + gdb_byte *valbuf) { char *registers = deprecated_grub_regcache_for_registers (regcache); - bfd_byte *buf = valbuf; + gdb_byte *buf = valbuf; DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */ } @@ -50,21 +52,54 @@ legacy_extract_return_value (struct type *type, struct regcache *regcache, Takes a local copy of the buffer to avoid const problems. */ void legacy_store_return_value (struct type *type, struct regcache *regcache, - const void *buf) + const gdb_byte *buf) { - bfd_byte *b = alloca (TYPE_LENGTH (type)); + 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) @@ -82,26 +117,14 @@ legacy_register_sim_regno (int regnum) return LEGACY_SIM_REGNO_IGNORE; } -int -generic_frameless_function_invocation_not (struct frame_info *fi) -{ - return 0; -} - -int -generic_return_value_on_stack_not (struct type *type) -{ - return 0; -} - CORE_ADDR generic_skip_trampoline_code (CORE_ADDR pc) { return 0; } -int -generic_in_solib_call_trampoline (CORE_ADDR pc, char *name) +CORE_ADDR +generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) { return 0; } @@ -118,13 +141,6 @@ generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) return 0; } -#if defined (CALL_DUMMY) -LONGEST legacy_call_dummy_words[] = CALL_DUMMY; -#else -LONGEST legacy_call_dummy_words[1]; -#endif -int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words); - void generic_remote_translate_xfer_address (struct gdbarch *gdbarch, struct regcache *regcache, @@ -135,12 +151,6 @@ generic_remote_translate_xfer_address (struct gdbarch *gdbarch, *rem_len = gdb_len; } -int -generic_prologue_frameless_p (CORE_ADDR ip) -{ - return ip == SKIP_PROLOGUE (ip); -} - /* Helper functions for INNER_THAN */ int @@ -170,7 +180,7 @@ default_float_format (struct gdbarch *gdbarch) return &floatformat_ieee_single_little; default: internal_error (__FILE__, __LINE__, - "default_float_format: bad byte order"); + _("default_float_format: bad byte order")); } } @@ -187,34 +197,12 @@ default_double_format (struct gdbarch *gdbarch) return &floatformat_ieee_double_little; default: internal_error (__FILE__, __LINE__, - "default_double_format: bad byte order"); + _("default_double_format: bad byte order")); } } /* Misc helper functions for targets. */ -int -deprecated_register_convertible_not (int num) -{ - return 0; -} - - -/* Under some ABI's that specify the `struct convention' for returning - structures by value, by the time we've returned from the function, - the return value is sitting there in the caller's buffer, but GDB - has no way to find the address of that buffer. - - On such architectures, use this function as your - extract_struct_value_address method. When asked to a struct - returned by value in this fashion, GDB will print a nice error - message, instead of garbage. */ -CORE_ADDR -generic_cannot_extract_struct_value_address (char *dummy) -{ - return 0; -} - CORE_ADDR core_addr_identity (CORE_ADDR addr) { @@ -234,17 +222,6 @@ no_op_reg_to_regnum (int reg) return reg; } -CORE_ADDR -deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev) -{ - if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ()) - return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev)); - else if (get_next_frame (prev) != NULL) - return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev)); - else - return read_pc (); -} - void default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) { @@ -284,7 +261,7 @@ legacy_virtual_frame_pointer (CORE_ADDR pc, else /* Should this be an internal error? I guess so, it is reflecting an architectural limitation in the current design. */ - internal_error (__FILE__, __LINE__, "No virtual frame pointer available"); + internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); *frame_offset = 0; } @@ -295,13 +272,7 @@ int generic_register_size (int regnum) { gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS); - if (gdbarch_register_type_p (current_gdbarch)) - return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum)); - else - /* FIXME: cagney/2003-03-01: Once all architectures implement - gdbarch_register_type(), this entire function can go away. It - is made obsolete by register_size(). */ - return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */ + return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum)); } /* Assume all registers are adjacent. */ @@ -324,40 +295,17 @@ generic_register_byte (int regnum) int legacy_pc_in_sigtramp (CORE_ADDR pc, char *name) { -#if !defined (IN_SIGTRAMP) - if (SIGTRAMP_START_P ()) - return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc); - else - return name && strcmp ("_sigtramp", name) == 0; +#if defined (DEPRECATED_IN_SIGTRAMP) + return DEPRECATED_IN_SIGTRAMP (pc, name); #else - return IN_SIGTRAMP (pc, name); + return name && strcmp ("_sigtramp", name) == 0; #endif } int -legacy_convert_register_p (int regnum, struct type *type) -{ - return DEPRECATED_REGISTER_CONVERTIBLE (regnum); -} - -void -legacy_register_to_value (struct frame_info *frame, int regnum, - struct type *type, void *to) +generic_convert_register_p (int regnum, struct type *type) { - char from[MAX_REGISTER_SIZE]; - get_frame_register (frame, regnum, from); - DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to); -} - -void -legacy_value_to_register (struct frame_info *frame, int regnum, - struct type *type, const void *tmp) -{ - char to[MAX_REGISTER_SIZE]; - char *from = alloca (TYPE_LENGTH (type)); - memcpy (from, from, TYPE_LENGTH (type)); - DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to); - put_frame_register (frame, regnum, to); + return 0; } int @@ -377,6 +325,13 @@ default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) return 0; } +int +generic_instruction_nullified (struct gdbarch *gdbarch, + struct regcache *regcache) +{ + return 0; +} + /* Functions to manipulate the endianness of the target. */ @@ -387,8 +342,17 @@ default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) 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. */ -int target_byte_order = BFD_ENDIAN_BIG; -int target_byte_order_auto = 1; +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 const char endian_big[] = "big"; static const char endian_little[] = "little"; @@ -405,14 +369,23 @@ static const char *set_endian_string; /* Called by ``show endian''. */ static void -show_endian (char *args, int from_tty) -{ - if (TARGET_BYTE_ORDER_AUTO) - printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n", - (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little")); +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) + 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 - printf_unfiltered ("The target is assumed to be %s endian\n", - (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little")); + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + fprintf_unfiltered (file, + _("The target is assumed to be big endian\n")); + else + fprintf_unfiltered (file, + _("The target is assumed to be little endian\n")); } static void @@ -429,7 +402,7 @@ set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) 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"); + printf_unfiltered (_("Little endian target not supported by GDB\n")); } else if (set_endian_string == endian_big) { @@ -438,34 +411,46 @@ set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) 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"); + printf_unfiltered (_("Big endian target not supported by GDB\n")); } else internal_error (__FILE__, __LINE__, - "set_endian: bad value"); - show_endian (NULL, from_tty); + _("set_endian: bad value")); + show_endian (gdb_stdout, from_tty, NULL, NULL); } /* Functions to manipulate the architecture of the target */ enum set_arch { set_arch_auto, set_arch_manual }; -int target_architecture_auto = 1; +static int target_architecture_auto = 1; -const char *set_architecture_string; +static const char *set_architecture_string; + +const char * +selected_architecture_name (void) +{ + if (target_architecture_auto) + return NULL; + else + return set_architecture_string; +} /* Called if the user enters ``show architecture'' without an argument. */ static void -show_architecture (char *args, int from_tty) +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) - printf_filtered ("The target architecture is set automatically (currently %s)\n", arch); + fprintf_filtered (file, _("\ +The target architecture is set automatically (currently %s)\n"), arch); else - printf_filtered ("The target architecture is assumed to be %s\n", arch); + fprintf_filtered (file, _("\ +The target architecture is assumed to be %s\n"), arch); } @@ -486,39 +471,53 @@ set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c) 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"); + _("set_architecture: bfd_scan_arch failed")); if (gdbarch_update_p (info)) target_architecture_auto = 0; else - printf_unfiltered ("Architecture `%s' not recognized.\n", + printf_unfiltered (_("Architecture `%s' not recognized.\n"), set_architecture_string); } - show_architecture (NULL, from_tty); + show_architecture (gdb_stdout, from_tty, NULL, NULL); } -/* FIXME: kettenis/20031124: Of the functions that follow, only - gdbarch_from_bfd is supposed to survive. The others will - dissappear since in the future GDB will (hopefully) be truly - multi-arch. However, for now we're still stuck with the concept of - a single active architecture. */ +/* Try to select a global architecture that matches "info". Return + non-zero if the attempt succeds. */ +int +gdbarch_update_p (struct gdbarch_info info) +{ + struct gdbarch *new_gdbarch = gdbarch_find_by_info (info); -/* Make GDBARCH the currently selected architecture. */ + /* If there no architecture by that name, reject the request. */ + if (new_gdbarch == NULL) + { + if (gdbarch_debug) + fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " + "Architecture not found\n"); + return 0; + } -static void -deprecated_select_gdbarch_hack (struct gdbarch *gdbarch) -{ - 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 (gdbarch_debug) + fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " + "Architecture 0x%08lx (%s) unchanged\n", + (long) new_gdbarch, + gdbarch_bfd_arch_info (new_gdbarch)->printable_name); + return 1; + } - /* FIXME: kettenis/20031024: The only way to select a specific - architecture is to clone its `struct gdbarch_info', and update - according to that copy. This is gross, but significant work will - need to be done before we can take a more sane approach. */ - gdbarch_info_init (&info); - info.bfd_arch_info = gdbarch_bfd_arch_info (gdbarch); - info.byte_order = gdbarch_byte_order (gdbarch); - info.osabi = gdbarch_osabi (gdbarch); - gdbarch_update_p (info); - gdb_assert (gdbarch == current_gdbarch); + /* 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, + gdbarch_bfd_arch_info (new_gdbarch)->printable_name); + deprecated_current_gdbarch_select_hack (new_gdbarch); + + return 1; } /* Return the architecture for ABFD. If no suitable architecture @@ -531,19 +530,9 @@ gdbarch_from_bfd (bfd *abfd) struct gdbarch *new_gdbarch; struct gdbarch_info info; - /* FIXME: kettenis/20031024: The only way to find the architecture - for a certain BFD is by doing an architecture update. This - activates the architecture, so we need to reactivate the old - architecture. This is gross, but significant work will need to - be done before we can take a more sane approach. */ gdbarch_info_init (&info); info.abfd = abfd; - if (! gdbarch_update_p (info)) - return NULL; - - new_gdbarch = current_gdbarch; - deprecated_select_gdbarch_hack (old_gdbarch); - return new_gdbarch; + return gdbarch_find_by_info (info); } /* Set the dynamic target-system-dependent parameters (architecture, @@ -556,8 +545,8 @@ set_gdbarch_from_file (bfd *abfd) gdbarch = gdbarch_from_bfd (abfd); if (gdbarch == NULL) - error ("Architecture of file not recognized.\n"); - deprecated_select_gdbarch_hack (gdbarch); + error (_("Architecture of file not recognized.")); + deprecated_current_gdbarch_select_hack (gdbarch); } /* Initialize the current architecture. Update the ``set @@ -604,11 +593,11 @@ initialize_current_architecture (void) } if (chosen == NULL) internal_error (__FILE__, __LINE__, - "initialize_current_architecture: No arch"); + _("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"); + _("initialize_current_architecture: Arch not found")); } /* Take several guesses at a byte order. */ @@ -646,7 +635,8 @@ initialize_current_architecture (void) if (! gdbarch_update_p (info)) internal_error (__FILE__, __LINE__, - "initialize_current_architecture: Selection of initial architecture failed"); + _("initialize_current_architecture: Selection of " + "initial architecture failed")); /* Create the ``set architecture'' command appending ``auto'' to the list of architectures. */ @@ -658,19 +648,13 @@ initialize_current_architecture (void) 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_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); - /* 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); } } @@ -689,6 +673,54 @@ gdbarch_info_init (struct gdbarch_info *info) info->osabi = GDB_OSABI_UNINITIALIZED; } +/* 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. */ + +void +gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info) +{ + /* "(gdb) set architecture ...". */ + if (info->bfd_arch_info == NULL + && !target_architecture_auto + && gdbarch != NULL) + info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch); + 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); + + /* "(gdb) set byte-order ...". */ + if (info->byte_order == BFD_ENDIAN_UNKNOWN + && !target_byte_order_auto + && gdbarch != NULL) + info->byte_order = gdbarch_byte_order (gdbarch); + /* 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); + + /* "(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); +} + /* */ extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */ @@ -697,13 +729,10 @@ void _initialize_gdbarch_utils (void) { struct cmd_list_element *c; - c = add_set_enum_cmd ("endian", class_support, - endian_enum, &set_endian_string, - "Set endianness of target.", - &setlist); - set_cmd_sfunc (c, set_endian); - /* Don't use set_from_show - need to print both auto/manual and - current setting. */ - add_cmd ("endian", class_support, show_endian, - "Show the current byte-order", &showlist); + add_setshow_enum_cmd ("endian", class_support, + endian_enum, &set_endian_string, _("\ +Set endianness of target."), _("\ +Show endianness of target."), NULL, + set_endian, show_endian, + &setlist, &showlist); }