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