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