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 /* 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); /* OK */
 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 (*deprecated_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 /* Default prepare_to_procced().  */
 317 int
 318 default_prepare_to_proceed (int select_it)
 319 {
 320   return 0;
 321 }
 322
 323 /* Generic prepare_to_proceed().  This one should be suitable for most
 324    targets that support threads. */
 325 int
 326 generic_prepare_to_proceed (int select_it)
 327 {
 328   ptid_t wait_ptid;
 329   struct target_waitstatus wait_status;
 330
 331   /* Get the last target status returned by target_wait().  */
 332   get_last_target_status (&wait_ptid, &wait_status);
 333
 334   /* Make sure we were stopped either at a breakpoint, or because
 335      of a Ctrl-C.  */
 336   if (wait_status.kind != TARGET_WAITKIND_STOPPED
 337       || (wait_status.value.sig != TARGET_SIGNAL_TRAP &&
 338           wait_status.value.sig != TARGET_SIGNAL_INT))
 339     {
 340       return 0;
 341     }
 342
 343   if (!ptid_equal (wait_ptid, minus_one_ptid)
 344       && !ptid_equal (inferior_ptid, wait_ptid))
 345     {
 346       /* Switched over from WAIT_PID.  */
 347       CORE_ADDR wait_pc = read_pc_pid (wait_ptid);
 348
 349       if (wait_pc != read_pc ())
 350         {
 351           if (select_it)
 352             {
 353               /* Switch back to WAIT_PID thread.  */
 354               inferior_ptid = wait_ptid;
 355
 356               /* FIXME: This stuff came from switch_to_thread() in
 357                  thread.c (which should probably be a public function).  */
 358               flush_cached_frames ();
 359               registers_changed ();
 360               stop_pc = wait_pc;
 361               select_frame (get_current_frame ());
 362             }
 363           /* We return 1 to indicate that there is a breakpoint here,
 364              so we need to step over it before continuing to avoid
 365              hitting it straight away. */
 366           if (breakpoint_here_p (wait_pc))
 367             {
 368               return 1;
 369             }
 370         }
 371     }
 372   return 0;
 373
 374 }
 375
 376 CORE_ADDR
 377 init_frame_pc_noop (int fromleaf, struct frame_info *prev)
 378 {
 379   /* Do nothing, implies return the same PC value.  */
 380   return get_frame_pc (prev);
 381 }
 382
 383 CORE_ADDR
 384 init_frame_pc_default (int fromleaf, struct frame_info *prev)
 385 {
 386   if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
 387     return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
 388   else if (get_next_frame (prev) != NULL)
 389     return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
 390   else
 391     return read_pc ();
 392 }
 393
 394 void
 395 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 396 {
 397   return;
 398 }
 399
 400 void
 401 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 402 {
 403   return;
 404 }
 405
 406 int
 407 cannot_register_not (int regnum)
 408 {
 409   return 0;
 410 }
 411
 412 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 413    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 414    raw.  */
 415
 416 void
 417 legacy_virtual_frame_pointer (CORE_ADDR pc,
 418                               int *frame_regnum,
 419                               LONGEST *frame_offset)
 420 {
 421   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 422      frame pointer of the current PC.  It is assuming that a single
 423      register and an offset can determine this.  I think it should
 424      instead generate a byte code expression as that would work better
 425      with things like Dwarf2's CFI.  */
 426   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 427     *frame_regnum = DEPRECATED_FP_REGNUM;
 428   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 429     *frame_regnum = SP_REGNUM;
 430   else
 431     /* Should this be an internal error?  I guess so, it is reflecting
 432        an architectural limitation in the current design.  */
 433     internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
 434   *frame_offset = 0;
 435 }
 436
 437 /* Assume the world is sane, every register's virtual and real size
 438    is identical.  */
 439
 440 int
 441 generic_register_size (int regnum)
 442 {
 443   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 444   if (gdbarch_register_type_p (current_gdbarch))
 445     return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
 446   else
 447     /* FIXME: cagney/2003-03-01: Once all architectures implement
 448        gdbarch_register_type(), this entire function can go away.  It
 449        is made obsolete by register_size().  */
 450     return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
 451 }
 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 += generic_register_size (i);
 465     }
 466   return byte;
 467 }
 468
 469 \f
 470 int
 471 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 472 {
 473 #if !defined (IN_SIGTRAMP)
 474   if (SIGTRAMP_START_P ())
 475     return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
 476   else
 477     return name && strcmp ("_sigtramp", name) == 0;
 478 #else
 479   return IN_SIGTRAMP (pc, name);
 480 #endif
 481 }
 482
 483 int
 484 legacy_convert_register_p (int regnum)
 485 {
 486   return REGISTER_CONVERTIBLE (regnum);
 487 }
 488
 489 void
 490 legacy_register_to_value (int regnum, struct type *type,
 491                           char *from, char *to)
 492 {
 493   REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 494 }
 495
 496 void
 497 legacy_value_to_register (struct type *type, int regnum,
 498                           char *from, char *to)
 499 {
 500   REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 501 }
 502
 503 \f
 504 /* Functions to manipulate the endianness of the target.  */
 505
 506 /* ``target_byte_order'' is only used when non- multi-arch.
 507    Multi-arch targets obtain the current byte order using the
 508    TARGET_BYTE_ORDER gdbarch method.
 509
 510    The choice of initial value is entirely arbitrary.  During startup,
 511    the function initialize_current_architecture() updates this value
 512    based on default byte-order information extracted from BFD.  */
 513 int target_byte_order = BFD_ENDIAN_BIG;
 514 int target_byte_order_auto = 1;
 515
 516 static const char endian_big[] = "big";
 517 static const char endian_little[] = "little";
 518 static const char endian_auto[] = "auto";
 519 static const char *endian_enum[] =
 520 {
 521   endian_big,
 522   endian_little,
 523   endian_auto,
 524   NULL,
 525 };
 526 static const char *set_endian_string;
 527
 528 /* Called by ``show endian''.  */
 529
 530 static void
 531 show_endian (char *args, int from_tty)
 532 {
 533   if (TARGET_BYTE_ORDER_AUTO)
 534     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 535                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 536   else
 537     printf_unfiltered ("The target is assumed to be %s endian\n",
 538                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 539 }
 540
 541 static void
 542 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 543 {
 544   if (set_endian_string == endian_auto)
 545     {
 546       target_byte_order_auto = 1;
 547     }
 548   else if (set_endian_string == endian_little)
 549     {
 550       target_byte_order_auto = 0;
 551       if (GDB_MULTI_ARCH)
 552         {
 553           struct gdbarch_info info;
 554           gdbarch_info_init (&info);
 555           info.byte_order = BFD_ENDIAN_LITTLE;
 556           if (! gdbarch_update_p (info))
 557             {
 558               printf_unfiltered ("Little endian target not supported by GDB\n");
 559             }
 560         }
 561       else
 562         {
 563           target_byte_order = BFD_ENDIAN_LITTLE;
 564         }
 565     }
 566   else if (set_endian_string == endian_big)
 567     {
 568       target_byte_order_auto = 0;
 569       if (GDB_MULTI_ARCH)
 570         {
 571           struct gdbarch_info info;
 572           gdbarch_info_init (&info);
 573           info.byte_order = BFD_ENDIAN_BIG;
 574           if (! gdbarch_update_p (info))
 575             {
 576               printf_unfiltered ("Big endian target not supported by GDB\n");
 577             }
 578         }
 579       else
 580         {
 581           target_byte_order = BFD_ENDIAN_BIG;
 582         }
 583     }
 584   else
 585     internal_error (__FILE__, __LINE__,
 586                     "set_endian: bad value");
 587   show_endian (NULL, from_tty);
 588 }
 589
 590 /* Set the endianness from a BFD.  */
 591
 592 static void
 593 set_endian_from_file (bfd *abfd)
 594 {
 595   int want;
 596   if (GDB_MULTI_ARCH)
 597     internal_error (__FILE__, __LINE__,
 598                     "set_endian_from_file: not for multi-arch");
 599   if (bfd_big_endian (abfd))
 600     want = BFD_ENDIAN_BIG;
 601   else
 602     want = BFD_ENDIAN_LITTLE;
 603   if (TARGET_BYTE_ORDER_AUTO)
 604     target_byte_order = want;
 605   else if (TARGET_BYTE_ORDER != want)
 606     warning ("%s endian file does not match %s endian target.",
 607              want == BFD_ENDIAN_BIG ? "big" : "little",
 608              TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little");
 609 }
 610
 611
 612 /* Functions to manipulate the architecture of the target */
 613
 614 enum set_arch { set_arch_auto, set_arch_manual };
 615
 616 int target_architecture_auto = 1;
 617
 618 const char *set_architecture_string;
 619
 620 /* Old way of changing the current architecture. */
 621
 622 extern const struct bfd_arch_info bfd_default_arch_struct;
 623 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
 624 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
 625
 626 static int
 627 arch_ok (const struct bfd_arch_info *arch)
 628 {
 629   if (GDB_MULTI_ARCH)
 630     internal_error (__FILE__, __LINE__,
 631                     "arch_ok: not multi-arched");
 632   /* Should be performing the more basic check that the binary is
 633      compatible with GDB. */
 634   /* Check with the target that the architecture is valid. */
 635   return (target_architecture_hook == NULL
 636           || target_architecture_hook (arch));
 637 }
 638
 639 static void
 640 set_arch (const struct bfd_arch_info *arch,
 641           enum set_arch type)
 642 {
 643   if (GDB_MULTI_ARCH)
 644     internal_error (__FILE__, __LINE__,
 645                     "set_arch: not multi-arched");
 646   switch (type)
 647     {
 648     case set_arch_auto:
 649       if (!arch_ok (arch))
 650         warning ("Target may not support %s architecture",
 651                  arch->printable_name);
 652       target_architecture = arch;
 653       break;
 654     case set_arch_manual:
 655       if (!arch_ok (arch))
 656         {
 657           printf_unfiltered ("Target does not support `%s' architecture.\n",
 658                              arch->printable_name);
 659         }
 660       else
 661         {
 662           target_architecture_auto = 0;
 663           target_architecture = arch;
 664         }
 665       break;
 666     }
 667   if (gdbarch_debug)
 668     gdbarch_dump (current_gdbarch, gdb_stdlog);
 669 }
 670
 671 /* Set the architecture from arch/machine (deprecated) */
 672
 673 void
 674 set_architecture_from_arch_mach (enum bfd_architecture arch,
 675                                  unsigned long mach)
 676 {
 677   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
 678   if (GDB_MULTI_ARCH)
 679     internal_error (__FILE__, __LINE__,
 680                     "set_architecture_from_arch_mach: not multi-arched");
 681   if (wanted != NULL)
 682     set_arch (wanted, set_arch_manual);
 683   else
 684     internal_error (__FILE__, __LINE__,
 685                     "gdbarch: hardwired architecture/machine not recognized");
 686 }
 687
 688 /* Set the architecture from a BFD (deprecated) */
 689
 690 static void
 691 set_architecture_from_file (bfd *abfd)
 692 {
 693   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
 694   if (GDB_MULTI_ARCH)
 695     internal_error (__FILE__, __LINE__,
 696                     "set_architecture_from_file: not multi-arched");
 697   if (target_architecture_auto)
 698     {
 699       set_arch (wanted, set_arch_auto);
 700     }
 701   else if (wanted != target_architecture)
 702     {
 703       warning ("%s architecture file may be incompatible with %s target.",
 704                wanted->printable_name,
 705                target_architecture->printable_name);
 706     }
 707 }
 708
 709
 710 /* Called if the user enters ``show architecture'' without an
 711    argument. */
 712
 713 static void
 714 show_architecture (char *args, int from_tty)
 715 {
 716   const char *arch;
 717   arch = TARGET_ARCHITECTURE->printable_name;
 718   if (target_architecture_auto)
 719     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 720   else
 721     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 722 }
 723
 724
 725 /* Called if the user enters ``set architecture'' with or without an
 726    argument. */
 727
 728 static void
 729 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 730 {
 731   if (strcmp (set_architecture_string, "auto") == 0)
 732     {
 733       target_architecture_auto = 1;
 734     }
 735   else if (GDB_MULTI_ARCH)
 736     {
 737       struct gdbarch_info info;
 738       gdbarch_info_init (&info);
 739       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 740       if (info.bfd_arch_info == NULL)
 741         internal_error (__FILE__, __LINE__,
 742                         "set_architecture: bfd_scan_arch failed");
 743       if (gdbarch_update_p (info))
 744         target_architecture_auto = 0;
 745       else
 746         printf_unfiltered ("Architecture `%s' not recognized.\n",
 747                            set_architecture_string);
 748     }
 749   else
 750     {
 751       const struct bfd_arch_info *arch
 752         = bfd_scan_arch (set_architecture_string);
 753       if (arch == NULL)
 754         internal_error (__FILE__, __LINE__,
 755                         "set_architecture: bfd_scan_arch failed");
 756       set_arch (arch, set_arch_manual);
 757     }
 758   show_architecture (NULL, from_tty);
 759 }
 760
 761 /* Set the dynamic target-system-dependent parameters (architecture,
 762    byte-order) using information found in the BFD */
 763
 764 void
 765 set_gdbarch_from_file (bfd *abfd)
 766 {
 767   if (GDB_MULTI_ARCH)
 768     {
 769       struct gdbarch_info info;
 770       gdbarch_info_init (&info);
 771       info.abfd = abfd;
 772       if (! gdbarch_update_p (info))
 773         error ("Architecture of file not recognized.\n");
 774     }
 775   else
 776     {
 777       set_architecture_from_file (abfd);
 778       set_endian_from_file (abfd);
 779     }
 780 }
 781
 782 /* Initialize the current architecture.  Update the ``set
 783    architecture'' command so that it specifies a list of valid
 784    architectures.  */
 785
 786 #ifdef DEFAULT_BFD_ARCH
 787 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 788 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 789 #else
 790 static const bfd_arch_info_type *default_bfd_arch;
 791 #endif
 792
 793 #ifdef DEFAULT_BFD_VEC
 794 extern const bfd_target DEFAULT_BFD_VEC;
 795 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 796 #else
 797 static const bfd_target *default_bfd_vec;
 798 #endif
 799
 800 void
 801 initialize_current_architecture (void)
 802 {
 803   const char **arches = gdbarch_printable_names ();
 804
 805   /* determine a default architecture and byte order. */
 806   struct gdbarch_info info;
 807   gdbarch_info_init (&info);
 808
 809   /* Find a default architecture. */
 810   if (info.bfd_arch_info == NULL
 811       && default_bfd_arch != NULL)
 812     info.bfd_arch_info = default_bfd_arch;
 813   if (info.bfd_arch_info == NULL)
 814     {
 815       /* Choose the architecture by taking the first one
 816          alphabetically. */
 817       const char *chosen = arches[0];
 818       const char **arch;
 819       for (arch = arches; *arch != NULL; arch++)
 820         {
 821           if (strcmp (*arch, chosen) < 0)
 822             chosen = *arch;
 823         }
 824       if (chosen == NULL)
 825         internal_error (__FILE__, __LINE__,
 826                         "initialize_current_architecture: No arch");
 827       info.bfd_arch_info = bfd_scan_arch (chosen);
 828       if (info.bfd_arch_info == NULL)
 829         internal_error (__FILE__, __LINE__,
 830                         "initialize_current_architecture: Arch not found");
 831     }
 832
 833   /* Take several guesses at a byte order.  */
 834   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 835       && default_bfd_vec != NULL)
 836     {
 837       /* Extract BFD's default vector's byte order. */
 838       switch (default_bfd_vec->byteorder)
 839         {
 840         case BFD_ENDIAN_BIG:
 841           info.byte_order = BFD_ENDIAN_BIG;
 842           break;
 843         case BFD_ENDIAN_LITTLE:
 844           info.byte_order = BFD_ENDIAN_LITTLE;
 845           break;
 846         default:
 847           break;
 848         }
 849     }
 850   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 851     {
 852       /* look for ``*el-*'' in the target name. */
 853       const char *chp;
 854       chp = strchr (target_name, '-');
 855       if (chp != NULL
 856           && chp - 2 >= target_name
 857           && strncmp (chp - 2, "el", 2) == 0)
 858         info.byte_order = BFD_ENDIAN_LITTLE;
 859     }
 860   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 861     {
 862       /* Wire it to big-endian!!! */
 863       info.byte_order = BFD_ENDIAN_BIG;
 864     }
 865
 866   if (GDB_MULTI_ARCH)
 867     {
 868       if (! gdbarch_update_p (info))
 869         {
 870           internal_error (__FILE__, __LINE__,
 871                           "initialize_current_architecture: Selection of initial architecture failed");
 872         }
 873     }
 874   else
 875     {
 876       /* If the multi-arch logic comes up with a byte-order (from BFD)
 877          use it for the non-multi-arch case.  */
 878       if (info.byte_order != BFD_ENDIAN_UNKNOWN)
 879         target_byte_order = info.byte_order;
 880       initialize_non_multiarch ();
 881     }
 882
 883   /* Create the ``set architecture'' command appending ``auto'' to the
 884      list of architectures. */
 885   {
 886     struct cmd_list_element *c;
 887     /* Append ``auto''. */
 888     int nr;
 889     for (nr = 0; arches[nr] != NULL; nr++);
 890     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 891     arches[nr + 0] = "auto";
 892     arches[nr + 1] = NULL;
 893     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 894        of ``const char *''.  We just happen to know that the casts are
 895        safe. */
 896     c = add_set_enum_cmd ("architecture", class_support,
 897                           arches, &set_architecture_string,
 898                           "Set architecture of target.",
 899                           &setlist);
 900     set_cmd_sfunc (c, set_architecture);
 901     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 902     /* Don't use set_from_show - need to print both auto/manual and
 903        current setting. */
 904     add_cmd ("architecture", class_support, show_architecture,
 905              "Show the current target architecture", &showlist);
 906   }
 907 }
 908
 909
 910 /* Initialize a gdbarch info to values that will be automatically
 911    overridden.  Note: Originally, this ``struct info'' was initialized
 912    using memset(0).  Unfortunatly, that ran into problems, namely
 913    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 914    can explicitly set each field to a well defined value is used.  */
 915
 916 void
 917 gdbarch_info_init (struct gdbarch_info *info)
 918 {
 919   memset (info, 0, sizeof (struct gdbarch_info));
 920   info->byte_order = BFD_ENDIAN_UNKNOWN;
 921   info->osabi = GDB_OSABI_UNINITIALIZED;
 922 }
 923
 924 /* */
 925
 926 extern initialize_file_ftype _initialize_gdbarch_utils;
 927
 928 void
 929 _initialize_gdbarch_utils (void)
 930 {
 931   struct cmd_list_element *c;
 932   c = add_set_enum_cmd ("endian", class_support,
 933                         endian_enum, &set_endian_string,
 934                         "Set endianness of target.",
 935                         &setlist);
 936   set_cmd_sfunc (c, set_endian);
 937   /* Don't use set_from_show - need to print both auto/manual and
 938      current setting. */
 939   add_cmd ("endian", class_support, show_endian,
 940            "Show the current byte-order", &showlist);
 941 }