1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include "arch-utils.h"
28 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
29 #include "gdb_string.h"
31 #include "gdb_assert.h"
32 #include "sim-regno.h"
35 #include "target-descriptions.h"
39 #include "floatformat.h"
42 always_use_struct_convention (int gcc_p, struct type *value_type)
47 enum return_value_convention
48 legacy_return_value (struct gdbarch *gdbarch, struct type *valtype,
49 struct regcache *regcache, gdb_byte *readbuf,
50 const gdb_byte *writebuf)
52 /* NOTE: cagney/2004-06-13: The gcc_p parameter to
53 USE_STRUCT_CONVENTION isn't used. */
54 int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
55 || TYPE_CODE (valtype) == TYPE_CODE_UNION
56 || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
57 && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype));
61 gdb_assert (!struct_return);
62 /* NOTE: cagney/2004-06-13: See stack.c:return_command. Old
63 architectures don't expect STORE_RETURN_VALUE to handle small
64 structures. Should not be called with such types. */
65 gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT
66 && TYPE_CODE (valtype) != TYPE_CODE_UNION);
67 STORE_RETURN_VALUE (valtype, regcache, writebuf);
72 gdb_assert (!struct_return);
73 EXTRACT_RETURN_VALUE (valtype, regcache, readbuf);
77 return RETURN_VALUE_STRUCT_CONVENTION;
79 return RETURN_VALUE_REGISTER_CONVENTION;
83 legacy_register_sim_regno (int regnum)
85 /* Only makes sense to supply raw registers. */
86 gdb_assert (regnum >= 0 && regnum < NUM_REGS);
87 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
88 suspected that some GDB/SIM combinations may rely on this
89 behavour. The default should be one2one_register_sim_regno
91 if (REGISTER_NAME (regnum) != NULL
92 && REGISTER_NAME (regnum)[0] != '\0')
95 return LEGACY_SIM_REGNO_IGNORE;
99 generic_skip_trampoline_code (CORE_ADDR pc)
105 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
111 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
117 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
123 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
124 struct regcache *regcache,
125 CORE_ADDR gdb_addr, int gdb_len,
126 CORE_ADDR * rem_addr, int *rem_len)
128 *rem_addr = gdb_addr;
132 /* Helper functions for INNER_THAN */
135 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
141 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
146 /* Misc helper functions for targets. */
149 core_addr_identity (CORE_ADDR addr)
155 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
156 struct target_ops *targ)
162 no_op_reg_to_regnum (int reg)
168 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
174 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
180 cannot_register_not (int regnum)
185 /* Legacy version of target_virtual_frame_pointer(). Assumes that
186 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
190 legacy_virtual_frame_pointer (CORE_ADDR pc,
192 LONGEST *frame_offset)
194 /* FIXME: cagney/2002-09-13: This code is used when identifying the
195 frame pointer of the current PC. It is assuming that a single
196 register and an offset can determine this. I think it should
197 instead generate a byte code expression as that would work better
198 with things like Dwarf2's CFI. */
199 if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
200 *frame_regnum = DEPRECATED_FP_REGNUM;
201 else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
202 *frame_regnum = SP_REGNUM;
204 /* Should this be an internal error? I guess so, it is reflecting
205 an architectural limitation in the current design. */
206 internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
210 /* Assume the world is sane, every register's virtual and real size
214 generic_register_size (int regnum)
216 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
217 return TYPE_LENGTH (register_type (current_gdbarch, regnum));
220 /* Assume all registers are adjacent. */
223 generic_register_byte (int regnum)
227 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
229 for (i = 0; i < regnum; i++)
231 byte += generic_register_size (i);
238 generic_convert_register_p (int regnum, struct type *type)
244 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
250 generic_instruction_nullified (struct gdbarch *gdbarch,
251 struct regcache *regcache)
257 default_remote_register_number (struct gdbarch *gdbarch,
264 /* Functions to manipulate the endianness of the target. */
266 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
268 static const char endian_big[] = "big";
269 static const char endian_little[] = "little";
270 static const char endian_auto[] = "auto";
271 static const char *endian_enum[] =
278 static const char *set_endian_string;
281 selected_byte_order (void)
283 if (target_byte_order_user != BFD_ENDIAN_UNKNOWN)
284 return TARGET_BYTE_ORDER;
286 return BFD_ENDIAN_UNKNOWN;
289 /* Called by ``show endian''. */
292 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
295 if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
296 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
297 fprintf_unfiltered (file, _("The target endianness is set automatically "
298 "(currently big endian)\n"));
300 fprintf_unfiltered (file, _("The target endianness is set automatically "
301 "(currently little endian)\n"));
303 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
304 fprintf_unfiltered (file,
305 _("The target is assumed to be big endian\n"));
307 fprintf_unfiltered (file,
308 _("The target is assumed to be little endian\n"));
312 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
314 struct gdbarch_info info;
316 gdbarch_info_init (&info);
318 if (set_endian_string == endian_auto)
320 target_byte_order_user = BFD_ENDIAN_UNKNOWN;
321 if (! gdbarch_update_p (info))
322 internal_error (__FILE__, __LINE__,
323 _("set_endian: architecture update failed"));
325 else if (set_endian_string == endian_little)
327 info.byte_order = BFD_ENDIAN_LITTLE;
328 if (! gdbarch_update_p (info))
329 printf_unfiltered (_("Little endian target not supported by GDB\n"));
331 target_byte_order_user = BFD_ENDIAN_LITTLE;
333 else if (set_endian_string == endian_big)
335 info.byte_order = BFD_ENDIAN_BIG;
336 if (! gdbarch_update_p (info))
337 printf_unfiltered (_("Big endian target not supported by GDB\n"));
339 target_byte_order_user = BFD_ENDIAN_BIG;
342 internal_error (__FILE__, __LINE__,
343 _("set_endian: bad value"));
345 show_endian (gdb_stdout, from_tty, NULL, NULL);
348 /* Given SELECTED, a currently selected BFD architecture, and
349 FROM_TARGET, a BFD architecture reported by the target description,
350 return what architecture to use. Either may be NULL; if both are
351 specified, we use the more specific. If the two are obviously
352 incompatible, warn the user. */
354 static const struct bfd_arch_info *
355 choose_architecture_for_target (const struct bfd_arch_info *selected,
356 const struct bfd_arch_info *from_target)
358 const struct bfd_arch_info *compat1, *compat2;
360 if (selected == NULL)
363 if (from_target == NULL)
366 /* struct bfd_arch_info objects are singletons: that is, there's
367 supposed to be exactly one instance for a given machine. So you
368 can tell whether two are equivalent by comparing pointers. */
369 if (from_target == selected)
372 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
373 incompatible. But if they are compatible, it returns the 'more
374 featureful' of the two arches. That is, if A can run code
375 written for B, but B can't run code written for A, then it'll
378 Some targets (e.g. MIPS as of 2006-12-04) don't fully
379 implement this, instead always returning NULL or the first
380 argument. We detect that case by checking both directions. */
382 compat1 = selected->compatible (selected, from_target);
383 compat2 = from_target->compatible (from_target, selected);
385 if (compat1 == NULL && compat2 == NULL)
387 warning (_("Selected architecture %s is not compatible "
388 "with reported target architecture %s"),
389 selected->printable_name, from_target->printable_name);
397 if (compat1 == compat2)
400 /* If the two didn't match, but one of them was a default architecture,
401 assume the more specific one is correct. This handles the case
402 where an executable or target description just says "mips", but
403 the other knows which MIPS variant. */
404 if (compat1->the_default)
406 if (compat2->the_default)
409 /* We have no idea which one is better. This is a bug, but not
410 a critical problem; warn the user. */
411 warning (_("Selected architecture %s is ambiguous with "
412 "reported target architecture %s"),
413 selected->printable_name, from_target->printable_name);
417 /* Functions to manipulate the architecture of the target */
419 enum set_arch { set_arch_auto, set_arch_manual };
421 static const struct bfd_arch_info *target_architecture_user;
423 static const char *set_architecture_string;
426 selected_architecture_name (void)
428 if (target_architecture_user == NULL)
431 return set_architecture_string;
434 /* Called if the user enters ``show architecture'' without an
438 show_architecture (struct ui_file *file, int from_tty,
439 struct cmd_list_element *c, const char *value)
442 arch = TARGET_ARCHITECTURE->printable_name;
443 if (target_architecture_user == NULL)
444 fprintf_filtered (file, _("\
445 The target architecture is set automatically (currently %s)\n"), arch);
447 fprintf_filtered (file, _("\
448 The target architecture is assumed to be %s\n"), arch);
452 /* Called if the user enters ``set architecture'' with or without an
456 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
458 struct gdbarch_info info;
460 gdbarch_info_init (&info);
462 if (strcmp (set_architecture_string, "auto") == 0)
464 target_architecture_user = NULL;
465 if (!gdbarch_update_p (info))
466 internal_error (__FILE__, __LINE__,
467 _("could not select an architecture automatically"));
471 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
472 if (info.bfd_arch_info == NULL)
473 internal_error (__FILE__, __LINE__,
474 _("set_architecture: bfd_scan_arch failed"));
475 if (gdbarch_update_p (info))
476 target_architecture_user = info.bfd_arch_info;
478 printf_unfiltered (_("Architecture `%s' not recognized.\n"),
479 set_architecture_string);
481 show_architecture (gdb_stdout, from_tty, NULL, NULL);
484 /* Try to select a global architecture that matches "info". Return
485 non-zero if the attempt succeds. */
487 gdbarch_update_p (struct gdbarch_info info)
489 struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
491 /* If there no architecture by that name, reject the request. */
492 if (new_gdbarch == NULL)
495 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
496 "Architecture not found\n");
500 /* If it is the same old architecture, accept the request (but don't
502 if (new_gdbarch == current_gdbarch)
505 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
506 "Architecture 0x%08lx (%s) unchanged\n",
508 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
512 /* It's a new architecture, swap it in. */
514 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
515 "New architecture 0x%08lx (%s) selected\n",
517 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
518 deprecated_current_gdbarch_select_hack (new_gdbarch);
523 /* Return the architecture for ABFD. If no suitable architecture
524 could be find, return NULL. */
527 gdbarch_from_bfd (bfd *abfd)
529 struct gdbarch *old_gdbarch = current_gdbarch;
530 struct gdbarch *new_gdbarch;
531 struct gdbarch_info info;
533 /* If we call gdbarch_find_by_info without filling in info.abfd,
534 then it will use the global exec_bfd. That's fine if we don't
535 have one of those either. And that's the only time we should
536 reach here with a NULL ABFD argument - when we are discarding
538 gdb_assert (abfd != NULL || exec_bfd == NULL);
540 gdbarch_info_init (&info);
542 return gdbarch_find_by_info (info);
545 /* Set the dynamic target-system-dependent parameters (architecture,
546 byte-order) using information found in the BFD */
549 set_gdbarch_from_file (bfd *abfd)
551 struct gdbarch *gdbarch;
553 gdbarch = gdbarch_from_bfd (abfd);
555 error (_("Architecture of file not recognized."));
556 deprecated_current_gdbarch_select_hack (gdbarch);
559 /* Initialize the current architecture. Update the ``set
560 architecture'' command so that it specifies a list of valid
563 #ifdef DEFAULT_BFD_ARCH
564 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
565 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
567 static const bfd_arch_info_type *default_bfd_arch;
570 #ifdef DEFAULT_BFD_VEC
571 extern const bfd_target DEFAULT_BFD_VEC;
572 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
574 static const bfd_target *default_bfd_vec;
577 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
580 initialize_current_architecture (void)
582 const char **arches = gdbarch_printable_names ();
584 /* determine a default architecture and byte order. */
585 struct gdbarch_info info;
586 gdbarch_info_init (&info);
588 /* Find a default architecture. */
589 if (default_bfd_arch == NULL)
591 /* Choose the architecture by taking the first one
593 const char *chosen = arches[0];
595 for (arch = arches; *arch != NULL; arch++)
597 if (strcmp (*arch, chosen) < 0)
601 internal_error (__FILE__, __LINE__,
602 _("initialize_current_architecture: No arch"));
603 default_bfd_arch = bfd_scan_arch (chosen);
604 if (default_bfd_arch == NULL)
605 internal_error (__FILE__, __LINE__,
606 _("initialize_current_architecture: Arch not found"));
609 info.bfd_arch_info = default_bfd_arch;
611 /* Take several guesses at a byte order. */
612 if (default_byte_order == BFD_ENDIAN_UNKNOWN
613 && default_bfd_vec != NULL)
615 /* Extract BFD's default vector's byte order. */
616 switch (default_bfd_vec->byteorder)
619 default_byte_order = BFD_ENDIAN_BIG;
621 case BFD_ENDIAN_LITTLE:
622 default_byte_order = BFD_ENDIAN_LITTLE;
628 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
630 /* look for ``*el-*'' in the target name. */
632 chp = strchr (target_name, '-');
634 && chp - 2 >= target_name
635 && strncmp (chp - 2, "el", 2) == 0)
636 default_byte_order = BFD_ENDIAN_LITTLE;
638 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
640 /* Wire it to big-endian!!! */
641 default_byte_order = BFD_ENDIAN_BIG;
644 info.byte_order = default_byte_order;
646 if (! gdbarch_update_p (info))
647 internal_error (__FILE__, __LINE__,
648 _("initialize_current_architecture: Selection of "
649 "initial architecture failed"));
651 /* Create the ``set architecture'' command appending ``auto'' to the
652 list of architectures. */
654 struct cmd_list_element *c;
655 /* Append ``auto''. */
657 for (nr = 0; arches[nr] != NULL; nr++);
658 arches = xrealloc (arches, sizeof (char*) * (nr + 2));
659 arches[nr + 0] = "auto";
660 arches[nr + 1] = NULL;
661 add_setshow_enum_cmd ("architecture", class_support,
662 arches, &set_architecture_string, _("\
663 Set architecture of target."), _("\
664 Show architecture of target."), NULL,
665 set_architecture, show_architecture,
666 &setlist, &showlist);
667 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
672 /* Initialize a gdbarch info to values that will be automatically
673 overridden. Note: Originally, this ``struct info'' was initialized
674 using memset(0). Unfortunately, that ran into problems, namely
675 BFD_ENDIAN_BIG is zero. An explicit initialization function that
676 can explicitly set each field to a well defined value is used. */
679 gdbarch_info_init (struct gdbarch_info *info)
681 memset (info, 0, sizeof (struct gdbarch_info));
682 info->byte_order = BFD_ENDIAN_UNKNOWN;
683 info->osabi = GDB_OSABI_UNINITIALIZED;
686 /* Similar to init, but this time fill in the blanks. Information is
687 obtained from the global "set ..." options and explicitly
688 initialized INFO fields. */
691 gdbarch_info_fill (struct gdbarch_info *info)
693 /* Check for the current file. */
694 if (info->abfd == NULL)
695 info->abfd = exec_bfd;
697 /* Check for the current target description. */
698 if (info->target_desc == NULL)
699 info->target_desc = target_current_description ();
701 /* "(gdb) set architecture ...". */
702 if (info->bfd_arch_info == NULL
703 && target_architecture_user)
704 info->bfd_arch_info = target_architecture_user;
706 if (info->bfd_arch_info == NULL
707 && info->abfd != NULL
708 && bfd_get_arch (info->abfd) != bfd_arch_unknown
709 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
710 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
711 /* From the target. */
712 if (info->target_desc != NULL)
713 info->bfd_arch_info = choose_architecture_for_target
714 (info->bfd_arch_info, tdesc_architecture (info->target_desc));
715 /* From the default. */
716 if (info->bfd_arch_info == NULL)
717 info->bfd_arch_info = default_bfd_arch;
719 /* "(gdb) set byte-order ...". */
720 if (info->byte_order == BFD_ENDIAN_UNKNOWN
721 && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
722 info->byte_order = target_byte_order_user;
723 /* From the INFO struct. */
724 if (info->byte_order == BFD_ENDIAN_UNKNOWN
725 && info->abfd != NULL)
726 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
727 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
728 : BFD_ENDIAN_UNKNOWN);
729 /* From the default. */
730 if (info->byte_order == BFD_ENDIAN_UNKNOWN)
731 info->byte_order = default_byte_order;
733 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
734 if (info->osabi == GDB_OSABI_UNINITIALIZED)
735 info->osabi = gdbarch_lookup_osabi (info->abfd);
737 /* Must have at least filled in the architecture. */
738 gdb_assert (info->bfd_arch_info != NULL);
743 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
746 _initialize_gdbarch_utils (void)
748 struct cmd_list_element *c;
749 add_setshow_enum_cmd ("endian", class_support,
750 endian_enum, &set_endian_string, _("\
751 Set endianness of target."), _("\
752 Show endianness of target."), NULL,
753 set_endian, show_endian,
754 &setlist, &showlist);