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 #if GDB_MULTI_ARCH
  26 #include "arch-utils.h"
  27 #include "gdbcmd.h"
  28 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
  29 #else
  30 /* Just include everything in sight so that the every old definition
  31    of macro is visible. */
  32 #include "symtab.h"
  33 #include "frame.h"
  34 #include "inferior.h"
  35 #include "breakpoint.h"
  36 #include "gdb_wait.h"
  37 #include "gdbcore.h"
  38 #include "gdbcmd.h"
  39 #include "target.h"
  40 #include "annotate.h"
  41 #endif
  42 #include "gdb_string.h"
  43 #include "regcache.h"
  44 #include "gdb_assert.h"
  45 #include "sim-regno.h"
  46
  47 #include "version.h"
  48
  49 #include "floatformat.h"
  50
  51 /* Implementation of extract return value that grubs around in the
  52    register cache.  */
  53 void
  54 legacy_extract_return_value (struct type *type, struct regcache *regcache,
  55                              void *valbuf)
  56 {
  57   char *registers = deprecated_grub_regcache_for_registers (regcache);
  58   bfd_byte *buf = valbuf;
  59   DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
  60 }
  61
  62 /* Implementation of store return value that grubs the register cache.
  63    Takes a local copy of the buffer to avoid const problems.  */
  64 void
  65 legacy_store_return_value (struct type *type, struct regcache *regcache,
  66                            const void *buf)
  67 {
  68   bfd_byte *b = alloca (TYPE_LENGTH (type));
  69   gdb_assert (regcache == current_regcache);
  70   memcpy (b, buf, TYPE_LENGTH (type));
  71   DEPRECATED_STORE_RETURN_VALUE (type, b);
  72 }
  73
  74
  75 int
  76 always_use_struct_convention (int gcc_p, struct type *value_type)
  77 {
  78   return 1;
  79 }
  80
  81
  82 int
  83 legacy_register_sim_regno (int regnum)
  84 {
  85   /* Only makes sense to supply raw registers.  */
  86   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  87   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  88      suspected that some GDB/SIM combinations may rely on this
  89      behavour.  The default should be one2one_register_sim_regno
  90      (below).  */
  91   if (REGISTER_NAME (regnum) != NULL
  92       && REGISTER_NAME (regnum)[0] != '\0')
  93     return regnum;
  94   else
  95     return LEGACY_SIM_REGNO_IGNORE;
  96 }
  97
  98 int
  99 generic_frameless_function_invocation_not (struct frame_info *fi)
 100 {
 101   return 0;
 102 }
 103
 104 int
 105 generic_return_value_on_stack_not (struct type *type)
 106 {
 107   return 0;
 108 }
 109
 110 CORE_ADDR
 111 generic_skip_trampoline_code (CORE_ADDR pc)
 112 {
 113   return 0;
 114 }
 115
 116 int
 117 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 118 {
 119   return 0;
 120 }
 121
 122 int
 123 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 124 {
 125   return 0;
 126 }
 127
 128 int
 129 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 130 {
 131   return 0;
 132 }
 133
 134 const char *
 135 legacy_register_name (int i)
 136 {
 137 #ifdef REGISTER_NAMES
 138   static char *names[] = REGISTER_NAMES;
 139   if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
 140     return NULL;
 141   else
 142     return names[i];
 143 #else
 144   internal_error (__FILE__, __LINE__,
 145                   "legacy_register_name: called.");
 146   return NULL;
 147 #endif
 148 }
 149
 150 #if defined (CALL_DUMMY)
 151 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
 152 #else
 153 LONGEST legacy_call_dummy_words[1];
 154 #endif
 155 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
 156
 157 void
 158 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 159                                        struct regcache *regcache,
 160                                        CORE_ADDR gdb_addr, int gdb_len,
 161                                        CORE_ADDR * rem_addr, int *rem_len)
 162 {
 163   *rem_addr = gdb_addr;
 164   *rem_len = gdb_len;
 165 }
 166
 167 int
 168 generic_prologue_frameless_p (CORE_ADDR ip)
 169 {
 170   return ip == SKIP_PROLOGUE (ip);
 171 }
 172
 173 /* New/multi-arched targets should use the correct gdbarch field
 174    instead of using this global pointer. */
 175 int
 176 legacy_print_insn (bfd_vma vma, disassemble_info *info)
 177 {
 178   return (*deprecated_tm_print_insn) (vma, info);
 179 }
 180
 181 /* Helper functions for INNER_THAN */
 182
 183 int
 184 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 185 {
 186   return (lhs < rhs);
 187 }
 188
 189 int
 190 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 191 {
 192   return (lhs > rhs);
 193 }
 194
 195
 196 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
 197
 198 const struct floatformat *
 199 default_float_format (struct gdbarch *gdbarch)
 200 {
 201 #if GDB_MULTI_ARCH
 202   int byte_order = gdbarch_byte_order (gdbarch);
 203 #else
 204   int byte_order = TARGET_BYTE_ORDER;
 205 #endif
 206   switch (byte_order)
 207     {
 208     case BFD_ENDIAN_BIG:
 209       return &floatformat_ieee_single_big;
 210     case BFD_ENDIAN_LITTLE:
 211       return &floatformat_ieee_single_little;
 212     default:
 213       internal_error (__FILE__, __LINE__,
 214                       "default_float_format: bad byte order");
 215     }
 216 }
 217
 218
 219 const struct floatformat *
 220 default_double_format (struct gdbarch *gdbarch)
 221 {
 222 #if GDB_MULTI_ARCH
 223   int byte_order = gdbarch_byte_order (gdbarch);
 224 #else
 225   int byte_order = TARGET_BYTE_ORDER;
 226 #endif
 227   switch (byte_order)
 228     {
 229     case BFD_ENDIAN_BIG:
 230       return &floatformat_ieee_double_big;
 231     case BFD_ENDIAN_LITTLE:
 232       return &floatformat_ieee_double_little;
 233     default:
 234       internal_error (__FILE__, __LINE__,
 235                       "default_double_format: bad byte order");
 236     }
 237 }
 238
 239 /* Misc helper functions for targets. */
 240
 241 int
 242 deprecated_register_convertible_not (int num)
 243 {
 244   return 0;
 245 }
 246
 247
 248 /* Under some ABI's that specify the `struct convention' for returning
 249    structures by value, by the time we've returned from the function,
 250    the return value is sitting there in the caller's buffer, but GDB
 251    has no way to find the address of that buffer.
 252
 253    On such architectures, use this function as your
 254    extract_struct_value_address method.  When asked to a struct
 255    returned by value in this fashion, GDB will print a nice error
 256    message, instead of garbage.  */
 257 CORE_ADDR
 258 generic_cannot_extract_struct_value_address (char *dummy)
 259 {
 260   return 0;
 261 }
 262
 263 CORE_ADDR
 264 core_addr_identity (CORE_ADDR addr)
 265 {
 266   return addr;
 267 }
 268
 269 int
 270 no_op_reg_to_regnum (int reg)
 271 {
 272   return reg;
 273 }
 274
 275 CORE_ADDR
 276 init_frame_pc_noop (int fromleaf, struct frame_info *prev)
 277 {
 278   /* Do nothing, implies return the same PC value.  */
 279   return get_frame_pc (prev);
 280 }
 281
 282 CORE_ADDR
 283 init_frame_pc_default (int fromleaf, struct frame_info *prev)
 284 {
 285   if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
 286     return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
 287   else if (get_next_frame (prev) != NULL)
 288     return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
 289   else
 290     return read_pc ();
 291 }
 292
 293 void
 294 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 295 {
 296   return;
 297 }
 298
 299 void
 300 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 301 {
 302   return;
 303 }
 304
 305 int
 306 cannot_register_not (int regnum)
 307 {
 308   return 0;
 309 }
 310
 311 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 312    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 313    raw.  */
 314
 315 void
 316 legacy_virtual_frame_pointer (CORE_ADDR pc,
 317                               int *frame_regnum,
 318                               LONGEST *frame_offset)
 319 {
 320   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 321      frame pointer of the current PC.  It is assuming that a single
 322      register and an offset can determine this.  I think it should
 323      instead generate a byte code expression as that would work better
 324      with things like Dwarf2's CFI.  */
 325   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 326     *frame_regnum = DEPRECATED_FP_REGNUM;
 327   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 328     *frame_regnum = SP_REGNUM;
 329   else
 330     /* Should this be an internal error?  I guess so, it is reflecting
 331        an architectural limitation in the current design.  */
 332     internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
 333   *frame_offset = 0;
 334 }
 335
 336 /* Assume the world is sane, every register's virtual and real size
 337    is identical.  */
 338
 339 int
 340 generic_register_size (int regnum)
 341 {
 342   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 343   if (gdbarch_register_type_p (current_gdbarch))
 344     return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
 345   else
 346     /* FIXME: cagney/2003-03-01: Once all architectures implement
 347        gdbarch_register_type(), this entire function can go away.  It
 348        is made obsolete by register_size().  */
 349     return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
 350 }
 351
 352 /* Assume all registers are adjacent.  */
 353
 354 int
 355 generic_register_byte (int regnum)
 356 {
 357   int byte;
 358   int i;
 359   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 360   byte = 0;
 361   for (i = 0; i < regnum; i++)
 362     {
 363       byte += generic_register_size (i);
 364     }
 365   return byte;
 366 }
 367
 368 \f
 369 int
 370 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 371 {
 372 #if !defined (IN_SIGTRAMP)
 373   if (SIGTRAMP_START_P ())
 374     return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
 375   else
 376     return name && strcmp ("_sigtramp", name) == 0;
 377 #else
 378   return IN_SIGTRAMP (pc, name);
 379 #endif
 380 }
 381
 382 int
 383 legacy_convert_register_p (int regnum, struct type *type)
 384 {
 385   return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
 386 }
 387
 388 void
 389 legacy_register_to_value (struct frame_info *frame, int regnum,
 390                           struct type *type, void *to)
 391 {
 392   char from[MAX_REGISTER_SIZE];
 393   frame_read_register (frame, regnum, from);
 394   DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 395 }
 396
 397 void
 398 legacy_value_to_register (struct frame_info *frame, int regnum,
 399                           struct type *type, const void *tmp)
 400 {
 401   char to[MAX_REGISTER_SIZE];
 402   char *from = alloca (TYPE_LENGTH (type));
 403   memcpy (from, from, TYPE_LENGTH (type));
 404   DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 405   put_frame_register (frame, regnum, to);
 406 }
 407
 408 \f
 409 /* Functions to manipulate the endianness of the target.  */
 410
 411 /* ``target_byte_order'' is only used when non- multi-arch.
 412    Multi-arch targets obtain the current byte order using the
 413    TARGET_BYTE_ORDER gdbarch method.
 414
 415    The choice of initial value is entirely arbitrary.  During startup,
 416    the function initialize_current_architecture() updates this value
 417    based on default byte-order information extracted from BFD.  */
 418 int target_byte_order = BFD_ENDIAN_BIG;
 419 int target_byte_order_auto = 1;
 420
 421 static const char endian_big[] = "big";
 422 static const char endian_little[] = "little";
 423 static const char endian_auto[] = "auto";
 424 static const char *endian_enum[] =
 425 {
 426   endian_big,
 427   endian_little,
 428   endian_auto,
 429   NULL,
 430 };
 431 static const char *set_endian_string;
 432
 433 /* Called by ``show endian''.  */
 434
 435 static void
 436 show_endian (char *args, int from_tty)
 437 {
 438   if (TARGET_BYTE_ORDER_AUTO)
 439     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 440                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 441   else
 442     printf_unfiltered ("The target is assumed to be %s endian\n",
 443                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 444 }
 445
 446 static void
 447 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 448 {
 449   if (set_endian_string == endian_auto)
 450     {
 451       target_byte_order_auto = 1;
 452     }
 453   else if (set_endian_string == endian_little)
 454     {
 455       target_byte_order_auto = 0;
 456       if (GDB_MULTI_ARCH)
 457         {
 458           struct gdbarch_info info;
 459           gdbarch_info_init (&info);
 460           info.byte_order = BFD_ENDIAN_LITTLE;
 461           if (! gdbarch_update_p (info))
 462             {
 463               printf_unfiltered ("Little endian target not supported by GDB\n");
 464             }
 465         }
 466       else
 467         {
 468           target_byte_order = BFD_ENDIAN_LITTLE;
 469         }
 470     }
 471   else if (set_endian_string == endian_big)
 472     {
 473       target_byte_order_auto = 0;
 474       if (GDB_MULTI_ARCH)
 475         {
 476           struct gdbarch_info info;
 477           gdbarch_info_init (&info);
 478           info.byte_order = BFD_ENDIAN_BIG;
 479           if (! gdbarch_update_p (info))
 480             {
 481               printf_unfiltered ("Big endian target not supported by GDB\n");
 482             }
 483         }
 484       else
 485         {
 486           target_byte_order = BFD_ENDIAN_BIG;
 487         }
 488     }
 489   else
 490     internal_error (__FILE__, __LINE__,
 491                     "set_endian: bad value");
 492   show_endian (NULL, from_tty);
 493 }
 494
 495 /* Set the endianness from a BFD.  */
 496
 497 static void
 498 set_endian_from_file (bfd *abfd)
 499 {
 500   int want;
 501   if (GDB_MULTI_ARCH)
 502     internal_error (__FILE__, __LINE__,
 503                     "set_endian_from_file: not for multi-arch");
 504   if (bfd_big_endian (abfd))
 505     want = BFD_ENDIAN_BIG;
 506   else
 507     want = BFD_ENDIAN_LITTLE;
 508   if (TARGET_BYTE_ORDER_AUTO)
 509     target_byte_order = want;
 510   else if (TARGET_BYTE_ORDER != want)
 511     warning ("%s endian file does not match %s endian target.",
 512              want == BFD_ENDIAN_BIG ? "big" : "little",
 513              TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little");
 514 }
 515
 516
 517 /* Functions to manipulate the architecture of the target */
 518
 519 enum set_arch { set_arch_auto, set_arch_manual };
 520
 521 int target_architecture_auto = 1;
 522
 523 const char *set_architecture_string;
 524
 525 /* Old way of changing the current architecture. */
 526
 527 extern const struct bfd_arch_info bfd_default_arch_struct;
 528 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
 529 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
 530
 531 static int
 532 arch_ok (const struct bfd_arch_info *arch)
 533 {
 534   if (GDB_MULTI_ARCH)
 535     internal_error (__FILE__, __LINE__,
 536                     "arch_ok: not multi-arched");
 537   /* Should be performing the more basic check that the binary is
 538      compatible with GDB. */
 539   /* Check with the target that the architecture is valid. */
 540   return (target_architecture_hook == NULL
 541           || target_architecture_hook (arch));
 542 }
 543
 544 static void
 545 set_arch (const struct bfd_arch_info *arch,
 546           enum set_arch type)
 547 {
 548   if (GDB_MULTI_ARCH)
 549     internal_error (__FILE__, __LINE__,
 550                     "set_arch: not multi-arched");
 551   switch (type)
 552     {
 553     case set_arch_auto:
 554       if (!arch_ok (arch))
 555         warning ("Target may not support %s architecture",
 556                  arch->printable_name);
 557       target_architecture = arch;
 558       break;
 559     case set_arch_manual:
 560       if (!arch_ok (arch))
 561         {
 562           printf_unfiltered ("Target does not support `%s' architecture.\n",
 563                              arch->printable_name);
 564         }
 565       else
 566         {
 567           target_architecture_auto = 0;
 568           target_architecture = arch;
 569         }
 570       break;
 571     }
 572   if (gdbarch_debug)
 573     gdbarch_dump (current_gdbarch, gdb_stdlog);
 574 }
 575
 576 /* Set the architecture from arch/machine (deprecated) */
 577
 578 void
 579 set_architecture_from_arch_mach (enum bfd_architecture arch,
 580                                  unsigned long mach)
 581 {
 582   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
 583   if (GDB_MULTI_ARCH)
 584     internal_error (__FILE__, __LINE__,
 585                     "set_architecture_from_arch_mach: not multi-arched");
 586   if (wanted != NULL)
 587     set_arch (wanted, set_arch_manual);
 588   else
 589     internal_error (__FILE__, __LINE__,
 590                     "gdbarch: hardwired architecture/machine not recognized");
 591 }
 592
 593 /* Set the architecture from a BFD (deprecated) */
 594
 595 static void
 596 set_architecture_from_file (bfd *abfd)
 597 {
 598   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
 599   if (GDB_MULTI_ARCH)
 600     internal_error (__FILE__, __LINE__,
 601                     "set_architecture_from_file: not multi-arched");
 602   if (target_architecture_auto)
 603     {
 604       set_arch (wanted, set_arch_auto);
 605     }
 606   else if (wanted != target_architecture)
 607     {
 608       warning ("%s architecture file may be incompatible with %s target.",
 609                wanted->printable_name,
 610                target_architecture->printable_name);
 611     }
 612 }
 613
 614
 615 /* Called if the user enters ``show architecture'' without an
 616    argument. */
 617
 618 static void
 619 show_architecture (char *args, int from_tty)
 620 {
 621   const char *arch;
 622   arch = TARGET_ARCHITECTURE->printable_name;
 623   if (target_architecture_auto)
 624     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 625   else
 626     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 627 }
 628
 629
 630 /* Called if the user enters ``set architecture'' with or without an
 631    argument. */
 632
 633 static void
 634 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 635 {
 636   if (strcmp (set_architecture_string, "auto") == 0)
 637     {
 638       target_architecture_auto = 1;
 639     }
 640   else if (GDB_MULTI_ARCH)
 641     {
 642       struct gdbarch_info info;
 643       gdbarch_info_init (&info);
 644       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 645       if (info.bfd_arch_info == NULL)
 646         internal_error (__FILE__, __LINE__,
 647                         "set_architecture: bfd_scan_arch failed");
 648       if (gdbarch_update_p (info))
 649         target_architecture_auto = 0;
 650       else
 651         printf_unfiltered ("Architecture `%s' not recognized.\n",
 652                            set_architecture_string);
 653     }
 654   else
 655     {
 656       const struct bfd_arch_info *arch
 657         = bfd_scan_arch (set_architecture_string);
 658       if (arch == NULL)
 659         internal_error (__FILE__, __LINE__,
 660                         "set_architecture: bfd_scan_arch failed");
 661       set_arch (arch, set_arch_manual);
 662     }
 663   show_architecture (NULL, from_tty);
 664 }
 665
 666 /* Set the dynamic target-system-dependent parameters (architecture,
 667    byte-order) using information found in the BFD */
 668
 669 void
 670 set_gdbarch_from_file (bfd *abfd)
 671 {
 672   if (GDB_MULTI_ARCH)
 673     {
 674       struct gdbarch_info info;
 675       gdbarch_info_init (&info);
 676       info.abfd = abfd;
 677       if (! gdbarch_update_p (info))
 678         error ("Architecture of file not recognized.\n");
 679     }
 680   else
 681     {
 682       set_architecture_from_file (abfd);
 683       set_endian_from_file (abfd);
 684     }
 685 }
 686
 687 /* Initialize the current architecture.  Update the ``set
 688    architecture'' command so that it specifies a list of valid
 689    architectures.  */
 690
 691 #ifdef DEFAULT_BFD_ARCH
 692 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 693 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 694 #else
 695 static const bfd_arch_info_type *default_bfd_arch;
 696 #endif
 697
 698 #ifdef DEFAULT_BFD_VEC
 699 extern const bfd_target DEFAULT_BFD_VEC;
 700 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 701 #else
 702 static const bfd_target *default_bfd_vec;
 703 #endif
 704
 705 void
 706 initialize_current_architecture (void)
 707 {
 708   const char **arches = gdbarch_printable_names ();
 709
 710   /* determine a default architecture and byte order. */
 711   struct gdbarch_info info;
 712   gdbarch_info_init (&info);
 713
 714   /* Find a default architecture. */
 715   if (info.bfd_arch_info == NULL
 716       && default_bfd_arch != NULL)
 717     info.bfd_arch_info = default_bfd_arch;
 718   if (info.bfd_arch_info == NULL)
 719     {
 720       /* Choose the architecture by taking the first one
 721          alphabetically. */
 722       const char *chosen = arches[0];
 723       const char **arch;
 724       for (arch = arches; *arch != NULL; arch++)
 725         {
 726           if (strcmp (*arch, chosen) < 0)
 727             chosen = *arch;
 728         }
 729       if (chosen == NULL)
 730         internal_error (__FILE__, __LINE__,
 731                         "initialize_current_architecture: No arch");
 732       info.bfd_arch_info = bfd_scan_arch (chosen);
 733       if (info.bfd_arch_info == NULL)
 734         internal_error (__FILE__, __LINE__,
 735                         "initialize_current_architecture: Arch not found");
 736     }
 737
 738   /* Take several guesses at a byte order.  */
 739   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 740       && default_bfd_vec != NULL)
 741     {
 742       /* Extract BFD's default vector's byte order. */
 743       switch (default_bfd_vec->byteorder)
 744         {
 745         case BFD_ENDIAN_BIG:
 746           info.byte_order = BFD_ENDIAN_BIG;
 747           break;
 748         case BFD_ENDIAN_LITTLE:
 749           info.byte_order = BFD_ENDIAN_LITTLE;
 750           break;
 751         default:
 752           break;
 753         }
 754     }
 755   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 756     {
 757       /* look for ``*el-*'' in the target name. */
 758       const char *chp;
 759       chp = strchr (target_name, '-');
 760       if (chp != NULL
 761           && chp - 2 >= target_name
 762           && strncmp (chp - 2, "el", 2) == 0)
 763         info.byte_order = BFD_ENDIAN_LITTLE;
 764     }
 765   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 766     {
 767       /* Wire it to big-endian!!! */
 768       info.byte_order = BFD_ENDIAN_BIG;
 769     }
 770
 771   if (GDB_MULTI_ARCH)
 772     {
 773       if (! gdbarch_update_p (info))
 774         {
 775           internal_error (__FILE__, __LINE__,
 776                           "initialize_current_architecture: Selection of initial architecture failed");
 777         }
 778     }
 779   else
 780     {
 781       /* If the multi-arch logic comes up with a byte-order (from BFD)
 782          use it for the non-multi-arch case.  */
 783       if (info.byte_order != BFD_ENDIAN_UNKNOWN)
 784         target_byte_order = info.byte_order;
 785       initialize_non_multiarch ();
 786     }
 787
 788   /* Create the ``set architecture'' command appending ``auto'' to the
 789      list of architectures. */
 790   {
 791     struct cmd_list_element *c;
 792     /* Append ``auto''. */
 793     int nr;
 794     for (nr = 0; arches[nr] != NULL; nr++);
 795     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 796     arches[nr + 0] = "auto";
 797     arches[nr + 1] = NULL;
 798     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 799        of ``const char *''.  We just happen to know that the casts are
 800        safe. */
 801     c = add_set_enum_cmd ("architecture", class_support,
 802                           arches, &set_architecture_string,
 803                           "Set architecture of target.",
 804                           &setlist);
 805     set_cmd_sfunc (c, set_architecture);
 806     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 807     /* Don't use set_from_show - need to print both auto/manual and
 808        current setting. */
 809     add_cmd ("architecture", class_support, show_architecture,
 810              "Show the current target architecture", &showlist);
 811   }
 812 }
 813
 814
 815 /* Initialize a gdbarch info to values that will be automatically
 816    overridden.  Note: Originally, this ``struct info'' was initialized
 817    using memset(0).  Unfortunatly, that ran into problems, namely
 818    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 819    can explicitly set each field to a well defined value is used.  */
 820
 821 void
 822 gdbarch_info_init (struct gdbarch_info *info)
 823 {
 824   memset (info, 0, sizeof (struct gdbarch_info));
 825   info->byte_order = BFD_ENDIAN_UNKNOWN;
 826   info->osabi = GDB_OSABI_UNINITIALIZED;
 827 }
 828
 829 /* */
 830
 831 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 832
 833 void
 834 _initialize_gdbarch_utils (void)
 835 {
 836   struct cmd_list_element *c;
 837   c = add_set_enum_cmd ("endian", class_support,
 838                         endian_enum, &set_endian_string,
 839                         "Set endianness of target.",
 840                         &setlist);
 841   set_cmd_sfunc (c, set_endian);
 842   /* Don't use set_from_show - need to print both auto/manual and
 843      current setting. */
 844   add_cmd ("endian", class_support, show_endian,
 845            "Show the current byte-order", &showlist);
 846 }