1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright (C) 1998-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
24 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et al. */
27 #include "sim-regno.h"
30 #include "target-descriptions.h"
35 #include "gdbsupport/version.h"
37 #include "floatformat.h"
42 default_displaced_step_hw_singlestep (struct gdbarch
*gdbarch
)
44 return !gdbarch_software_single_step_p (gdbarch
);
48 displaced_step_at_entry_point (struct gdbarch
*gdbarch
)
53 addr
= entry_point_address ();
55 /* Inferior calls also use the entry point as a breakpoint location.
56 We don't want displaced stepping to interfere with those
57 breakpoints, so leave space. */
58 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bp_len
);
65 legacy_register_sim_regno (struct gdbarch
*gdbarch
, int regnum
)
67 /* Only makes sense to supply raw registers. */
68 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
));
69 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
70 suspected that some GDB/SIM combinations may rely on this
71 behaviour. The default should be one2one_register_sim_regno
73 if (gdbarch_register_name (gdbarch
, regnum
) != NULL
74 && gdbarch_register_name (gdbarch
, regnum
)[0] != '\0')
77 return LEGACY_SIM_REGNO_IGNORE
;
81 /* See arch-utils.h */
84 default_memtag_to_string (struct gdbarch
*gdbarch
, struct value
*tag
)
86 error (_("This architecture has no method to convert a memory tag to"
90 /* See arch-utils.h */
93 default_tagged_address_p (struct gdbarch
*gdbarch
, struct value
*address
)
95 /* By default, assume the address is untagged. */
99 /* See arch-utils.h */
102 default_memtag_matches_p (struct gdbarch
*gdbarch
, struct value
*address
)
104 /* By default, assume the tags match. */
108 /* See arch-utils.h */
111 default_set_memtags (struct gdbarch
*gdbarch
, struct value
*address
,
112 size_t length
, const gdb::byte_vector
&tags
,
113 memtag_type tag_type
)
115 /* By default, return true (successful); */
119 /* See arch-utils.h */
122 default_get_memtag (struct gdbarch
*gdbarch
, struct value
*address
,
123 memtag_type tag_type
)
125 /* By default, return no tag. */
130 generic_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
136 generic_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
142 generic_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
143 CORE_ADDR pc
, const char *name
)
149 generic_stack_frame_destroyed_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
155 default_code_of_frame_writable (struct gdbarch
*gdbarch
,
156 struct frame_info
*frame
)
161 /* Helper functions for gdbarch_inner_than */
164 core_addr_lessthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
170 core_addr_greaterthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
175 /* Misc helper functions for targets. */
178 core_addr_identity (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
184 convert_from_func_ptr_addr_identity (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
185 struct target_ops
*targ
)
191 no_op_reg_to_regnum (struct gdbarch
*gdbarch
, int reg
)
197 default_coff_make_msymbol_special (int val
, struct minimal_symbol
*msym
)
202 /* See arch-utils.h. */
205 default_make_symbol_special (struct symbol
*sym
, struct objfile
*objfile
)
210 /* See arch-utils.h. */
213 default_adjust_dwarf2_addr (CORE_ADDR pc
)
218 /* See arch-utils.h. */
221 default_adjust_dwarf2_line (CORE_ADDR addr
, int rel
)
226 /* See arch-utils.h. */
229 default_execute_dwarf_cfa_vendor_op (struct gdbarch
*gdbarch
, gdb_byte op
,
230 struct dwarf2_frame_state
*fs
)
236 cannot_register_not (struct gdbarch
*gdbarch
, int regnum
)
241 /* Legacy version of target_virtual_frame_pointer(). Assumes that
242 there is an gdbarch_deprecated_fp_regnum and that it is the same,
246 legacy_virtual_frame_pointer (struct gdbarch
*gdbarch
,
249 LONGEST
*frame_offset
)
251 /* FIXME: cagney/2002-09-13: This code is used when identifying the
252 frame pointer of the current PC. It is assuming that a single
253 register and an offset can determine this. I think it should
254 instead generate a byte code expression as that would work better
255 with things like Dwarf2's CFI. */
256 if (gdbarch_deprecated_fp_regnum (gdbarch
) >= 0
257 && gdbarch_deprecated_fp_regnum (gdbarch
)
258 < gdbarch_num_regs (gdbarch
))
259 *frame_regnum
= gdbarch_deprecated_fp_regnum (gdbarch
);
260 else if (gdbarch_sp_regnum (gdbarch
) >= 0
261 && gdbarch_sp_regnum (gdbarch
)
262 < gdbarch_num_regs (gdbarch
))
263 *frame_regnum
= gdbarch_sp_regnum (gdbarch
);
265 /* Should this be an internal error? I guess so, it is reflecting
266 an architectural limitation in the current design. */
267 internal_error (__FILE__
, __LINE__
,
268 _("No virtual frame pointer available"));
272 /* Return a floating-point format for a floating-point variable of
273 length LEN in bits. If non-NULL, NAME is the name of its type.
274 If no suitable type is found, return NULL. */
276 const struct floatformat
**
277 default_floatformat_for_type (struct gdbarch
*gdbarch
,
278 const char *name
, int len
)
280 const struct floatformat
**format
= NULL
;
282 /* Check if this is a bfloat16 type. It has the same size as the
283 IEEE half float type, so we use the base type name to tell them
285 if (name
!= nullptr && strcmp (name
, "__bf16") == 0
286 && len
== gdbarch_bfloat16_bit (gdbarch
))
287 format
= gdbarch_bfloat16_format (gdbarch
);
288 else if (len
== gdbarch_half_bit (gdbarch
))
289 format
= gdbarch_half_format (gdbarch
);
290 else if (len
== gdbarch_float_bit (gdbarch
))
291 format
= gdbarch_float_format (gdbarch
);
292 else if (len
== gdbarch_double_bit (gdbarch
))
293 format
= gdbarch_double_format (gdbarch
);
294 else if (len
== gdbarch_long_double_bit (gdbarch
))
295 format
= gdbarch_long_double_format (gdbarch
);
296 /* On i386 the 'long double' type takes 96 bits,
297 while the real number of used bits is only 80,
298 both in processor and in memory.
299 The code below accepts the real bit size. */
300 else if (gdbarch_long_double_format (gdbarch
) != NULL
301 && len
== gdbarch_long_double_format (gdbarch
)[0]->totalsize
)
302 format
= gdbarch_long_double_format (gdbarch
);
308 generic_convert_register_p (struct gdbarch
*gdbarch
, int regnum
,
315 default_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
321 generic_instruction_nullified (struct gdbarch
*gdbarch
,
322 struct regcache
*regcache
)
328 default_remote_register_number (struct gdbarch
*gdbarch
,
334 /* See arch-utils.h. */
337 default_vsyscall_range (struct gdbarch
*gdbarch
, struct mem_range
*range
)
343 /* Functions to manipulate the endianness of the target. */
345 static enum bfd_endian target_byte_order_user
= BFD_ENDIAN_UNKNOWN
;
347 static const char endian_big
[] = "big";
348 static const char endian_little
[] = "little";
349 static const char endian_auto
[] = "auto";
350 static const char *const endian_enum
[] =
357 static const char *set_endian_string
;
360 selected_byte_order (void)
362 return target_byte_order_user
;
365 /* Called by ``show endian''. */
368 show_endian (struct ui_file
*file
, int from_tty
, struct cmd_list_element
*c
,
371 if (target_byte_order_user
== BFD_ENDIAN_UNKNOWN
)
372 if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG
)
373 fprintf_unfiltered (file
, _("The target endianness is set automatically "
374 "(currently big endian).\n"));
376 fprintf_unfiltered (file
, _("The target endianness is set automatically "
377 "(currently little endian).\n"));
379 if (target_byte_order_user
== BFD_ENDIAN_BIG
)
380 fprintf_unfiltered (file
,
381 _("The target is set to big endian.\n"));
383 fprintf_unfiltered (file
,
384 _("The target is set to little endian.\n"));
388 set_endian (const char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
390 struct gdbarch_info info
;
392 gdbarch_info_init (&info
);
394 if (set_endian_string
== endian_auto
)
396 target_byte_order_user
= BFD_ENDIAN_UNKNOWN
;
397 if (! gdbarch_update_p (info
))
398 internal_error (__FILE__
, __LINE__
,
399 _("set_endian: architecture update failed"));
401 else if (set_endian_string
== endian_little
)
403 info
.byte_order
= BFD_ENDIAN_LITTLE
;
404 if (! gdbarch_update_p (info
))
405 printf_unfiltered (_("Little endian target not supported by GDB\n"));
407 target_byte_order_user
= BFD_ENDIAN_LITTLE
;
409 else if (set_endian_string
== endian_big
)
411 info
.byte_order
= BFD_ENDIAN_BIG
;
412 if (! gdbarch_update_p (info
))
413 printf_unfiltered (_("Big endian target not supported by GDB\n"));
415 target_byte_order_user
= BFD_ENDIAN_BIG
;
418 internal_error (__FILE__
, __LINE__
,
419 _("set_endian: bad value"));
421 show_endian (gdb_stdout
, from_tty
, NULL
, NULL
);
424 /* Given SELECTED, a currently selected BFD architecture, and
425 TARGET_DESC, the current target description, return what
428 SELECTED may be NULL, in which case we return the architecture
429 associated with TARGET_DESC. If SELECTED specifies a variant
430 of the architecture associated with TARGET_DESC, return the
431 more specific of the two.
433 If SELECTED is a different architecture, but it is accepted as
434 compatible by the target, we can use the target architecture.
436 If SELECTED is obviously incompatible, warn the user. */
438 static const struct bfd_arch_info
*
439 choose_architecture_for_target (const struct target_desc
*target_desc
,
440 const struct bfd_arch_info
*selected
)
442 const struct bfd_arch_info
*from_target
= tdesc_architecture (target_desc
);
443 const struct bfd_arch_info
*compat1
, *compat2
;
445 if (selected
== NULL
)
448 if (from_target
== NULL
)
451 /* struct bfd_arch_info objects are singletons: that is, there's
452 supposed to be exactly one instance for a given machine. So you
453 can tell whether two are equivalent by comparing pointers. */
454 if (from_target
== selected
)
457 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
458 incompatible. But if they are compatible, it returns the 'more
459 featureful' of the two arches. That is, if A can run code
460 written for B, but B can't run code written for A, then it'll
463 Some targets (e.g. MIPS as of 2006-12-04) don't fully
464 implement this, instead always returning NULL or the first
465 argument. We detect that case by checking both directions. */
467 compat1
= selected
->compatible (selected
, from_target
);
468 compat2
= from_target
->compatible (from_target
, selected
);
470 if (compat1
== NULL
&& compat2
== NULL
)
472 /* BFD considers the architectures incompatible. Check our
473 target description whether it accepts SELECTED as compatible
475 if (tdesc_compatible_p (target_desc
, selected
))
478 warning (_("Selected architecture %s is not compatible "
479 "with reported target architecture %s"),
480 selected
->printable_name
, from_target
->printable_name
);
488 if (compat1
== compat2
)
491 /* If the two didn't match, but one of them was a default
492 architecture, assume the more specific one is correct. This
493 handles the case where an executable or target description just
494 says "mips", but the other knows which MIPS variant. */
495 if (compat1
->the_default
)
497 if (compat2
->the_default
)
500 /* We have no idea which one is better. This is a bug, but not
501 a critical problem; warn the user. */
502 warning (_("Selected architecture %s is ambiguous with "
503 "reported target architecture %s"),
504 selected
->printable_name
, from_target
->printable_name
);
508 /* Functions to manipulate the architecture of the target. */
510 enum set_arch
{ set_arch_auto
, set_arch_manual
};
512 static const struct bfd_arch_info
*target_architecture_user
;
514 static const char *set_architecture_string
;
517 selected_architecture_name (void)
519 if (target_architecture_user
== NULL
)
522 return set_architecture_string
;
525 /* Called if the user enters ``show architecture'' without an
529 show_architecture (struct ui_file
*file
, int from_tty
,
530 struct cmd_list_element
*c
, const char *value
)
532 if (target_architecture_user
== NULL
)
533 fprintf_filtered (file
, _("The target architecture is set to "
534 "\"auto\" (currently \"%s\").\n"),
535 gdbarch_bfd_arch_info (get_current_arch ())->printable_name
);
537 fprintf_filtered (file
, _("The target architecture is set to \"%s\".\n"),
538 set_architecture_string
);
542 /* Called if the user enters ``set architecture'' with or without an
546 set_architecture (const char *ignore_args
,
547 int from_tty
, struct cmd_list_element
*c
)
549 struct gdbarch_info info
;
551 gdbarch_info_init (&info
);
553 if (strcmp (set_architecture_string
, "auto") == 0)
555 target_architecture_user
= NULL
;
556 if (!gdbarch_update_p (info
))
557 internal_error (__FILE__
, __LINE__
,
558 _("could not select an architecture automatically"));
562 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
563 if (info
.bfd_arch_info
== NULL
)
564 internal_error (__FILE__
, __LINE__
,
565 _("set_architecture: bfd_scan_arch failed"));
566 if (gdbarch_update_p (info
))
567 target_architecture_user
= info
.bfd_arch_info
;
569 printf_unfiltered (_("Architecture `%s' not recognized.\n"),
570 set_architecture_string
);
572 show_architecture (gdb_stdout
, from_tty
, NULL
, NULL
);
575 /* Try to select a global architecture that matches "info". Return
576 non-zero if the attempt succeeds. */
578 gdbarch_update_p (struct gdbarch_info info
)
580 struct gdbarch
*new_gdbarch
;
582 /* Check for the current file. */
583 if (info
.abfd
== NULL
)
584 info
.abfd
= current_program_space
->exec_bfd ();
585 if (info
.abfd
== NULL
)
586 info
.abfd
= core_bfd
;
588 /* Check for the current target description. */
589 if (info
.target_desc
== NULL
)
590 info
.target_desc
= target_current_description ();
592 new_gdbarch
= gdbarch_find_by_info (info
);
594 /* If there no architecture by that name, reject the request. */
595 if (new_gdbarch
== NULL
)
598 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update_p: "
599 "Architecture not found\n");
603 /* If it is the same old architecture, accept the request (but don't
605 if (new_gdbarch
== target_gdbarch ())
608 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update_p: "
609 "Architecture %s (%s) unchanged\n",
610 host_address_to_string (new_gdbarch
),
611 gdbarch_bfd_arch_info (new_gdbarch
)->printable_name
);
615 /* It's a new architecture, swap it in. */
617 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update_p: "
618 "New architecture %s (%s) selected\n",
619 host_address_to_string (new_gdbarch
),
620 gdbarch_bfd_arch_info (new_gdbarch
)->printable_name
);
621 set_target_gdbarch (new_gdbarch
);
626 /* Return the architecture for ABFD. If no suitable architecture
627 could be find, return NULL. */
630 gdbarch_from_bfd (bfd
*abfd
)
632 struct gdbarch_info info
;
633 gdbarch_info_init (&info
);
636 return gdbarch_find_by_info (info
);
639 /* Set the dynamic target-system-dependent parameters (architecture,
640 byte-order) using information found in the BFD */
643 set_gdbarch_from_file (bfd
*abfd
)
645 struct gdbarch_info info
;
646 struct gdbarch
*gdbarch
;
648 gdbarch_info_init (&info
);
650 info
.target_desc
= target_current_description ();
651 gdbarch
= gdbarch_find_by_info (info
);
654 error (_("Architecture of file not recognized."));
655 set_target_gdbarch (gdbarch
);
658 /* Initialize the current architecture. Update the ``set
659 architecture'' command so that it specifies a list of valid
662 #ifdef DEFAULT_BFD_ARCH
663 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
664 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
666 static const bfd_arch_info_type
*default_bfd_arch
;
669 #ifdef DEFAULT_BFD_VEC
670 extern const bfd_target DEFAULT_BFD_VEC
;
671 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
673 static const bfd_target
*default_bfd_vec
;
676 static enum bfd_endian default_byte_order
= BFD_ENDIAN_UNKNOWN
;
679 initialize_current_architecture (void)
681 const char **arches
= gdbarch_printable_names ();
682 struct gdbarch_info info
;
684 /* determine a default architecture and byte order. */
685 gdbarch_info_init (&info
);
687 /* Find a default architecture. */
688 if (default_bfd_arch
== NULL
)
690 /* Choose the architecture by taking the first one
692 const char *chosen
= arches
[0];
694 for (arch
= arches
; *arch
!= NULL
; arch
++)
696 if (strcmp (*arch
, chosen
) < 0)
700 internal_error (__FILE__
, __LINE__
,
701 _("initialize_current_architecture: No arch"));
702 default_bfd_arch
= bfd_scan_arch (chosen
);
703 if (default_bfd_arch
== NULL
)
704 internal_error (__FILE__
, __LINE__
,
705 _("initialize_current_architecture: Arch not found"));
708 info
.bfd_arch_info
= default_bfd_arch
;
710 /* Take several guesses at a byte order. */
711 if (default_byte_order
== BFD_ENDIAN_UNKNOWN
712 && default_bfd_vec
!= NULL
)
714 /* Extract BFD's default vector's byte order. */
715 switch (default_bfd_vec
->byteorder
)
718 default_byte_order
= BFD_ENDIAN_BIG
;
720 case BFD_ENDIAN_LITTLE
:
721 default_byte_order
= BFD_ENDIAN_LITTLE
;
727 if (default_byte_order
== BFD_ENDIAN_UNKNOWN
)
729 /* look for ``*el-*'' in the target name. */
731 chp
= strchr (target_name
, '-');
733 && chp
- 2 >= target_name
734 && startswith (chp
- 2, "el"))
735 default_byte_order
= BFD_ENDIAN_LITTLE
;
737 if (default_byte_order
== BFD_ENDIAN_UNKNOWN
)
739 /* Wire it to big-endian!!! */
740 default_byte_order
= BFD_ENDIAN_BIG
;
743 info
.byte_order
= default_byte_order
;
744 info
.byte_order_for_code
= info
.byte_order
;
746 if (! gdbarch_update_p (info
))
747 internal_error (__FILE__
, __LINE__
,
748 _("initialize_current_architecture: Selection of "
749 "initial architecture failed"));
751 /* Create the ``set architecture'' command appending ``auto'' to the
752 list of architectures. */
754 /* Append ``auto''. */
756 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
757 arches
= XRESIZEVEC (const char *, arches
, nr
+ 2);
758 arches
[nr
+ 0] = "auto";
759 arches
[nr
+ 1] = NULL
;
760 set_show_commands architecture_cmds
761 = add_setshow_enum_cmd ("architecture", class_support
,
762 arches
, &set_architecture_string
,
763 _("Set architecture of target."),
764 _("Show architecture of target."), NULL
,
765 set_architecture
, show_architecture
,
766 &setlist
, &showlist
);
767 add_alias_cmd ("processor", architecture_cmds
.set
, class_support
, 1,
773 /* Initialize a gdbarch info to values that will be automatically
774 overridden. Note: Originally, this ``struct info'' was initialized
775 using memset(0). Unfortunately, that ran into problems, namely
776 BFD_ENDIAN_BIG is zero. An explicit initialization function that
777 can explicitly set each field to a well defined value is used. */
780 gdbarch_info_init (struct gdbarch_info
*info
)
782 memset (info
, 0, sizeof (struct gdbarch_info
));
783 info
->byte_order
= BFD_ENDIAN_UNKNOWN
;
784 info
->byte_order_for_code
= info
->byte_order
;
787 /* Similar to init, but this time fill in the blanks. Information is
788 obtained from the global "set ..." options and explicitly
789 initialized INFO fields. */
792 gdbarch_info_fill (struct gdbarch_info
*info
)
794 /* "(gdb) set architecture ...". */
795 if (info
->bfd_arch_info
== NULL
796 && target_architecture_user
)
797 info
->bfd_arch_info
= target_architecture_user
;
799 if (info
->bfd_arch_info
== NULL
800 && info
->abfd
!= NULL
801 && bfd_get_arch (info
->abfd
) != bfd_arch_unknown
802 && bfd_get_arch (info
->abfd
) != bfd_arch_obscure
)
803 info
->bfd_arch_info
= bfd_get_arch_info (info
->abfd
);
804 /* From the target. */
805 if (info
->target_desc
!= NULL
)
806 info
->bfd_arch_info
= choose_architecture_for_target
807 (info
->target_desc
, info
->bfd_arch_info
);
808 /* From the default. */
809 if (info
->bfd_arch_info
== NULL
)
810 info
->bfd_arch_info
= default_bfd_arch
;
812 /* "(gdb) set byte-order ...". */
813 if (info
->byte_order
== BFD_ENDIAN_UNKNOWN
814 && target_byte_order_user
!= BFD_ENDIAN_UNKNOWN
)
815 info
->byte_order
= target_byte_order_user
;
816 /* From the INFO struct. */
817 if (info
->byte_order
== BFD_ENDIAN_UNKNOWN
818 && info
->abfd
!= NULL
)
819 info
->byte_order
= (bfd_big_endian (info
->abfd
) ? BFD_ENDIAN_BIG
820 : bfd_little_endian (info
->abfd
) ? BFD_ENDIAN_LITTLE
821 : BFD_ENDIAN_UNKNOWN
);
822 /* From the default. */
823 if (info
->byte_order
== BFD_ENDIAN_UNKNOWN
)
824 info
->byte_order
= default_byte_order
;
825 info
->byte_order_for_code
= info
->byte_order
;
826 /* Wire the default to the last selected byte order. */
827 default_byte_order
= info
->byte_order
;
829 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
830 /* From the manual override, or from file. */
831 if (info
->osabi
== GDB_OSABI_UNKNOWN
)
832 info
->osabi
= gdbarch_lookup_osabi (info
->abfd
);
833 /* From the target. */
835 if (info
->osabi
== GDB_OSABI_UNKNOWN
&& info
->target_desc
!= NULL
)
836 info
->osabi
= tdesc_osabi (info
->target_desc
);
837 /* From the configured default. */
838 #ifdef GDB_OSABI_DEFAULT
839 if (info
->osabi
== GDB_OSABI_UNKNOWN
)
840 info
->osabi
= GDB_OSABI_DEFAULT
;
842 /* If we still don't know which osabi to pick, pick none. */
843 if (info
->osabi
== GDB_OSABI_UNKNOWN
)
844 info
->osabi
= GDB_OSABI_NONE
;
846 /* Must have at least filled in the architecture. */
847 gdb_assert (info
->bfd_arch_info
!= NULL
);
850 /* Return "current" architecture. If the target is running, this is
851 the architecture of the selected frame. Otherwise, the "current"
852 architecture defaults to the target architecture.
854 This function should normally be called solely by the command
855 interpreter routines to determine the architecture to execute a
858 get_current_arch (void)
860 if (has_stack_frames ())
861 return get_frame_arch (get_selected_frame (NULL
));
863 return target_gdbarch ();
867 default_has_shared_address_space (struct gdbarch
*gdbarch
)
869 /* Simply say no. In most unix-like targets each inferior/process
870 has its own address space. */
875 default_fast_tracepoint_valid_at (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
878 /* We don't know if maybe the target has some way to do fast
879 tracepoints that doesn't need gdbarch, so always say yes. */
886 default_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
,
889 int kind
= gdbarch_breakpoint_kind_from_pc (gdbarch
, pcptr
);
891 return gdbarch_sw_breakpoint_from_kind (gdbarch
, kind
, lenptr
);
894 default_breakpoint_kind_from_current_state (struct gdbarch
*gdbarch
,
895 struct regcache
*regcache
,
898 return gdbarch_breakpoint_kind_from_pc (gdbarch
, pcptr
);
903 default_gen_return_address (struct gdbarch
*gdbarch
,
904 struct agent_expr
*ax
, struct axs_value
*value
,
907 error (_("This architecture has no method to collect a return address."));
911 default_return_in_first_hidden_param_p (struct gdbarch
*gdbarch
,
914 /* Usually, the return value's address is stored the in the "first hidden"
915 parameter if the return value should be passed by reference, as
917 return !(language_pass_by_reference (type
).trivially_copyable
);
920 int default_insn_is_call (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
925 int default_insn_is_ret (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
930 int default_insn_is_jump (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
935 /* See arch-utils.h. */
938 default_program_breakpoint_here_p (struct gdbarch
*gdbarch
,
942 const gdb_byte
*bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &address
, &len
);
944 /* Software breakpoints unsupported? */
945 if (bpoint
== nullptr)
948 gdb_byte
*target_mem
= (gdb_byte
*) alloca (len
);
950 /* Enable the automatic memory restoration from breakpoints while
951 we read the memory. Otherwise we may find temporary breakpoints, ones
952 inserted by GDB, and flag them as permanent breakpoints. */
953 scoped_restore restore_memory
954 = make_scoped_restore_show_memory_breakpoints (0);
956 if (target_read_memory (address
, target_mem
, len
) == 0)
958 /* Check if this is a breakpoint instruction for this architecture,
959 including ones used by GDB. */
960 if (memcmp (target_mem
, bpoint
, len
) == 0)
968 default_skip_permanent_breakpoint (struct regcache
*regcache
)
970 struct gdbarch
*gdbarch
= regcache
->arch ();
971 CORE_ADDR current_pc
= regcache_read_pc (regcache
);
974 gdbarch_breakpoint_from_pc (gdbarch
, ¤t_pc
, &bp_len
);
975 current_pc
+= bp_len
;
976 regcache_write_pc (regcache
, current_pc
);
980 default_infcall_mmap (CORE_ADDR size
, unsigned prot
)
982 error (_("This target does not support inferior memory allocation by mmap."));
986 default_infcall_munmap (CORE_ADDR addr
, CORE_ADDR size
)
988 /* Memory reserved by inferior mmap is kept leaked. */
991 /* -mcmodel=large is used so that no GOT (Global Offset Table) is needed to be
992 created in inferior memory by GDB (normally it is set by ld.so). */
995 default_gcc_target_options (struct gdbarch
*gdbarch
)
997 return string_printf ("-m%d%s", gdbarch_ptr_bit (gdbarch
),
998 (gdbarch_ptr_bit (gdbarch
) == 64
999 ? " -mcmodel=large" : ""));
1002 /* gdbarch gnu_triplet_regexp method. */
1005 default_gnu_triplet_regexp (struct gdbarch
*gdbarch
)
1007 return gdbarch_bfd_arch_info (gdbarch
)->arch_name
;
1010 /* Default method for gdbarch_addressable_memory_unit_size. The default is
1011 based on the bits_per_byte defined in the bfd library for the current
1012 architecture, this is usually 8-bits, and so this function will usually
1013 return 1 indicating 1 byte is 1 octet. */
1016 default_addressable_memory_unit_size (struct gdbarch
*gdbarch
)
1018 return gdbarch_bfd_arch_info (gdbarch
)->bits_per_byte
/ 8;
1022 default_guess_tracepoint_registers (struct gdbarch
*gdbarch
,
1023 struct regcache
*regcache
,
1026 int pc_regno
= gdbarch_pc_regnum (gdbarch
);
1029 /* This guessing code below only works if the PC register isn't
1030 a pseudo-register. The value of a pseudo-register isn't stored
1031 in the (non-readonly) regcache -- instead it's recomputed
1032 (probably from some other cached raw register) whenever the
1033 register is read. In this case, a custom method implementation
1034 should be used by the architecture. */
1035 if (pc_regno
< 0 || pc_regno
>= gdbarch_num_regs (gdbarch
))
1038 regs
= (gdb_byte
*) alloca (register_size (gdbarch
, pc_regno
));
1039 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
1040 gdbarch_byte_order (gdbarch
), addr
);
1041 regcache
->raw_supply (pc_regno
, regs
);
1045 default_print_insn (bfd_vma memaddr
, disassemble_info
*info
)
1047 disassembler_ftype disassemble_fn
;
1049 disassemble_fn
= disassembler (info
->arch
, info
->endian
== BFD_ENDIAN_BIG
,
1050 info
->mach
, current_program_space
->exec_bfd ());
1052 gdb_assert (disassemble_fn
!= NULL
);
1053 return (*disassemble_fn
) (memaddr
, info
);
1056 /* See arch-utils.h. */
1059 gdbarch_skip_prologue_noexcept (gdbarch
*gdbarch
, CORE_ADDR pc
) noexcept
1061 CORE_ADDR new_pc
= pc
;
1065 new_pc
= gdbarch_skip_prologue (gdbarch
, pc
);
1067 catch (const gdb_exception
&ex
)
1073 /* See arch-utils.h. */
1076 default_in_indirect_branch_thunk (gdbarch
*gdbarch
, CORE_ADDR pc
)
1081 /* See arch-utils.h. */
1084 default_type_align (struct gdbarch
*gdbarch
, struct type
*type
)
1089 /* See arch-utils.h. */
1092 default_get_pc_address_flags (frame_info
*frame
, CORE_ADDR pc
)
1097 /* See arch-utils.h. */
1099 default_read_core_file_mappings (struct gdbarch
*gdbarch
,
1101 gdb::function_view
<void (ULONGEST count
)>
1103 gdb::function_view
<void (int num
,
1107 const char *filename
)>
1112 void _initialize_gdbarch_utils ();
1114 _initialize_gdbarch_utils ()
1116 add_setshow_enum_cmd ("endian", class_support
,
1117 endian_enum
, &set_endian_string
,
1118 _("Set endianness of target."),
1119 _("Show endianness of target."),
1120 NULL
, set_endian
, show_endian
,
1121 &setlist
, &showlist
);