* gdbarch.sh (target_gdbarch): New global variable.
[platform/upstream/binutils.git] / gdb / arch-utils.c
1 /* Dynamic architecture support for GDB, the GNU debugger.
2
3    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4    2008 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21 #include "defs.h"
22
23 #include "arch-utils.h"
24 #include "buildsym.h"
25 #include "gdbcmd.h"
26 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
27 #include "gdb_string.h"
28 #include "regcache.h"
29 #include "gdb_assert.h"
30 #include "sim-regno.h"
31 #include "gdbcore.h"
32 #include "osabi.h"
33 #include "target-descriptions.h"
34 #include "objfiles.h"
35
36 #include "version.h"
37
38 #include "floatformat.h"
39
40
41 struct displaced_step_closure *
42 simple_displaced_step_copy_insn (struct gdbarch *gdbarch,
43                                  CORE_ADDR from, CORE_ADDR to,
44                                  struct regcache *regs)
45 {
46   size_t len = gdbarch_max_insn_length (gdbarch);
47   gdb_byte *buf = xmalloc (len);
48
49   read_memory (from, buf, len);
50   write_memory (to, buf, len);
51
52   if (debug_displaced)
53     {
54       fprintf_unfiltered (gdb_stdlog, "displaced: copy 0x%s->0x%s: ",
55                           paddr_nz (from), paddr_nz (to));
56       displaced_step_dump_bytes (gdb_stdlog, buf, len);
57     }
58
59   return (struct displaced_step_closure *) buf;
60 }
61
62
63 void
64 simple_displaced_step_free_closure (struct gdbarch *gdbarch,
65                                     struct displaced_step_closure *closure)
66 {
67   xfree (closure);
68 }
69
70
71 CORE_ADDR
72 displaced_step_at_entry_point (struct gdbarch *gdbarch)
73 {
74   CORE_ADDR addr;
75   int bp_len;
76
77   addr = entry_point_address ();
78
79   /* Make certain that the address points at real code, and not a
80      function descriptor.  */
81   addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
82
83   /* Inferior calls also use the entry point as a breakpoint location.
84      We don't want displaced stepping to interfere with those
85      breakpoints, so leave space.  */
86   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
87   addr += bp_len * 2;
88
89   return addr;
90 }
91
92 int
93 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
94 {
95   /* Only makes sense to supply raw registers.  */
96   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
97   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
98      suspected that some GDB/SIM combinations may rely on this
99      behavour.  The default should be one2one_register_sim_regno
100      (below).  */
101   if (gdbarch_register_name (gdbarch, regnum) != NULL
102       && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
103     return regnum;
104   else
105     return LEGACY_SIM_REGNO_IGNORE;
106 }
107
108 CORE_ADDR
109 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
110 {
111   return 0;
112 }
113
114 CORE_ADDR
115 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
116 {
117   return 0;
118 }
119
120 int
121 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
122 {
123   return 0;
124 }
125
126 int
127 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
128 {
129   return 0;
130 }
131
132 /* Helper functions for gdbarch_inner_than */
133
134 int
135 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
136 {
137   return (lhs < rhs);
138 }
139
140 int
141 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
142 {
143   return (lhs > rhs);
144 }
145
146 /* Misc helper functions for targets. */
147
148 CORE_ADDR
149 core_addr_identity (CORE_ADDR addr)
150 {
151   return addr;
152 }
153
154 CORE_ADDR
155 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
156                                      struct target_ops *targ)
157 {
158   return addr;
159 }
160
161 int
162 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
163 {
164   return reg;
165 }
166
167 void
168 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
169 {
170   return;
171 }
172
173 void
174 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
175 {
176   return;
177 }
178
179 int
180 cannot_register_not (struct gdbarch *gdbarch, int regnum)
181 {
182   return 0;
183 }
184
185 /* Legacy version of target_virtual_frame_pointer().  Assumes that
186    there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or
187    raw.  */
188
189 void
190 legacy_virtual_frame_pointer (struct gdbarch *gdbarch, 
191                               CORE_ADDR pc,
192                               int *frame_regnum,
193                               LONGEST *frame_offset)
194 {
195   /* FIXME: cagney/2002-09-13: This code is used when identifying the
196      frame pointer of the current PC.  It is assuming that a single
197      register and an offset can determine this.  I think it should
198      instead generate a byte code expression as that would work better
199      with things like Dwarf2's CFI.  */
200   if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
201       && gdbarch_deprecated_fp_regnum (gdbarch)
202            < gdbarch_num_regs (gdbarch))
203     *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
204   else if (gdbarch_sp_regnum (gdbarch) >= 0
205            && gdbarch_sp_regnum (gdbarch)
206                 < gdbarch_num_regs (gdbarch))
207     *frame_regnum = gdbarch_sp_regnum (gdbarch);
208   else
209     /* Should this be an internal error?  I guess so, it is reflecting
210        an architectural limitation in the current design.  */
211     internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
212   *frame_offset = 0;
213 }
214
215 \f
216 int
217 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
218                             struct type *type)
219 {
220   return 0;
221 }
222
223 int
224 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
225 {
226   return 0;
227 }
228
229 int
230 generic_instruction_nullified (struct gdbarch *gdbarch,
231                                struct regcache *regcache)
232 {
233   return 0;
234 }
235
236 int
237 default_remote_register_number (struct gdbarch *gdbarch,
238                                 int regno)
239 {
240   return regno;
241 }
242
243 \f
244 /* Functions to manipulate the endianness of the target.  */
245
246 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
247
248 static const char endian_big[] = "big";
249 static const char endian_little[] = "little";
250 static const char endian_auto[] = "auto";
251 static const char *endian_enum[] =
252 {
253   endian_big,
254   endian_little,
255   endian_auto,
256   NULL,
257 };
258 static const char *set_endian_string;
259
260 enum bfd_endian
261 selected_byte_order (void)
262 {
263   if (target_byte_order_user != BFD_ENDIAN_UNKNOWN)
264     return gdbarch_byte_order (current_gdbarch);
265   else
266     return BFD_ENDIAN_UNKNOWN;
267 }
268
269 /* Called by ``show endian''.  */
270
271 static void
272 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
273              const char *value)
274 {
275   if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
276     if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
277       fprintf_unfiltered (file, _("The target endianness is set automatically "
278                                   "(currently big endian)\n"));
279     else
280       fprintf_unfiltered (file, _("The target endianness is set automatically "
281                            "(currently little endian)\n"));
282   else
283     if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
284       fprintf_unfiltered (file,
285                           _("The target is assumed to be big endian\n"));
286     else
287       fprintf_unfiltered (file,
288                           _("The target is assumed to be little endian\n"));
289 }
290
291 static void
292 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
293 {
294   struct gdbarch_info info;
295
296   gdbarch_info_init (&info);
297
298   if (set_endian_string == endian_auto)
299     {
300       target_byte_order_user = BFD_ENDIAN_UNKNOWN;
301       if (! gdbarch_update_p (info))
302         internal_error (__FILE__, __LINE__,
303                         _("set_endian: architecture update failed"));
304     }
305   else if (set_endian_string == endian_little)
306     {
307       info.byte_order = BFD_ENDIAN_LITTLE;
308       if (! gdbarch_update_p (info))
309         printf_unfiltered (_("Little endian target not supported by GDB\n"));
310       else
311         target_byte_order_user = BFD_ENDIAN_LITTLE;
312     }
313   else if (set_endian_string == endian_big)
314     {
315       info.byte_order = BFD_ENDIAN_BIG;
316       if (! gdbarch_update_p (info))
317         printf_unfiltered (_("Big endian target not supported by GDB\n"));
318       else
319         target_byte_order_user = BFD_ENDIAN_BIG;
320     }
321   else
322     internal_error (__FILE__, __LINE__,
323                     _("set_endian: bad value"));
324
325   show_endian (gdb_stdout, from_tty, NULL, NULL);
326 }
327
328 /* Given SELECTED, a currently selected BFD architecture, and
329    FROM_TARGET, a BFD architecture reported by the target description,
330    return what architecture to use.  Either may be NULL; if both are
331    specified, we use the more specific.  If the two are obviously
332    incompatible, warn the user.  */
333
334 static const struct bfd_arch_info *
335 choose_architecture_for_target (const struct bfd_arch_info *selected,
336                                 const struct bfd_arch_info *from_target)
337 {
338   const struct bfd_arch_info *compat1, *compat2;
339
340   if (selected == NULL)
341     return from_target;
342
343   if (from_target == NULL)
344     return selected;
345
346   /* struct bfd_arch_info objects are singletons: that is, there's
347      supposed to be exactly one instance for a given machine.  So you
348      can tell whether two are equivalent by comparing pointers.  */
349   if (from_target == selected)
350     return selected;
351
352   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
353      incompatible.  But if they are compatible, it returns the 'more
354      featureful' of the two arches.  That is, if A can run code
355      written for B, but B can't run code written for A, then it'll
356      return A.
357
358      Some targets (e.g. MIPS as of 2006-12-04) don't fully
359      implement this, instead always returning NULL or the first
360      argument.  We detect that case by checking both directions.  */
361
362   compat1 = selected->compatible (selected, from_target);
363   compat2 = from_target->compatible (from_target, selected);
364
365   if (compat1 == NULL && compat2 == NULL)
366     {
367       warning (_("Selected architecture %s is not compatible "
368                  "with reported target architecture %s"),
369                selected->printable_name, from_target->printable_name);
370       return selected;
371     }
372
373   if (compat1 == NULL)
374     return compat2;
375   if (compat2 == NULL)
376     return compat1;
377   if (compat1 == compat2)
378     return compat1;
379
380   /* If the two didn't match, but one of them was a default architecture,
381      assume the more specific one is correct.  This handles the case
382      where an executable or target description just says "mips", but
383      the other knows which MIPS variant.  */
384   if (compat1->the_default)
385     return compat2;
386   if (compat2->the_default)
387     return compat1;
388
389   /* We have no idea which one is better.  This is a bug, but not
390      a critical problem; warn the user.  */
391   warning (_("Selected architecture %s is ambiguous with "
392              "reported target architecture %s"),
393            selected->printable_name, from_target->printable_name);
394   return selected;
395 }
396
397 /* Functions to manipulate the architecture of the target */
398
399 enum set_arch { set_arch_auto, set_arch_manual };
400
401 static const struct bfd_arch_info *target_architecture_user;
402
403 static const char *set_architecture_string;
404
405 const char *
406 selected_architecture_name (void)
407 {
408   if (target_architecture_user == NULL)
409     return NULL;
410   else
411     return set_architecture_string;
412 }
413
414 /* Called if the user enters ``show architecture'' without an
415    argument. */
416
417 static void
418 show_architecture (struct ui_file *file, int from_tty,
419                    struct cmd_list_element *c, const char *value)
420 {
421   const char *arch;
422   arch = gdbarch_bfd_arch_info (current_gdbarch)->printable_name;
423   if (target_architecture_user == NULL)
424     fprintf_filtered (file, _("\
425 The target architecture is set automatically (currently %s)\n"), arch);
426   else
427     fprintf_filtered (file, _("\
428 The target architecture is assumed to be %s\n"), arch);
429 }
430
431
432 /* Called if the user enters ``set architecture'' with or without an
433    argument. */
434
435 static void
436 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
437 {
438   struct gdbarch_info info;
439
440   gdbarch_info_init (&info);
441
442   if (strcmp (set_architecture_string, "auto") == 0)
443     {
444       target_architecture_user = NULL;
445       if (!gdbarch_update_p (info))
446         internal_error (__FILE__, __LINE__,
447                         _("could not select an architecture automatically"));
448     }
449   else
450     {
451       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
452       if (info.bfd_arch_info == NULL)
453         internal_error (__FILE__, __LINE__,
454                         _("set_architecture: bfd_scan_arch failed"));
455       if (gdbarch_update_p (info))
456         target_architecture_user = info.bfd_arch_info;
457       else
458         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
459                            set_architecture_string);
460     }
461   show_architecture (gdb_stdout, from_tty, NULL, NULL);
462 }
463
464 /* Try to select a global architecture that matches "info".  Return
465    non-zero if the attempt succeds.  */
466 int
467 gdbarch_update_p (struct gdbarch_info info)
468 {
469   struct gdbarch *new_gdbarch;
470
471   /* Check for the current file.  */
472   if (info.abfd == NULL)
473     info.abfd = exec_bfd;
474   if (info.abfd == NULL)
475     info.abfd = core_bfd;
476
477   /* Check for the current target description.  */
478   if (info.target_desc == NULL)
479     info.target_desc = target_current_description ();
480
481   new_gdbarch = gdbarch_find_by_info (info);
482
483   /* If there no architecture by that name, reject the request.  */
484   if (new_gdbarch == NULL)
485     {
486       if (gdbarch_debug)
487         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
488                             "Architecture not found\n");
489       return 0;
490     }
491
492   /* If it is the same old architecture, accept the request (but don't
493      swap anything).  */
494   if (new_gdbarch == target_gdbarch)
495     {
496       if (gdbarch_debug)
497         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
498                             "Architecture 0x%08lx (%s) unchanged\n",
499                             (long) new_gdbarch,
500                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
501       return 1;
502     }
503
504   /* It's a new architecture, swap it in.  */
505   if (gdbarch_debug)
506     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
507                         "New architecture 0x%08lx (%s) selected\n",
508                         (long) new_gdbarch,
509                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
510   deprecated_current_gdbarch_select_hack (new_gdbarch);
511
512   return 1;
513 }
514
515 /* Return the architecture for ABFD.  If no suitable architecture
516    could be find, return NULL.  */
517
518 struct gdbarch *
519 gdbarch_from_bfd (bfd *abfd)
520 {
521   struct gdbarch_info info;
522   gdbarch_info_init (&info);
523   info.abfd = abfd;
524   return gdbarch_find_by_info (info);
525 }
526
527 /* Set the dynamic target-system-dependent parameters (architecture,
528    byte-order) using information found in the BFD */
529
530 void
531 set_gdbarch_from_file (bfd *abfd)
532 {
533   struct gdbarch_info info;
534   struct gdbarch *gdbarch;
535
536   gdbarch_info_init (&info);
537   info.abfd = abfd;
538   info.target_desc = target_current_description ();
539   gdbarch = gdbarch_find_by_info (info);
540
541   if (gdbarch == NULL)
542     error (_("Architecture of file not recognized."));
543   deprecated_current_gdbarch_select_hack (gdbarch);
544 }
545
546 /* Initialize the current architecture.  Update the ``set
547    architecture'' command so that it specifies a list of valid
548    architectures.  */
549
550 #ifdef DEFAULT_BFD_ARCH
551 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
552 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
553 #else
554 static const bfd_arch_info_type *default_bfd_arch;
555 #endif
556
557 #ifdef DEFAULT_BFD_VEC
558 extern const bfd_target DEFAULT_BFD_VEC;
559 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
560 #else
561 static const bfd_target *default_bfd_vec;
562 #endif
563
564 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
565
566 void
567 initialize_current_architecture (void)
568 {
569   const char **arches = gdbarch_printable_names ();
570
571   /* determine a default architecture and byte order. */
572   struct gdbarch_info info;
573   gdbarch_info_init (&info);
574   
575   /* Find a default architecture. */
576   if (default_bfd_arch == NULL)
577     {
578       /* Choose the architecture by taking the first one
579          alphabetically. */
580       const char *chosen = arches[0];
581       const char **arch;
582       for (arch = arches; *arch != NULL; arch++)
583         {
584           if (strcmp (*arch, chosen) < 0)
585             chosen = *arch;
586         }
587       if (chosen == NULL)
588         internal_error (__FILE__, __LINE__,
589                         _("initialize_current_architecture: No arch"));
590       default_bfd_arch = bfd_scan_arch (chosen);
591       if (default_bfd_arch == NULL)
592         internal_error (__FILE__, __LINE__,
593                         _("initialize_current_architecture: Arch not found"));
594     }
595
596   info.bfd_arch_info = default_bfd_arch;
597
598   /* Take several guesses at a byte order.  */
599   if (default_byte_order == BFD_ENDIAN_UNKNOWN
600       && default_bfd_vec != NULL)
601     {
602       /* Extract BFD's default vector's byte order. */
603       switch (default_bfd_vec->byteorder)
604         {
605         case BFD_ENDIAN_BIG:
606           default_byte_order = BFD_ENDIAN_BIG;
607           break;
608         case BFD_ENDIAN_LITTLE:
609           default_byte_order = BFD_ENDIAN_LITTLE;
610           break;
611         default:
612           break;
613         }
614     }
615   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
616     {
617       /* look for ``*el-*'' in the target name. */
618       const char *chp;
619       chp = strchr (target_name, '-');
620       if (chp != NULL
621           && chp - 2 >= target_name
622           && strncmp (chp - 2, "el", 2) == 0)
623         default_byte_order = BFD_ENDIAN_LITTLE;
624     }
625   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
626     {
627       /* Wire it to big-endian!!! */
628       default_byte_order = BFD_ENDIAN_BIG;
629     }
630
631   info.byte_order = default_byte_order;
632   info.byte_order_for_code = info.byte_order;
633
634   if (! gdbarch_update_p (info))
635     internal_error (__FILE__, __LINE__,
636                     _("initialize_current_architecture: Selection of "
637                       "initial architecture failed"));
638
639   /* Create the ``set architecture'' command appending ``auto'' to the
640      list of architectures. */
641   {
642     struct cmd_list_element *c;
643     /* Append ``auto''. */
644     int nr;
645     for (nr = 0; arches[nr] != NULL; nr++);
646     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
647     arches[nr + 0] = "auto";
648     arches[nr + 1] = NULL;
649     add_setshow_enum_cmd ("architecture", class_support,
650                           arches, &set_architecture_string, _("\
651 Set architecture of target."), _("\
652 Show architecture of target."), NULL,
653                           set_architecture, show_architecture,
654                           &setlist, &showlist);
655     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
656   }
657 }
658
659
660 /* Initialize a gdbarch info to values that will be automatically
661    overridden.  Note: Originally, this ``struct info'' was initialized
662    using memset(0).  Unfortunately, that ran into problems, namely
663    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
664    can explicitly set each field to a well defined value is used.  */
665
666 void
667 gdbarch_info_init (struct gdbarch_info *info)
668 {
669   memset (info, 0, sizeof (struct gdbarch_info));
670   info->byte_order = BFD_ENDIAN_UNKNOWN;
671   info->byte_order_for_code = info->byte_order;
672   info->osabi = GDB_OSABI_UNINITIALIZED;
673 }
674
675 /* Similar to init, but this time fill in the blanks.  Information is
676    obtained from the global "set ..." options and explicitly
677    initialized INFO fields.  */
678
679 void
680 gdbarch_info_fill (struct gdbarch_info *info)
681 {
682   /* "(gdb) set architecture ...".  */
683   if (info->bfd_arch_info == NULL
684       && target_architecture_user)
685     info->bfd_arch_info = target_architecture_user;
686   /* From the file.  */
687   if (info->bfd_arch_info == NULL
688       && info->abfd != NULL
689       && bfd_get_arch (info->abfd) != bfd_arch_unknown
690       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
691     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
692   /* From the target.  */
693   if (info->target_desc != NULL)
694     info->bfd_arch_info = choose_architecture_for_target
695       (info->bfd_arch_info, tdesc_architecture (info->target_desc));
696   /* From the default.  */
697   if (info->bfd_arch_info == NULL)
698     info->bfd_arch_info = default_bfd_arch;
699
700   /* "(gdb) set byte-order ...".  */
701   if (info->byte_order == BFD_ENDIAN_UNKNOWN
702       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
703     info->byte_order = target_byte_order_user;
704   /* From the INFO struct.  */
705   if (info->byte_order == BFD_ENDIAN_UNKNOWN
706       && info->abfd != NULL)
707     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
708                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
709                         : BFD_ENDIAN_UNKNOWN);
710   /* From the default.  */
711   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
712     info->byte_order = default_byte_order;
713   info->byte_order_for_code = info->byte_order;
714
715   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
716   if (info->osabi == GDB_OSABI_UNINITIALIZED)
717     info->osabi = gdbarch_lookup_osabi (info->abfd);
718
719   /* Must have at least filled in the architecture.  */
720   gdb_assert (info->bfd_arch_info != NULL);
721 }
722
723 /* */
724
725 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
726
727 void
728 _initialize_gdbarch_utils (void)
729 {
730   struct cmd_list_element *c;
731   add_setshow_enum_cmd ("endian", class_support,
732                         endian_enum, &set_endian_string, _("\
733 Set endianness of target."), _("\
734 Show endianness of target."), NULL,
735                         set_endian, show_endian,
736                         &setlist, &showlist);
737 }