Update readelf's display of RELR sections to include the number of locations relocated
[binutils-gdb.git] / gdb / arch-utils.c
blobb8a18a58af2a91fd24a64b64e2f5bdb64b134c30
1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright (C) 1998-2024 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/>. */
21 #include "arch-utils.h"
22 #include "extract-store-integer.h"
23 #include "gdbcmd.h"
24 #include "inferior.h"
25 #include "infrun.h"
26 #include "regcache.h"
27 #include "sim-regno.h"
28 #include "gdbcore.h"
29 #include "osabi.h"
30 #include "target-descriptions.h"
31 #include "objfiles.h"
32 #include "language.h"
33 #include "symtab.h"
34 #include "dummy-frame.h"
35 #include "frame-unwind.h"
36 #include "reggroups.h"
37 #include "auxv.h"
38 #include "observable.h"
39 #include "solib-target.h"
41 #include "gdbsupport/version.h"
43 #include "floatformat.h"
45 #include "dis-asm.h"
47 bool
48 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch)
50 return !gdbarch_software_single_step_p (gdbarch);
53 CORE_ADDR
54 displaced_step_at_entry_point (struct gdbarch *gdbarch)
56 CORE_ADDR addr;
57 int bp_len;
59 addr = entry_point_address ();
61 /* Inferior calls also use the entry point as a breakpoint location.
62 We don't want displaced stepping to interfere with those
63 breakpoints, so leave space. */
64 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
65 addr += bp_len * 2;
67 return addr;
70 int
71 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
73 /* Only makes sense to supply raw registers. */
74 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
75 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
76 suspected that some GDB/SIM combinations may rely on this
77 behaviour. The default should be one2one_register_sim_regno
78 (below). */
79 if (gdbarch_register_name (gdbarch, regnum)[0] != '\0')
80 return regnum;
81 else
82 return LEGACY_SIM_REGNO_IGNORE;
85 /* See arch-utils.h */
87 CORE_ADDR
88 default_remove_non_address_bits (struct gdbarch *gdbarch, CORE_ADDR pointer)
90 /* By default, just return the pointer value. */
91 return pointer;
94 /* See arch-utils.h */
96 std::string
97 default_memtag_to_string (struct gdbarch *gdbarch, struct value *tag)
99 error (_("This architecture has no method to convert a memory tag to"
100 " a string."));
103 /* See arch-utils.h */
105 bool
106 default_tagged_address_p (struct gdbarch *gdbarch, CORE_ADDR address)
108 /* By default, assume the address is untagged. */
109 return false;
112 /* See arch-utils.h */
114 bool
115 default_memtag_matches_p (struct gdbarch *gdbarch, struct value *address)
117 /* By default, assume the tags match. */
118 return true;
121 /* See arch-utils.h */
123 bool
124 default_set_memtags (struct gdbarch *gdbarch, struct value *address,
125 size_t length, const gdb::byte_vector &tags,
126 memtag_type tag_type)
128 /* By default, return true (successful); */
129 return true;
132 /* See arch-utils.h */
134 struct value *
135 default_get_memtag (struct gdbarch *gdbarch, struct value *address,
136 memtag_type tag_type)
138 /* By default, return no tag. */
139 return nullptr;
142 CORE_ADDR
143 generic_skip_trampoline_code (const frame_info_ptr &frame, CORE_ADDR pc)
145 return 0;
148 CORE_ADDR
149 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
151 return 0;
155 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
156 CORE_ADDR pc, const char *name)
158 return 0;
162 generic_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
164 return 0;
168 default_code_of_frame_writable (struct gdbarch *gdbarch,
169 const frame_info_ptr &frame)
171 return 1;
174 /* Helper functions for gdbarch_inner_than */
177 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
179 return (lhs < rhs);
183 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
185 return (lhs > rhs);
188 /* Misc helper functions for targets. */
190 CORE_ADDR
191 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
193 return addr;
196 CORE_ADDR
197 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
198 struct target_ops *targ)
200 return addr;
204 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
206 return reg;
209 void
210 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
212 return;
215 /* See arch-utils.h. */
217 void
218 default_make_symbol_special (struct symbol *sym, struct objfile *objfile)
220 return;
223 /* See arch-utils.h. */
225 CORE_ADDR
226 default_adjust_dwarf2_addr (CORE_ADDR pc)
228 return pc;
231 /* See arch-utils.h. */
233 CORE_ADDR
234 default_adjust_dwarf2_line (CORE_ADDR addr, int rel)
236 return addr;
239 /* See arch-utils.h. */
241 bool
242 default_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op,
243 struct dwarf2_frame_state *fs)
245 return false;
249 cannot_register_not (struct gdbarch *gdbarch, int regnum)
251 return 0;
254 /* Legacy version of target_virtual_frame_pointer(). Assumes that
255 there is an gdbarch_deprecated_fp_regnum and that it is the same,
256 cooked or raw. */
258 void
259 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
260 CORE_ADDR pc,
261 int *frame_regnum,
262 LONGEST *frame_offset)
264 /* FIXME: cagney/2002-09-13: This code is used when identifying the
265 frame pointer of the current PC. It is assuming that a single
266 register and an offset can determine this. I think it should
267 instead generate a byte code expression as that would work better
268 with things like Dwarf2's CFI. */
269 if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
270 && gdbarch_deprecated_fp_regnum (gdbarch)
271 < gdbarch_num_regs (gdbarch))
272 *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
273 else if (gdbarch_sp_regnum (gdbarch) >= 0
274 && gdbarch_sp_regnum (gdbarch)
275 < gdbarch_num_regs (gdbarch))
276 *frame_regnum = gdbarch_sp_regnum (gdbarch);
277 else
278 /* Should this be an internal error? I guess so, it is reflecting
279 an architectural limitation in the current design. */
280 internal_error (_("No virtual frame pointer available"));
281 *frame_offset = 0;
284 /* Return a floating-point format for a floating-point variable of
285 length LEN in bits. If non-NULL, NAME is the name of its type.
286 If no suitable type is found, return NULL. */
288 const struct floatformat **
289 default_floatformat_for_type (struct gdbarch *gdbarch,
290 const char *name, int len)
292 const struct floatformat **format = NULL;
294 /* Check if this is a bfloat16 type. It has the same size as the
295 IEEE half float type, so we use the base type name to tell them
296 apart. */
297 if (name != nullptr && strcmp (name, "__bf16") == 0
298 && len == gdbarch_bfloat16_bit (gdbarch))
299 format = gdbarch_bfloat16_format (gdbarch);
300 else if (len == gdbarch_half_bit (gdbarch))
301 format = gdbarch_half_format (gdbarch);
302 else if (len == gdbarch_float_bit (gdbarch))
303 format = gdbarch_float_format (gdbarch);
304 else if (len == gdbarch_double_bit (gdbarch))
305 format = gdbarch_double_format (gdbarch);
306 else if (len == gdbarch_long_double_bit (gdbarch))
307 format = gdbarch_long_double_format (gdbarch);
308 /* On i386 the 'long double' type takes 96 bits,
309 while the real number of used bits is only 80,
310 both in processor and in memory.
311 The code below accepts the real bit size. */
312 else if (gdbarch_long_double_format (gdbarch) != NULL
313 && len == gdbarch_long_double_format (gdbarch)[0]->totalsize)
314 format = gdbarch_long_double_format (gdbarch);
316 return format;
320 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
321 struct type *type)
323 return 0;
327 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
329 return 0;
333 generic_instruction_nullified (struct gdbarch *gdbarch,
334 struct regcache *regcache)
336 return 0;
340 default_remote_register_number (struct gdbarch *gdbarch,
341 int regno)
343 return regno;
346 /* See arch-utils.h. */
349 default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
351 return 0;
355 /* Functions to manipulate the endianness of the target. */
357 static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN;
359 static const char endian_big[] = "big";
360 static const char endian_little[] = "little";
361 static const char endian_auto[] = "auto";
362 static const char *const endian_enum[] =
364 endian_big,
365 endian_little,
366 endian_auto,
367 NULL,
369 static const char *set_endian_string = endian_auto;
371 enum bfd_endian
372 selected_byte_order (void)
374 return target_byte_order_user;
377 /* Called by ``show endian''. */
379 static void
380 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
381 const char *value)
383 if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
384 if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
385 gdb_printf (file, _("The target endianness is set automatically "
386 "(currently big endian).\n"));
387 else
388 gdb_printf (file, _("The target endianness is set automatically "
389 "(currently little endian).\n"));
390 else
391 if (target_byte_order_user == BFD_ENDIAN_BIG)
392 gdb_printf (file,
393 _("The target is set to big endian.\n"));
394 else
395 gdb_printf (file,
396 _("The target is set to little endian.\n"));
399 static void
400 set_endian (const char *ignore_args, int from_tty, struct cmd_list_element *c)
402 struct gdbarch_info info;
404 if (set_endian_string == endian_auto)
406 target_byte_order_user = BFD_ENDIAN_UNKNOWN;
407 if (! gdbarch_update_p (info))
408 internal_error (_("set_endian: architecture update failed"));
410 else if (set_endian_string == endian_little)
412 info.byte_order = BFD_ENDIAN_LITTLE;
413 if (! gdbarch_update_p (info))
414 gdb_printf (gdb_stderr,
415 _("Little endian target not supported by GDB\n"));
416 else
417 target_byte_order_user = BFD_ENDIAN_LITTLE;
419 else if (set_endian_string == endian_big)
421 info.byte_order = BFD_ENDIAN_BIG;
422 if (! gdbarch_update_p (info))
423 gdb_printf (gdb_stderr,
424 _("Big endian target not supported by GDB\n"));
425 else
426 target_byte_order_user = BFD_ENDIAN_BIG;
428 else
429 internal_error (_("set_endian: bad value"));
431 show_endian (gdb_stdout, from_tty, NULL, NULL);
434 /* Given SELECTED, a currently selected BFD architecture, and
435 TARGET_DESC, the current target description, return what
436 architecture to use.
438 SELECTED may be NULL, in which case we return the architecture
439 associated with TARGET_DESC. If SELECTED specifies a variant
440 of the architecture associated with TARGET_DESC, return the
441 more specific of the two.
443 If SELECTED is a different architecture, but it is accepted as
444 compatible by the target, we can use the target architecture.
446 If SELECTED is obviously incompatible, warn the user. */
448 static const struct bfd_arch_info *
449 choose_architecture_for_target (const struct target_desc *target_desc,
450 const struct bfd_arch_info *selected)
452 const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
453 const struct bfd_arch_info *compat1, *compat2;
455 if (selected == NULL)
456 return from_target;
458 if (from_target == NULL)
459 return selected;
461 /* struct bfd_arch_info objects are singletons: that is, there's
462 supposed to be exactly one instance for a given machine. So you
463 can tell whether two are equivalent by comparing pointers. */
464 if (from_target == selected)
465 return selected;
467 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
468 incompatible. But if they are compatible, it returns the 'more
469 featureful' of the two arches. That is, if A can run code
470 written for B, but B can't run code written for A, then it'll
471 return A.
473 Some targets (e.g. MIPS as of 2006-12-04) don't fully
474 implement this, instead always returning NULL or the first
475 argument. We detect that case by checking both directions. */
477 compat1 = selected->compatible (selected, from_target);
478 compat2 = from_target->compatible (from_target, selected);
480 if (compat1 == NULL && compat2 == NULL)
482 /* BFD considers the architectures incompatible. Check our
483 target description whether it accepts SELECTED as compatible
484 anyway. */
485 if (tdesc_compatible_p (target_desc, selected))
486 return from_target;
488 warning (_("Selected architecture %s is not compatible "
489 "with reported target architecture %s"),
490 selected->printable_name, from_target->printable_name);
491 return selected;
494 if (compat1 == NULL)
495 return compat2;
496 if (compat2 == NULL)
497 return compat1;
498 if (compat1 == compat2)
499 return compat1;
501 /* If the two didn't match, but one of them was a default
502 architecture, assume the more specific one is correct. This
503 handles the case where an executable or target description just
504 says "mips", but the other knows which MIPS variant. */
505 if (compat1->the_default)
506 return compat2;
507 if (compat2->the_default)
508 return compat1;
510 /* We have no idea which one is better. This is a bug, but not
511 a critical problem; warn the user. */
512 warning (_("Selected architecture %s is ambiguous with "
513 "reported target architecture %s"),
514 selected->printable_name, from_target->printable_name);
515 return selected;
518 /* Functions to manipulate the architecture of the target. */
520 enum set_arch { set_arch_auto, set_arch_manual };
522 static const struct bfd_arch_info *target_architecture_user;
524 static const char *set_architecture_string;
526 const char *
527 selected_architecture_name (void)
529 if (target_architecture_user == NULL)
530 return NULL;
531 else
532 return set_architecture_string;
535 /* Called if the user enters ``show architecture'' without an
536 argument. */
538 static void
539 show_architecture (struct ui_file *file, int from_tty,
540 struct cmd_list_element *c, const char *value)
542 if (target_architecture_user == NULL)
543 gdb_printf (file, _("The target architecture is set to "
544 "\"auto\" (currently \"%s\").\n"),
545 gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
546 else
547 gdb_printf (file, _("The target architecture is set to \"%s\".\n"),
548 set_architecture_string);
552 /* Called if the user enters ``set architecture'' with or without an
553 argument. */
555 static void
556 set_architecture (const char *ignore_args,
557 int from_tty, struct cmd_list_element *c)
559 struct gdbarch_info info;
561 if (strcmp (set_architecture_string, "auto") == 0)
563 target_architecture_user = NULL;
564 if (!gdbarch_update_p (info))
565 internal_error (_("could not select an architecture automatically"));
567 else
569 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
570 if (info.bfd_arch_info == NULL)
571 internal_error (_("set_architecture: bfd_scan_arch failed"));
572 if (gdbarch_update_p (info))
573 target_architecture_user = info.bfd_arch_info;
574 else
575 gdb_printf (gdb_stderr,
576 _("Architecture `%s' not recognized.\n"),
577 set_architecture_string);
579 show_architecture (gdb_stdout, from_tty, NULL, NULL);
582 /* Try to select a global architecture that matches "info". Return
583 non-zero if the attempt succeeds. */
585 gdbarch_update_p (struct gdbarch_info info)
587 struct gdbarch *new_gdbarch;
589 /* Check for the current file. */
590 if (info.abfd == NULL)
591 info.abfd = current_program_space->exec_bfd ();
592 if (info.abfd == NULL)
593 info.abfd = current_program_space->core_bfd ();
595 /* Check for the current target description. */
596 if (info.target_desc == NULL)
597 info.target_desc = target_current_description ();
599 new_gdbarch = gdbarch_find_by_info (info);
601 /* If there no architecture by that name, reject the request. */
602 if (new_gdbarch == NULL)
604 if (gdbarch_debug)
605 gdb_printf (gdb_stdlog, "gdbarch_update_p: "
606 "Architecture not found\n");
607 return 0;
610 /* If it is the same old architecture, accept the request (but don't
611 swap anything). */
612 if (new_gdbarch == current_inferior ()->arch ())
614 if (gdbarch_debug)
615 gdb_printf (gdb_stdlog, "gdbarch_update_p: "
616 "Architecture %s (%s) unchanged\n",
617 host_address_to_string (new_gdbarch),
618 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
619 return 1;
622 /* It's a new architecture, swap it in. */
623 if (gdbarch_debug)
624 gdb_printf (gdb_stdlog, "gdbarch_update_p: "
625 "New architecture %s (%s) selected\n",
626 host_address_to_string (new_gdbarch),
627 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
629 current_inferior ()->set_arch (new_gdbarch);
631 return 1;
634 /* Return the architecture for ABFD. If no suitable architecture
635 could be find, return NULL. */
637 struct gdbarch *
638 gdbarch_from_bfd (bfd *abfd)
640 struct gdbarch_info info;
642 info.abfd = abfd;
643 return gdbarch_find_by_info (info);
646 /* Set the dynamic target-system-dependent parameters (architecture,
647 byte-order) using information found in the BFD */
649 void
650 set_gdbarch_from_file (bfd *abfd)
652 struct gdbarch_info info;
653 struct gdbarch *gdbarch;
655 info.abfd = abfd;
656 info.target_desc = target_current_description ();
657 gdbarch = gdbarch_find_by_info (info);
659 if (gdbarch == NULL)
660 error (_("Architecture of file not recognized."));
662 current_inferior ()->set_arch (gdbarch);
665 /* Initialize the current architecture. Update the ``set
666 architecture'' command so that it specifies a list of valid
667 architectures. */
669 #ifdef DEFAULT_BFD_ARCH
670 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
671 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
672 #else
673 static const bfd_arch_info_type *default_bfd_arch;
674 #endif
676 #ifdef DEFAULT_BFD_VEC
677 extern const bfd_target DEFAULT_BFD_VEC;
678 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
679 #else
680 static const bfd_target *default_bfd_vec;
681 #endif
683 static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN;
685 /* Printable names of architectures. Used as the enum list of the
686 "set arch" command. */
687 static std::vector<const char *> arches;
689 void
690 initialize_current_architecture (void)
692 arches = gdbarch_printable_names ();
694 /* Find a default architecture. */
695 if (default_bfd_arch == NULL)
697 /* Choose the architecture by taking the first one
698 alphabetically. */
699 const char *chosen = arches[0];
701 for (const char *arch : arches)
703 if (strcmp (arch, chosen) < 0)
704 chosen = arch;
707 if (chosen == NULL)
708 internal_error (_("initialize_current_architecture: No arch"));
710 default_bfd_arch = bfd_scan_arch (chosen);
711 if (default_bfd_arch == NULL)
712 internal_error (_("initialize_current_architecture: Arch not found"));
715 gdbarch_info info;
716 info.bfd_arch_info = default_bfd_arch;
718 /* Take several guesses at a byte order. */
719 if (default_byte_order == BFD_ENDIAN_UNKNOWN
720 && default_bfd_vec != NULL)
722 /* Extract BFD's default vector's byte order. */
723 switch (default_bfd_vec->byteorder)
725 case BFD_ENDIAN_BIG:
726 default_byte_order = BFD_ENDIAN_BIG;
727 break;
728 case BFD_ENDIAN_LITTLE:
729 default_byte_order = BFD_ENDIAN_LITTLE;
730 break;
731 default:
732 break;
735 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
737 /* look for ``*el-*'' in the target name. */
738 const char *chp;
739 chp = strchr (target_name, '-');
740 if (chp != NULL
741 && chp - 2 >= target_name
742 && startswith (chp - 2, "el"))
743 default_byte_order = BFD_ENDIAN_LITTLE;
745 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
747 /* Wire it to big-endian!!! */
748 default_byte_order = BFD_ENDIAN_BIG;
751 info.byte_order = default_byte_order;
752 info.byte_order_for_code = info.byte_order;
754 if (! gdbarch_update_p (info))
755 internal_error (_("initialize_current_architecture: Selection of "
756 "initial architecture failed"));
758 /* Create the ``set architecture'' command appending ``auto'' to the
759 list of architectures. */
761 /* Append ``auto''. */
762 set_architecture_string = "auto";
763 arches.push_back (set_architecture_string);
764 arches.push_back (nullptr);
765 set_show_commands architecture_cmds
766 = add_setshow_enum_cmd ("architecture", class_support,
767 arches.data (), &set_architecture_string,
768 _("Set architecture of target."),
769 _("Show architecture of target."), NULL,
770 set_architecture, show_architecture,
771 &setlist, &showlist);
772 add_alias_cmd ("processor", architecture_cmds.set, class_support, 1,
773 &setlist);
777 /* Similar to init, but this time fill in the blanks. Information is
778 obtained from the global "set ..." options and explicitly
779 initialized INFO fields. */
781 void
782 gdbarch_info_fill (struct gdbarch_info *info)
784 /* "(gdb) set architecture ...". */
785 if (info->bfd_arch_info == NULL
786 && target_architecture_user)
787 info->bfd_arch_info = target_architecture_user;
788 /* From the file. */
789 if (info->bfd_arch_info == NULL
790 && info->abfd != NULL
791 && bfd_get_arch (info->abfd) != bfd_arch_unknown
792 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
793 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
794 /* From the target. */
795 if (info->target_desc != NULL)
796 info->bfd_arch_info = choose_architecture_for_target
797 (info->target_desc, info->bfd_arch_info);
798 /* From the default. */
799 if (info->bfd_arch_info == NULL)
800 info->bfd_arch_info = default_bfd_arch;
802 /* "(gdb) set byte-order ...". */
803 if (info->byte_order == BFD_ENDIAN_UNKNOWN
804 && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
805 info->byte_order = target_byte_order_user;
806 /* From the INFO struct. */
807 if (info->byte_order == BFD_ENDIAN_UNKNOWN
808 && info->abfd != NULL)
809 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
810 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
811 : BFD_ENDIAN_UNKNOWN);
812 /* From the default. */
813 if (info->byte_order == BFD_ENDIAN_UNKNOWN)
814 info->byte_order = default_byte_order;
815 info->byte_order_for_code = info->byte_order;
816 /* Wire the default to the last selected byte order. */
817 default_byte_order = info->byte_order;
819 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
820 /* From the manual override, or from file. */
821 if (info->osabi == GDB_OSABI_UNKNOWN)
822 info->osabi = gdbarch_lookup_osabi (info->abfd);
823 /* From the target. */
825 if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
826 info->osabi = tdesc_osabi (info->target_desc);
827 /* From the configured default. */
828 #ifdef GDB_OSABI_DEFAULT
829 if (info->osabi == GDB_OSABI_UNKNOWN)
830 info->osabi = GDB_OSABI_DEFAULT;
831 #endif
832 /* If we still don't know which osabi to pick, pick none. */
833 if (info->osabi == GDB_OSABI_UNKNOWN)
834 info->osabi = GDB_OSABI_NONE;
836 /* Must have at least filled in the architecture. */
837 gdb_assert (info->bfd_arch_info != NULL);
840 /* Return "current" architecture. If the target is running, this is
841 the architecture of the selected frame. Otherwise, the "current"
842 architecture defaults to the target architecture.
844 This function should normally be called solely by the command
845 interpreter routines to determine the architecture to execute a
846 command in. */
847 struct gdbarch *
848 get_current_arch (void)
850 if (has_stack_frames ())
851 return get_frame_arch (get_selected_frame (NULL));
852 else
853 return current_inferior ()->arch ();
857 default_has_shared_address_space (struct gdbarch *gdbarch)
859 /* Simply say no. In most unix-like targets each inferior/process
860 has its own address space. */
861 return 0;
865 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr,
866 std::string *msg)
868 /* We don't know if maybe the target has some way to do fast
869 tracepoints that doesn't need gdbarch, so always say yes. */
870 if (msg)
871 msg->clear ();
872 return 1;
875 const gdb_byte *
876 default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
877 int *lenptr)
879 int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
881 return gdbarch_sw_breakpoint_from_kind (gdbarch, kind, lenptr);
884 default_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
885 struct regcache *regcache,
886 CORE_ADDR *pcptr)
888 return gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
892 void
893 default_gen_return_address (struct gdbarch *gdbarch,
894 struct agent_expr *ax, struct axs_value *value,
895 CORE_ADDR scope)
897 error (_("This architecture has no method to collect a return address."));
901 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
902 struct type *type)
904 /* Usually, the return value's address is stored the in the "first hidden"
905 parameter if the return value should be passed by reference, as
906 specified in ABI. */
907 return !(language_pass_by_reference (type).trivially_copyable);
910 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
912 return 0;
915 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
917 return 0;
920 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
922 return 0;
925 /* See arch-utils.h. */
927 bool
928 default_program_breakpoint_here_p (struct gdbarch *gdbarch,
929 CORE_ADDR address)
931 int len;
932 const gdb_byte *bpoint = gdbarch_breakpoint_from_pc (gdbarch, &address, &len);
934 /* Software breakpoints unsupported? */
935 if (bpoint == nullptr)
936 return false;
938 gdb_byte *target_mem = (gdb_byte *) alloca (len);
940 /* Enable the automatic memory restoration from breakpoints while
941 we read the memory. Otherwise we may find temporary breakpoints, ones
942 inserted by GDB, and flag them as permanent breakpoints. */
943 scoped_restore restore_memory
944 = make_scoped_restore_show_memory_breakpoints (0);
946 if (target_read_memory (address, target_mem, len) == 0)
948 /* Check if this is a breakpoint instruction for this architecture,
949 including ones used by GDB. */
950 if (memcmp (target_mem, bpoint, len) == 0)
951 return true;
954 return false;
957 void
958 default_skip_permanent_breakpoint (struct regcache *regcache)
960 struct gdbarch *gdbarch = regcache->arch ();
961 CORE_ADDR current_pc = regcache_read_pc (regcache);
962 int bp_len;
964 gdbarch_breakpoint_from_pc (gdbarch, &current_pc, &bp_len);
965 current_pc += bp_len;
966 regcache_write_pc (regcache, current_pc);
969 CORE_ADDR
970 default_infcall_mmap (CORE_ADDR size, unsigned prot)
972 error (_("This target does not support inferior memory allocation by mmap."));
975 void
976 default_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
978 /* Memory reserved by inferior mmap is kept leaked. */
981 /* -mcmodel=large is used so that no GOT (Global Offset Table) is needed to be
982 created in inferior memory by GDB (normally it is set by ld.so). */
984 std::string
985 default_gcc_target_options (struct gdbarch *gdbarch)
987 return string_printf ("-m%d%s", gdbarch_ptr_bit (gdbarch),
988 (gdbarch_ptr_bit (gdbarch) == 64
989 ? " -mcmodel=large" : ""));
992 /* gdbarch gnu_triplet_regexp method. */
994 const char *
995 default_gnu_triplet_regexp (struct gdbarch *gdbarch)
997 return gdbarch_bfd_arch_info (gdbarch)->arch_name;
1000 /* Default method for gdbarch_addressable_memory_unit_size. The default is
1001 based on the bits_per_byte defined in the bfd library for the current
1002 architecture, this is usually 8-bits, and so this function will usually
1003 return 1 indicating 1 byte is 1 octet. */
1006 default_addressable_memory_unit_size (struct gdbarch *gdbarch)
1008 return gdbarch_bfd_arch_info (gdbarch)->bits_per_byte / 8;
1011 void
1012 default_guess_tracepoint_registers (struct gdbarch *gdbarch,
1013 struct regcache *regcache,
1014 CORE_ADDR addr)
1016 int pc_regno = gdbarch_pc_regnum (gdbarch);
1017 gdb_byte *regs;
1019 /* This guessing code below only works if the PC register isn't
1020 a pseudo-register. The value of a pseudo-register isn't stored
1021 in the (non-readonly) regcache -- instead it's recomputed
1022 (probably from some other cached raw register) whenever the
1023 register is read. In this case, a custom method implementation
1024 should be used by the architecture. */
1025 if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
1026 return;
1028 regs = (gdb_byte *) alloca (register_size (gdbarch, pc_regno));
1029 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
1030 gdbarch_byte_order (gdbarch), addr);
1031 regcache->raw_supply (pc_regno, regs);
1035 default_print_insn (bfd_vma memaddr, disassemble_info *info)
1037 disassembler_ftype disassemble_fn;
1039 disassemble_fn = disassembler (info->arch, info->endian == BFD_ENDIAN_BIG,
1040 info->mach, current_program_space->exec_bfd ());
1042 gdb_assert (disassemble_fn != NULL);
1043 return (*disassemble_fn) (memaddr, info);
1046 /* See arch-utils.h. */
1048 CORE_ADDR
1049 gdbarch_skip_prologue_noexcept (gdbarch *gdbarch, CORE_ADDR pc) noexcept
1051 CORE_ADDR new_pc = pc;
1055 new_pc = gdbarch_skip_prologue (gdbarch, pc);
1057 catch (const gdb_exception &ex)
1060 return new_pc;
1063 /* See arch-utils.h. */
1065 bool
1066 default_in_indirect_branch_thunk (gdbarch *gdbarch, CORE_ADDR pc)
1068 return false;
1071 /* See arch-utils.h. */
1073 ULONGEST
1074 default_type_align (struct gdbarch *gdbarch, struct type *type)
1076 return 0;
1079 /* See arch-utils.h. */
1081 std::string
1082 default_get_pc_address_flags (const frame_info_ptr &frame, CORE_ADDR pc)
1084 return "";
1087 /* See arch-utils.h. */
1088 void
1089 default_read_core_file_mappings
1090 (struct gdbarch *gdbarch,
1091 struct bfd *cbfd,
1092 read_core_file_mappings_pre_loop_ftype pre_loop_cb,
1093 read_core_file_mappings_loop_ftype loop_cb)
1097 /* See arch-utils.h. */
1098 bool
1099 default_use_target_description_from_corefile_notes (struct gdbarch *gdbarch,
1100 struct bfd *corefile_bfd)
1102 /* Always trust the corefile target description contained in the target
1103 description note. */
1104 return true;
1107 CORE_ADDR
1108 default_get_return_buf_addr (struct type *val_type,
1109 const frame_info_ptr &cur_frame)
1111 return 0;
1114 bool
1115 default_dwarf2_omit_typedef_p (struct type *target_type, const char *producer,
1116 const char *name)
1118 return false;
1121 static CORE_ADDR
1122 default_update_call_site_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
1124 return pc;
1127 /* Non-zero if we want to trace architecture code. */
1129 #ifndef GDBARCH_DEBUG
1130 #define GDBARCH_DEBUG 0
1131 #endif
1132 unsigned int gdbarch_debug = GDBARCH_DEBUG;
1133 static void
1134 show_gdbarch_debug (struct ui_file *file, int from_tty,
1135 struct cmd_list_element *c, const char *value)
1137 gdb_printf (file, _("Architecture debugging is %s.\n"), value);
1140 static const char *
1141 pformat (struct gdbarch *gdbarch, const struct floatformat **format)
1143 if (format == NULL)
1144 return "(null)";
1146 int format_index = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE ? 1 : 0;
1147 return format[format_index]->name;
1150 static const char *
1151 pstring (const char *string)
1153 if (string == NULL)
1154 return "(null)";
1155 return string;
1158 static const char *
1159 pstring_ptr (std::string *string)
1161 if (string == nullptr)
1162 return "(null)";
1163 return string->c_str ();
1166 /* Helper function to print a list of strings, represented as "const
1167 char *const *". The list is printed comma-separated. */
1169 static const char *
1170 pstring_list (const char *const *list)
1172 static char ret[100];
1173 const char *const *p;
1174 size_t offset = 0;
1176 if (list == NULL)
1177 return "(null)";
1179 ret[0] = '\0';
1180 for (p = list; *p != NULL && offset < sizeof (ret); ++p)
1182 size_t s = xsnprintf (ret + offset, sizeof (ret) - offset, "%s, ", *p);
1183 offset += 2 + s;
1186 if (offset > 0)
1188 gdb_assert (offset - 2 < sizeof (ret));
1189 ret[offset - 2] = '\0';
1192 return ret;
1195 #include "gdbarch.c"
1197 enum return_value_convention
1198 default_gdbarch_return_value
1199 (struct gdbarch *gdbarch, struct value *function, struct type *valtype,
1200 struct regcache *regcache, struct value **read_value,
1201 const gdb_byte *writebuf)
1203 gdb_byte *readbuf = nullptr;
1205 if (read_value != nullptr)
1207 *read_value = value::allocate (valtype);
1208 readbuf = (*read_value)->contents_raw ().data ();
1211 return gdbarch->return_value (gdbarch, function, valtype, regcache,
1212 readbuf, writebuf);
1215 obstack *gdbarch_obstack (gdbarch *arch)
1217 return &arch->obstack;
1220 /* See gdbarch.h. */
1222 char *
1223 gdbarch_obstack_strdup (struct gdbarch *arch, const char *string)
1225 return obstack_strdup (&arch->obstack, string);
1228 /* Free a gdbarch struct. This should never happen in normal
1229 operation --- once you've created a gdbarch, you keep it around.
1230 However, if an architecture's init function encounters an error
1231 building the structure, it may need to clean up a partially
1232 constructed gdbarch. */
1234 void
1235 gdbarch_free (struct gdbarch *arch)
1237 gdb_assert (arch != NULL);
1238 gdb_assert (!arch->initialized_p);
1239 delete arch;
1242 /* See gdbarch.h. */
1244 struct gdbarch_tdep_base *
1245 gdbarch_tdep_1 (struct gdbarch *gdbarch)
1247 if (gdbarch_debug >= 2)
1248 gdb_printf (gdb_stdlog, "gdbarch_tdep_1 called\n");
1249 return gdbarch->tdep.get ();
1252 registry<gdbarch> *
1253 registry_accessor<gdbarch>::get (gdbarch *arch)
1255 return &arch->registry_fields;
1258 /* Keep a registry of the architectures known by GDB. */
1260 struct gdbarch_registration
1262 enum bfd_architecture bfd_architecture;
1263 gdbarch_init_ftype *init;
1264 gdbarch_dump_tdep_ftype *dump_tdep;
1265 gdbarch_supports_arch_info_ftype *supports_arch_info;
1266 struct gdbarch_list *arches;
1267 struct gdbarch_registration *next;
1270 static struct gdbarch_registration *gdbarch_registry = NULL;
1272 std::vector<const char *>
1273 gdbarch_printable_names ()
1275 /* Accumulate a list of names based on the registered list of
1276 architectures. */
1277 std::vector<const char *> arches;
1279 for (gdbarch_registration *rego = gdbarch_registry;
1280 rego != nullptr;
1281 rego = rego->next)
1283 const struct bfd_arch_info *ap
1284 = bfd_lookup_arch (rego->bfd_architecture, 0);
1285 if (ap == nullptr)
1286 internal_error (_("gdbarch_architecture_names: multi-arch unknown"));
1289 if (rego->supports_arch_info == nullptr
1290 || rego->supports_arch_info (ap))
1291 arches.push_back (ap->printable_name);
1292 ap = ap->next;
1294 while (ap != NULL);
1297 return arches;
1301 void
1302 gdbarch_register (enum bfd_architecture bfd_architecture,
1303 gdbarch_init_ftype *init,
1304 gdbarch_dump_tdep_ftype *dump_tdep,
1305 gdbarch_supports_arch_info_ftype *supports_arch_info)
1307 struct gdbarch_registration **curr;
1308 const struct bfd_arch_info *bfd_arch_info;
1310 /* Check that BFD recognizes this architecture */
1311 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1312 if (bfd_arch_info == NULL)
1314 internal_error (_("gdbarch: Attempt to register "
1315 "unknown architecture (%d)"),
1316 bfd_architecture);
1318 /* Check that we haven't seen this architecture before. */
1319 for (curr = &gdbarch_registry;
1320 (*curr) != NULL;
1321 curr = &(*curr)->next)
1323 if (bfd_architecture == (*curr)->bfd_architecture)
1324 internal_error (_("gdbarch: Duplicate registration "
1325 "of architecture (%s)"),
1326 bfd_arch_info->printable_name);
1328 /* log it */
1329 if (gdbarch_debug)
1330 gdb_printf (gdb_stdlog, "gdbarch_register (%s, %s)\n",
1331 bfd_arch_info->printable_name,
1332 host_address_to_string (init));
1333 /* Append it */
1334 (*curr) = XNEW (struct gdbarch_registration);
1335 (*curr)->bfd_architecture = bfd_architecture;
1336 (*curr)->init = init;
1337 (*curr)->dump_tdep = dump_tdep;
1338 (*curr)->supports_arch_info = supports_arch_info;
1339 (*curr)->arches = NULL;
1340 (*curr)->next = NULL;
1343 /* Look for an architecture using gdbarch_info. */
1345 struct gdbarch_list *
1346 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1347 const struct gdbarch_info *info)
1349 for (; arches != NULL; arches = arches->next)
1351 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1352 continue;
1353 if (info->byte_order != arches->gdbarch->byte_order)
1354 continue;
1355 if (info->osabi != arches->gdbarch->osabi)
1356 continue;
1357 if (info->target_desc != arches->gdbarch->target_desc)
1358 continue;
1359 return arches;
1361 return NULL;
1365 /* Find an architecture that matches the specified INFO. Create a new
1366 architecture if needed. Return that new architecture. */
1368 struct gdbarch *
1369 gdbarch_find_by_info (struct gdbarch_info info)
1371 struct gdbarch *new_gdbarch;
1372 struct gdbarch_registration *rego;
1374 /* Fill in missing parts of the INFO struct using a number of
1375 sources: "set ..."; INFOabfd supplied; and the global
1376 defaults. */
1377 gdbarch_info_fill (&info);
1379 /* Must have found some sort of architecture. */
1380 gdb_assert (info.bfd_arch_info != nullptr);
1382 if (gdbarch_debug)
1384 gdb_printf (gdb_stdlog,
1385 "gdbarch_find_by_info: info.bfd_arch_info %s\n",
1386 (info.bfd_arch_info != nullptr
1387 ? info.bfd_arch_info->printable_name
1388 : "(null)"));
1389 gdb_printf (gdb_stdlog,
1390 "gdbarch_find_by_info: info.byte_order %d (%s)\n",
1391 info.byte_order,
1392 (info.byte_order == BFD_ENDIAN_BIG ? "big"
1393 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
1394 : "default"));
1395 gdb_printf (gdb_stdlog,
1396 "gdbarch_find_by_info: info.osabi %d (%s)\n",
1397 info.osabi, gdbarch_osabi_name (info.osabi));
1398 gdb_printf (gdb_stdlog,
1399 "gdbarch_find_by_info: info.abfd %s\n",
1400 host_address_to_string (info.abfd));
1403 /* Find the tdep code that knows about this architecture. */
1404 for (rego = gdbarch_registry;
1405 rego != nullptr;
1406 rego = rego->next)
1407 if (rego->bfd_architecture == info.bfd_arch_info->arch)
1408 break;
1409 if (rego == nullptr)
1411 if (gdbarch_debug)
1412 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1413 "No matching architecture\n");
1414 return nullptr;
1417 /* Ask the tdep code for an architecture that matches "info". */
1418 new_gdbarch = rego->init (info, rego->arches);
1420 /* Did the tdep code like it? No. Reject the change and revert to
1421 the old architecture. */
1422 if (new_gdbarch == nullptr)
1424 if (gdbarch_debug)
1425 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1426 "Target rejected architecture\n");
1427 return nullptr;
1430 /* Is this a pre-existing architecture (as determined by already
1431 being initialized)? Move it to the front of the architecture
1432 list (keeping the list sorted Most Recently Used). */
1433 if (new_gdbarch->initialized_p)
1435 struct gdbarch_list **list;
1436 struct gdbarch_list *self;
1437 if (gdbarch_debug)
1438 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1439 "Previous architecture %s (%s) selected\n",
1440 host_address_to_string (new_gdbarch),
1441 new_gdbarch->bfd_arch_info->printable_name);
1442 /* Find the existing arch in the list. */
1443 for (list = &rego->arches;
1444 (*list) != nullptr && (*list)->gdbarch != new_gdbarch;
1445 list = &(*list)->next);
1446 /* It had better be in the list of architectures. */
1447 gdb_assert ((*list) != nullptr && (*list)->gdbarch == new_gdbarch);
1448 /* Unlink SELF. */
1449 self = (*list);
1450 (*list) = self->next;
1451 /* Insert SELF at the front. */
1452 self->next = rego->arches;
1453 rego->arches = self;
1454 /* Return it. */
1455 return new_gdbarch;
1458 /* It's a new architecture. */
1459 if (gdbarch_debug)
1460 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1461 "New architecture %s (%s) selected\n",
1462 host_address_to_string (new_gdbarch),
1463 new_gdbarch->bfd_arch_info->printable_name);
1465 /* Insert the new architecture into the front of the architecture
1466 list (keep the list sorted Most Recently Used). */
1468 struct gdbarch_list *self = XNEW (struct gdbarch_list);
1469 self->next = rego->arches;
1470 self->gdbarch = new_gdbarch;
1471 rego->arches = self;
1474 /* Check that the newly installed architecture is valid. Plug in
1475 any post init values. */
1476 new_gdbarch->dump_tdep = rego->dump_tdep;
1477 verify_gdbarch (new_gdbarch);
1478 new_gdbarch->initialized_p = true;
1480 if (gdbarch_debug)
1481 gdbarch_dump (new_gdbarch, gdb_stdlog);
1483 gdb::observers::new_architecture.notify (new_gdbarch);
1485 return new_gdbarch;
1488 /* See gdbarch.h. */
1490 bool
1491 gdbarch_initialized_p (gdbarch *arch)
1493 return arch->initialized_p;
1496 void _initialize_gdbarch_utils ();
1497 void
1498 _initialize_gdbarch_utils ()
1500 add_setshow_enum_cmd ("endian", class_support,
1501 endian_enum, &set_endian_string,
1502 _("Set endianness of target."),
1503 _("Show endianness of target."),
1504 NULL, set_endian, show_endian,
1505 &setlist, &showlist);
1506 add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
1507 Set architecture debugging."), _("\
1508 Show architecture debugging."), _("\
1509 When non-zero, architecture debugging is enabled."),
1510 NULL,
1511 show_gdbarch_debug,
1512 &setdebuglist, &showdebuglist);