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