gdb/arch-utils.c

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