GDB (xrefs)
Loading...
Searching...
No Matches
arch-utils.c
Go to the documentation of this file.
1/* Dynamic architecture support for GDB, the GNU debugger.
2
3 Copyright (C) 1998-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21
22#include "arch-utils.h"
23#include "gdbcmd.h"
24#include "inferior.h" /* enum CALL_DUMMY_LOCATION et al. */
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"
40
41#include "gdbsupport/version.h"
42
43#include "floatformat.h"
44
45#include "dis-asm.h"
46
47bool
49{
51}
52
53CORE_ADDR
55{
56 CORE_ADDR addr;
57 int bp_len;
58
59 addr = entry_point_address ();
60
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;
66
67 return addr;
68}
69
70int
72{
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
83}
84
85/* See arch-utils.h */
86
87CORE_ADDR
89{
90 /* By default, just return the pointer value. */
91 return pointer;
92}
93
94/* See arch-utils.h */
95
96std::string
98{
99 error (_("This architecture has no method to convert a memory tag to"
100 " a string."));
101}
102
103/* See arch-utils.h */
104
105bool
107{
108 /* By default, assume the address is untagged. */
109 return false;
110}
111
112/* See arch-utils.h */
113
114bool
116{
117 /* By default, assume the tags match. */
118 return true;
119}
120
121/* See arch-utils.h */
122
123bool
124default_set_memtags (struct gdbarch *gdbarch, struct value *address,
125 size_t length, const gdb::byte_vector &tags,
126 memtag_type tag_type)
127{
128 /* By default, return true (successful); */
129 return true;
130}
131
132/* See arch-utils.h */
133
134struct value *
136 memtag_type tag_type)
137{
138 /* By default, return no tag. */
139 return nullptr;
140}
141
142CORE_ADDR
144{
145 return 0;
146}
147
148CORE_ADDR
150{
151 return 0;
152}
153
154int
156 CORE_ADDR pc, const char *name)
157{
158 return 0;
159}
160
161int
163{
164 return 0;
165}
166
167int
169 frame_info_ptr frame)
170{
171 return 1;
172}
173
174/* Helper functions for gdbarch_inner_than */
175
176int
177core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
178{
179 return (lhs < rhs);
180}
181
182int
183core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
184{
185 return (lhs > rhs);
186}
187
188/* Misc helper functions for targets. */
189
190CORE_ADDR
191core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
192{
193 return addr;
194}
195
196CORE_ADDR
198 struct target_ops *targ)
199{
200 return addr;
201}
202
203int
205{
206 return reg;
207}
208
209void
211{
212 return;
213}
214
215/* See arch-utils.h. */
216
217void
219{
220 return;
221}
222
223/* See arch-utils.h. */
224
225CORE_ADDR
227{
228 return pc;
229}
230
231/* See arch-utils.h. */
232
233CORE_ADDR
234default_adjust_dwarf2_line (CORE_ADDR addr, int rel)
235{
236 return addr;
237}
238
239/* See arch-utils.h. */
240
241bool
243 struct dwarf2_frame_state *fs)
244{
245 return false;
246}
247
248int
250{
251 return 0;
252}
253
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. */
257
258void
260 CORE_ADDR pc,
261 int *frame_regnum,
262 LONGEST *frame_offset)
263{
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. */
272 *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
273 else if (gdbarch_sp_regnum (gdbarch) >= 0
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;
282}
283
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. */
287
288const struct floatformat **
290 const char *name, int len)
291{
292 const struct floatformat **format = NULL;
293
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))
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))
306 else if (len == gdbarch_long_double_bit (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)
315
316 return format;
317}
318
319int
321 struct type *type)
322{
323 return 0;
324}
325
326int
328{
329 return 0;
330}
331
332int
334 struct regcache *regcache)
335{
336 return 0;
337}
338
339int
341 int regno)
342{
343 return regno;
344}
345
346/* See arch-utils.h. */
347
348int
350{
351 return 0;
352}
353
354
355/* Functions to manipulate the endianness of the target. */
356
357static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN;
358
359static const char endian_big[] = "big";
360static const char endian_little[] = "little";
361static const char endian_auto[] = "auto";
362static const char *const endian_enum[] =
363{
367 NULL,
368};
369static const char *set_endian_string = endian_auto;
370
371enum bfd_endian
373{
375}
376
377/* Called by ``show endian''. */
378
379static void
380show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
381 const char *value)
382{
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"));
397}
398
399static void
400set_endian (const char *ignore_args, int from_tty, struct cmd_list_element *c)
401{
402 struct gdbarch_info info;
403
405 {
406 target_byte_order_user = BFD_ENDIAN_UNKNOWN;
407 if (! gdbarch_update_p (info))
408 internal_error (_("set_endian: architecture update failed"));
409 }
411 {
412 info.byte_order = BFD_ENDIAN_LITTLE;
413 if (! gdbarch_update_p (info))
415 _("Little endian target not supported by GDB\n"));
416 else
417 target_byte_order_user = BFD_ENDIAN_LITTLE;
418 }
419 else if (set_endian_string == endian_big)
420 {
421 info.byte_order = BFD_ENDIAN_BIG;
422 if (! gdbarch_update_p (info))
424 _("Big endian target not supported by GDB\n"));
425 else
426 target_byte_order_user = BFD_ENDIAN_BIG;
427 }
428 else
429 internal_error (_("set_endian: bad value"));
430
431 show_endian (gdb_stdout, from_tty, NULL, NULL);
432}
433
434/* Given SELECTED, a currently selected BFD architecture, and
435 TARGET_DESC, the current target description, return what
436 architecture to use.
437
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.
442
443 If SELECTED is a different architecture, but it is accepted as
444 compatible by the target, we can use the target architecture.
445
446 If SELECTED is obviously incompatible, warn the user. */
447
448static const struct bfd_arch_info *
450 const struct bfd_arch_info *selected)
451{
452 const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
453 const struct bfd_arch_info *compat1, *compat2;
454
455 if (selected == NULL)
456 return from_target;
457
458 if (from_target == NULL)
459 return selected;
460
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;
466
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.
472
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. */
476
477 compat1 = selected->compatible (selected, from_target);
478 compat2 = from_target->compatible (from_target, selected);
479
480 if (compat1 == NULL && compat2 == NULL)
481 {
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;
487
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;
492 }
493
494 if (compat1 == NULL)
495 return compat2;
496 if (compat2 == NULL)
497 return compat1;
498 if (compat1 == compat2)
499 return compat1;
500
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;
509
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;
516}
517
518/* Functions to manipulate the architecture of the target. */
519
521
522static const struct bfd_arch_info *target_architecture_user;
523
524static const char *set_architecture_string;
525
526const char *
528{
529 if (target_architecture_user == NULL)
530 return NULL;
531 else
533}
534
535/* Called if the user enters ``show architecture'' without an
536 argument. */
537
538static void
539show_architecture (struct ui_file *file, int from_tty,
540 struct cmd_list_element *c, const char *value)
541{
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"),
549}
550
551
552/* Called if the user enters ``set architecture'' with or without an
553 argument. */
554
555static void
556set_architecture (const char *ignore_args,
557 int from_tty, struct cmd_list_element *c)
558{
559 struct gdbarch_info info;
560
561 if (strcmp (set_architecture_string, "auto") == 0)
562 {
564 if (!gdbarch_update_p (info))
565 internal_error (_("could not select an architecture automatically"));
566 }
567 else
568 {
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
576 _("Architecture `%s' not recognized.\n"),
578 }
579 show_architecture (gdb_stdout, from_tty, NULL, NULL);
580}
581
582/* Try to select a global architecture that matches "info". Return
583 non-zero if the attempt succeeds. */
584int
586{
587 struct gdbarch *new_gdbarch;
588
589 /* Check for the current file. */
590 if (info.abfd == NULL)
592 if (info.abfd == NULL)
593 info.abfd = core_bfd;
594
595 /* Check for the current target description. */
596 if (info.target_desc == NULL)
597 info.target_desc = target_current_description ();
598
599 new_gdbarch = gdbarch_find_by_info (info);
600
601 /* If there no architecture by that name, reject the request. */
602 if (new_gdbarch == NULL)
603 {
604 if (gdbarch_debug)
605 gdb_printf (gdb_stdlog, "gdbarch_update_p: "
606 "Architecture not found\n");
607 return 0;
608 }
609
610 /* If it is the same old architecture, accept the request (but don't
611 swap anything). */
612 if (new_gdbarch == target_gdbarch ())
613 {
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;
620 }
621
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);
628 set_target_gdbarch (new_gdbarch);
629
630 return 1;
631}
632
633/* Return the architecture for ABFD. If no suitable architecture
634 could be find, return NULL. */
635
636struct gdbarch *
638{
639 struct gdbarch_info info;
640
641 info.abfd = abfd;
642 return gdbarch_find_by_info (info);
643}
644
645/* Set the dynamic target-system-dependent parameters (architecture,
646 byte-order) using information found in the BFD */
647
648void
650{
651 struct gdbarch_info info;
652 struct gdbarch *gdbarch;
653
654 info.abfd = abfd;
655 info.target_desc = target_current_description ();
657
658 if (gdbarch == NULL)
659 error (_("Architecture of file not recognized."));
661}
662
663/* Initialize the current architecture. Update the ``set
664 architecture'' command so that it specifies a list of valid
665 architectures. */
666
667#ifdef DEFAULT_BFD_ARCH
668extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
669static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
670#else
671static const bfd_arch_info_type *default_bfd_arch;
672#endif
673
674#ifdef DEFAULT_BFD_VEC
675extern const bfd_target DEFAULT_BFD_VEC;
676static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
677#else
678static const bfd_target *default_bfd_vec;
679#endif
680
681static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN;
682
683/* Printable names of architectures. Used as the enum list of the
684 "set arch" command. */
685static std::vector<const char *> arches;
686
687void
689{
691
692 /* Find a default architecture. */
693 if (default_bfd_arch == NULL)
694 {
695 /* Choose the architecture by taking the first one
696 alphabetically. */
697 const char *chosen = arches[0];
698
699 for (const char *arch : arches)
700 {
701 if (strcmp (arch, chosen) < 0)
702 chosen = arch;
703 }
704
705 if (chosen == NULL)
706 internal_error (_("initialize_current_architecture: No arch"));
707
708 default_bfd_arch = bfd_scan_arch (chosen);
709 if (default_bfd_arch == NULL)
710 internal_error (_("initialize_current_architecture: Arch not found"));
711 }
712
714 info.bfd_arch_info = default_bfd_arch;
715
716 /* Take several guesses at a byte order. */
717 if (default_byte_order == BFD_ENDIAN_UNKNOWN
718 && default_bfd_vec != NULL)
719 {
720 /* Extract BFD's default vector's byte order. */
721 switch (default_bfd_vec->byteorder)
722 {
723 case BFD_ENDIAN_BIG:
724 default_byte_order = BFD_ENDIAN_BIG;
725 break;
726 case BFD_ENDIAN_LITTLE:
727 default_byte_order = BFD_ENDIAN_LITTLE;
728 break;
729 default:
730 break;
731 }
732 }
733 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
734 {
735 /* look for ``*el-*'' in the target name. */
736 const char *chp;
737 chp = strchr (target_name, '-');
738 if (chp != NULL
739 && chp - 2 >= target_name
740 && startswith (chp - 2, "el"))
741 default_byte_order = BFD_ENDIAN_LITTLE;
742 }
743 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
744 {
745 /* Wire it to big-endian!!! */
746 default_byte_order = BFD_ENDIAN_BIG;
747 }
748
749 info.byte_order = default_byte_order;
750 info.byte_order_for_code = info.byte_order;
751
752 if (! gdbarch_update_p (info))
753 internal_error (_("initialize_current_architecture: Selection of "
754 "initial architecture failed"));
755
756 /* Create the ``set architecture'' command appending ``auto'' to the
757 list of architectures. */
758 {
759 /* Append ``auto''. */
762 arches.push_back (nullptr);
763 set_show_commands architecture_cmds
764 = add_setshow_enum_cmd ("architecture", class_support,
766 _("Set architecture of target."),
767 _("Show architecture of target."), NULL,
769 &setlist, &showlist);
770 add_alias_cmd ("processor", architecture_cmds.set, class_support, 1,
771 &setlist);
772 }
773}
774
775/* Similar to init, but this time fill in the blanks. Information is
776 obtained from the global "set ..." options and explicitly
777 initialized INFO fields. */
778
779void
781{
782 /* "(gdb) set architecture ...". */
783 if (info->bfd_arch_info == NULL
785 info->bfd_arch_info = target_architecture_user;
786 /* From the file. */
787 if (info->bfd_arch_info == NULL
788 && info->abfd != NULL
789 && bfd_get_arch (info->abfd) != bfd_arch_unknown
790 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
791 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
792 /* From the target. */
793 if (info->target_desc != NULL)
794 info->bfd_arch_info = choose_architecture_for_target
795 (info->target_desc, info->bfd_arch_info);
796 /* From the default. */
797 if (info->bfd_arch_info == NULL)
798 info->bfd_arch_info = default_bfd_arch;
799
800 /* "(gdb) set byte-order ...". */
801 if (info->byte_order == BFD_ENDIAN_UNKNOWN
802 && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
803 info->byte_order = target_byte_order_user;
804 /* From the INFO struct. */
805 if (info->byte_order == BFD_ENDIAN_UNKNOWN
806 && info->abfd != NULL)
807 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
808 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
809 : BFD_ENDIAN_UNKNOWN);
810 /* From the default. */
811 if (info->byte_order == BFD_ENDIAN_UNKNOWN)
812 info->byte_order = default_byte_order;
813 info->byte_order_for_code = info->byte_order;
814 /* Wire the default to the last selected byte order. */
815 default_byte_order = info->byte_order;
816
817 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
818 /* From the manual override, or from file. */
819 if (info->osabi == GDB_OSABI_UNKNOWN)
820 info->osabi = gdbarch_lookup_osabi (info->abfd);
821 /* From the target. */
822
823 if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
824 info->osabi = tdesc_osabi (info->target_desc);
825 /* From the configured default. */
826#ifdef GDB_OSABI_DEFAULT
827 if (info->osabi == GDB_OSABI_UNKNOWN)
828 info->osabi = GDB_OSABI_DEFAULT;
829#endif
830 /* If we still don't know which osabi to pick, pick none. */
831 if (info->osabi == GDB_OSABI_UNKNOWN)
832 info->osabi = GDB_OSABI_NONE;
833
834 /* Must have at least filled in the architecture. */
835 gdb_assert (info->bfd_arch_info != NULL);
836}
837
838/* Return "current" architecture. If the target is running, this is
839 the architecture of the selected frame. Otherwise, the "current"
840 architecture defaults to the target architecture.
841
842 This function should normally be called solely by the command
843 interpreter routines to determine the architecture to execute a
844 command in. */
845struct gdbarch *
847{
848 if (has_stack_frames ())
849 return get_frame_arch (get_selected_frame (NULL));
850 else
851 return target_gdbarch ();
852}
853
854int
856{
857 /* Simply say no. In most unix-like targets each inferior/process
858 has its own address space. */
859 return 0;
860}
861
862int
864 std::string *msg)
865{
866 /* We don't know if maybe the target has some way to do fast
867 tracepoints that doesn't need gdbarch, so always say yes. */
868 if (msg)
869 msg->clear ();
870 return 1;
871}
872
873const gdb_byte *
874default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
875 int *lenptr)
876{
877 int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
878
879 return gdbarch_sw_breakpoint_from_kind (gdbarch, kind, lenptr);
880}
881int
883 struct regcache *regcache,
884 CORE_ADDR *pcptr)
885{
887}
888
889
890void
892 struct agent_expr *ax, struct axs_value *value,
893 CORE_ADDR scope)
894{
895 error (_("This architecture has no method to collect a return address."));
896}
897
898int
900 struct type *type)
901{
902 /* Usually, the return value's address is stored the in the "first hidden"
903 parameter if the return value should be passed by reference, as
904 specified in ABI. */
906}
907
908int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
909{
910 return 0;
911}
912
913int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
914{
915 return 0;
916}
917
918int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
919{
920 return 0;
921}
922
923/* See arch-utils.h. */
924
925bool
927 CORE_ADDR address)
928{
929 int len;
930 const gdb_byte *bpoint = gdbarch_breakpoint_from_pc (gdbarch, &address, &len);
931
932 /* Software breakpoints unsupported? */
933 if (bpoint == nullptr)
934 return false;
935
936 gdb_byte *target_mem = (gdb_byte *) alloca (len);
937
938 /* Enable the automatic memory restoration from breakpoints while
939 we read the memory. Otherwise we may find temporary breakpoints, ones
940 inserted by GDB, and flag them as permanent breakpoints. */
941 scoped_restore restore_memory
943
944 if (target_read_memory (address, target_mem, len) == 0)
945 {
946 /* Check if this is a breakpoint instruction for this architecture,
947 including ones used by GDB. */
948 if (memcmp (target_mem, bpoint, len) == 0)
949 return true;
950 }
951
952 return false;
953}
954
955void
957{
958 struct gdbarch *gdbarch = regcache->arch ();
959 CORE_ADDR current_pc = regcache_read_pc (regcache);
960 int bp_len;
961
962 gdbarch_breakpoint_from_pc (gdbarch, &current_pc, &bp_len);
963 current_pc += bp_len;
964 regcache_write_pc (regcache, current_pc);
965}
966
967CORE_ADDR
968default_infcall_mmap (CORE_ADDR size, unsigned prot)
969{
970 error (_("This target does not support inferior memory allocation by mmap."));
971}
972
973void
974default_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
975{
976 /* Memory reserved by inferior mmap is kept leaked. */
977}
978
979/* -mcmodel=large is used so that no GOT (Global Offset Table) is needed to be
980 created in inferior memory by GDB (normally it is set by ld.so). */
981
982std::string
984{
985 return string_printf ("-m%d%s", gdbarch_ptr_bit (gdbarch),
986 (gdbarch_ptr_bit (gdbarch) == 64
987 ? " -mcmodel=large" : ""));
988}
989
990/* gdbarch gnu_triplet_regexp method. */
991
992const char *
994{
995 return gdbarch_bfd_arch_info (gdbarch)->arch_name;
996}
997
998/* Default method for gdbarch_addressable_memory_unit_size. The default is
999 based on the bits_per_byte defined in the bfd library for the current
1000 architecture, this is usually 8-bits, and so this function will usually
1001 return 1 indicating 1 byte is 1 octet. */
1002
1003int
1005{
1006 return gdbarch_bfd_arch_info (gdbarch)->bits_per_byte / 8;
1007}
1008
1009void
1011 struct regcache *regcache,
1012 CORE_ADDR addr)
1013{
1014 int pc_regno = gdbarch_pc_regnum (gdbarch);
1015 gdb_byte *regs;
1016
1017 /* This guessing code below only works if the PC register isn't
1018 a pseudo-register. The value of a pseudo-register isn't stored
1019 in the (non-readonly) regcache -- instead it's recomputed
1020 (probably from some other cached raw register) whenever the
1021 register is read. In this case, a custom method implementation
1022 should be used by the architecture. */
1023 if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
1024 return;
1025
1026 regs = (gdb_byte *) alloca (register_size (gdbarch, pc_regno));
1027 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
1028 gdbarch_byte_order (gdbarch), addr);
1029 regcache->raw_supply (pc_regno, regs);
1030}
1031
1032int
1033default_print_insn (bfd_vma memaddr, disassemble_info *info)
1034{
1035 disassembler_ftype disassemble_fn;
1036
1037 disassemble_fn = disassembler (info->arch, info->endian == BFD_ENDIAN_BIG,
1039
1040 gdb_assert (disassemble_fn != NULL);
1041 return (*disassemble_fn) (memaddr, info);
1042}
1043
1044/* See arch-utils.h. */
1045
1046CORE_ADDR
1048{
1049 CORE_ADDR new_pc = pc;
1050
1051 try
1052 {
1053 new_pc = gdbarch_skip_prologue (gdbarch, pc);
1054 }
1055 catch (const gdb_exception &ex)
1056 {}
1057
1058 return new_pc;
1059}
1060
1061/* See arch-utils.h. */
1062
1063bool
1065{
1066 return false;
1067}
1068
1069/* See arch-utils.h. */
1070
1071ULONGEST
1073{
1074 return 0;
1075}
1076
1077/* See arch-utils.h. */
1078
1079std::string
1081{
1082 return "";
1083}
1084
1085/* See arch-utils.h. */
1086void
1088 (struct gdbarch *gdbarch,
1089 struct bfd *cbfd,
1092{
1093}
1094
1095CORE_ADDR
1097{
1098 return 0;
1099}
1100
1101/* Non-zero if we want to trace architecture code. */
1102
1103#ifndef GDBARCH_DEBUG
1104#define GDBARCH_DEBUG 0
1105#endif
1107static void
1108show_gdbarch_debug (struct ui_file *file, int from_tty,
1109 struct cmd_list_element *c, const char *value)
1110{
1111 gdb_printf (file, _("Architecture debugging is %s.\n"), value);
1112}
1113
1114static const char *
1115pformat (struct gdbarch *gdbarch, const struct floatformat **format)
1116{
1117 if (format == NULL)
1118 return "(null)";
1119
1120 int format_index = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE ? 1 : 0;
1121 return format[format_index]->name;
1122}
1123
1124static const char *
1125pstring (const char *string)
1126{
1127 if (string == NULL)
1128 return "(null)";
1129 return string;
1130}
1131
1132static const char *
1133pstring_ptr (char **string)
1134{
1135 if (string == NULL || *string == NULL)
1136 return "(null)";
1137 return *string;
1138}
1139
1140/* Helper function to print a list of strings, represented as "const
1141 char *const *". The list is printed comma-separated. */
1142
1143static const char *
1144pstring_list (const char *const *list)
1145{
1146 static char ret[100];
1147 const char *const *p;
1148 size_t offset = 0;
1149
1150 if (list == NULL)
1151 return "(null)";
1152
1153 ret[0] = '\0';
1154 for (p = list; *p != NULL && offset < sizeof (ret); ++p)
1155 {
1156 size_t s = xsnprintf (ret + offset, sizeof (ret) - offset, "%s, ", *p);
1157 offset += 2 + s;
1158 }
1159
1160 if (offset > 0)
1161 {
1162 gdb_assert (offset - 2 < sizeof (ret));
1163 ret[offset - 2] = '\0';
1164 }
1165
1166 return ret;
1167}
1168
1169#include "gdbarch.c"
1170
1171obstack *gdbarch_obstack (gdbarch *arch)
1172{
1173 return &arch->obstack;
1174}
1175
1176/* See gdbarch.h. */
1177
1178char *
1179gdbarch_obstack_strdup (struct gdbarch *arch, const char *string)
1180{
1181 return obstack_strdup (&arch->obstack, string);
1182}
1183
1184
1185/* Free a gdbarch struct. This should never happen in normal
1186 operation --- once you've created a gdbarch, you keep it around.
1187 However, if an architecture's init function encounters an error
1188 building the structure, it may need to clean up a partially
1189 constructed gdbarch. */
1190
1191void
1192gdbarch_free (struct gdbarch *arch)
1193{
1194 gdb_assert (arch != NULL);
1195 gdb_assert (!arch->initialized_p);
1196 delete arch;
1197}
1198
1199/* See gdbarch.h. */
1200
1201struct gdbarch_tdep_base *
1203{
1204 if (gdbarch_debug >= 2)
1205 gdb_printf (gdb_stdlog, "gdbarch_tdep_1 called\n");
1206 return gdbarch->tdep;
1207}
1208
1211{
1212 return &arch->registry_fields;
1213}
1214
1215/* Keep a registry of the architectures known by GDB. */
1216
1218{
1224};
1225
1227
1228std::vector<const char *>
1230{
1231 /* Accumulate a list of names based on the registed list of
1232 architectures. */
1233 std::vector<const char *> arches;
1234
1236 rego != nullptr;
1237 rego = rego->next)
1238 {
1239 const struct bfd_arch_info *ap
1240 = bfd_lookup_arch (rego->bfd_architecture, 0);
1241 if (ap == nullptr)
1242 internal_error (_("gdbarch_architecture_names: multi-arch unknown"));
1243 do
1244 {
1245 arches.push_back (ap->printable_name);
1246 ap = ap->next;
1247 }
1248 while (ap != NULL);
1249 }
1250
1251 return arches;
1252}
1253
1254
1255void
1256gdbarch_register (enum bfd_architecture bfd_architecture,
1257 gdbarch_init_ftype *init,
1258 gdbarch_dump_tdep_ftype *dump_tdep)
1259{
1260 struct gdbarch_registration **curr;
1261 const struct bfd_arch_info *bfd_arch_info;
1262
1263 /* Check that BFD recognizes this architecture */
1264 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1265 if (bfd_arch_info == NULL)
1266 {
1267 internal_error (_("gdbarch: Attempt to register "
1268 "unknown architecture (%d)"),
1269 bfd_architecture);
1270 }
1271 /* Check that we haven't seen this architecture before. */
1272 for (curr = &gdbarch_registry;
1273 (*curr) != NULL;
1274 curr = &(*curr)->next)
1275 {
1276 if (bfd_architecture == (*curr)->bfd_architecture)
1277 internal_error (_("gdbarch: Duplicate registration "
1278 "of architecture (%s)"),
1279 bfd_arch_info->printable_name);
1280 }
1281 /* log it */
1282 if (gdbarch_debug)
1283 gdb_printf (gdb_stdlog, "gdbarch_register (%s, %s)\n",
1284 bfd_arch_info->printable_name,
1285 host_address_to_string (init));
1286 /* Append it */
1287 (*curr) = XNEW (struct gdbarch_registration);
1288 (*curr)->bfd_architecture = bfd_architecture;
1289 (*curr)->init = init;
1290 (*curr)->dump_tdep = dump_tdep;
1291 (*curr)->arches = NULL;
1292 (*curr)->next = NULL;
1293}
1294
1295/* Look for an architecture using gdbarch_info. */
1296
1297struct gdbarch_list *
1299 const struct gdbarch_info *info)
1300{
1301 for (; arches != NULL; arches = arches->next)
1302 {
1303 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1304 continue;
1305 if (info->byte_order != arches->gdbarch->byte_order)
1306 continue;
1307 if (info->osabi != arches->gdbarch->osabi)
1308 continue;
1309 if (info->target_desc != arches->gdbarch->target_desc)
1310 continue;
1311 return arches;
1312 }
1313 return NULL;
1314}
1315
1316
1317/* Find an architecture that matches the specified INFO. Create a new
1318 architecture if needed. Return that new architecture. */
1319
1320struct gdbarch *
1322{
1323 struct gdbarch *new_gdbarch;
1324 struct gdbarch_registration *rego;
1325
1326 /* Fill in missing parts of the INFO struct using a number of
1327 sources: "set ..."; INFOabfd supplied; and the global
1328 defaults. */
1329 gdbarch_info_fill (&info);
1330
1331 /* Must have found some sort of architecture. */
1332 gdb_assert (info.bfd_arch_info != nullptr);
1333
1334 if (gdbarch_debug)
1335 {
1337 "gdbarch_find_by_info: info.bfd_arch_info %s\n",
1338 (info.bfd_arch_info != nullptr
1339 ? info.bfd_arch_info->printable_name
1340 : "(null)"));
1342 "gdbarch_find_by_info: info.byte_order %d (%s)\n",
1343 info.byte_order,
1344 (info.byte_order == BFD_ENDIAN_BIG ? "big"
1345 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
1346 : "default"));
1348 "gdbarch_find_by_info: info.osabi %d (%s)\n",
1349 info.osabi, gdbarch_osabi_name (info.osabi));
1351 "gdbarch_find_by_info: info.abfd %s\n",
1352 host_address_to_string (info.abfd));
1353 }
1354
1355 /* Find the tdep code that knows about this architecture. */
1356 for (rego = gdbarch_registry;
1357 rego != nullptr;
1358 rego = rego->next)
1359 if (rego->bfd_architecture == info.bfd_arch_info->arch)
1360 break;
1361 if (rego == nullptr)
1362 {
1363 if (gdbarch_debug)
1364 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1365 "No matching architecture\n");
1366 return nullptr;
1367 }
1368
1369 /* Ask the tdep code for an architecture that matches "info". */
1370 new_gdbarch = rego->init (info, rego->arches);
1371
1372 /* Did the tdep code like it? No. Reject the change and revert to
1373 the old architecture. */
1374 if (new_gdbarch == nullptr)
1375 {
1376 if (gdbarch_debug)
1377 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1378 "Target rejected architecture\n");
1379 return nullptr;
1380 }
1381
1382 /* Is this a pre-existing architecture (as determined by already
1383 being initialized)? Move it to the front of the architecture
1384 list (keeping the list sorted Most Recently Used). */
1385 if (new_gdbarch->initialized_p)
1386 {
1387 struct gdbarch_list **list;
1388 struct gdbarch_list *self;
1389 if (gdbarch_debug)
1390 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1391 "Previous architecture %s (%s) selected\n",
1392 host_address_to_string (new_gdbarch),
1393 new_gdbarch->bfd_arch_info->printable_name);
1394 /* Find the existing arch in the list. */
1395 for (list = &rego->arches;
1396 (*list) != nullptr && (*list)->gdbarch != new_gdbarch;
1397 list = &(*list)->next);
1398 /* It had better be in the list of architectures. */
1399 gdb_assert ((*list) != nullptr && (*list)->gdbarch == new_gdbarch);
1400 /* Unlink SELF. */
1401 self = (*list);
1402 (*list) = self->next;
1403 /* Insert SELF at the front. */
1404 self->next = rego->arches;
1405 rego->arches = self;
1406 /* Return it. */
1407 return new_gdbarch;
1408 }
1409
1410 /* It's a new architecture. */
1411 if (gdbarch_debug)
1412 gdb_printf (gdb_stdlog, "gdbarch_find_by_info: "
1413 "New architecture %s (%s) selected\n",
1414 host_address_to_string (new_gdbarch),
1415 new_gdbarch->bfd_arch_info->printable_name);
1416
1417 /* Insert the new architecture into the front of the architecture
1418 list (keep the list sorted Most Recently Used). */
1419 {
1420 struct gdbarch_list *self = XNEW (struct gdbarch_list);
1421 self->next = rego->arches;
1422 self->gdbarch = new_gdbarch;
1423 rego->arches = self;
1424 }
1425
1426 /* Check that the newly installed architecture is valid. Plug in
1427 any post init values. */
1428 new_gdbarch->dump_tdep = rego->dump_tdep;
1429 verify_gdbarch (new_gdbarch);
1430 new_gdbarch->initialized_p = true;
1431
1432 if (gdbarch_debug)
1433 gdbarch_dump (new_gdbarch, gdb_stdlog);
1434
1435 return new_gdbarch;
1436}
1437
1438/* Make the specified architecture current. */
1439
1440void
1441set_target_gdbarch (struct gdbarch *new_gdbarch)
1442{
1443 gdb_assert (new_gdbarch != NULL);
1444 gdb_assert (new_gdbarch->initialized_p);
1445 current_inferior ()->gdbarch = new_gdbarch;
1446 gdb::observers::architecture_changed.notify (new_gdbarch);
1448}
1449
1450/* Return the current inferior's arch. */
1451
1452struct gdbarch *
1454{
1455 return current_inferior ()->gdbarch;
1456}
1457
1459void
1461{
1464 _("Set endianness of target."),
1465 _("Show endianness of target."),
1466 NULL, set_endian, show_endian,
1467 &setlist, &showlist);
1469Set architecture debugging."), _("\
1470Show architecture debugging."), _("\
1471When non-zero, architecture debugging is enabled."),
1472 NULL,
1475}
int regnum
const char *const name
std::string default_get_pc_address_flags(frame_info_ptr frame, CORE_ADDR pc)
void gdbarch_free(struct gdbarch *arch)
ULONGEST default_type_align(struct gdbarch *gdbarch, struct type *type)
static const char * pstring_list(const char *const *list)
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition arch-utils.c:637
unsigned int gdbarch_debug
static const char * set_architecture_string
Definition arch-utils.c:524
bool default_execute_dwarf_cfa_vendor_op(struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs)
Definition arch-utils.c:242
static const char * pstring_ptr(char **string)
int generic_in_solib_return_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
Definition arch-utils.c:155
#define GDBARCH_DEBUG
int default_insn_is_ret(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition arch-utils.c:913
static const char endian_little[]
Definition arch-utils.c:360
static void show_gdbarch_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static const bfd_arch_info_type * default_bfd_arch
Definition arch-utils.c:671
int default_print_insn(bfd_vma memaddr, disassemble_info *info)
const struct floatformat ** default_floatformat_for_type(struct gdbarch *gdbarch, const char *name, int len)
Definition arch-utils.c:289
void set_target_gdbarch(struct gdbarch *new_gdbarch)
static const char * pformat(struct gdbarch *gdbarch, const struct floatformat **format)
CORE_ADDR generic_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR pc)
Definition arch-utils.c:143
int gdbarch_update_p(struct gdbarch_info info)
Definition arch-utils.c:585
void default_skip_permanent_breakpoint(struct regcache *regcache)
Definition arch-utils.c:956
CORE_ADDR displaced_step_at_entry_point(struct gdbarch *gdbarch)
Definition arch-utils.c:54
void gdbarch_info_fill(struct gdbarch_info *info)
Definition arch-utils.c:780
static const char * set_endian_string
Definition arch-utils.c:369
int default_insn_is_jump(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition arch-utils.c:918
void default_guess_tracepoint_registers(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
struct gdbarch * get_current_arch(void)
Definition arch-utils.c:846
void set_gdbarch_from_file(bfd *abfd)
Definition arch-utils.c:649
static const char endian_auto[]
Definition arch-utils.c:361
int default_addressable_memory_unit_size(struct gdbarch *gdbarch)
void default_read_core_file_mappings(struct gdbarch *gdbarch, struct bfd *cbfd, read_core_file_mappings_pre_loop_ftype pre_loop_cb, read_core_file_mappings_loop_ftype loop_cb)
int generic_instruction_nullified(struct gdbarch *gdbarch, struct regcache *regcache)
Definition arch-utils.c:333
CORE_ADDR default_adjust_dwarf2_line(CORE_ADDR addr, int rel)
Definition arch-utils.c:234
struct gdbarch * target_gdbarch(void)
static enum bfd_endian default_byte_order
Definition arch-utils.c:681
static const char *const endian_enum[]
Definition arch-utils.c:362
struct value * default_get_memtag(struct gdbarch *gdbarch, struct value *address, memtag_type tag_type)
Definition arch-utils.c:135
static void set_architecture(const char *ignore_args, int from_tty, struct cmd_list_element *c)
Definition arch-utils.c:556
static std::vector< const char * > arches
Definition arch-utils.c:685
static const bfd_target * default_bfd_vec
Definition arch-utils.c:678
CORE_ADDR default_get_return_buf_addr(struct type *val_type, frame_info_ptr cur_frame)
CORE_ADDR default_remove_non_address_bits(struct gdbarch *gdbarch, CORE_ADDR pointer)
Definition arch-utils.c:88
int default_breakpoint_kind_from_current_state(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr)
Definition arch-utils.c:882
char * gdbarch_obstack_strdup(struct gdbarch *arch, const char *string)
static const char * pstring(const char *string)
int default_fast_tracepoint_valid_at(struct gdbarch *gdbarch, CORE_ADDR addr, std::string *msg)
Definition arch-utils.c:863
void initialize_current_architecture(void)
Definition arch-utils.c:688
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
const char * default_gnu_triplet_regexp(struct gdbarch *gdbarch)
Definition arch-utils.c:993
int legacy_register_sim_regno(struct gdbarch *gdbarch, int regnum)
Definition arch-utils.c:71
CORE_ADDR gdbarch_skip_prologue_noexcept(gdbarch *gdbarch, CORE_ADDR pc) noexcept
int generic_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition arch-utils.c:162
void default_infcall_munmap(CORE_ADDR addr, CORE_ADDR size)
Definition arch-utils.c:974
void default_make_symbol_special(struct symbol *sym, struct objfile *objfile)
Definition arch-utils.c:218
bool default_tagged_address_p(struct gdbarch *gdbarch, struct value *address)
Definition arch-utils.c:106
set_arch
Definition arch-utils.c:520
@ set_arch_manual
Definition arch-utils.c:520
@ set_arch_auto
Definition arch-utils.c:520
int core_addr_greaterthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:183
bool default_memtag_matches_p(struct gdbarch *gdbarch, struct value *address)
Definition arch-utils.c:115
CORE_ADDR core_addr_identity(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition arch-utils.c:191
static const struct bfd_arch_info * target_architecture_user
Definition arch-utils.c:522
static void set_endian(const char *ignore_args, int from_tty, struct cmd_list_element *c)
Definition arch-utils.c:400
static const struct bfd_arch_info * choose_architecture_for_target(const struct target_desc *target_desc, const struct bfd_arch_info *selected)
Definition arch-utils.c:449
obstack * gdbarch_obstack(gdbarch *arch)
static enum bfd_endian target_byte_order_user
Definition arch-utils.c:357
const gdb_byte * default_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition arch-utils.c:874
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition arch-utils.c:177
enum bfd_endian selected_byte_order(void)
Definition arch-utils.c:372
void _initialize_gdbarch_utils()
std::string default_memtag_to_string(struct gdbarch *gdbarch, struct value *tag)
Definition arch-utils.c:97
std::vector< const char * > gdbarch_printable_names()
int generic_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition arch-utils.c:320
bool default_displaced_step_hw_singlestep(struct gdbarch *gdbarch)
Definition arch-utils.c:48
int no_op_reg_to_regnum(struct gdbarch *gdbarch, int reg)
Definition arch-utils.c:204
static const char endian_big[]
Definition arch-utils.c:359
struct gdbarch_tdep_base * gdbarch_tdep_1(struct gdbarch *gdbarch)
int default_has_shared_address_space(struct gdbarch *gdbarch)
Definition arch-utils.c:855
int default_stabs_argument_has_addr(struct gdbarch *gdbarch, struct type *type)
Definition arch-utils.c:327
std::string default_gcc_target_options(struct gdbarch *gdbarch)
Definition arch-utils.c:983
bool default_set_memtags(struct gdbarch *gdbarch, struct value *address, size_t length, const gdb::byte_vector &tags, memtag_type tag_type)
Definition arch-utils.c:124
const char * selected_architecture_name(void)
Definition arch-utils.c:527
int default_vsyscall_range(struct gdbarch *gdbarch, struct mem_range *range)
Definition arch-utils.c:349
void default_coff_make_msymbol_special(int val, struct minimal_symbol *msym)
Definition arch-utils.c:210
int cannot_register_not(struct gdbarch *gdbarch, int regnum)
Definition arch-utils.c:249
bool default_in_indirect_branch_thunk(gdbarch *gdbarch, CORE_ADDR pc)
void default_gen_return_address(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
Definition arch-utils.c:891
int default_return_in_first_hidden_param_p(struct gdbarch *gdbarch, struct type *type)
Definition arch-utils.c:899
bool default_program_breakpoint_here_p(struct gdbarch *gdbarch, CORE_ADDR address)
Definition arch-utils.c:926
static void show_architecture(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition arch-utils.c:539
int default_code_of_frame_writable(struct gdbarch *gdbarch, frame_info_ptr frame)
Definition arch-utils.c:168
CORE_ADDR generic_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition arch-utils.c:149
static struct gdbarch_registration * gdbarch_registry
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
static void show_endian(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition arch-utils.c:380
int default_remote_register_number(struct gdbarch *gdbarch, int regno)
Definition arch-utils.c:340
int default_insn_is_call(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition arch-utils.c:908
CORE_ADDR default_adjust_dwarf2_addr(CORE_ADDR pc)
Definition arch-utils.c:226
CORE_ADDR default_infcall_mmap(CORE_ADDR size, unsigned prot)
Definition arch-utils.c:968
struct gdbarch * gdbarch_find_by_info(struct gdbarch_info info)
gdbarch_virtual_frame_pointer_ftype legacy_virtual_frame_pointer
gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr_identity
struct gdbarch * gdbarch
Definition inferior.h:626
gdbarch * arch() const
Definition regcache.c:230
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1053
struct cmd_list_element * showlist
Definition cli-cmds.c:125
struct cmd_list_element * setlist
Definition cli-cmds.c:117
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:163
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition cli-decode.c:294
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:618
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
@ class_maintenance
Definition command.h:65
@ class_support
Definition command.h:58
#define DEFAULT_BFD_ARCH
Definition config.h:35
#define DEFAULT_BFD_VEC
Definition config.h:38
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:561
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:2907
bool has_stack_frames()
Definition frame.c:1784
frame_info_ptr get_selected_frame(const char *message)
Definition frame.c:1813
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2023
int gdbarch_half_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1507
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition gdbarch.c:2712
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1370
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition gdbarch.c:2142
const struct floatformat ** gdbarch_half_format(struct gdbarch *gdbarch)
Definition gdbarch.c:1524
const struct floatformat ** gdbarch_bfloat16_format(struct gdbarch *gdbarch)
Definition gdbarch.c:1491
CORE_ADDR gdbarch_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR ip)
Definition gdbarch.c:2630
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition gdbarch.c:1899
int gdbarch_float_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1540
int gdbarch_deprecated_fp_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2197
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2006
const struct floatformat ** gdbarch_double_format(struct gdbarch *gdbarch)
Definition gdbarch.c:1590
int gdbarch_long_double_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1606
int gdbarch_bfloat16_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1474
const gdb_byte * gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, int kind, int *size)
Definition gdbarch.c:2746
const struct floatformat ** gdbarch_float_format(struct gdbarch *gdbarch)
Definition gdbarch.c:1557
const struct floatformat ** gdbarch_long_double_format(struct gdbarch *gdbarch)
Definition gdbarch.c:1623
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition gdbarch.c:1361
bool gdbarch_software_single_step_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3223
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1691
int gdbarch_double_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1573
int gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr)
Definition gdbarch.c:2729
void gdbarch_dump(struct gdbarch *gdbarch, struct ui_file *file)
Definition gdbarch.c:526
static void verify_gdbarch(struct gdbarch *gdbarch)
Definition gdbarch.c:287
void() gdbarch_dump_tdep_ftype(struct gdbarch *gdbarch, struct ui_file *file)
Definition gdbarch.h:270
memtag_type
Definition gdbarch.h:128
struct gdbarch *() gdbarch_init_ftype(struct gdbarch_info info, struct gdbarch_list *arches)
Definition gdbarch.h:269
gdb::function_view< void(int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs, const char *filename, const bfd_build_id *build_id)> read_core_file_mappings_loop_ftype
Definition gdbarch.h:150
gdb::function_view< void(ULONGEST count)> read_core_file_mappings_pre_loop_ftype
Definition gdbarch.h:142
#define core_bfd
Definition gdbcore.h:130
size_t size
Definition go32-nat.c:241
struct inferior * current_inferior(void)
Definition inferior.c:54
struct language_pass_by_ref_info language_pass_by_reference(struct type *type)
Definition language.c:563
observable< struct gdbarch * > architecture_changed
info(c)
Definition gdbarch.py:184
CORE_ADDR entry_point_address(void)
Definition objfiles.c:373
#define GDB_OSABI_DEFAULT
Definition osabi.c:31
enum gdb_osabi gdbarch_lookup_osabi(bfd *abfd)
Definition osabi.c:237
const char * gdbarch_osabi_name(enum gdb_osabi osabi)
Definition osabi.c:90
@ GDB_OSABI_NONE
Definition osabi.h:27
@ GDB_OSABI_UNKNOWN
Definition osabi.h:26
struct program_space * current_program_space
Definition progspace.c:39
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition regcache.c:1324
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition regcache.c:1368
void registers_changed(void)
Definition regcache.c:577
@ LEGACY_SIM_REGNO_IGNORE
Definition sim-regno.h:36
bfd * abfd
Definition gdbarch.h:259
struct gdbarch * gdbarch
Definition gdbarch.h:241
struct gdbarch_list * next
Definition gdbarch.h:242
struct gdbarch_list * arches
gdbarch_dump_tdep_ftype * dump_tdep
gdbarch_init_ftype * init
enum bfd_architecture bfd_architecture
struct gdbarch_registration * next
gdbarch_dump_tdep_ftype * dump_tdep
Definition gdbarch.c:49
registry< gdbarch > registry_fields
Definition gdbarch.c:38
const struct bfd_arch_info * bfd_arch_info
Definition gdbarch.c:41
bool initialized_p
Definition gdbarch.c:33
auto_obstack obstack
Definition gdbarch.c:36
bfd * exec_bfd() const
Definition progspace.h:264
Definition value.c:72
static registry< T > * get(T *obj)
Definition registry.h:41
cmd_list_element * set
Definition command.h:406
Definition value.c:181
struct value::@195::@196 reg
CORE_ADDR address
Definition value.c:246
const struct bfd_arch_info * tdesc_architecture(const struct target_desc *target_desc)
const struct target_desc * target_current_description(void)
enum gdb_osabi tdesc_osabi(const struct target_desc *target_desc)
int tdesc_compatible_p(const struct target_desc *target_desc, const struct bfd_arch_info *arch)
scoped_restore_tmpl< int > make_scoped_restore_show_memory_breakpoints(int show)
Definition target.c:1653
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1771
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
#define gdb_stderr
Definition utils.h:193
#define gdb_stdlog
Definition utils.h:196
#define gdb_stdout
Definition utils.h:188
const char target_name[]
Definition version.c:4