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