1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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"
38 #include "floatformat.h"
40 /* Implementation of extract return value that grubs around in the
43 legacy_extract_return_value (struct type *type, struct regcache *regcache,
46 char *registers = deprecated_grub_regcache_for_registers (regcache);
47 bfd_byte *buf = valbuf;
48 DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
51 /* Implementation of store return value that grubs the register cache.
52 Takes a local copy of the buffer to avoid const problems. */
54 legacy_store_return_value (struct type *type, struct regcache *regcache,
57 bfd_byte *b = alloca (TYPE_LENGTH (type));
58 gdb_assert (regcache == current_regcache);
59 memcpy (b, buf, TYPE_LENGTH (type));
60 DEPRECATED_STORE_RETURN_VALUE (type, b);
65 always_use_struct_convention (int gcc_p, struct type *value_type)
72 legacy_register_sim_regno (int regnum)
74 /* Only makes sense to supply raw registers. */
75 gdb_assert (regnum >= 0 && regnum < NUM_REGS);
76 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
77 suspected that some GDB/SIM combinations may rely on this
78 behavour. The default should be one2one_register_sim_regno
80 if (REGISTER_NAME (regnum) != NULL
81 && REGISTER_NAME (regnum)[0] != '\0')
84 return LEGACY_SIM_REGNO_IGNORE;
88 generic_frameless_function_invocation_not (struct frame_info *fi)
94 generic_return_value_on_stack_not (struct type *type)
100 generic_skip_trampoline_code (CORE_ADDR pc)
106 generic_skip_solib_resolver (CORE_ADDR pc)
112 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
118 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
124 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
129 #if defined (CALL_DUMMY)
130 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
132 LONGEST legacy_call_dummy_words[1];
134 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
137 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
138 struct regcache *regcache,
139 CORE_ADDR gdb_addr, int gdb_len,
140 CORE_ADDR * rem_addr, int *rem_len)
142 *rem_addr = gdb_addr;
147 generic_prologue_frameless_p (CORE_ADDR ip)
149 return ip == SKIP_PROLOGUE (ip);
152 /* Helper functions for INNER_THAN */
155 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
161 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
167 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
169 const struct floatformat *
170 default_float_format (struct gdbarch *gdbarch)
172 int byte_order = gdbarch_byte_order (gdbarch);
176 return &floatformat_ieee_single_big;
177 case BFD_ENDIAN_LITTLE:
178 return &floatformat_ieee_single_little;
180 internal_error (__FILE__, __LINE__,
181 "default_float_format: bad byte order");
186 const struct floatformat *
187 default_double_format (struct gdbarch *gdbarch)
189 int byte_order = gdbarch_byte_order (gdbarch);
193 return &floatformat_ieee_double_big;
194 case BFD_ENDIAN_LITTLE:
195 return &floatformat_ieee_double_little;
197 internal_error (__FILE__, __LINE__,
198 "default_double_format: bad byte order");
202 /* Misc helper functions for targets. */
205 deprecated_register_convertible_not (int num)
212 core_addr_identity (CORE_ADDR addr)
218 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
219 struct target_ops *targ)
225 no_op_reg_to_regnum (int reg)
231 deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev)
233 if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
234 return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
235 else if (get_next_frame (prev) != NULL)
236 return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
242 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
248 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
254 cannot_register_not (int regnum)
259 /* Legacy version of target_virtual_frame_pointer(). Assumes that
260 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
264 legacy_virtual_frame_pointer (CORE_ADDR pc,
266 LONGEST *frame_offset)
268 /* FIXME: cagney/2002-09-13: This code is used when identifying the
269 frame pointer of the current PC. It is assuming that a single
270 register and an offset can determine this. I think it should
271 instead generate a byte code expression as that would work better
272 with things like Dwarf2's CFI. */
273 if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
274 *frame_regnum = DEPRECATED_FP_REGNUM;
275 else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
276 *frame_regnum = SP_REGNUM;
278 /* Should this be an internal error? I guess so, it is reflecting
279 an architectural limitation in the current design. */
280 internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
284 /* Assume the world is sane, every register's virtual and real size
288 generic_register_size (int regnum)
290 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
291 if (gdbarch_register_type_p (current_gdbarch))
292 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
294 /* FIXME: cagney/2003-03-01: Once all architectures implement
295 gdbarch_register_type(), this entire function can go away. It
296 is made obsolete by register_size(). */
297 return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
300 /* Assume all registers are adjacent. */
303 generic_register_byte (int regnum)
307 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
309 for (i = 0; i < regnum; i++)
311 byte += generic_register_size (i);
318 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
320 #if !defined (IN_SIGTRAMP)
321 if (SIGTRAMP_START_P ())
322 return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
324 return name && strcmp ("_sigtramp", name) == 0;
326 return IN_SIGTRAMP (pc, name);
331 legacy_convert_register_p (int regnum, struct type *type)
333 return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
337 legacy_register_to_value (struct frame_info *frame, int regnum,
338 struct type *type, void *to)
340 char from[MAX_REGISTER_SIZE];
341 get_frame_register (frame, regnum, from);
342 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
346 legacy_value_to_register (struct frame_info *frame, int regnum,
347 struct type *type, const void *tmp)
349 char to[MAX_REGISTER_SIZE];
350 char *from = alloca (TYPE_LENGTH (type));
351 memcpy (from, from, TYPE_LENGTH (type));
352 DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
353 put_frame_register (frame, regnum, to);
357 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
359 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
360 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type))
362 CHECK_TYPEDEF (type);
364 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
365 || TYPE_CODE (type) == TYPE_CODE_UNION
366 || TYPE_CODE (type) == TYPE_CODE_SET
367 || TYPE_CODE (type) == TYPE_CODE_BITSTRING);
374 /* Functions to manipulate the endianness of the target. */
376 /* ``target_byte_order'' is only used when non- multi-arch.
377 Multi-arch targets obtain the current byte order using the
378 TARGET_BYTE_ORDER gdbarch method.
380 The choice of initial value is entirely arbitrary. During startup,
381 the function initialize_current_architecture() updates this value
382 based on default byte-order information extracted from BFD. */
383 int target_byte_order = BFD_ENDIAN_BIG;
384 int target_byte_order_auto = 1;
386 static const char endian_big[] = "big";
387 static const char endian_little[] = "little";
388 static const char endian_auto[] = "auto";
389 static const char *endian_enum[] =
396 static const char *set_endian_string;
398 /* Called by ``show endian''. */
401 show_endian (char *args, int from_tty)
403 if (TARGET_BYTE_ORDER_AUTO)
404 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
405 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
407 printf_unfiltered ("The target is assumed to be %s endian\n",
408 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
412 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
414 if (set_endian_string == endian_auto)
416 target_byte_order_auto = 1;
418 else if (set_endian_string == endian_little)
420 struct gdbarch_info info;
421 target_byte_order_auto = 0;
422 gdbarch_info_init (&info);
423 info.byte_order = BFD_ENDIAN_LITTLE;
424 if (! gdbarch_update_p (info))
425 printf_unfiltered ("Little endian target not supported by GDB\n");
427 else if (set_endian_string == endian_big)
429 struct gdbarch_info info;
430 target_byte_order_auto = 0;
431 gdbarch_info_init (&info);
432 info.byte_order = BFD_ENDIAN_BIG;
433 if (! gdbarch_update_p (info))
434 printf_unfiltered ("Big endian target not supported by GDB\n");
437 internal_error (__FILE__, __LINE__,
438 "set_endian: bad value");
439 show_endian (NULL, from_tty);
442 /* Functions to manipulate the architecture of the target */
444 enum set_arch { set_arch_auto, set_arch_manual };
446 int target_architecture_auto = 1;
448 const char *set_architecture_string;
450 /* Called if the user enters ``show architecture'' without an
454 show_architecture (char *args, int from_tty)
457 arch = TARGET_ARCHITECTURE->printable_name;
458 if (target_architecture_auto)
459 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
461 printf_filtered ("The target architecture is assumed to be %s\n", arch);
465 /* Called if the user enters ``set architecture'' with or without an
469 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
471 if (strcmp (set_architecture_string, "auto") == 0)
473 target_architecture_auto = 1;
477 struct gdbarch_info info;
478 gdbarch_info_init (&info);
479 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
480 if (info.bfd_arch_info == NULL)
481 internal_error (__FILE__, __LINE__,
482 "set_architecture: bfd_scan_arch failed");
483 if (gdbarch_update_p (info))
484 target_architecture_auto = 0;
486 printf_unfiltered ("Architecture `%s' not recognized.\n",
487 set_architecture_string);
489 show_architecture (NULL, from_tty);
492 /* Try to select a global architecture that matches "info". Return
493 non-zero if the attempt succeds. */
495 gdbarch_update_p (struct gdbarch_info info)
497 struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
499 /* If there no architecture by that name, reject the request. */
500 if (new_gdbarch == NULL)
503 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
504 "Architecture not found\n");
508 /* If it is the same old architecture, accept the request (but don't
510 if (new_gdbarch == current_gdbarch)
513 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
514 "Architecture 0x%08lx (%s) unchanged\n",
516 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
520 /* It's a new architecture, swap it in. */
522 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
523 "New architecture 0x%08lx (%s) selected\n",
525 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
526 deprecated_current_gdbarch_select_hack (new_gdbarch);
531 /* FIXME: kettenis/20031124: Of the functions that follow, only
532 gdbarch_from_bfd is supposed to survive. The others will
533 dissappear since in the future GDB will (hopefully) be truly
534 multi-arch. However, for now we're still stuck with the concept of
535 a single active architecture. */
537 /* Make GDBARCH the currently selected architecture. */
540 deprecated_select_gdbarch_hack (struct gdbarch *gdbarch)
542 struct gdbarch_info info;
544 /* FIXME: kettenis/20031024: The only way to select a specific
545 architecture is to clone its `struct gdbarch_info', and update
546 according to that copy. This is gross, but significant work will
547 need to be done before we can take a more sane approach. */
548 gdbarch_info_init (&info);
549 info.bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
550 info.byte_order = gdbarch_byte_order (gdbarch);
551 info.osabi = gdbarch_osabi (gdbarch);
552 gdbarch_update_p (info);
553 gdb_assert (gdbarch == current_gdbarch);
556 /* Return the architecture for ABFD. If no suitable architecture
557 could be find, return NULL. */
560 gdbarch_from_bfd (bfd *abfd)
562 struct gdbarch *old_gdbarch = current_gdbarch;
563 struct gdbarch *new_gdbarch;
564 struct gdbarch_info info;
566 /* FIXME: kettenis/20031024: The only way to find the architecture
567 for a certain BFD is by doing an architecture update. This
568 activates the architecture, so we need to reactivate the old
569 architecture. This is gross, but significant work will need to
570 be done before we can take a more sane approach. */
571 gdbarch_info_init (&info);
573 if (! gdbarch_update_p (info))
576 new_gdbarch = current_gdbarch;
577 deprecated_select_gdbarch_hack (old_gdbarch);
581 /* Set the dynamic target-system-dependent parameters (architecture,
582 byte-order) using information found in the BFD */
585 set_gdbarch_from_file (bfd *abfd)
587 struct gdbarch *gdbarch;
589 gdbarch = gdbarch_from_bfd (abfd);
591 error ("Architecture of file not recognized.\n");
592 deprecated_select_gdbarch_hack (gdbarch);
595 /* Initialize the current architecture. Update the ``set
596 architecture'' command so that it specifies a list of valid
599 #ifdef DEFAULT_BFD_ARCH
600 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
601 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
603 static const bfd_arch_info_type *default_bfd_arch;
606 #ifdef DEFAULT_BFD_VEC
607 extern const bfd_target DEFAULT_BFD_VEC;
608 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
610 static const bfd_target *default_bfd_vec;
614 initialize_current_architecture (void)
616 const char **arches = gdbarch_printable_names ();
618 /* determine a default architecture and byte order. */
619 struct gdbarch_info info;
620 gdbarch_info_init (&info);
622 /* Find a default architecture. */
623 if (info.bfd_arch_info == NULL
624 && default_bfd_arch != NULL)
625 info.bfd_arch_info = default_bfd_arch;
626 if (info.bfd_arch_info == NULL)
628 /* Choose the architecture by taking the first one
630 const char *chosen = arches[0];
632 for (arch = arches; *arch != NULL; arch++)
634 if (strcmp (*arch, chosen) < 0)
638 internal_error (__FILE__, __LINE__,
639 "initialize_current_architecture: No arch");
640 info.bfd_arch_info = bfd_scan_arch (chosen);
641 if (info.bfd_arch_info == NULL)
642 internal_error (__FILE__, __LINE__,
643 "initialize_current_architecture: Arch not found");
646 /* Take several guesses at a byte order. */
647 if (info.byte_order == BFD_ENDIAN_UNKNOWN
648 && default_bfd_vec != NULL)
650 /* Extract BFD's default vector's byte order. */
651 switch (default_bfd_vec->byteorder)
654 info.byte_order = BFD_ENDIAN_BIG;
656 case BFD_ENDIAN_LITTLE:
657 info.byte_order = BFD_ENDIAN_LITTLE;
663 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
665 /* look for ``*el-*'' in the target name. */
667 chp = strchr (target_name, '-');
669 && chp - 2 >= target_name
670 && strncmp (chp - 2, "el", 2) == 0)
671 info.byte_order = BFD_ENDIAN_LITTLE;
673 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
675 /* Wire it to big-endian!!! */
676 info.byte_order = BFD_ENDIAN_BIG;
679 if (! gdbarch_update_p (info))
680 internal_error (__FILE__, __LINE__,
681 "initialize_current_architecture: Selection of initial architecture failed");
683 /* Create the ``set architecture'' command appending ``auto'' to the
684 list of architectures. */
686 struct cmd_list_element *c;
687 /* Append ``auto''. */
689 for (nr = 0; arches[nr] != NULL; nr++);
690 arches = xrealloc (arches, sizeof (char*) * (nr + 2));
691 arches[nr + 0] = "auto";
692 arches[nr + 1] = NULL;
693 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
694 of ``const char *''. We just happen to know that the casts are
696 c = add_set_enum_cmd ("architecture", class_support,
697 arches, &set_architecture_string,
698 "Set architecture of target.",
700 set_cmd_sfunc (c, set_architecture);
701 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
702 /* Don't use set_from_show - need to print both auto/manual and
704 add_cmd ("architecture", class_support, show_architecture,
705 "Show the current target architecture", &showlist);
710 /* Initialize a gdbarch info to values that will be automatically
711 overridden. Note: Originally, this ``struct info'' was initialized
712 using memset(0). Unfortunately, that ran into problems, namely
713 BFD_ENDIAN_BIG is zero. An explicit initialization function that
714 can explicitly set each field to a well defined value is used. */
717 gdbarch_info_init (struct gdbarch_info *info)
719 memset (info, 0, sizeof (struct gdbarch_info));
720 info->byte_order = BFD_ENDIAN_UNKNOWN;
721 info->osabi = GDB_OSABI_UNINITIALIZED;
724 /* Similar it init, but this time fill in the blanks. Information is
725 obtained from the specified architecture, global "set ..." options,
726 and explicitly initialized INFO fields. */
729 gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info)
731 /* "(gdb) set architecture ...". */
732 if (info->bfd_arch_info == NULL
733 && !target_architecture_auto
735 info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
736 if (info->bfd_arch_info == NULL
737 && info->abfd != NULL
738 && bfd_get_arch (info->abfd) != bfd_arch_unknown
739 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
740 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
741 if (info->bfd_arch_info == NULL
743 info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
745 /* "(gdb) set byte-order ...". */
746 if (info->byte_order == BFD_ENDIAN_UNKNOWN
747 && !target_byte_order_auto
749 info->byte_order = gdbarch_byte_order (gdbarch);
750 /* From the INFO struct. */
751 if (info->byte_order == BFD_ENDIAN_UNKNOWN
752 && info->abfd != NULL)
753 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
754 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
755 : BFD_ENDIAN_UNKNOWN);
756 /* From the current target. */
757 if (info->byte_order == BFD_ENDIAN_UNKNOWN
759 info->byte_order = gdbarch_byte_order (gdbarch);
761 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
762 if (info->osabi == GDB_OSABI_UNINITIALIZED)
763 info->osabi = gdbarch_lookup_osabi (info->abfd);
764 if (info->osabi == GDB_OSABI_UNINITIALIZED
766 info->osabi = gdbarch_osabi (gdbarch);
768 /* Must have at least filled in the architecture. */
769 gdb_assert (info->bfd_arch_info != NULL);
774 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
777 _initialize_gdbarch_utils (void)
779 struct cmd_list_element *c;
780 c = add_set_enum_cmd ("endian", class_support,
781 endian_enum, &set_endian_string,
782 "Set endianness of target.",
784 set_cmd_sfunc (c, set_endian);
785 /* Don't use set_from_show - need to print both auto/manual and
787 add_cmd ("endian", class_support, show_endian,
788 "Show the current byte-order", &showlist);