gdb/arch-utils.c

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
   4    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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24
  25 #include "arch-utils.h"
  26 #include "buildsym.h"
  27 #include "gdbcmd.h"
  28 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
  29 #include "gdb_string.h"
  30 #include "regcache.h"
  31 #include "gdb_assert.h"
  32 #include "sim-regno.h"
  33
  34 #include "version.h"
  35
  36 #include "floatformat.h"
  37
  38 /* Implementation of extract return value that grubs around in the
  39    register cache.  */
  40 void
  41 legacy_extract_return_value (struct type *type, struct regcache *regcache,
  42                              void *valbuf)
  43 {
  44   char *registers = deprecated_grub_regcache_for_registers (regcache);
  45   bfd_byte *buf = valbuf;
  46   DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
  47 }
  48
  49 /* Implementation of store return value that grubs the register cache.
  50    Takes a local copy of the buffer to avoid const problems.  */
  51 void
  52 legacy_store_return_value (struct type *type, struct regcache *regcache,
  53                            const void *buf)
  54 {
  55   bfd_byte *b = alloca (TYPE_LENGTH (type));
  56   gdb_assert (regcache == current_regcache);
  57   memcpy (b, buf, TYPE_LENGTH (type));
  58   DEPRECATED_STORE_RETURN_VALUE (type, b);
  59 }
  60
  61
  62 int
  63 always_use_struct_convention (int gcc_p, struct type *value_type)
  64 {
  65   return 1;
  66 }
  67
  68
  69 int
  70 legacy_register_sim_regno (int regnum)
  71 {
  72   /* Only makes sense to supply raw registers.  */
  73   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  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      behavour.  The default should be one2one_register_sim_regno
  77      (below).  */
  78   if (REGISTER_NAME (regnum) != NULL
  79       && REGISTER_NAME (regnum)[0] != '\0')
  80     return regnum;
  81   else
  82     return LEGACY_SIM_REGNO_IGNORE;
  83 }
  84
  85 int
  86 generic_frameless_function_invocation_not (struct frame_info *fi)
  87 {
  88   return 0;
  89 }
  90
  91 int
  92 generic_return_value_on_stack_not (struct type *type)
  93 {
  94   return 0;
  95 }
  96
  97 CORE_ADDR
  98 generic_skip_trampoline_code (CORE_ADDR pc)
  99 {
 100   return 0;
 101 }
 102
 103 int
 104 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 105 {
 106   return 0;
 107 }
 108
 109 int
 110 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 111 {
 112   return 0;
 113 }
 114
 115 int
 116 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 117 {
 118   return 0;
 119 }
 120
 121 #if defined (CALL_DUMMY)
 122 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
 123 #else
 124 LONGEST legacy_call_dummy_words[1];
 125 #endif
 126 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
 127
 128 void
 129 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 130                                        struct regcache *regcache,
 131                                        CORE_ADDR gdb_addr, int gdb_len,
 132                                        CORE_ADDR * rem_addr, int *rem_len)
 133 {
 134   *rem_addr = gdb_addr;
 135   *rem_len = gdb_len;
 136 }
 137
 138 int
 139 generic_prologue_frameless_p (CORE_ADDR ip)
 140 {
 141   return ip == SKIP_PROLOGUE (ip);
 142 }
 143
 144 /* Helper functions for INNER_THAN */
 145
 146 int
 147 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 148 {
 149   return (lhs < rhs);
 150 }
 151
 152 int
 153 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 154 {
 155   return (lhs > rhs);
 156 }
 157
 158
 159 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
 160
 161 const struct floatformat *
 162 default_float_format (struct gdbarch *gdbarch)
 163 {
 164   int byte_order = gdbarch_byte_order (gdbarch);
 165   switch (byte_order)
 166     {
 167     case BFD_ENDIAN_BIG:
 168       return &floatformat_ieee_single_big;
 169     case BFD_ENDIAN_LITTLE:
 170       return &floatformat_ieee_single_little;
 171     default:
 172       internal_error (__FILE__, __LINE__,
 173                       "default_float_format: bad byte order");
 174     }
 175 }
 176
 177
 178 const struct floatformat *
 179 default_double_format (struct gdbarch *gdbarch)
 180 {
 181   int byte_order = gdbarch_byte_order (gdbarch);
 182   switch (byte_order)
 183     {
 184     case BFD_ENDIAN_BIG:
 185       return &floatformat_ieee_double_big;
 186     case BFD_ENDIAN_LITTLE:
 187       return &floatformat_ieee_double_little;
 188     default:
 189       internal_error (__FILE__, __LINE__,
 190                       "default_double_format: bad byte order");
 191     }
 192 }
 193
 194 /* Misc helper functions for targets. */
 195
 196 int
 197 deprecated_register_convertible_not (int num)
 198 {
 199   return 0;
 200 }
 201
 202
 203 CORE_ADDR
 204 core_addr_identity (CORE_ADDR addr)
 205 {
 206   return addr;
 207 }
 208
 209 CORE_ADDR
 210 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 211                                      struct target_ops *targ)
 212 {
 213   return addr;
 214 }
 215
 216 int
 217 no_op_reg_to_regnum (int reg)
 218 {
 219   return reg;
 220 }
 221
 222 CORE_ADDR
 223 deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev)
 224 {
 225   if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
 226     return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
 227   else if (get_next_frame (prev) != NULL)
 228     return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
 229   else
 230     return read_pc ();
 231 }
 232
 233 void
 234 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 235 {
 236   return;
 237 }
 238
 239 void
 240 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 241 {
 242   return;
 243 }
 244
 245 int
 246 cannot_register_not (int regnum)
 247 {
 248   return 0;
 249 }
 250
 251 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 252    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 253    raw.  */
 254
 255 void
 256 legacy_virtual_frame_pointer (CORE_ADDR pc,
 257                               int *frame_regnum,
 258                               LONGEST *frame_offset)
 259 {
 260   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 261      frame pointer of the current PC.  It is assuming that a single
 262      register and an offset can determine this.  I think it should
 263      instead generate a byte code expression as that would work better
 264      with things like Dwarf2's CFI.  */
 265   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 266     *frame_regnum = DEPRECATED_FP_REGNUM;
 267   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 268     *frame_regnum = SP_REGNUM;
 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__, "No virtual frame pointer available");
 273   *frame_offset = 0;
 274 }
 275
 276 /* Assume the world is sane, every register's virtual and real size
 277    is identical.  */
 278
 279 int
 280 generic_register_size (int regnum)
 281 {
 282   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 283   if (gdbarch_register_type_p (current_gdbarch))
 284     return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
 285   else
 286     /* FIXME: cagney/2003-03-01: Once all architectures implement
 287        gdbarch_register_type(), this entire function can go away.  It
 288        is made obsolete by register_size().  */
 289     return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
 290 }
 291
 292 /* Assume all registers are adjacent.  */
 293
 294 int
 295 generic_register_byte (int regnum)
 296 {
 297   int byte;
 298   int i;
 299   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 300   byte = 0;
 301   for (i = 0; i < regnum; i++)
 302     {
 303       byte += generic_register_size (i);
 304     }
 305   return byte;
 306 }
 307
 308 \f
 309 int
 310 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 311 {
 312 #if !defined (IN_SIGTRAMP)
 313   if (SIGTRAMP_START_P ())
 314     return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
 315   else
 316     return name && strcmp ("_sigtramp", name) == 0;
 317 #else
 318   return IN_SIGTRAMP (pc, name);
 319 #endif
 320 }
 321
 322 int
 323 legacy_convert_register_p (int regnum, struct type *type)
 324 {
 325   return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
 326 }
 327
 328 void
 329 legacy_register_to_value (struct frame_info *frame, int regnum,
 330                           struct type *type, void *to)
 331 {
 332   char from[MAX_REGISTER_SIZE];
 333   get_frame_register (frame, regnum, from);
 334   DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 335 }
 336
 337 void
 338 legacy_value_to_register (struct frame_info *frame, int regnum,
 339                           struct type *type, const void *tmp)
 340 {
 341   char to[MAX_REGISTER_SIZE];
 342   char *from = alloca (TYPE_LENGTH (type));
 343   memcpy (from, from, TYPE_LENGTH (type));
 344   DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 345   put_frame_register (frame, regnum, to);
 346 }
 347
 348 int
 349 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 350 {
 351   if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
 352       && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type))
 353     {
 354       CHECK_TYPEDEF (type);
 355
 356       return (TYPE_CODE (type) == TYPE_CODE_STRUCT
 357               || TYPE_CODE (type) == TYPE_CODE_UNION
 358               || TYPE_CODE (type) == TYPE_CODE_SET
 359               || TYPE_CODE (type) == TYPE_CODE_BITSTRING);
 360     }
 361
 362   return 0;
 363 }
 364
 365 \f
 366 /* Functions to manipulate the endianness of the target.  */
 367
 368 /* ``target_byte_order'' is only used when non- multi-arch.
 369    Multi-arch targets obtain the current byte order using the
 370    TARGET_BYTE_ORDER gdbarch method.
 371
 372    The choice of initial value is entirely arbitrary.  During startup,
 373    the function initialize_current_architecture() updates this value
 374    based on default byte-order information extracted from BFD.  */
 375 int target_byte_order = BFD_ENDIAN_BIG;
 376 int target_byte_order_auto = 1;
 377
 378 static const char endian_big[] = "big";
 379 static const char endian_little[] = "little";
 380 static const char endian_auto[] = "auto";
 381 static const char *endian_enum[] =
 382 {
 383   endian_big,
 384   endian_little,
 385   endian_auto,
 386   NULL,
 387 };
 388 static const char *set_endian_string;
 389
 390 /* Called by ``show endian''.  */
 391
 392 static void
 393 show_endian (char *args, int from_tty)
 394 {
 395   if (TARGET_BYTE_ORDER_AUTO)
 396     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 397                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 398   else
 399     printf_unfiltered ("The target is assumed to be %s endian\n",
 400                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 401 }
 402
 403 static void
 404 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 405 {
 406   if (set_endian_string == endian_auto)
 407     {
 408       target_byte_order_auto = 1;
 409     }
 410   else if (set_endian_string == endian_little)
 411     {
 412       struct gdbarch_info info;
 413       target_byte_order_auto = 0;
 414       gdbarch_info_init (&info);
 415       info.byte_order = BFD_ENDIAN_LITTLE;
 416       if (! gdbarch_update_p (info))
 417         printf_unfiltered ("Little endian target not supported by GDB\n");
 418     }
 419   else if (set_endian_string == endian_big)
 420     {
 421       struct gdbarch_info info;
 422       target_byte_order_auto = 0;
 423       gdbarch_info_init (&info);
 424       info.byte_order = BFD_ENDIAN_BIG;
 425       if (! gdbarch_update_p (info))
 426         printf_unfiltered ("Big endian target not supported by GDB\n");
 427     }
 428   else
 429     internal_error (__FILE__, __LINE__,
 430                     "set_endian: bad value");
 431   show_endian (NULL, from_tty);
 432 }
 433
 434 /* Functions to manipulate the architecture of the target */
 435
 436 enum set_arch { set_arch_auto, set_arch_manual };
 437
 438 int target_architecture_auto = 1;
 439
 440 const char *set_architecture_string;
 441
 442 /* Called if the user enters ``show architecture'' without an
 443    argument. */
 444
 445 static void
 446 show_architecture (char *args, int from_tty)
 447 {
 448   const char *arch;
 449   arch = TARGET_ARCHITECTURE->printable_name;
 450   if (target_architecture_auto)
 451     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 452   else
 453     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 454 }
 455
 456
 457 /* Called if the user enters ``set architecture'' with or without an
 458    argument. */
 459
 460 static void
 461 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 462 {
 463   if (strcmp (set_architecture_string, "auto") == 0)
 464     {
 465       target_architecture_auto = 1;
 466     }
 467   else
 468     {
 469       struct gdbarch_info info;
 470       gdbarch_info_init (&info);
 471       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 472       if (info.bfd_arch_info == NULL)
 473         internal_error (__FILE__, __LINE__,
 474                         "set_architecture: bfd_scan_arch failed");
 475       if (gdbarch_update_p (info))
 476         target_architecture_auto = 0;
 477       else
 478         printf_unfiltered ("Architecture `%s' not recognized.\n",
 479                            set_architecture_string);
 480     }
 481   show_architecture (NULL, from_tty);
 482 }
 483
 484 /* FIXME: kettenis/20031124: Of the functions that follow, only
 485    gdbarch_from_bfd is supposed to survive.  The others will
 486    dissappear since in the future GDB will (hopefully) be truly
 487    multi-arch.  However, for now we're still stuck with the concept of
 488    a single active architecture.  */
 489
 490 /* Make GDBARCH the currently selected architecture.  */
 491
 492 static void
 493 deprecated_select_gdbarch_hack (struct gdbarch *gdbarch)
 494 {
 495   struct gdbarch_info info;
 496
 497   /* FIXME: kettenis/20031024: The only way to select a specific
 498      architecture is to clone its `struct gdbarch_info', and update
 499      according to that copy.  This is gross, but significant work will
 500      need to be done before we can take a more sane approach.  */
 501   gdbarch_info_init (&info);
 502   info.bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 503   info.byte_order = gdbarch_byte_order (gdbarch);
 504   info.osabi = gdbarch_osabi (gdbarch);
 505   gdbarch_update_p (info);
 506   gdb_assert (gdbarch == current_gdbarch);
 507 }
 508
 509 /* Return the architecture for ABFD.  If no suitable architecture
 510    could be find, return NULL.  */
 511
 512 struct gdbarch *
 513 gdbarch_from_bfd (bfd *abfd)
 514 {
 515   struct gdbarch *old_gdbarch = current_gdbarch;
 516   struct gdbarch *new_gdbarch;
 517   struct gdbarch_info info;
 518
 519   /* FIXME: kettenis/20031024: The only way to find the architecture
 520      for a certain BFD is by doing an architecture update.  This
 521      activates the architecture, so we need to reactivate the old
 522      architecture.  This is gross, but significant work will need to
 523      be done before we can take a more sane approach.  */
 524   gdbarch_info_init (&info);
 525   info.abfd = abfd;
 526   if (! gdbarch_update_p (info))
 527     return NULL;
 528
 529   new_gdbarch = current_gdbarch;
 530   deprecated_select_gdbarch_hack (old_gdbarch);
 531   return new_gdbarch;
 532 }
 533
 534 /* Set the dynamic target-system-dependent parameters (architecture,
 535    byte-order) using information found in the BFD */
 536
 537 void
 538 set_gdbarch_from_file (bfd *abfd)
 539 {
 540   struct gdbarch *gdbarch;
 541
 542   gdbarch = gdbarch_from_bfd (abfd);
 543   if (gdbarch == NULL)
 544     error ("Architecture of file not recognized.\n");
 545   deprecated_select_gdbarch_hack (gdbarch);
 546 }
 547
 548 /* Initialize the current architecture.  Update the ``set
 549    architecture'' command so that it specifies a list of valid
 550    architectures.  */
 551
 552 #ifdef DEFAULT_BFD_ARCH
 553 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 554 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 555 #else
 556 static const bfd_arch_info_type *default_bfd_arch;
 557 #endif
 558
 559 #ifdef DEFAULT_BFD_VEC
 560 extern const bfd_target DEFAULT_BFD_VEC;
 561 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 562 #else
 563 static const bfd_target *default_bfd_vec;
 564 #endif
 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 (info.bfd_arch_info == NULL
 577       && default_bfd_arch != NULL)
 578     info.bfd_arch_info = default_bfd_arch;
 579   if (info.bfd_arch_info == NULL)
 580     {
 581       /* Choose the architecture by taking the first one
 582          alphabetically. */
 583       const char *chosen = arches[0];
 584       const char **arch;
 585       for (arch = arches; *arch != NULL; arch++)
 586         {
 587           if (strcmp (*arch, chosen) < 0)
 588             chosen = *arch;
 589         }
 590       if (chosen == NULL)
 591         internal_error (__FILE__, __LINE__,
 592                         "initialize_current_architecture: No arch");
 593       info.bfd_arch_info = bfd_scan_arch (chosen);
 594       if (info.bfd_arch_info == NULL)
 595         internal_error (__FILE__, __LINE__,
 596                         "initialize_current_architecture: Arch not found");
 597     }
 598
 599   /* Take several guesses at a byte order.  */
 600   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 601       && default_bfd_vec != NULL)
 602     {
 603       /* Extract BFD's default vector's byte order. */
 604       switch (default_bfd_vec->byteorder)
 605         {
 606         case BFD_ENDIAN_BIG:
 607           info.byte_order = BFD_ENDIAN_BIG;
 608           break;
 609         case BFD_ENDIAN_LITTLE:
 610           info.byte_order = BFD_ENDIAN_LITTLE;
 611           break;
 612         default:
 613           break;
 614         }
 615     }
 616   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 617     {
 618       /* look for ``*el-*'' in the target name. */
 619       const char *chp;
 620       chp = strchr (target_name, '-');
 621       if (chp != NULL
 622           && chp - 2 >= target_name
 623           && strncmp (chp - 2, "el", 2) == 0)
 624         info.byte_order = BFD_ENDIAN_LITTLE;
 625     }
 626   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 627     {
 628       /* Wire it to big-endian!!! */
 629       info.byte_order = BFD_ENDIAN_BIG;
 630     }
 631
 632   if (! gdbarch_update_p (info))
 633     internal_error (__FILE__, __LINE__,
 634                     "initialize_current_architecture: Selection of initial architecture failed");
 635
 636   /* Create the ``set architecture'' command appending ``auto'' to the
 637      list of architectures. */
 638   {
 639     struct cmd_list_element *c;
 640     /* Append ``auto''. */
 641     int nr;
 642     for (nr = 0; arches[nr] != NULL; nr++);
 643     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 644     arches[nr + 0] = "auto";
 645     arches[nr + 1] = NULL;
 646     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 647        of ``const char *''.  We just happen to know that the casts are
 648        safe. */
 649     c = add_set_enum_cmd ("architecture", class_support,
 650                           arches, &set_architecture_string,
 651                           "Set architecture of target.",
 652                           &setlist);
 653     set_cmd_sfunc (c, set_architecture);
 654     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 655     /* Don't use set_from_show - need to print both auto/manual and
 656        current setting. */
 657     add_cmd ("architecture", class_support, show_architecture,
 658              "Show the current target architecture", &showlist);
 659   }
 660 }
 661
 662
 663 /* Initialize a gdbarch info to values that will be automatically
 664    overridden.  Note: Originally, this ``struct info'' was initialized
 665    using memset(0).  Unfortunately, that ran into problems, namely
 666    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 667    can explicitly set each field to a well defined value is used.  */
 668
 669 void
 670 gdbarch_info_init (struct gdbarch_info *info)
 671 {
 672   memset (info, 0, sizeof (struct gdbarch_info));
 673   info->byte_order = BFD_ENDIAN_UNKNOWN;
 674   info->osabi = GDB_OSABI_UNINITIALIZED;
 675 }
 676
 677 /* */
 678
 679 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 680
 681 void
 682 _initialize_gdbarch_utils (void)
 683 {
 684   struct cmd_list_element *c;
 685   c = add_set_enum_cmd ("endian", class_support,
 686                         endian_enum, &set_endian_string,
 687                         "Set endianness of target.",
 688                         &setlist);
 689   set_cmd_sfunc (c, set_endian);
 690   /* Don't use set_from_show - need to print both auto/manual and
 691      current setting. */
 692   add_cmd ("endian", class_support, show_endian,
 693            "Show the current byte-order", &showlist);
 694 }