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