1 /* Dynamic architecture support for GDB, the GNU debugger.
2 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include "arch-utils.h"
26 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
28 /* Just include everything in sight so that the every old definition
29 of macro is visible. */
30 #include "gdb_string.h"
34 #include "breakpoint.h"
42 #include "gdb_assert.h"
46 #include "floatformat.h"
48 /* Use the program counter to determine the contents and size
49 of a breakpoint instruction. If no target-dependent macro
50 BREAKPOINT_FROM_PC has been defined to implement this function,
51 assume that the breakpoint doesn't depend on the PC, and
52 use the values of the BIG_BREAKPOINT and LITTLE_BREAKPOINT macros.
53 Return a pointer to a string of bytes that encode a breakpoint
54 instruction, stores the length of the string to *lenptr,
55 and optionally adjust the pc to point to the correct memory location
56 for inserting the breakpoint. */
59 legacy_breakpoint_from_pc (CORE_ADDR
* pcptr
, int *lenptr
)
61 /* {BIG_,LITTLE_}BREAKPOINT is the sequence of bytes we insert for a
62 breakpoint. On some machines, breakpoints are handled by the
63 target environment and we don't have to worry about them here. */
65 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
67 static unsigned char big_break_insn
[] = BIG_BREAKPOINT
;
68 *lenptr
= sizeof (big_break_insn
);
69 return big_break_insn
;
72 #ifdef LITTLE_BREAKPOINT
73 if (TARGET_BYTE_ORDER
!= BFD_ENDIAN_BIG
)
75 static unsigned char little_break_insn
[] = LITTLE_BREAKPOINT
;
76 *lenptr
= sizeof (little_break_insn
);
77 return little_break_insn
;
82 static unsigned char break_insn
[] = BREAKPOINT
;
83 *lenptr
= sizeof (break_insn
);
92 generic_frameless_function_invocation_not (struct frame_info
*fi
)
98 generic_return_value_on_stack_not (struct type
*type
)
104 generic_skip_trampoline_code (CORE_ADDR pc
)
110 generic_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
116 generic_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
122 legacy_register_name (int i
)
124 #ifdef REGISTER_NAMES
125 static char *names
[] = REGISTER_NAMES
;
126 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
131 internal_error (__FILE__
, __LINE__
,
132 "legacy_register_name: called.");
137 #if defined (CALL_DUMMY)
138 LONGEST legacy_call_dummy_words
[] = CALL_DUMMY
;
140 LONGEST legacy_call_dummy_words
[1];
142 int legacy_sizeof_call_dummy_words
= sizeof (legacy_call_dummy_words
);
145 generic_remote_translate_xfer_address (CORE_ADDR gdb_addr
, int gdb_len
,
146 CORE_ADDR
* rem_addr
, int *rem_len
)
148 *rem_addr
= gdb_addr
;
153 generic_prologue_frameless_p (CORE_ADDR ip
)
155 #ifdef SKIP_PROLOGUE_FRAMELESS_P
156 return ip
== SKIP_PROLOGUE_FRAMELESS_P (ip
);
158 return ip
== SKIP_PROLOGUE (ip
);
162 /* New/multi-arched targets should use the correct gdbarch field
163 instead of using this global pointer. */
165 legacy_print_insn (bfd_vma vma
, disassemble_info
*info
)
167 return (*tm_print_insn
) (vma
, info
);
170 /* Helper functions for INNER_THAN */
173 core_addr_lessthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
179 core_addr_greaterthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
185 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
187 const struct floatformat
*
188 default_float_format (struct gdbarch
*gdbarch
)
191 int byte_order
= gdbarch_byte_order (gdbarch
);
193 int byte_order
= TARGET_BYTE_ORDER
;
198 return &floatformat_ieee_single_big
;
199 case BFD_ENDIAN_LITTLE
:
200 return &floatformat_ieee_single_little
;
202 internal_error (__FILE__
, __LINE__
,
203 "default_float_format: bad byte order");
208 const struct floatformat
*
209 default_double_format (struct gdbarch
*gdbarch
)
212 int byte_order
= gdbarch_byte_order (gdbarch
);
214 int byte_order
= TARGET_BYTE_ORDER
;
219 return &floatformat_ieee_double_big
;
220 case BFD_ENDIAN_LITTLE
:
221 return &floatformat_ieee_double_little
;
223 internal_error (__FILE__
, __LINE__
,
224 "default_double_format: bad byte order");
228 /* Misc helper functions for targets. */
231 frame_num_args_unknown (struct frame_info
*fi
)
238 generic_register_convertible_not (int num
)
244 /* Under some ABI's that specify the `struct convention' for returning
245 structures by value, by the time we've returned from the function,
246 the return value is sitting there in the caller's buffer, but GDB
247 has no way to find the address of that buffer.
249 On such architectures, use this function as your
250 extract_struct_value_address method. When asked to a struct
251 returned by value in this fashion, GDB will print a nice error
252 message, instead of garbage. */
254 generic_cannot_extract_struct_value_address (char *dummy
)
260 default_register_sim_regno (int num
)
267 core_addr_identity (CORE_ADDR addr
)
273 no_op_reg_to_regnum (int reg
)
278 /* For use by frame_args_address and frame_locals_address. */
280 default_frame_address (struct frame_info
*fi
)
285 /* Default prepare_to_procced(). */
287 default_prepare_to_proceed (int select_it
)
292 /* Generic prepare_to_proceed(). This one should be suitable for most
293 targets that support threads. */
295 generic_prepare_to_proceed (int select_it
)
298 struct target_waitstatus wait_status
;
300 /* Get the last target status returned by target_wait(). */
301 get_last_target_status (&wait_ptid
, &wait_status
);
303 /* Make sure we were stopped either at a breakpoint, or because
305 if (wait_status
.kind
!= TARGET_WAITKIND_STOPPED
306 || (wait_status
.value
.sig
!= TARGET_SIGNAL_TRAP
&&
307 wait_status
.value
.sig
!= TARGET_SIGNAL_INT
))
312 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
313 && !ptid_equal (inferior_ptid
, wait_ptid
))
315 /* Switched over from WAIT_PID. */
316 CORE_ADDR wait_pc
= read_pc_pid (wait_ptid
);
318 if (wait_pc
!= read_pc ())
322 /* Switch back to WAIT_PID thread. */
323 inferior_ptid
= wait_ptid
;
325 /* FIXME: This stuff came from switch_to_thread() in
326 thread.c (which should probably be a public function). */
327 flush_cached_frames ();
328 registers_changed ();
330 select_frame (get_current_frame (), 0);
332 /* We return 1 to indicate that there is a breakpoint here,
333 so we need to step over it before continuing to avoid
334 hitting it straight away. */
335 if (breakpoint_here_p (wait_pc
))
346 init_frame_pc_noop (int fromleaf
, struct frame_info
*prev
)
352 init_frame_pc_default (int fromleaf
, struct frame_info
*prev
)
355 prev
->pc
= SAVED_PC_AFTER_CALL (prev
->next
);
356 else if (prev
->next
!= NULL
)
357 prev
->pc
= FRAME_SAVED_PC (prev
->next
);
359 prev
->pc
= read_pc ();
363 cannot_register_not (int regnum
)
368 /* Legacy version of target_virtual_frame_pointer(). Assumes that
369 there is an FP_REGNUM and that it is the same, cooked or raw. */
372 legacy_virtual_frame_pointer (CORE_ADDR pc
,
374 LONGEST
*frame_offset
)
376 gdb_assert (FP_REGNUM
>= 0);
377 *frame_regnum
= FP_REGNUM
;
381 /* Assume the world is flat. Every register is large enough to fit a
385 generic_register_raw_size (int regnum
)
387 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
388 return TARGET_INT_BIT
/ HOST_CHAR_BIT
;
391 /* Assume the virtual size corresponds to the virtual type. */
394 generic_register_virtual_size (int regnum
)
396 return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum
));
400 /* Functions to manipulate the endianness of the target. */
402 #ifndef TARGET_BYTE_ORDER_DEFAULT
403 #define TARGET_BYTE_ORDER_DEFAULT BFD_ENDIAN_BIG /* arbitrary */
405 /* ``target_byte_order'' is only used when non- multi-arch.
406 Multi-arch targets obtain the current byte order using
407 TARGET_BYTE_ORDER which is controlled by gdbarch.*. */
408 int target_byte_order
= TARGET_BYTE_ORDER_DEFAULT
;
409 int target_byte_order_auto
= 1;
411 static const char endian_big
[] = "big";
412 static const char endian_little
[] = "little";
413 static const char endian_auto
[] = "auto";
414 static const char *endian_enum
[] =
421 static const char *set_endian_string
;
423 /* Called by ``show endian''. */
426 show_endian (char *args
, int from_tty
)
428 if (TARGET_BYTE_ORDER_AUTO
)
429 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
430 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
432 printf_unfiltered ("The target is assumed to be %s endian\n",
433 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
437 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
439 if (set_endian_string
== endian_auto
)
441 target_byte_order_auto
= 1;
443 else if (set_endian_string
== endian_little
)
445 target_byte_order_auto
= 0;
448 struct gdbarch_info info
;
449 gdbarch_info_init (&info
);
450 info
.byte_order
= BFD_ENDIAN_LITTLE
;
451 if (! gdbarch_update_p (info
))
453 printf_unfiltered ("Little endian target not supported by GDB\n");
458 target_byte_order
= BFD_ENDIAN_LITTLE
;
461 else if (set_endian_string
== endian_big
)
463 target_byte_order_auto
= 0;
466 struct gdbarch_info info
;
467 gdbarch_info_init (&info
);
468 info
.byte_order
= BFD_ENDIAN_BIG
;
469 if (! gdbarch_update_p (info
))
471 printf_unfiltered ("Big endian target not supported by GDB\n");
476 target_byte_order
= BFD_ENDIAN_BIG
;
480 internal_error (__FILE__
, __LINE__
,
481 "set_endian: bad value");
482 show_endian (NULL
, from_tty
);
485 /* Set the endianness from a BFD. */
488 set_endian_from_file (bfd
*abfd
)
492 internal_error (__FILE__
, __LINE__
,
493 "set_endian_from_file: not for multi-arch");
494 if (bfd_big_endian (abfd
))
495 want
= BFD_ENDIAN_BIG
;
497 want
= BFD_ENDIAN_LITTLE
;
498 if (TARGET_BYTE_ORDER_AUTO
)
499 target_byte_order
= want
;
500 else if (TARGET_BYTE_ORDER
!= want
)
501 warning ("%s endian file does not match %s endian target.",
502 want
== BFD_ENDIAN_BIG
? "big" : "little",
503 TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little");
507 /* Functions to manipulate the architecture of the target */
509 enum set_arch
{ set_arch_auto
, set_arch_manual
};
511 int target_architecture_auto
= 1;
513 const char *set_architecture_string
;
515 /* Old way of changing the current architecture. */
517 extern const struct bfd_arch_info bfd_default_arch_struct
;
518 const struct bfd_arch_info
*target_architecture
= &bfd_default_arch_struct
;
519 int (*target_architecture_hook
) (const struct bfd_arch_info
*ap
);
522 arch_ok (const struct bfd_arch_info
*arch
)
525 internal_error (__FILE__
, __LINE__
,
526 "arch_ok: not multi-arched");
527 /* Should be performing the more basic check that the binary is
528 compatible with GDB. */
529 /* Check with the target that the architecture is valid. */
530 return (target_architecture_hook
== NULL
531 || target_architecture_hook (arch
));
535 set_arch (const struct bfd_arch_info
*arch
,
539 internal_error (__FILE__
, __LINE__
,
540 "set_arch: not multi-arched");
545 warning ("Target may not support %s architecture",
546 arch
->printable_name
);
547 target_architecture
= arch
;
549 case set_arch_manual
:
552 printf_unfiltered ("Target does not support `%s' architecture.\n",
553 arch
->printable_name
);
557 target_architecture_auto
= 0;
558 target_architecture
= arch
;
563 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
566 /* Set the architecture from arch/machine (deprecated) */
569 set_architecture_from_arch_mach (enum bfd_architecture arch
,
572 const struct bfd_arch_info
*wanted
= bfd_lookup_arch (arch
, mach
);
574 internal_error (__FILE__
, __LINE__
,
575 "set_architecture_from_arch_mach: not multi-arched");
577 set_arch (wanted
, set_arch_manual
);
579 internal_error (__FILE__
, __LINE__
,
580 "gdbarch: hardwired architecture/machine not recognized");
583 /* Set the architecture from a BFD (deprecated) */
586 set_architecture_from_file (bfd
*abfd
)
588 const struct bfd_arch_info
*wanted
= bfd_get_arch_info (abfd
);
590 internal_error (__FILE__
, __LINE__
,
591 "set_architecture_from_file: not multi-arched");
592 if (target_architecture_auto
)
594 set_arch (wanted
, set_arch_auto
);
596 else if (wanted
!= target_architecture
)
598 warning ("%s architecture file may be incompatible with %s target.",
599 wanted
->printable_name
,
600 target_architecture
->printable_name
);
605 /* Called if the user enters ``show architecture'' without an
609 show_architecture (char *args
, int from_tty
)
612 arch
= TARGET_ARCHITECTURE
->printable_name
;
613 if (target_architecture_auto
)
614 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
616 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
620 /* Called if the user enters ``set architecture'' with or without an
624 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
626 if (strcmp (set_architecture_string
, "auto") == 0)
628 target_architecture_auto
= 1;
630 else if (GDB_MULTI_ARCH
)
632 struct gdbarch_info info
;
633 gdbarch_info_init (&info
);
634 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
635 if (info
.bfd_arch_info
== NULL
)
636 internal_error (__FILE__
, __LINE__
,
637 "set_architecture: bfd_scan_arch failed");
638 if (gdbarch_update_p (info
))
639 target_architecture_auto
= 0;
641 printf_unfiltered ("Architecture `%s' not recognized.\n",
642 set_architecture_string
);
646 const struct bfd_arch_info
*arch
647 = bfd_scan_arch (set_architecture_string
);
649 internal_error (__FILE__
, __LINE__
,
650 "set_architecture: bfd_scan_arch failed");
651 set_arch (arch
, set_arch_manual
);
653 show_architecture (NULL
, from_tty
);
656 /* Set the dynamic target-system-dependent parameters (architecture,
657 byte-order) using information found in the BFD */
660 set_gdbarch_from_file (bfd
*abfd
)
664 struct gdbarch_info info
;
665 gdbarch_info_init (&info
);
667 if (! gdbarch_update_p (info
))
668 error ("Architecture of file not recognized.\n");
672 set_architecture_from_file (abfd
);
673 set_endian_from_file (abfd
);
677 /* Initialize the current architecture. Update the ``set
678 architecture'' command so that it specifies a list of valid
681 #ifdef DEFAULT_BFD_ARCH
682 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
683 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
685 static const bfd_arch_info_type
*default_bfd_arch
;
688 #ifdef DEFAULT_BFD_VEC
689 extern const bfd_target DEFAULT_BFD_VEC
;
690 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
692 static const bfd_target
*default_bfd_vec
;
696 initialize_current_architecture (void)
698 const char **arches
= gdbarch_printable_names ();
700 /* determine a default architecture and byte order. */
701 struct gdbarch_info info
;
702 gdbarch_info_init (&info
);
704 /* Find a default architecture. */
705 if (info
.bfd_arch_info
== NULL
706 && default_bfd_arch
!= NULL
)
707 info
.bfd_arch_info
= default_bfd_arch
;
708 if (info
.bfd_arch_info
== NULL
)
710 /* Choose the architecture by taking the first one
712 const char *chosen
= arches
[0];
714 for (arch
= arches
; *arch
!= NULL
; arch
++)
716 if (strcmp (*arch
, chosen
) < 0)
720 internal_error (__FILE__
, __LINE__
,
721 "initialize_current_architecture: No arch");
722 info
.bfd_arch_info
= bfd_scan_arch (chosen
);
723 if (info
.bfd_arch_info
== NULL
)
724 internal_error (__FILE__
, __LINE__
,
725 "initialize_current_architecture: Arch not found");
728 /* take several guesses at a byte order. */
729 /* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
731 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
732 && default_bfd_vec
!= NULL
)
734 /* Extract BFD's default vector's byte order. */
735 switch (default_bfd_vec
->byteorder
)
738 info
.byte_order
= BFD_ENDIAN_BIG
;
740 case BFD_ENDIAN_LITTLE
:
741 info
.byte_order
= BFD_ENDIAN_LITTLE
;
747 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
749 /* look for ``*el-*'' in the target name. */
751 chp
= strchr (target_name
, '-');
753 && chp
- 2 >= target_name
754 && strncmp (chp
- 2, "el", 2) == 0)
755 info
.byte_order
= BFD_ENDIAN_LITTLE
;
757 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
759 /* Wire it to big-endian!!! */
760 info
.byte_order
= BFD_ENDIAN_BIG
;
765 if (! gdbarch_update_p (info
))
767 internal_error (__FILE__
, __LINE__
,
768 "initialize_current_architecture: Selection of initial architecture failed");
772 initialize_non_multiarch ();
774 /* Create the ``set architecture'' command appending ``auto'' to the
775 list of architectures. */
777 struct cmd_list_element
*c
;
778 /* Append ``auto''. */
780 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
781 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
782 arches
[nr
+ 0] = "auto";
783 arches
[nr
+ 1] = NULL
;
784 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
785 of ``const char *''. We just happen to know that the casts are
787 c
= add_set_enum_cmd ("architecture", class_support
,
788 arches
, &set_architecture_string
,
789 "Set architecture of target.",
791 c
->function
.sfunc
= set_architecture
;
792 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
793 /* Don't use set_from_show - need to print both auto/manual and
795 add_cmd ("architecture", class_support
, show_architecture
,
796 "Show the current target architecture", &showlist
);
801 /* Initialize a gdbarch info to values that will be automatically
802 overridden. Note: Originally, this ``struct info'' was initialized
803 using memset(0). Unfortunatly, that ran into problems, namely
804 BFD_ENDIAN_BIG is zero. An explicit initialization function that
805 can explicitly set each field to a well defined value is used. */
808 gdbarch_info_init (struct gdbarch_info
*info
)
810 memset (info
, 0, sizeof (struct gdbarch_info
));
811 info
->byte_order
= BFD_ENDIAN_UNKNOWN
;
816 extern initialize_file_ftype _initialize_gdbarch_utils
;
819 _initialize_gdbarch_utils (void)
821 struct cmd_list_element
*c
;
822 c
= add_set_enum_cmd ("endian", class_support
,
823 endian_enum
, &set_endian_string
,
824 "Set endianness of target.",
826 c
->function
.sfunc
= set_endian
;
827 /* Don't use set_from_show - need to print both auto/manual and
829 add_cmd ("endian", class_support
, show_endian
,
830 "Show the current byte-order", &showlist
);