1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 2008, 2009 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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
26 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
27 #include "gdb_string.h"
29 #include "gdb_assert.h"
30 #include "sim-regno.h"
33 #include "target-descriptions.h"
38 #include "floatformat.h"
41 struct displaced_step_closure *
42 simple_displaced_step_copy_insn (struct gdbarch *gdbarch,
43 CORE_ADDR from, CORE_ADDR to,
44 struct regcache *regs)
46 size_t len = gdbarch_max_insn_length (gdbarch);
47 gdb_byte *buf = xmalloc (len);
49 read_memory (from, buf, len);
50 write_memory (to, buf, len);
54 fprintf_unfiltered (gdb_stdlog, "displaced: copy 0x%s->0x%s: ",
55 paddr_nz (from), paddr_nz (to));
56 displaced_step_dump_bytes (gdb_stdlog, buf, len);
59 return (struct displaced_step_closure *) buf;
64 simple_displaced_step_free_closure (struct gdbarch *gdbarch,
65 struct displaced_step_closure *closure)
72 displaced_step_at_entry_point (struct gdbarch *gdbarch)
77 addr = entry_point_address ();
79 /* Make certain that the address points at real code, and not a
80 function descriptor. */
81 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
83 /* Inferior calls also use the entry point as a breakpoint location.
84 We don't want displaced stepping to interfere with those
85 breakpoints, so leave space. */
86 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
93 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
95 /* Only makes sense to supply raw registers. */
96 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
97 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
98 suspected that some GDB/SIM combinations may rely on this
99 behavour. The default should be one2one_register_sim_regno
101 if (gdbarch_register_name (gdbarch, regnum) != NULL
102 && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
105 return LEGACY_SIM_REGNO_IGNORE;
109 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
115 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
121 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
127 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
132 /* Helper functions for gdbarch_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 (struct gdbarch *gdbarch, 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 (struct gdbarch *gdbarch, 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 (struct gdbarch *gdbarch, int regnum)
185 /* Legacy version of target_virtual_frame_pointer(). Assumes that
186 there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or
190 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
193 LONGEST *frame_offset)
195 /* FIXME: cagney/2002-09-13: This code is used when identifying the
196 frame pointer of the current PC. It is assuming that a single
197 register and an offset can determine this. I think it should
198 instead generate a byte code expression as that would work better
199 with things like Dwarf2's CFI. */
200 if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
201 && gdbarch_deprecated_fp_regnum (gdbarch)
202 < gdbarch_num_regs (gdbarch))
203 *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
204 else if (gdbarch_sp_regnum (gdbarch) >= 0
205 && gdbarch_sp_regnum (gdbarch)
206 < gdbarch_num_regs (gdbarch))
207 *frame_regnum = gdbarch_sp_regnum (gdbarch);
209 /* Should this be an internal error? I guess so, it is reflecting
210 an architectural limitation in the current design. */
211 internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
217 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
224 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
230 generic_instruction_nullified (struct gdbarch *gdbarch,
231 struct regcache *regcache)
237 default_remote_register_number (struct gdbarch *gdbarch,
244 /* Functions to manipulate the endianness of the target. */
246 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
248 static const char endian_big[] = "big";
249 static const char endian_little[] = "little";
250 static const char endian_auto[] = "auto";
251 static const char *endian_enum[] =
258 static const char *set_endian_string;
261 selected_byte_order (void)
263 return target_byte_order_user;
266 /* Called by ``show endian''. */
269 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
272 if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
273 if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
274 fprintf_unfiltered (file, _("The target endianness is set automatically "
275 "(currently big endian)\n"));
277 fprintf_unfiltered (file, _("The target endianness is set automatically "
278 "(currently little endian)\n"));
280 if (target_byte_order_user == BFD_ENDIAN_BIG)
281 fprintf_unfiltered (file,
282 _("The target is assumed to be big endian\n"));
284 fprintf_unfiltered (file,
285 _("The target is assumed to be little endian\n"));
289 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
291 struct gdbarch_info info;
293 gdbarch_info_init (&info);
295 if (set_endian_string == endian_auto)
297 target_byte_order_user = BFD_ENDIAN_UNKNOWN;
298 if (! gdbarch_update_p (info))
299 internal_error (__FILE__, __LINE__,
300 _("set_endian: architecture update failed"));
302 else if (set_endian_string == endian_little)
304 info.byte_order = BFD_ENDIAN_LITTLE;
305 if (! gdbarch_update_p (info))
306 printf_unfiltered (_("Little endian target not supported by GDB\n"));
308 target_byte_order_user = BFD_ENDIAN_LITTLE;
310 else if (set_endian_string == endian_big)
312 info.byte_order = BFD_ENDIAN_BIG;
313 if (! gdbarch_update_p (info))
314 printf_unfiltered (_("Big endian target not supported by GDB\n"));
316 target_byte_order_user = BFD_ENDIAN_BIG;
319 internal_error (__FILE__, __LINE__,
320 _("set_endian: bad value"));
322 show_endian (gdb_stdout, from_tty, NULL, NULL);
325 /* Given SELECTED, a currently selected BFD architecture, and
326 FROM_TARGET, a BFD architecture reported by the target description,
327 return what architecture to use. Either may be NULL; if both are
328 specified, we use the more specific. If the two are obviously
329 incompatible, warn the user. */
331 static const struct bfd_arch_info *
332 choose_architecture_for_target (const struct bfd_arch_info *selected,
333 const struct bfd_arch_info *from_target)
335 const struct bfd_arch_info *compat1, *compat2;
337 if (selected == NULL)
340 if (from_target == NULL)
343 /* struct bfd_arch_info objects are singletons: that is, there's
344 supposed to be exactly one instance for a given machine. So you
345 can tell whether two are equivalent by comparing pointers. */
346 if (from_target == selected)
349 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
350 incompatible. But if they are compatible, it returns the 'more
351 featureful' of the two arches. That is, if A can run code
352 written for B, but B can't run code written for A, then it'll
355 Some targets (e.g. MIPS as of 2006-12-04) don't fully
356 implement this, instead always returning NULL or the first
357 argument. We detect that case by checking both directions. */
359 compat1 = selected->compatible (selected, from_target);
360 compat2 = from_target->compatible (from_target, selected);
362 if (compat1 == NULL && compat2 == NULL)
364 warning (_("Selected architecture %s is not compatible "
365 "with reported target architecture %s"),
366 selected->printable_name, from_target->printable_name);
374 if (compat1 == compat2)
377 /* If the two didn't match, but one of them was a default architecture,
378 assume the more specific one is correct. This handles the case
379 where an executable or target description just says "mips", but
380 the other knows which MIPS variant. */
381 if (compat1->the_default)
383 if (compat2->the_default)
386 /* We have no idea which one is better. This is a bug, but not
387 a critical problem; warn the user. */
388 warning (_("Selected architecture %s is ambiguous with "
389 "reported target architecture %s"),
390 selected->printable_name, from_target->printable_name);
394 /* Functions to manipulate the architecture of the target */
396 enum set_arch { set_arch_auto, set_arch_manual };
398 static const struct bfd_arch_info *target_architecture_user;
400 static const char *set_architecture_string;
403 selected_architecture_name (void)
405 if (target_architecture_user == NULL)
408 return set_architecture_string;
411 /* Called if the user enters ``show architecture'' without an
415 show_architecture (struct ui_file *file, int from_tty,
416 struct cmd_list_element *c, const char *value)
418 if (target_architecture_user == NULL)
419 fprintf_filtered (file, _("\
420 The target architecture is set automatically (currently %s)\n"),
421 gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
423 fprintf_filtered (file, _("\
424 The target architecture is assumed to be %s\n"), set_architecture_string);
428 /* Called if the user enters ``set architecture'' with or without an
432 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
434 struct gdbarch_info info;
436 gdbarch_info_init (&info);
438 if (strcmp (set_architecture_string, "auto") == 0)
440 target_architecture_user = NULL;
441 if (!gdbarch_update_p (info))
442 internal_error (__FILE__, __LINE__,
443 _("could not select an architecture automatically"));
447 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
448 if (info.bfd_arch_info == NULL)
449 internal_error (__FILE__, __LINE__,
450 _("set_architecture: bfd_scan_arch failed"));
451 if (gdbarch_update_p (info))
452 target_architecture_user = info.bfd_arch_info;
454 printf_unfiltered (_("Architecture `%s' not recognized.\n"),
455 set_architecture_string);
457 show_architecture (gdb_stdout, from_tty, NULL, NULL);
460 /* Try to select a global architecture that matches "info". Return
461 non-zero if the attempt succeds. */
463 gdbarch_update_p (struct gdbarch_info info)
465 struct gdbarch *new_gdbarch;
467 /* Check for the current file. */
468 if (info.abfd == NULL)
469 info.abfd = exec_bfd;
470 if (info.abfd == NULL)
471 info.abfd = core_bfd;
473 /* Check for the current target description. */
474 if (info.target_desc == NULL)
475 info.target_desc = target_current_description ();
477 new_gdbarch = gdbarch_find_by_info (info);
479 /* If there no architecture by that name, reject the request. */
480 if (new_gdbarch == NULL)
483 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
484 "Architecture not found\n");
488 /* If it is the same old architecture, accept the request (but don't
490 if (new_gdbarch == target_gdbarch)
493 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
494 "Architecture %s (%s) unchanged\n",
495 host_address_to_string (new_gdbarch),
496 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
500 /* It's a new architecture, swap it in. */
502 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
503 "New architecture %s (%s) selected\n",
504 host_address_to_string (new_gdbarch),
505 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
506 deprecated_current_gdbarch_select_hack (new_gdbarch);
511 /* Return the architecture for ABFD. If no suitable architecture
512 could be find, return NULL. */
515 gdbarch_from_bfd (bfd *abfd)
517 struct gdbarch_info info;
518 gdbarch_info_init (&info);
520 return gdbarch_find_by_info (info);
523 /* Set the dynamic target-system-dependent parameters (architecture,
524 byte-order) using information found in the BFD */
527 set_gdbarch_from_file (bfd *abfd)
529 struct gdbarch_info info;
530 struct gdbarch *gdbarch;
532 gdbarch_info_init (&info);
534 info.target_desc = target_current_description ();
535 gdbarch = gdbarch_find_by_info (info);
538 error (_("Architecture of file not recognized."));
539 deprecated_current_gdbarch_select_hack (gdbarch);
542 /* Initialize the current architecture. Update the ``set
543 architecture'' command so that it specifies a list of valid
546 #ifdef DEFAULT_BFD_ARCH
547 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
548 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
550 static const bfd_arch_info_type *default_bfd_arch;
553 #ifdef DEFAULT_BFD_VEC
554 extern const bfd_target DEFAULT_BFD_VEC;
555 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
557 static const bfd_target *default_bfd_vec;
560 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
563 initialize_current_architecture (void)
565 const char **arches = gdbarch_printable_names ();
567 /* determine a default architecture and byte order. */
568 struct gdbarch_info info;
569 gdbarch_info_init (&info);
571 /* Find a default architecture. */
572 if (default_bfd_arch == NULL)
574 /* Choose the architecture by taking the first one
576 const char *chosen = arches[0];
578 for (arch = arches; *arch != NULL; arch++)
580 if (strcmp (*arch, chosen) < 0)
584 internal_error (__FILE__, __LINE__,
585 _("initialize_current_architecture: No arch"));
586 default_bfd_arch = bfd_scan_arch (chosen);
587 if (default_bfd_arch == NULL)
588 internal_error (__FILE__, __LINE__,
589 _("initialize_current_architecture: Arch not found"));
592 info.bfd_arch_info = default_bfd_arch;
594 /* Take several guesses at a byte order. */
595 if (default_byte_order == BFD_ENDIAN_UNKNOWN
596 && default_bfd_vec != NULL)
598 /* Extract BFD's default vector's byte order. */
599 switch (default_bfd_vec->byteorder)
602 default_byte_order = BFD_ENDIAN_BIG;
604 case BFD_ENDIAN_LITTLE:
605 default_byte_order = BFD_ENDIAN_LITTLE;
611 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
613 /* look for ``*el-*'' in the target name. */
615 chp = strchr (target_name, '-');
617 && chp - 2 >= target_name
618 && strncmp (chp - 2, "el", 2) == 0)
619 default_byte_order = BFD_ENDIAN_LITTLE;
621 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
623 /* Wire it to big-endian!!! */
624 default_byte_order = BFD_ENDIAN_BIG;
627 info.byte_order = default_byte_order;
628 info.byte_order_for_code = info.byte_order;
630 if (! gdbarch_update_p (info))
631 internal_error (__FILE__, __LINE__,
632 _("initialize_current_architecture: Selection of "
633 "initial architecture failed"));
635 /* Create the ``set architecture'' command appending ``auto'' to the
636 list of architectures. */
638 struct cmd_list_element *c;
639 /* Append ``auto''. */
641 for (nr = 0; arches[nr] != NULL; nr++);
642 arches = xrealloc (arches, sizeof (char*) * (nr + 2));
643 arches[nr + 0] = "auto";
644 arches[nr + 1] = NULL;
645 add_setshow_enum_cmd ("architecture", class_support,
646 arches, &set_architecture_string, _("\
647 Set architecture of target."), _("\
648 Show architecture of target."), NULL,
649 set_architecture, show_architecture,
650 &setlist, &showlist);
651 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
656 /* Initialize a gdbarch info to values that will be automatically
657 overridden. Note: Originally, this ``struct info'' was initialized
658 using memset(0). Unfortunately, that ran into problems, namely
659 BFD_ENDIAN_BIG is zero. An explicit initialization function that
660 can explicitly set each field to a well defined value is used. */
663 gdbarch_info_init (struct gdbarch_info *info)
665 memset (info, 0, sizeof (struct gdbarch_info));
666 info->byte_order = BFD_ENDIAN_UNKNOWN;
667 info->byte_order_for_code = info->byte_order;
668 info->osabi = GDB_OSABI_UNINITIALIZED;
671 /* Similar to init, but this time fill in the blanks. Information is
672 obtained from the global "set ..." options and explicitly
673 initialized INFO fields. */
676 gdbarch_info_fill (struct gdbarch_info *info)
678 /* "(gdb) set architecture ...". */
679 if (info->bfd_arch_info == NULL
680 && target_architecture_user)
681 info->bfd_arch_info = target_architecture_user;
683 if (info->bfd_arch_info == NULL
684 && info->abfd != NULL
685 && bfd_get_arch (info->abfd) != bfd_arch_unknown
686 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
687 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
688 /* From the target. */
689 if (info->target_desc != NULL)
690 info->bfd_arch_info = choose_architecture_for_target
691 (info->bfd_arch_info, tdesc_architecture (info->target_desc));
692 /* From the default. */
693 if (info->bfd_arch_info == NULL)
694 info->bfd_arch_info = default_bfd_arch;
696 /* "(gdb) set byte-order ...". */
697 if (info->byte_order == BFD_ENDIAN_UNKNOWN
698 && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
699 info->byte_order = target_byte_order_user;
700 /* From the INFO struct. */
701 if (info->byte_order == BFD_ENDIAN_UNKNOWN
702 && info->abfd != NULL)
703 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
704 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
705 : BFD_ENDIAN_UNKNOWN);
706 /* From the default. */
707 if (info->byte_order == BFD_ENDIAN_UNKNOWN)
708 info->byte_order = default_byte_order;
709 info->byte_order_for_code = info->byte_order;
711 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
712 if (info->osabi == GDB_OSABI_UNINITIALIZED)
713 info->osabi = gdbarch_lookup_osabi (info->abfd);
715 /* Must have at least filled in the architecture. */
716 gdb_assert (info->bfd_arch_info != NULL);
719 /* Return "current" architecture. If the target is running, this is the
720 architecture of the selected frame. Otherwise, the "current" architecture
721 defaults to the target architecture.
723 This function should normally be called solely by the command interpreter
724 routines to determine the architecture to execute a command in. */
726 get_current_arch (void)
728 if (has_stack_frames ())
729 return get_frame_arch (get_selected_frame (NULL));
731 return target_gdbarch;
736 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
739 _initialize_gdbarch_utils (void)
741 struct cmd_list_element *c;
742 add_setshow_enum_cmd ("endian", class_support,
743 endian_enum, &set_endian_string, _("\
744 Set endianness of target."), _("\
745 Show endianness of target."), NULL,
746 set_endian, show_endian,
747 &setlist, &showlist);