]> Git Repo - binutils.git/blob - gdb/arch-utils.c
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / gdb / arch-utils.c
1 /* Dynamic architecture support for GDB, the GNU debugger.
2
3    Copyright (C) 1998-2022 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
40 #include "gdbsupport/version.h"
41
42 #include "floatformat.h"
43
44 #include "dis-asm.h"
45
46 bool
47 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch)
48 {
49   return !gdbarch_software_single_step_p (gdbarch);
50 }
51
52 CORE_ADDR
53 displaced_step_at_entry_point (struct gdbarch *gdbarch)
54 {
55   CORE_ADDR addr;
56   int bp_len;
57
58   addr = entry_point_address ();
59
60   /* Inferior calls also use the entry point as a breakpoint location.
61      We don't want displaced stepping to interfere with those
62      breakpoints, so leave space.  */
63   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
64   addr += bp_len * 2;
65
66   return addr;
67 }
68
69 int
70 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
71 {
72   /* Only makes sense to supply raw registers.  */
73   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
74   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
75      suspected that some GDB/SIM combinations may rely on this
76      behaviour.  The default should be one2one_register_sim_regno
77      (below).  */
78   if (gdbarch_register_name (gdbarch, regnum) != NULL
79       && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
80     return regnum;
81   else
82     return LEGACY_SIM_REGNO_IGNORE;
83 }
84
85
86 /* See arch-utils.h */
87
88 std::string
89 default_memtag_to_string (struct gdbarch *gdbarch, struct value *tag)
90 {
91   error (_("This architecture has no method to convert a memory tag to"
92            " a string."));
93 }
94
95 /* See arch-utils.h */
96
97 bool
98 default_tagged_address_p (struct gdbarch *gdbarch, struct value *address)
99 {
100   /* By default, assume the address is untagged.  */
101   return false;
102 }
103
104 /* See arch-utils.h */
105
106 bool
107 default_memtag_matches_p (struct gdbarch *gdbarch, struct value *address)
108 {
109   /* By default, assume the tags match.  */
110   return true;
111 }
112
113 /* See arch-utils.h */
114
115 bool
116 default_set_memtags (struct gdbarch *gdbarch, struct value *address,
117                      size_t length, const gdb::byte_vector &tags,
118                      memtag_type tag_type)
119 {
120   /* By default, return true (successful);  */
121   return true;
122 }
123
124 /* See arch-utils.h */
125
126 struct value *
127 default_get_memtag (struct gdbarch *gdbarch, struct value *address,
128                     memtag_type tag_type)
129 {
130   /* By default, return no tag.  */
131   return nullptr;
132 }
133
134 CORE_ADDR
135 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
136 {
137   return 0;
138 }
139
140 CORE_ADDR
141 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
142 {
143   return 0;
144 }
145
146 int
147 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
148                                     CORE_ADDR pc, const char *name)
149 {
150   return 0;
151 }
152
153 int
154 generic_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
155 {
156   return 0;
157 }
158
159 int
160 default_code_of_frame_writable (struct gdbarch *gdbarch,
161                                 struct frame_info *frame)
162 {
163   return 1;
164 }
165
166 /* Helper functions for gdbarch_inner_than */
167
168 int
169 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
170 {
171   return (lhs < rhs);
172 }
173
174 int
175 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
176 {
177   return (lhs > rhs);
178 }
179
180 /* Misc helper functions for targets.  */
181
182 CORE_ADDR
183 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
184 {
185   return addr;
186 }
187
188 CORE_ADDR
189 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
190                                      struct target_ops *targ)
191 {
192   return addr;
193 }
194
195 int
196 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
197 {
198   return reg;
199 }
200
201 void
202 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
203 {
204   return;
205 }
206
207 /* See arch-utils.h.  */
208
209 void
210 default_make_symbol_special (struct symbol *sym, struct objfile *objfile)
211 {
212   return;
213 }
214
215 /* See arch-utils.h.  */
216
217 CORE_ADDR
218 default_adjust_dwarf2_addr (CORE_ADDR pc)
219 {
220   return pc;
221 }
222
223 /* See arch-utils.h.  */
224
225 CORE_ADDR
226 default_adjust_dwarf2_line (CORE_ADDR addr, int rel)
227 {
228   return addr;
229 }
230
231 /* See arch-utils.h.  */
232
233 bool
234 default_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op,
235                                      struct dwarf2_frame_state *fs)
236 {
237   return false;
238 }
239
240 int
241 cannot_register_not (struct gdbarch *gdbarch, int regnum)
242 {
243   return 0;
244 }
245
246 /* Legacy version of target_virtual_frame_pointer().  Assumes that
247    there is an gdbarch_deprecated_fp_regnum and that it is the same,
248    cooked or raw.  */
249
250 void
251 legacy_virtual_frame_pointer (struct gdbarch *gdbarch, 
252                               CORE_ADDR pc,
253                               int *frame_regnum,
254                               LONGEST *frame_offset)
255 {
256   /* FIXME: cagney/2002-09-13: This code is used when identifying the
257      frame pointer of the current PC.  It is assuming that a single
258      register and an offset can determine this.  I think it should
259      instead generate a byte code expression as that would work better
260      with things like Dwarf2's CFI.  */
261   if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
262       && gdbarch_deprecated_fp_regnum (gdbarch)
263            < gdbarch_num_regs (gdbarch))
264     *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
265   else if (gdbarch_sp_regnum (gdbarch) >= 0
266            && gdbarch_sp_regnum (gdbarch)
267                 < gdbarch_num_regs (gdbarch))
268     *frame_regnum = gdbarch_sp_regnum (gdbarch);
269   else
270     /* Should this be an internal error?  I guess so, it is reflecting
271        an architectural limitation in the current design.  */
272     internal_error (__FILE__, __LINE__, 
273                     _("No virtual frame pointer available"));
274   *frame_offset = 0;
275 }
276
277 /* Return a floating-point format for a floating-point variable of
278    length LEN in bits.  If non-NULL, NAME is the name of its type.
279    If no suitable type is found, return NULL.  */
280
281 const struct floatformat **
282 default_floatformat_for_type (struct gdbarch *gdbarch,
283                               const char *name, int len)
284 {
285   const struct floatformat **format = NULL;
286
287   /* Check if this is a bfloat16 type.  It has the same size as the
288      IEEE half float type, so we use the base type name to tell them
289      apart.  */
290   if (name != nullptr && strcmp (name, "__bf16") == 0
291       && len == gdbarch_bfloat16_bit (gdbarch))
292     format = gdbarch_bfloat16_format (gdbarch);
293   else if (len == gdbarch_half_bit (gdbarch))
294     format = gdbarch_half_format (gdbarch);
295   else if (len == gdbarch_float_bit (gdbarch))
296     format = gdbarch_float_format (gdbarch);
297   else if (len == gdbarch_double_bit (gdbarch))
298     format = gdbarch_double_format (gdbarch);
299   else if (len == gdbarch_long_double_bit (gdbarch))
300     format = gdbarch_long_double_format (gdbarch);
301   /* On i386 the 'long double' type takes 96 bits,
302      while the real number of used bits is only 80,
303      both in processor and in memory.
304      The code below accepts the real bit size.  */
305   else if (gdbarch_long_double_format (gdbarch) != NULL
306            && len == gdbarch_long_double_format (gdbarch)[0]->totalsize)
307     format = gdbarch_long_double_format (gdbarch);
308
309   return format;
310 }
311 \f
312 int
313 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
314                             struct type *type)
315 {
316   return 0;
317 }
318
319 int
320 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
321 {
322   return 0;
323 }
324
325 int
326 generic_instruction_nullified (struct gdbarch *gdbarch,
327                                struct regcache *regcache)
328 {
329   return 0;
330 }
331
332 int
333 default_remote_register_number (struct gdbarch *gdbarch,
334                                 int regno)
335 {
336   return regno;
337 }
338
339 /* See arch-utils.h.  */
340
341 int
342 default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
343 {
344   return 0;
345 }
346
347 \f
348 /* Functions to manipulate the endianness of the target.  */
349
350 static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN;
351
352 static const char endian_big[] = "big";
353 static const char endian_little[] = "little";
354 static const char endian_auto[] = "auto";
355 static const char *const endian_enum[] =
356 {
357   endian_big,
358   endian_little,
359   endian_auto,
360   NULL,
361 };
362 static const char *set_endian_string = endian_auto;
363
364 enum bfd_endian
365 selected_byte_order (void)
366 {
367   return target_byte_order_user;
368 }
369
370 /* Called by ``show endian''.  */
371
372 static void
373 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
374              const char *value)
375 {
376   if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
377     if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
378       fprintf_filtered (file, _("The target endianness is set automatically "
379                                 "(currently big endian).\n"));
380     else
381       fprintf_filtered (file, _("The target endianness is set automatically "
382                                 "(currently little endian).\n"));
383   else
384     if (target_byte_order_user == BFD_ENDIAN_BIG)
385       fprintf_filtered (file,
386                         _("The target is set to big endian.\n"));
387     else
388       fprintf_filtered (file,
389                         _("The target is set to little endian.\n"));
390 }
391
392 static void
393 set_endian (const char *ignore_args, int from_tty, struct cmd_list_element *c)
394 {
395   struct gdbarch_info info;
396
397   if (set_endian_string == endian_auto)
398     {
399       target_byte_order_user = BFD_ENDIAN_UNKNOWN;
400       if (! gdbarch_update_p (info))
401         internal_error (__FILE__, __LINE__,
402                         _("set_endian: architecture update failed"));
403     }
404   else if (set_endian_string == endian_little)
405     {
406       info.byte_order = BFD_ENDIAN_LITTLE;
407       if (! gdbarch_update_p (info))
408         fprintf_unfiltered (gdb_stderr,
409                             _("Little endian target not supported by GDB\n"));
410       else
411         target_byte_order_user = BFD_ENDIAN_LITTLE;
412     }
413   else if (set_endian_string == endian_big)
414     {
415       info.byte_order = BFD_ENDIAN_BIG;
416       if (! gdbarch_update_p (info))
417         fprintf_unfiltered (gdb_stderr,
418                             _("Big endian target not supported by GDB\n"));
419       else
420         target_byte_order_user = BFD_ENDIAN_BIG;
421     }
422   else
423     internal_error (__FILE__, __LINE__,
424                     _("set_endian: bad value"));
425
426   show_endian (gdb_stdout, from_tty, NULL, NULL);
427 }
428
429 /* Given SELECTED, a currently selected BFD architecture, and
430    TARGET_DESC, the current target description, return what
431    architecture to use.
432
433    SELECTED may be NULL, in which case we return the architecture
434    associated with TARGET_DESC.  If SELECTED specifies a variant
435    of the architecture associated with TARGET_DESC, return the
436    more specific of the two.
437
438    If SELECTED is a different architecture, but it is accepted as
439    compatible by the target, we can use the target architecture.
440
441    If SELECTED is obviously incompatible, warn the user.  */
442
443 static const struct bfd_arch_info *
444 choose_architecture_for_target (const struct target_desc *target_desc,
445                                 const struct bfd_arch_info *selected)
446 {
447   const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
448   const struct bfd_arch_info *compat1, *compat2;
449
450   if (selected == NULL)
451     return from_target;
452
453   if (from_target == NULL)
454     return selected;
455
456   /* struct bfd_arch_info objects are singletons: that is, there's
457      supposed to be exactly one instance for a given machine.  So you
458      can tell whether two are equivalent by comparing pointers.  */
459   if (from_target == selected)
460     return selected;
461
462   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
463      incompatible.  But if they are compatible, it returns the 'more
464      featureful' of the two arches.  That is, if A can run code
465      written for B, but B can't run code written for A, then it'll
466      return A.
467
468      Some targets (e.g. MIPS as of 2006-12-04) don't fully
469      implement this, instead always returning NULL or the first
470      argument.  We detect that case by checking both directions.  */
471
472   compat1 = selected->compatible (selected, from_target);
473   compat2 = from_target->compatible (from_target, selected);
474
475   if (compat1 == NULL && compat2 == NULL)
476     {
477       /* BFD considers the architectures incompatible.  Check our
478          target description whether it accepts SELECTED as compatible
479          anyway.  */
480       if (tdesc_compatible_p (target_desc, selected))
481         return from_target;
482
483       warning (_("Selected architecture %s is not compatible "
484                  "with reported target architecture %s"),
485                selected->printable_name, from_target->printable_name);
486       return selected;
487     }
488
489   if (compat1 == NULL)
490     return compat2;
491   if (compat2 == NULL)
492     return compat1;
493   if (compat1 == compat2)
494     return compat1;
495
496   /* If the two didn't match, but one of them was a default
497      architecture, assume the more specific one is correct.  This
498      handles the case where an executable or target description just
499      says "mips", but the other knows which MIPS variant.  */
500   if (compat1->the_default)
501     return compat2;
502   if (compat2->the_default)
503     return compat1;
504
505   /* We have no idea which one is better.  This is a bug, but not
506      a critical problem; warn the user.  */
507   warning (_("Selected architecture %s is ambiguous with "
508              "reported target architecture %s"),
509            selected->printable_name, from_target->printable_name);
510   return selected;
511 }
512
513 /* Functions to manipulate the architecture of the target.  */
514
515 enum set_arch { set_arch_auto, set_arch_manual };
516
517 static const struct bfd_arch_info *target_architecture_user;
518
519 static const char *set_architecture_string;
520
521 const char *
522 selected_architecture_name (void)
523 {
524   if (target_architecture_user == NULL)
525     return NULL;
526   else
527     return set_architecture_string;
528 }
529
530 /* Called if the user enters ``show architecture'' without an
531    argument.  */
532
533 static void
534 show_architecture (struct ui_file *file, int from_tty,
535                    struct cmd_list_element *c, const char *value)
536 {
537   if (target_architecture_user == NULL)
538     fprintf_filtered (file, _("The target architecture is set to "
539                               "\"auto\" (currently \"%s\").\n"),
540                       gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
541   else
542     fprintf_filtered (file, _("The target architecture is set to \"%s\".\n"),
543                       set_architecture_string);
544 }
545
546
547 /* Called if the user enters ``set architecture'' with or without an
548    argument.  */
549
550 static void
551 set_architecture (const char *ignore_args,
552                   int from_tty, struct cmd_list_element *c)
553 {
554   struct gdbarch_info info;
555
556   if (strcmp (set_architecture_string, "auto") == 0)
557     {
558       target_architecture_user = NULL;
559       if (!gdbarch_update_p (info))
560         internal_error (__FILE__, __LINE__,
561                         _("could not select an architecture automatically"));
562     }
563   else
564     {
565       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
566       if (info.bfd_arch_info == NULL)
567         internal_error (__FILE__, __LINE__,
568                         _("set_architecture: bfd_scan_arch failed"));
569       if (gdbarch_update_p (info))
570         target_architecture_user = info.bfd_arch_info;
571       else
572         fprintf_unfiltered (gdb_stderr,
573                             _("Architecture `%s' not recognized.\n"),
574                             set_architecture_string);
575     }
576   show_architecture (gdb_stdout, from_tty, NULL, NULL);
577 }
578
579 /* Try to select a global architecture that matches "info".  Return
580    non-zero if the attempt succeeds.  */
581 int
582 gdbarch_update_p (struct gdbarch_info info)
583 {
584   struct gdbarch *new_gdbarch;
585
586   /* Check for the current file.  */
587   if (info.abfd == NULL)
588     info.abfd = current_program_space->exec_bfd ();
589   if (info.abfd == NULL)
590     info.abfd = core_bfd;
591
592   /* Check for the current target description.  */
593   if (info.target_desc == NULL)
594     info.target_desc = target_current_description ();
595
596   new_gdbarch = gdbarch_find_by_info (info);
597
598   /* If there no architecture by that name, reject the request.  */
599   if (new_gdbarch == NULL)
600     {
601       if (gdbarch_debug)
602         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
603                             "Architecture not found\n");
604       return 0;
605     }
606
607   /* If it is the same old architecture, accept the request (but don't
608      swap anything).  */
609   if (new_gdbarch == target_gdbarch ())
610     {
611       if (gdbarch_debug)
612         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
613                             "Architecture %s (%s) unchanged\n",
614                             host_address_to_string (new_gdbarch),
615                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
616       return 1;
617     }
618
619   /* It's a new architecture, swap it in.  */
620   if (gdbarch_debug)
621     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
622                         "New architecture %s (%s) selected\n",
623                         host_address_to_string (new_gdbarch),
624                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
625   set_target_gdbarch (new_gdbarch);
626
627   return 1;
628 }
629
630 /* Return the architecture for ABFD.  If no suitable architecture
631    could be find, return NULL.  */
632
633 struct gdbarch *
634 gdbarch_from_bfd (bfd *abfd)
635 {
636   struct gdbarch_info info;
637
638   info.abfd = abfd;
639   return gdbarch_find_by_info (info);
640 }
641
642 /* Set the dynamic target-system-dependent parameters (architecture,
643    byte-order) using information found in the BFD */
644
645 void
646 set_gdbarch_from_file (bfd *abfd)
647 {
648   struct gdbarch_info info;
649   struct gdbarch *gdbarch;
650
651   info.abfd = abfd;
652   info.target_desc = target_current_description ();
653   gdbarch = gdbarch_find_by_info (info);
654
655   if (gdbarch == NULL)
656     error (_("Architecture of file not recognized."));
657   set_target_gdbarch (gdbarch);
658 }
659
660 /* Initialize the current architecture.  Update the ``set
661    architecture'' command so that it specifies a list of valid
662    architectures.  */
663
664 #ifdef DEFAULT_BFD_ARCH
665 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
666 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
667 #else
668 static const bfd_arch_info_type *default_bfd_arch;
669 #endif
670
671 #ifdef DEFAULT_BFD_VEC
672 extern const bfd_target DEFAULT_BFD_VEC;
673 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
674 #else
675 static const bfd_target *default_bfd_vec;
676 #endif
677
678 static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN;
679
680 /* Printable names of architectures.  Used as the enum list of the
681    "set arch" command.  */
682 static std::vector<const char *> arches;
683
684 void
685 initialize_current_architecture (void)
686 {
687   arches = gdbarch_printable_names ();
688   
689   /* Find a default architecture.  */
690   if (default_bfd_arch == NULL)
691     {
692       /* Choose the architecture by taking the first one
693          alphabetically.  */
694       const char *chosen = arches[0];
695
696       for (const char *arch : arches)
697         {
698           if (strcmp (arch, chosen) < 0)
699             chosen = arch;
700         }
701
702       if (chosen == NULL)
703         internal_error (__FILE__, __LINE__,
704                         _("initialize_current_architecture: No arch"));
705
706       default_bfd_arch = bfd_scan_arch (chosen);
707       if (default_bfd_arch == NULL)
708         internal_error (__FILE__, __LINE__,
709                         _("initialize_current_architecture: Arch not found"));
710     }
711
712   gdbarch_info info;
713   info.bfd_arch_info = default_bfd_arch;
714
715   /* Take several guesses at a byte order.  */
716   if (default_byte_order == BFD_ENDIAN_UNKNOWN
717       && default_bfd_vec != NULL)
718     {
719       /* Extract BFD's default vector's byte order.  */
720       switch (default_bfd_vec->byteorder)
721         {
722         case BFD_ENDIAN_BIG:
723           default_byte_order = BFD_ENDIAN_BIG;
724           break;
725         case BFD_ENDIAN_LITTLE:
726           default_byte_order = BFD_ENDIAN_LITTLE;
727           break;
728         default:
729           break;
730         }
731     }
732   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
733     {
734       /* look for ``*el-*'' in the target name.  */
735       const char *chp;
736       chp = strchr (target_name, '-');
737       if (chp != NULL
738           && chp - 2 >= target_name
739           && startswith (chp - 2, "el"))
740         default_byte_order = BFD_ENDIAN_LITTLE;
741     }
742   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
743     {
744       /* Wire it to big-endian!!! */
745       default_byte_order = BFD_ENDIAN_BIG;
746     }
747
748   info.byte_order = default_byte_order;
749   info.byte_order_for_code = info.byte_order;
750
751   if (! gdbarch_update_p (info))
752     internal_error (__FILE__, __LINE__,
753                     _("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''.  */
760     set_architecture_string = "auto";
761     arches.push_back (set_architecture_string);
762     arches.push_back (nullptr);
763     set_show_commands architecture_cmds
764       = add_setshow_enum_cmd ("architecture", class_support,
765                               arches.data (), &set_architecture_string,
766                               _("Set architecture of target."),
767                               _("Show architecture of target."), NULL,
768                               set_architecture, show_architecture,
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
779 void
780 gdbarch_info_fill (struct gdbarch_info *info)
781 {
782   /* "(gdb) set architecture ...".  */
783   if (info->bfd_arch_info == NULL
784       && target_architecture_user)
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.  */
845 struct gdbarch *
846 get_current_arch (void)
847 {
848   if (has_stack_frames ())
849     return get_frame_arch (get_selected_frame (NULL));
850   else
851     return target_gdbarch ();
852 }
853
854 int
855 default_has_shared_address_space (struct gdbarch *gdbarch)
856 {
857   /* Simply say no.  In most unix-like targets each inferior/process
858      has its own address space.  */
859   return 0;
860 }
861
862 int
863 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr,
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
873 const gdb_byte *
874 default_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 }
881 int
882 default_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
883                                             struct regcache *regcache,
884                                             CORE_ADDR *pcptr)
885 {
886   return gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
887 }
888
889
890 void
891 default_gen_return_address (struct gdbarch *gdbarch,
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
898 int
899 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
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.  */
905   return !(language_pass_by_reference (type).trivially_copyable);
906 }
907
908 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
909 {
910   return 0;
911 }
912
913 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
914 {
915   return 0;
916 }
917
918 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
919 {
920   return 0;
921 }
922
923 /*  See arch-utils.h.  */
924
925 bool
926 default_program_breakpoint_here_p (struct gdbarch *gdbarch,
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
942     = make_scoped_restore_show_memory_breakpoints (0);
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
955 void
956 default_skip_permanent_breakpoint (struct regcache *regcache)
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
967 CORE_ADDR
968 default_infcall_mmap (CORE_ADDR size, unsigned prot)
969 {
970   error (_("This target does not support inferior memory allocation by mmap."));
971 }
972
973 void
974 default_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
982 std::string
983 default_gcc_target_options (struct gdbarch *gdbarch)
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
992 const char *
993 default_gnu_triplet_regexp (struct gdbarch *gdbarch)
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
1003 int
1004 default_addressable_memory_unit_size (struct gdbarch *gdbarch)
1005 {
1006   return gdbarch_bfd_arch_info (gdbarch)->bits_per_byte / 8;
1007 }
1008
1009 void
1010 default_guess_tracepoint_registers (struct gdbarch *gdbarch,
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
1032 int
1033 default_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,
1038                                  info->mach, current_program_space->exec_bfd ());
1039
1040   gdb_assert (disassemble_fn != NULL);
1041   return (*disassemble_fn) (memaddr, info);
1042 }
1043
1044 /* See arch-utils.h.  */
1045
1046 CORE_ADDR
1047 gdbarch_skip_prologue_noexcept (gdbarch *gdbarch, CORE_ADDR pc) noexcept
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
1063 bool
1064 default_in_indirect_branch_thunk (gdbarch *gdbarch, CORE_ADDR pc)
1065 {
1066   return false;
1067 }
1068
1069 /* See arch-utils.h.  */
1070
1071 ULONGEST
1072 default_type_align (struct gdbarch *gdbarch, struct type *type)
1073 {
1074   return 0;
1075 }
1076
1077 /* See arch-utils.h.  */
1078
1079 std::string
1080 default_get_pc_address_flags (frame_info *frame, CORE_ADDR pc)
1081 {
1082   return "";
1083 }
1084
1085 /* See arch-utils.h.  */
1086 void
1087 default_read_core_file_mappings
1088   (struct gdbarch *gdbarch,
1089    struct bfd *cbfd,
1090    read_core_file_mappings_pre_loop_ftype pre_loop_cb,
1091    read_core_file_mappings_loop_ftype loop_cb)
1092 {
1093 }
1094
1095 /* Static function declarations */
1096
1097 static void alloc_gdbarch_data (struct gdbarch *);
1098
1099 /* Non-zero if we want to trace architecture code.  */
1100
1101 #ifndef GDBARCH_DEBUG
1102 #define GDBARCH_DEBUG 0
1103 #endif
1104 unsigned int gdbarch_debug = GDBARCH_DEBUG;
1105 static void
1106 show_gdbarch_debug (struct ui_file *file, int from_tty,
1107                     struct cmd_list_element *c, const char *value)
1108 {
1109   fprintf_filtered (file, _("Architecture debugging is %s.\n"), value);
1110 }
1111
1112 static const char *
1113 pformat (const struct floatformat **format)
1114 {
1115   if (format == NULL)
1116     return "(null)";
1117   else
1118     /* Just print out one of them - this is only for diagnostics.  */
1119     return format[0]->name;
1120 }
1121
1122 static const char *
1123 pstring (const char *string)
1124 {
1125   if (string == NULL)
1126     return "(null)";
1127   return string;
1128 }
1129
1130 static const char *
1131 pstring_ptr (char **string)
1132 {
1133   if (string == NULL || *string == NULL)
1134     return "(null)";
1135   return *string;
1136 }
1137
1138 /* Helper function to print a list of strings, represented as "const
1139    char *const *".  The list is printed comma-separated.  */
1140
1141 static const char *
1142 pstring_list (const char *const *list)
1143 {
1144   static char ret[100];
1145   const char *const *p;
1146   size_t offset = 0;
1147
1148   if (list == NULL)
1149     return "(null)";
1150
1151   ret[0] = '\0';
1152   for (p = list; *p != NULL && offset < sizeof (ret); ++p)
1153     {
1154       size_t s = xsnprintf (ret + offset, sizeof (ret) - offset, "%s, ", *p);
1155       offset += 2 + s;
1156     }
1157
1158   if (offset > 0)
1159     {
1160       gdb_assert (offset - 2 < sizeof (ret));
1161       ret[offset - 2] = '\0';
1162     }
1163
1164   return ret;
1165 }
1166
1167 #include "gdbarch.c"
1168
1169 obstack *gdbarch_obstack (gdbarch *arch)
1170 {
1171   return arch->obstack;
1172 }
1173
1174 /* See gdbarch.h.  */
1175
1176 char *
1177 gdbarch_obstack_strdup (struct gdbarch *arch, const char *string)
1178 {
1179   return obstack_strdup (arch->obstack, string);
1180 }
1181
1182
1183 /* Free a gdbarch struct.  This should never happen in normal
1184    operation --- once you've created a gdbarch, you keep it around.
1185    However, if an architecture's init function encounters an error
1186    building the structure, it may need to clean up a partially
1187    constructed gdbarch.  */
1188
1189 void
1190 gdbarch_free (struct gdbarch *arch)
1191 {
1192   struct obstack *obstack;
1193
1194   gdb_assert (arch != NULL);
1195   gdb_assert (!arch->initialized_p);
1196   obstack = arch->obstack;
1197   obstack_free (obstack, 0); /* Includes the ARCH.  */
1198   xfree (obstack);
1199 }
1200
1201 struct gdbarch_tdep *
1202 gdbarch_tdep (struct gdbarch *gdbarch)
1203 {
1204   if (gdbarch_debug >= 2)
1205     fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1206   return gdbarch->tdep;
1207 }
1208
1209 /* Keep a registry of per-architecture data-pointers required by GDB
1210    modules.  */
1211
1212 struct gdbarch_data
1213 {
1214   unsigned index;
1215   int init_p;
1216   gdbarch_data_pre_init_ftype *pre_init;
1217   gdbarch_data_post_init_ftype *post_init;
1218 };
1219
1220 struct gdbarch_data_registration
1221 {
1222   struct gdbarch_data *data;
1223   struct gdbarch_data_registration *next;
1224 };
1225
1226 struct gdbarch_data_registry
1227 {
1228   unsigned nr;
1229   struct gdbarch_data_registration *registrations;
1230 };
1231
1232 static struct gdbarch_data_registry gdbarch_data_registry =
1233 {
1234   0, NULL,
1235 };
1236
1237 static struct gdbarch_data *
1238 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
1239                        gdbarch_data_post_init_ftype *post_init)
1240 {
1241   struct gdbarch_data_registration **curr;
1242
1243   /* Append the new registration.  */
1244   for (curr = &gdbarch_data_registry.registrations;
1245        (*curr) != NULL;
1246        curr = &(*curr)->next);
1247   (*curr) = XNEW (struct gdbarch_data_registration);
1248   (*curr)->next = NULL;
1249   (*curr)->data = XNEW (struct gdbarch_data);
1250   (*curr)->data->index = gdbarch_data_registry.nr++;
1251   (*curr)->data->pre_init = pre_init;
1252   (*curr)->data->post_init = post_init;
1253   (*curr)->data->init_p = 1;
1254   return (*curr)->data;
1255 }
1256
1257 struct gdbarch_data *
1258 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
1259 {
1260   return gdbarch_data_register (pre_init, NULL);
1261 }
1262
1263 struct gdbarch_data *
1264 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
1265 {
1266   return gdbarch_data_register (NULL, post_init);
1267 }
1268
1269 /* Create/delete the gdbarch data vector.  */
1270
1271 static void
1272 alloc_gdbarch_data (struct gdbarch *gdbarch)
1273 {
1274   gdb_assert (gdbarch->data == NULL);
1275   gdbarch->nr_data = gdbarch_data_registry.nr;
1276   gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
1277 }
1278
1279 /* Return the current value of the specified per-architecture
1280    data-pointer.  */
1281
1282 void *
1283 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
1284 {
1285   gdb_assert (data->index < gdbarch->nr_data);
1286   if (gdbarch->data[data->index] == NULL)
1287     {
1288       /* The data-pointer isn't initialized, call init() to get a
1289          value.  */
1290       if (data->pre_init != NULL)
1291         /* Mid architecture creation: pass just the obstack, and not
1292            the entire architecture, as that way it isn't possible for
1293            pre-init code to refer to undefined architecture
1294            fields.  */
1295         gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
1296       else if (gdbarch->initialized_p
1297                && data->post_init != NULL)
1298         /* Post architecture creation: pass the entire architecture
1299            (as all fields are valid), but be careful to also detect
1300            recursive references.  */
1301         {
1302           gdb_assert (data->init_p);
1303           data->init_p = 0;
1304           gdbarch->data[data->index] = data->post_init (gdbarch);
1305           data->init_p = 1;
1306         }
1307       else
1308         internal_error (__FILE__, __LINE__,
1309                         _("gdbarch post-init data field can only be used "
1310                           "after gdbarch is fully initialised"));
1311       gdb_assert (gdbarch->data[data->index] != NULL);
1312     }
1313   return gdbarch->data[data->index];
1314 }
1315
1316
1317 /* Keep a registry of the architectures known by GDB.  */
1318
1319 struct gdbarch_registration
1320 {
1321   enum bfd_architecture bfd_architecture;
1322   gdbarch_init_ftype *init;
1323   gdbarch_dump_tdep_ftype *dump_tdep;
1324   struct gdbarch_list *arches;
1325   struct gdbarch_registration *next;
1326 };
1327
1328 static struct gdbarch_registration *gdbarch_registry = NULL;
1329
1330 std::vector<const char *>
1331 gdbarch_printable_names ()
1332 {
1333   /* Accumulate a list of names based on the registed list of
1334      architectures.  */
1335   std::vector<const char *> arches;
1336
1337   for (gdbarch_registration *rego = gdbarch_registry;
1338        rego != nullptr;
1339        rego = rego->next)
1340     {
1341       const struct bfd_arch_info *ap
1342         = bfd_lookup_arch (rego->bfd_architecture, 0);
1343       if (ap == nullptr)
1344         internal_error (__FILE__, __LINE__,
1345                         _("gdbarch_architecture_names: multi-arch unknown"));
1346       do
1347         {
1348           arches.push_back (ap->printable_name);
1349           ap = ap->next;
1350         }
1351       while (ap != NULL);
1352     }
1353
1354   return arches;
1355 }
1356
1357
1358 void
1359 gdbarch_register (enum bfd_architecture bfd_architecture,
1360                   gdbarch_init_ftype *init,
1361                   gdbarch_dump_tdep_ftype *dump_tdep)
1362 {
1363   struct gdbarch_registration **curr;
1364   const struct bfd_arch_info *bfd_arch_info;
1365
1366   /* Check that BFD recognizes this architecture */
1367   bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1368   if (bfd_arch_info == NULL)
1369     {
1370       internal_error (__FILE__, __LINE__,
1371                       _("gdbarch: Attempt to register "
1372                         "unknown architecture (%d)"),
1373                       bfd_architecture);
1374     }
1375   /* Check that we haven't seen this architecture before.  */
1376   for (curr = &gdbarch_registry;
1377        (*curr) != NULL;
1378        curr = &(*curr)->next)
1379     {
1380       if (bfd_architecture == (*curr)->bfd_architecture)
1381         internal_error (__FILE__, __LINE__,
1382                         _("gdbarch: Duplicate registration "
1383                           "of architecture (%s)"),
1384                         bfd_arch_info->printable_name);
1385     }
1386   /* log it */
1387   if (gdbarch_debug)
1388     fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, %s)\n",
1389                         bfd_arch_info->printable_name,
1390                         host_address_to_string (init));
1391   /* Append it */
1392   (*curr) = XNEW (struct gdbarch_registration);
1393   (*curr)->bfd_architecture = bfd_architecture;
1394   (*curr)->init = init;
1395   (*curr)->dump_tdep = dump_tdep;
1396   (*curr)->arches = NULL;
1397   (*curr)->next = NULL;
1398 }
1399
1400 void
1401 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1402                        gdbarch_init_ftype *init)
1403 {
1404   gdbarch_register (bfd_architecture, init, NULL);
1405 }
1406
1407
1408 /* Look for an architecture using gdbarch_info.  */
1409
1410 struct gdbarch_list *
1411 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1412                              const struct gdbarch_info *info)
1413 {
1414   for (; arches != NULL; arches = arches->next)
1415     {
1416       if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1417         continue;
1418       if (info->byte_order != arches->gdbarch->byte_order)
1419         continue;
1420       if (info->osabi != arches->gdbarch->osabi)
1421         continue;
1422       if (info->target_desc != arches->gdbarch->target_desc)
1423         continue;
1424       return arches;
1425     }
1426   return NULL;
1427 }
1428
1429
1430 /* Find an architecture that matches the specified INFO.  Create a new
1431    architecture if needed.  Return that new architecture.  */
1432
1433 struct gdbarch *
1434 gdbarch_find_by_info (struct gdbarch_info info)
1435 {
1436   struct gdbarch *new_gdbarch;
1437   struct gdbarch_registration *rego;
1438
1439   /* Fill in missing parts of the INFO struct using a number of
1440      sources: "set ..."; INFOabfd supplied; and the global
1441      defaults.  */
1442   gdbarch_info_fill (&info);
1443
1444   /* Must have found some sort of architecture.  */
1445   gdb_assert (info.bfd_arch_info != NULL);
1446
1447   if (gdbarch_debug)
1448     {
1449       fprintf_unfiltered (gdb_stdlog,
1450                           "gdbarch_find_by_info: info.bfd_arch_info %s\n",
1451                           (info.bfd_arch_info != NULL
1452                            ? info.bfd_arch_info->printable_name
1453                            : "(null)"));
1454       fprintf_unfiltered (gdb_stdlog,
1455                           "gdbarch_find_by_info: info.byte_order %d (%s)\n",
1456                           info.byte_order,
1457                           (info.byte_order == BFD_ENDIAN_BIG ? "big"
1458                            : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
1459                            : "default"));
1460       fprintf_unfiltered (gdb_stdlog,
1461                           "gdbarch_find_by_info: info.osabi %d (%s)\n",
1462                           info.osabi, gdbarch_osabi_name (info.osabi));
1463       fprintf_unfiltered (gdb_stdlog,
1464                           "gdbarch_find_by_info: info.abfd %s\n",
1465                           host_address_to_string (info.abfd));
1466     }
1467
1468   /* Find the tdep code that knows about this architecture.  */
1469   for (rego = gdbarch_registry;
1470        rego != NULL;
1471        rego = rego->next)
1472     if (rego->bfd_architecture == info.bfd_arch_info->arch)
1473       break;
1474   if (rego == NULL)
1475     {
1476       if (gdbarch_debug)
1477         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
1478                             "No matching architecture\n");
1479       return 0;
1480     }
1481
1482   /* Ask the tdep code for an architecture that matches "info".  */
1483   new_gdbarch = rego->init (info, rego->arches);
1484
1485   /* Did the tdep code like it?  No.  Reject the change and revert to
1486      the old architecture.  */
1487   if (new_gdbarch == NULL)
1488     {
1489       if (gdbarch_debug)
1490         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
1491                             "Target rejected architecture\n");
1492       return NULL;
1493     }
1494
1495   /* Is this a pre-existing architecture (as determined by already
1496      being initialized)?  Move it to the front of the architecture
1497      list (keeping the list sorted Most Recently Used).  */
1498   if (new_gdbarch->initialized_p)
1499     {
1500       struct gdbarch_list **list;
1501       struct gdbarch_list *self;
1502       if (gdbarch_debug)
1503         fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
1504                             "Previous architecture %s (%s) selected\n",
1505                             host_address_to_string (new_gdbarch),
1506                             new_gdbarch->bfd_arch_info->printable_name);
1507       /* Find the existing arch in the list.  */
1508       for (list = &rego->arches;
1509            (*list) != NULL && (*list)->gdbarch != new_gdbarch;
1510            list = &(*list)->next);
1511       /* It had better be in the list of architectures.  */
1512       gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
1513       /* Unlink SELF.  */
1514       self = (*list);
1515       (*list) = self->next;
1516       /* Insert SELF at the front.  */
1517       self->next = rego->arches;
1518       rego->arches = self;
1519       /* Return it.  */
1520       return new_gdbarch;
1521     }
1522
1523   /* It's a new architecture.  */
1524   if (gdbarch_debug)
1525     fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: "
1526                         "New architecture %s (%s) selected\n",
1527                         host_address_to_string (new_gdbarch),
1528                         new_gdbarch->bfd_arch_info->printable_name);
1529
1530   /* Insert the new architecture into the front of the architecture
1531      list (keep the list sorted Most Recently Used).  */
1532   {
1533     struct gdbarch_list *self = XNEW (struct gdbarch_list);
1534     self->next = rego->arches;
1535     self->gdbarch = new_gdbarch;
1536     rego->arches = self;
1537   }
1538
1539   /* Check that the newly installed architecture is valid.  Plug in
1540      any post init values.  */
1541   new_gdbarch->dump_tdep = rego->dump_tdep;
1542   verify_gdbarch (new_gdbarch);
1543   new_gdbarch->initialized_p = 1;
1544
1545   if (gdbarch_debug)
1546     gdbarch_dump (new_gdbarch, gdb_stdlog);
1547
1548   return new_gdbarch;
1549 }
1550
1551 /* Make the specified architecture current.  */
1552
1553 void
1554 set_target_gdbarch (struct gdbarch *new_gdbarch)
1555 {
1556   gdb_assert (new_gdbarch != NULL);
1557   gdb_assert (new_gdbarch->initialized_p);
1558   current_inferior ()->gdbarch = new_gdbarch;
1559   gdb::observers::architecture_changed.notify (new_gdbarch);
1560   registers_changed ();
1561 }
1562
1563 /* Return the current inferior's arch.  */
1564
1565 struct gdbarch *
1566 target_gdbarch (void)
1567 {
1568   return current_inferior ()->gdbarch;
1569 }
1570
1571 void _initialize_gdbarch_utils ();
1572 void
1573 _initialize_gdbarch_utils ()
1574 {
1575   add_setshow_enum_cmd ("endian", class_support,
1576                         endian_enum, &set_endian_string, 
1577                         _("Set endianness of target."),
1578                         _("Show endianness of target."),
1579                         NULL, set_endian, show_endian,
1580                         &setlist, &showlist);
1581   add_setshow_zuinteger_cmd ("arch", class_maintenance, &gdbarch_debug, _("\
1582 Set architecture debugging."), _("\
1583 Show architecture debugging."), _("\
1584 When non-zero, architecture debugging is enabled."),
1585                             NULL,
1586                             show_gdbarch_debug,
1587                             &setdebuglist, &showdebuglist);
1588 }
This page took 0.116174 seconds and 4 git commands to generate.