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