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"
36 #include "floatformat.h"
38 /* Implementation of extract return value that grubs around in the
41 legacy_extract_return_value (struct type *type, struct regcache *regcache,
44 char *registers = deprecated_grub_regcache_for_registers (regcache);
45 bfd_byte *buf = valbuf;
46 DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
49 /* Implementation of store return value that grubs the register cache.
50 Takes a local copy of the buffer to avoid const problems. */
52 legacy_store_return_value (struct type *type, struct regcache *regcache,
55 bfd_byte *b = alloca (TYPE_LENGTH (type));
56 gdb_assert (regcache == current_regcache);
57 memcpy (b, buf, TYPE_LENGTH (type));
58 DEPRECATED_STORE_RETURN_VALUE (type, b);
63 always_use_struct_convention (int gcc_p, struct type *value_type)
70 legacy_register_sim_regno (int regnum)
72 /* Only makes sense to supply raw registers. */
73 gdb_assert (regnum >= 0 && regnum < NUM_REGS);
74 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
75 suspected that some GDB/SIM combinations may rely on this
76 behavour. The default should be one2one_register_sim_regno
78 if (REGISTER_NAME (regnum) != NULL
79 && REGISTER_NAME (regnum)[0] != '\0')
82 return LEGACY_SIM_REGNO_IGNORE;
86 generic_frameless_function_invocation_not (struct frame_info *fi)
92 generic_return_value_on_stack_not (struct type *type)
98 generic_skip_trampoline_code (CORE_ADDR pc)
104 generic_skip_solib_resolver (CORE_ADDR pc)
110 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
116 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
122 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
127 #if defined (CALL_DUMMY)
128 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
130 LONGEST legacy_call_dummy_words[1];
132 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
135 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
136 struct regcache *regcache,
137 CORE_ADDR gdb_addr, int gdb_len,
138 CORE_ADDR * rem_addr, int *rem_len)
140 *rem_addr = gdb_addr;
145 generic_prologue_frameless_p (CORE_ADDR ip)
147 return ip == SKIP_PROLOGUE (ip);
150 /* Helper functions for INNER_THAN */
153 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
159 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
165 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
167 const struct floatformat *
168 default_float_format (struct gdbarch *gdbarch)
170 int byte_order = gdbarch_byte_order (gdbarch);
174 return &floatformat_ieee_single_big;
175 case BFD_ENDIAN_LITTLE:
176 return &floatformat_ieee_single_little;
178 internal_error (__FILE__, __LINE__,
179 "default_float_format: bad byte order");
184 const struct floatformat *
185 default_double_format (struct gdbarch *gdbarch)
187 int byte_order = gdbarch_byte_order (gdbarch);
191 return &floatformat_ieee_double_big;
192 case BFD_ENDIAN_LITTLE:
193 return &floatformat_ieee_double_little;
195 internal_error (__FILE__, __LINE__,
196 "default_double_format: bad byte order");
200 /* Misc helper functions for targets. */
203 deprecated_register_convertible_not (int num)
210 core_addr_identity (CORE_ADDR addr)
216 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
217 struct target_ops *targ)
223 no_op_reg_to_regnum (int reg)
229 deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev)
231 if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
232 return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
233 else if (get_next_frame (prev) != NULL)
234 return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
240 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
246 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
252 cannot_register_not (int regnum)
257 /* Legacy version of target_virtual_frame_pointer(). Assumes that
258 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
262 legacy_virtual_frame_pointer (CORE_ADDR pc,
264 LONGEST *frame_offset)
266 /* FIXME: cagney/2002-09-13: This code is used when identifying the
267 frame pointer of the current PC. It is assuming that a single
268 register and an offset can determine this. I think it should
269 instead generate a byte code expression as that would work better
270 with things like Dwarf2's CFI. */
271 if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
272 *frame_regnum = DEPRECATED_FP_REGNUM;
273 else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
274 *frame_regnum = SP_REGNUM;
276 /* Should this be an internal error? I guess so, it is reflecting
277 an architectural limitation in the current design. */
278 internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
282 /* Assume the world is sane, every register's virtual and real size
286 generic_register_size (int regnum)
288 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
289 if (gdbarch_register_type_p (current_gdbarch))
290 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
292 /* FIXME: cagney/2003-03-01: Once all architectures implement
293 gdbarch_register_type(), this entire function can go away. It
294 is made obsolete by register_size(). */
295 return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
298 /* Assume all registers are adjacent. */
301 generic_register_byte (int regnum)
305 gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
307 for (i = 0; i < regnum; i++)
309 byte += generic_register_size (i);
316 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
318 #if !defined (IN_SIGTRAMP)
319 if (SIGTRAMP_START_P ())
320 return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
322 return name && strcmp ("_sigtramp", name) == 0;
324 return IN_SIGTRAMP (pc, name);
329 legacy_convert_register_p (int regnum, struct type *type)
331 return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
335 legacy_register_to_value (struct frame_info *frame, int regnum,
336 struct type *type, void *to)
338 char from[MAX_REGISTER_SIZE];
339 get_frame_register (frame, regnum, from);
340 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
344 legacy_value_to_register (struct frame_info *frame, int regnum,
345 struct type *type, const void *tmp)
347 char to[MAX_REGISTER_SIZE];
348 char *from = alloca (TYPE_LENGTH (type));
349 memcpy (from, from, TYPE_LENGTH (type));
350 DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
351 put_frame_register (frame, regnum, to);
355 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
357 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
358 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type))
360 CHECK_TYPEDEF (type);
362 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
363 || TYPE_CODE (type) == TYPE_CODE_UNION
364 || TYPE_CODE (type) == TYPE_CODE_SET
365 || TYPE_CODE (type) == TYPE_CODE_BITSTRING);
372 /* Functions to manipulate the endianness of the target. */
374 /* ``target_byte_order'' is only used when non- multi-arch.
375 Multi-arch targets obtain the current byte order using the
376 TARGET_BYTE_ORDER gdbarch method.
378 The choice of initial value is entirely arbitrary. During startup,
379 the function initialize_current_architecture() updates this value
380 based on default byte-order information extracted from BFD. */
381 int target_byte_order = BFD_ENDIAN_BIG;
382 int target_byte_order_auto = 1;
384 static const char endian_big[] = "big";
385 static const char endian_little[] = "little";
386 static const char endian_auto[] = "auto";
387 static const char *endian_enum[] =
394 static const char *set_endian_string;
396 /* Called by ``show endian''. */
399 show_endian (char *args, int from_tty)
401 if (TARGET_BYTE_ORDER_AUTO)
402 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
403 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
405 printf_unfiltered ("The target is assumed to be %s endian\n",
406 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
410 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
412 if (set_endian_string == endian_auto)
414 target_byte_order_auto = 1;
416 else if (set_endian_string == endian_little)
418 struct gdbarch_info info;
419 target_byte_order_auto = 0;
420 gdbarch_info_init (&info);
421 info.byte_order = BFD_ENDIAN_LITTLE;
422 if (! gdbarch_update_p (info))
423 printf_unfiltered ("Little endian target not supported by GDB\n");
425 else if (set_endian_string == endian_big)
427 struct gdbarch_info info;
428 target_byte_order_auto = 0;
429 gdbarch_info_init (&info);
430 info.byte_order = BFD_ENDIAN_BIG;
431 if (! gdbarch_update_p (info))
432 printf_unfiltered ("Big endian target not supported by GDB\n");
435 internal_error (__FILE__, __LINE__,
436 "set_endian: bad value");
437 show_endian (NULL, from_tty);
440 /* Functions to manipulate the architecture of the target */
442 enum set_arch { set_arch_auto, set_arch_manual };
444 int target_architecture_auto = 1;
446 const char *set_architecture_string;
448 /* Called if the user enters ``show architecture'' without an
452 show_architecture (char *args, int from_tty)
455 arch = TARGET_ARCHITECTURE->printable_name;
456 if (target_architecture_auto)
457 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
459 printf_filtered ("The target architecture is assumed to be %s\n", arch);
463 /* Called if the user enters ``set architecture'' with or without an
467 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
469 if (strcmp (set_architecture_string, "auto") == 0)
471 target_architecture_auto = 1;
475 struct gdbarch_info info;
476 gdbarch_info_init (&info);
477 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
478 if (info.bfd_arch_info == NULL)
479 internal_error (__FILE__, __LINE__,
480 "set_architecture: bfd_scan_arch failed");
481 if (gdbarch_update_p (info))
482 target_architecture_auto = 0;
484 printf_unfiltered ("Architecture `%s' not recognized.\n",
485 set_architecture_string);
487 show_architecture (NULL, from_tty);
490 /* FIXME: kettenis/20031124: Of the functions that follow, only
491 gdbarch_from_bfd is supposed to survive. The others will
492 dissappear since in the future GDB will (hopefully) be truly
493 multi-arch. However, for now we're still stuck with the concept of
494 a single active architecture. */
496 /* Make GDBARCH the currently selected architecture. */
499 deprecated_select_gdbarch_hack (struct gdbarch *gdbarch)
501 struct gdbarch_info info;
503 /* FIXME: kettenis/20031024: The only way to select a specific
504 architecture is to clone its `struct gdbarch_info', and update
505 according to that copy. This is gross, but significant work will
506 need to be done before we can take a more sane approach. */
507 gdbarch_info_init (&info);
508 info.bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
509 info.byte_order = gdbarch_byte_order (gdbarch);
510 info.osabi = gdbarch_osabi (gdbarch);
511 gdbarch_update_p (info);
512 gdb_assert (gdbarch == current_gdbarch);
515 /* Return the architecture for ABFD. If no suitable architecture
516 could be find, return NULL. */
519 gdbarch_from_bfd (bfd *abfd)
521 struct gdbarch *old_gdbarch = current_gdbarch;
522 struct gdbarch *new_gdbarch;
523 struct gdbarch_info info;
525 /* FIXME: kettenis/20031024: The only way to find the architecture
526 for a certain BFD is by doing an architecture update. This
527 activates the architecture, so we need to reactivate the old
528 architecture. This is gross, but significant work will need to
529 be done before we can take a more sane approach. */
530 gdbarch_info_init (&info);
532 if (! gdbarch_update_p (info))
535 new_gdbarch = current_gdbarch;
536 deprecated_select_gdbarch_hack (old_gdbarch);
540 /* Set the dynamic target-system-dependent parameters (architecture,
541 byte-order) using information found in the BFD */
544 set_gdbarch_from_file (bfd *abfd)
546 struct gdbarch *gdbarch;
548 gdbarch = gdbarch_from_bfd (abfd);
550 error ("Architecture of file not recognized.\n");
551 deprecated_select_gdbarch_hack (gdbarch);
554 /* Initialize the current architecture. Update the ``set
555 architecture'' command so that it specifies a list of valid
558 #ifdef DEFAULT_BFD_ARCH
559 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
560 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
562 static const bfd_arch_info_type *default_bfd_arch;
565 #ifdef DEFAULT_BFD_VEC
566 extern const bfd_target DEFAULT_BFD_VEC;
567 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
569 static const bfd_target *default_bfd_vec;
573 initialize_current_architecture (void)
575 const char **arches = gdbarch_printable_names ();
577 /* determine a default architecture and byte order. */
578 struct gdbarch_info info;
579 gdbarch_info_init (&info);
581 /* Find a default architecture. */
582 if (info.bfd_arch_info == NULL
583 && default_bfd_arch != NULL)
584 info.bfd_arch_info = default_bfd_arch;
585 if (info.bfd_arch_info == NULL)
587 /* Choose the architecture by taking the first one
589 const char *chosen = arches[0];
591 for (arch = arches; *arch != NULL; arch++)
593 if (strcmp (*arch, chosen) < 0)
597 internal_error (__FILE__, __LINE__,
598 "initialize_current_architecture: No arch");
599 info.bfd_arch_info = bfd_scan_arch (chosen);
600 if (info.bfd_arch_info == NULL)
601 internal_error (__FILE__, __LINE__,
602 "initialize_current_architecture: Arch not found");
605 /* Take several guesses at a byte order. */
606 if (info.byte_order == BFD_ENDIAN_UNKNOWN
607 && default_bfd_vec != NULL)
609 /* Extract BFD's default vector's byte order. */
610 switch (default_bfd_vec->byteorder)
613 info.byte_order = BFD_ENDIAN_BIG;
615 case BFD_ENDIAN_LITTLE:
616 info.byte_order = BFD_ENDIAN_LITTLE;
622 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
624 /* look for ``*el-*'' in the target name. */
626 chp = strchr (target_name, '-');
628 && chp - 2 >= target_name
629 && strncmp (chp - 2, "el", 2) == 0)
630 info.byte_order = BFD_ENDIAN_LITTLE;
632 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
634 /* Wire it to big-endian!!! */
635 info.byte_order = BFD_ENDIAN_BIG;
638 if (! gdbarch_update_p (info))
639 internal_error (__FILE__, __LINE__,
640 "initialize_current_architecture: Selection of initial architecture failed");
642 /* Create the ``set architecture'' command appending ``auto'' to the
643 list of architectures. */
645 struct cmd_list_element *c;
646 /* Append ``auto''. */
648 for (nr = 0; arches[nr] != NULL; nr++);
649 arches = xrealloc (arches, sizeof (char*) * (nr + 2));
650 arches[nr + 0] = "auto";
651 arches[nr + 1] = NULL;
652 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
653 of ``const char *''. We just happen to know that the casts are
655 c = add_set_enum_cmd ("architecture", class_support,
656 arches, &set_architecture_string,
657 "Set architecture of target.",
659 set_cmd_sfunc (c, set_architecture);
660 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
661 /* Don't use set_from_show - need to print both auto/manual and
663 add_cmd ("architecture", class_support, show_architecture,
664 "Show the current target architecture", &showlist);
669 /* Initialize a gdbarch info to values that will be automatically
670 overridden. Note: Originally, this ``struct info'' was initialized
671 using memset(0). Unfortunately, that ran into problems, namely
672 BFD_ENDIAN_BIG is zero. An explicit initialization function that
673 can explicitly set each field to a well defined value is used. */
676 gdbarch_info_init (struct gdbarch_info *info)
678 memset (info, 0, sizeof (struct gdbarch_info));
679 info->byte_order = BFD_ENDIAN_UNKNOWN;
680 info->osabi = GDB_OSABI_UNINITIALIZED;
685 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
688 _initialize_gdbarch_utils (void)
690 struct cmd_list_element *c;
691 c = add_set_enum_cmd ("endian", class_support,
692 endian_enum, &set_endian_string,
693 "Set endianness of target.",
695 set_cmd_sfunc (c, set_endian);
696 /* Don't use set_from_show - need to print both auto/manual and
698 add_cmd ("endian", class_support, show_endian,
699 "Show the current byte-order", &showlist);