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. */
25 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
27 /* Just include everything in sight so that the every old definition
28 of macro is visible. */
29 #include "gdb_string.h"
33 #include "breakpoint.h"
41 #include "gdb_assert.h"
45 #include "floatformat.h"
47 /* Use the program counter to determine the contents and size
48 of a breakpoint instruction. If no target-dependent macro
49 BREAKPOINT_FROM_PC has been defined to implement this function,
50 assume that the breakpoint doesn't depend on the PC, and
51 use the values of the BIG_BREAKPOINT and LITTLE_BREAKPOINT macros.
52 Return a pointer to a string of bytes that encode a breakpoint
53 instruction, stores the length of the string to *lenptr,
54 and optionally adjust the pc to point to the correct memory location
55 for inserting the breakpoint. */
58 legacy_breakpoint_from_pc (CORE_ADDR
* pcptr
, int *lenptr
)
60 /* {BIG_,LITTLE_}BREAKPOINT is the sequence of bytes we insert for a
61 breakpoint. On some machines, breakpoints are handled by the
62 target environment and we don't have to worry about them here. */
64 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
66 static unsigned char big_break_insn
[] = BIG_BREAKPOINT
;
67 *lenptr
= sizeof (big_break_insn
);
68 return big_break_insn
;
71 #ifdef LITTLE_BREAKPOINT
72 if (TARGET_BYTE_ORDER
!= BIG_ENDIAN
)
74 static unsigned char little_break_insn
[] = LITTLE_BREAKPOINT
;
75 *lenptr
= sizeof (little_break_insn
);
76 return little_break_insn
;
81 static unsigned char break_insn
[] = BREAKPOINT
;
82 *lenptr
= sizeof (break_insn
);
91 generic_frameless_function_invocation_not (struct frame_info
*fi
)
97 generic_return_value_on_stack_not (struct type
*type
)
103 generic_skip_trampoline_code (CORE_ADDR pc
)
109 generic_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
115 generic_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
121 legacy_register_name (int i
)
123 #ifdef REGISTER_NAMES
124 static char *names
[] = REGISTER_NAMES
;
125 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
130 internal_error (__FILE__
, __LINE__
,
131 "legacy_register_name: called.");
136 #if defined (CALL_DUMMY)
137 LONGEST legacy_call_dummy_words
[] = CALL_DUMMY
;
139 LONGEST legacy_call_dummy_words
[1];
141 int legacy_sizeof_call_dummy_words
= sizeof (legacy_call_dummy_words
);
144 generic_remote_translate_xfer_address (CORE_ADDR gdb_addr
, int gdb_len
,
145 CORE_ADDR
* rem_addr
, int *rem_len
)
147 *rem_addr
= gdb_addr
;
152 generic_prologue_frameless_p (CORE_ADDR ip
)
154 #ifdef SKIP_PROLOGUE_FRAMELESS_P
155 return ip
== SKIP_PROLOGUE_FRAMELESS_P (ip
);
157 return ip
== SKIP_PROLOGUE (ip
);
161 /* New/multi-arched targets should use the correct gdbarch field
162 instead of using this global pointer. */
164 legacy_print_insn (bfd_vma vma
, disassemble_info
*info
)
166 return (*tm_print_insn
) (vma
, info
);
169 /* Helper functions for INNER_THAN */
172 core_addr_lessthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
178 core_addr_greaterthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
184 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
186 const struct floatformat
*
187 default_float_format (struct gdbarch
*gdbarch
)
190 int byte_order
= gdbarch_byte_order (gdbarch
);
192 int byte_order
= TARGET_BYTE_ORDER
;
197 return &floatformat_ieee_single_big
;
199 return &floatformat_ieee_single_little
;
201 internal_error (__FILE__
, __LINE__
,
202 "default_float_format: bad byte order");
207 const struct floatformat
*
208 default_double_format (struct gdbarch
*gdbarch
)
211 int byte_order
= gdbarch_byte_order (gdbarch
);
213 int byte_order
= TARGET_BYTE_ORDER
;
218 return &floatformat_ieee_double_big
;
220 return &floatformat_ieee_double_little
;
222 internal_error (__FILE__
, __LINE__
,
223 "default_double_format: bad byte order");
227 /* Misc helper functions for targets. */
230 frame_num_args_unknown (struct frame_info
*fi
)
237 generic_register_convertible_not (int num
)
244 default_register_sim_regno (int num
)
251 core_addr_identity (CORE_ADDR addr
)
257 no_op_reg_to_regnum (int reg
)
262 /* For use by frame_args_address and frame_locals_address. */
264 default_frame_address (struct frame_info
*fi
)
269 /* Default prepare_to_procced(). */
271 default_prepare_to_proceed (int select_it
)
276 /* Generic prepare_to_proceed(). This one should be suitable for most
277 targets that support threads. */
279 generic_prepare_to_proceed (int select_it
)
282 struct target_waitstatus wait_status
;
284 /* Get the last target status returned by target_wait(). */
285 get_last_target_status (&wait_ptid
, &wait_status
);
287 /* Make sure we were stopped either at a breakpoint, or because
289 if (wait_status
.kind
!= TARGET_WAITKIND_STOPPED
290 || (wait_status
.value
.sig
!= TARGET_SIGNAL_TRAP
&&
291 wait_status
.value
.sig
!= TARGET_SIGNAL_INT
))
296 if (!ptid_equal (wait_ptid
, minus_one_ptid
)
297 && !ptid_equal (inferior_ptid
, wait_ptid
))
299 /* Switched over from WAIT_PID. */
300 CORE_ADDR wait_pc
= read_pc_pid (wait_ptid
);
302 if (wait_pc
!= read_pc ())
306 /* Switch back to WAIT_PID thread. */
307 inferior_ptid
= wait_ptid
;
309 /* FIXME: This stuff came from switch_to_thread() in
310 thread.c (which should probably be a public function). */
311 flush_cached_frames ();
312 registers_changed ();
314 select_frame (get_current_frame (), 0);
316 /* We return 1 to indicate that there is a breakpoint here,
317 so we need to step over it before continuing to avoid
318 hitting it straight away. */
319 if (breakpoint_here_p (wait_pc
))
330 init_frame_pc_noop (int fromleaf
, struct frame_info
*prev
)
336 init_frame_pc_default (int fromleaf
, struct frame_info
*prev
)
339 prev
->pc
= SAVED_PC_AFTER_CALL (prev
->next
);
340 else if (prev
->next
!= NULL
)
341 prev
->pc
= FRAME_SAVED_PC (prev
->next
);
343 prev
->pc
= read_pc ();
347 cannot_register_not (int regnum
)
352 /* Legacy version of target_virtual_frame_pointer(). Assumes that
353 there is an FP_REGNUM and that it is the same, cooked or raw. */
356 legacy_virtual_frame_pointer (CORE_ADDR pc
,
358 LONGEST
*frame_offset
)
360 gdb_assert (FP_REGNUM
>= 0);
361 *frame_regnum
= FP_REGNUM
;
365 /* Functions to manipulate the endianness of the target. */
367 #ifdef TARGET_BYTE_ORDER_SELECTABLE
368 /* compat - Catch old targets that expect a selectable byte-order to
369 default to BIG_ENDIAN */
370 #ifndef TARGET_BYTE_ORDER_DEFAULT
371 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
374 #if !TARGET_BYTE_ORDER_SELECTABLE_P
375 #ifndef TARGET_BYTE_ORDER_DEFAULT
376 /* compat - Catch old non byte-order selectable targets that do not
377 define TARGET_BYTE_ORDER_DEFAULT and instead expect
378 TARGET_BYTE_ORDER to be used as the default. For targets that
379 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
380 below will get a strange compiler warning. */
381 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
384 #ifndef TARGET_BYTE_ORDER_DEFAULT
385 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
387 /* ``target_byte_order'' is only used when non- multi-arch.
388 Multi-arch targets obtain the current byte order using
389 TARGET_BYTE_ORDER which is controlled by gdbarch.*. */
390 int target_byte_order
= TARGET_BYTE_ORDER_DEFAULT
;
391 int target_byte_order_auto
= 1;
393 static const char endian_big
[] = "big";
394 static const char endian_little
[] = "little";
395 static const char endian_auto
[] = "auto";
396 static const char *endian_enum
[] =
403 static const char *set_endian_string
;
405 /* Called by ``show endian''. */
408 show_endian (char *args
, int from_tty
)
410 if (TARGET_BYTE_ORDER_AUTO
)
411 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
412 (TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little"));
414 printf_unfiltered ("The target is assumed to be %s endian\n",
415 (TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little"));
419 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
421 if (!TARGET_BYTE_ORDER_SELECTABLE_P
)
423 printf_unfiltered ("Byte order is not selectable.");
425 else if (set_endian_string
== endian_auto
)
427 target_byte_order_auto
= 1;
429 else if (set_endian_string
== endian_little
)
431 target_byte_order_auto
= 0;
434 struct gdbarch_info info
;
435 memset (&info
, 0, sizeof info
);
436 info
.byte_order
= LITTLE_ENDIAN
;
437 if (! gdbarch_update_p (info
))
439 printf_unfiltered ("Little endian target not supported by GDB\n");
444 target_byte_order
= LITTLE_ENDIAN
;
447 else if (set_endian_string
== endian_big
)
449 target_byte_order_auto
= 0;
452 struct gdbarch_info info
;
453 memset (&info
, 0, sizeof info
);
454 info
.byte_order
= BIG_ENDIAN
;
455 if (! gdbarch_update_p (info
))
457 printf_unfiltered ("Big endian target not supported by GDB\n");
462 target_byte_order
= BIG_ENDIAN
;
466 internal_error (__FILE__
, __LINE__
,
467 "set_endian: bad value");
468 show_endian (NULL
, from_tty
);
471 /* Set the endianness from a BFD. */
474 set_endian_from_file (bfd
*abfd
)
477 internal_error (__FILE__
, __LINE__
,
478 "set_endian_from_file: not for multi-arch");
479 if (TARGET_BYTE_ORDER_SELECTABLE_P
)
483 if (bfd_big_endian (abfd
))
486 want
= LITTLE_ENDIAN
;
487 if (TARGET_BYTE_ORDER_AUTO
)
488 target_byte_order
= want
;
489 else if (TARGET_BYTE_ORDER
!= want
)
490 warning ("%s endian file does not match %s endian target.",
491 want
== BIG_ENDIAN
? "big" : "little",
492 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
496 if (bfd_big_endian (abfd
)
497 ? TARGET_BYTE_ORDER
!= BIG_ENDIAN
498 : TARGET_BYTE_ORDER
== BIG_ENDIAN
)
499 warning ("%s endian file does not match %s endian target.",
500 bfd_big_endian (abfd
) ? "big" : "little",
501 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
506 /* Functions to manipulate the architecture of the target */
508 enum set_arch
{ set_arch_auto
, set_arch_manual
};
510 int target_architecture_auto
= 1;
512 const char *set_architecture_string
;
514 /* Old way of changing the current architecture. */
516 extern const struct bfd_arch_info bfd_default_arch_struct
;
517 const struct bfd_arch_info
*target_architecture
= &bfd_default_arch_struct
;
518 int (*target_architecture_hook
) (const struct bfd_arch_info
*ap
);
521 arch_ok (const struct bfd_arch_info
*arch
)
524 internal_error (__FILE__
, __LINE__
,
525 "arch_ok: not multi-arched");
526 /* Should be performing the more basic check that the binary is
527 compatible with GDB. */
528 /* Check with the target that the architecture is valid. */
529 return (target_architecture_hook
== NULL
530 || target_architecture_hook (arch
));
534 set_arch (const struct bfd_arch_info
*arch
,
538 internal_error (__FILE__
, __LINE__
,
539 "set_arch: not multi-arched");
544 warning ("Target may not support %s architecture",
545 arch
->printable_name
);
546 target_architecture
= arch
;
548 case set_arch_manual
:
551 printf_unfiltered ("Target does not support `%s' architecture.\n",
552 arch
->printable_name
);
556 target_architecture_auto
= 0;
557 target_architecture
= arch
;
562 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
565 /* Set the architecture from arch/machine (deprecated) */
568 set_architecture_from_arch_mach (enum bfd_architecture arch
,
571 const struct bfd_arch_info
*wanted
= bfd_lookup_arch (arch
, mach
);
573 internal_error (__FILE__
, __LINE__
,
574 "set_architecture_from_arch_mach: not multi-arched");
576 set_arch (wanted
, set_arch_manual
);
578 internal_error (__FILE__
, __LINE__
,
579 "gdbarch: hardwired architecture/machine not recognized");
582 /* Set the architecture from a BFD (deprecated) */
585 set_architecture_from_file (bfd
*abfd
)
587 const struct bfd_arch_info
*wanted
= bfd_get_arch_info (abfd
);
589 internal_error (__FILE__
, __LINE__
,
590 "set_architecture_from_file: not multi-arched");
591 if (target_architecture_auto
)
593 set_arch (wanted
, set_arch_auto
);
595 else if (wanted
!= target_architecture
)
597 warning ("%s architecture file may be incompatible with %s target.",
598 wanted
->printable_name
,
599 target_architecture
->printable_name
);
604 /* Called if the user enters ``show architecture'' without an
608 show_architecture (char *args
, int from_tty
)
611 arch
= TARGET_ARCHITECTURE
->printable_name
;
612 if (target_architecture_auto
)
613 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
615 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
619 /* Called if the user enters ``set architecture'' with or without an
623 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
625 if (strcmp (set_architecture_string
, "auto") == 0)
627 target_architecture_auto
= 1;
629 else if (GDB_MULTI_ARCH
)
631 struct gdbarch_info info
;
632 memset (&info
, 0, sizeof info
);
633 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
634 if (info
.bfd_arch_info
== NULL
)
635 internal_error (__FILE__
, __LINE__
,
636 "set_architecture: bfd_scan_arch failed");
637 if (gdbarch_update_p (info
))
638 target_architecture_auto
= 0;
640 printf_unfiltered ("Architecture `%s' not recognized.\n",
641 set_architecture_string
);
645 const struct bfd_arch_info
*arch
646 = bfd_scan_arch (set_architecture_string
);
648 internal_error (__FILE__
, __LINE__
,
649 "set_architecture: bfd_scan_arch failed");
650 set_arch (arch
, set_arch_manual
);
652 show_architecture (NULL
, from_tty
);
655 /* Set the dynamic target-system-dependent parameters (architecture,
656 byte-order) using information found in the BFD */
659 set_gdbarch_from_file (bfd
*abfd
)
663 struct gdbarch_info info
;
664 memset (&info
, 0, sizeof info
);
666 if (! gdbarch_update_p (info
))
667 error ("Architecture of file not recognized.\n");
671 set_architecture_from_file (abfd
);
672 set_endian_from_file (abfd
);
676 /* Initialize the current architecture. Update the ``set
677 architecture'' command so that it specifies a list of valid
680 #ifdef DEFAULT_BFD_ARCH
681 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
682 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
684 static const bfd_arch_info_type
*default_bfd_arch
;
687 #ifdef DEFAULT_BFD_VEC
688 extern const bfd_target DEFAULT_BFD_VEC
;
689 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
691 static const bfd_target
*default_bfd_vec
;
695 initialize_current_architecture (void)
697 const char **arches
= gdbarch_printable_names ();
699 /* determine a default architecture and byte order. */
700 struct gdbarch_info info
;
701 memset (&info
, 0, sizeof (info
));
703 /* Find a default architecture. */
704 if (info
.bfd_arch_info
== NULL
705 && default_bfd_arch
!= NULL
)
706 info
.bfd_arch_info
= default_bfd_arch
;
707 if (info
.bfd_arch_info
== NULL
)
709 /* Choose the architecture by taking the first one
711 const char *chosen
= arches
[0];
713 for (arch
= arches
; *arch
!= NULL
; arch
++)
715 if (strcmp (*arch
, chosen
) < 0)
719 internal_error (__FILE__
, __LINE__
,
720 "initialize_current_architecture: No arch");
721 info
.bfd_arch_info
= bfd_scan_arch (chosen
);
722 if (info
.bfd_arch_info
== NULL
)
723 internal_error (__FILE__
, __LINE__
,
724 "initialize_current_architecture: Arch not found");
727 /* take several guesses at a byte order. */
728 /* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
730 if (info
.byte_order
== 0
731 && default_bfd_vec
!= NULL
)
733 /* Extract BFD's default vector's byte order. */
734 switch (default_bfd_vec
->byteorder
)
737 info
.byte_order
= BIG_ENDIAN
;
739 case BFD_ENDIAN_LITTLE
:
740 info
.byte_order
= LITTLE_ENDIAN
;
746 if (info
.byte_order
== 0)
748 /* look for ``*el-*'' in the target name. */
750 chp
= strchr (target_name
, '-');
752 && chp
- 2 >= target_name
753 && strncmp (chp
- 2, "el", 2) == 0)
754 info
.byte_order
= LITTLE_ENDIAN
;
756 if (info
.byte_order
== 0)
758 /* Wire it to big-endian!!! */
759 info
.byte_order
= BIG_ENDIAN
;
764 if (! gdbarch_update_p (info
))
766 internal_error (__FILE__
, __LINE__
,
767 "initialize_current_architecture: Selection of initial architecture failed");
771 initialize_non_multiarch ();
773 /* Create the ``set architecture'' command appending ``auto'' to the
774 list of architectures. */
776 struct cmd_list_element
*c
;
777 /* Append ``auto''. */
779 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
780 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
781 arches
[nr
+ 0] = "auto";
782 arches
[nr
+ 1] = NULL
;
783 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
784 of ``const char *''. We just happen to know that the casts are
786 c
= add_set_enum_cmd ("architecture", class_support
,
787 arches
, &set_architecture_string
,
788 "Set architecture of target.",
790 c
->function
.sfunc
= set_architecture
;
791 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
792 /* Don't use set_from_show - need to print both auto/manual and
794 add_cmd ("architecture", class_support
, show_architecture
,
795 "Show the current target architecture", &showlist
);
802 extern initialize_file_ftype _initialize_gdbarch_utils
;
805 _initialize_gdbarch_utils (void)
807 struct cmd_list_element
*c
;
808 c
= add_set_enum_cmd ("endian", class_support
,
809 endian_enum
, &set_endian_string
,
810 "Set endianness of target.",
812 c
->function
.sfunc
= set_endian
;
813 /* Don't use set_from_show - need to print both auto/manual and
815 add_cmd ("endian", class_support
, show_endian
,
816 "Show the current byte-order", &showlist
);