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