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