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 \f
 448 int
 449 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 450 {
 451   return IN_SIGTRAMP(pc, name);
 452 }
 453
 454 int
 455 legacy_convert_register_p (int regnum)
 456 {
 457   return REGISTER_CONVERTIBLE (regnum);
 458 }
 459
 460 void
 461 legacy_register_to_value (int regnum, struct type *type,
 462                           char *from, char *to)
 463 {
 464   REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 465 }
 466
 467 void
 468 legacy_value_to_register (struct type *type, int regnum,
 469                           char *from, char *to)
 470 {
 471   REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 472 }
 473
 474 \f
 475 /* Functions to manipulate the endianness of the target.  */
 476
 477 /* ``target_byte_order'' is only used when non- multi-arch.
 478    Multi-arch targets obtain the current byte order using the
 479    TARGET_BYTE_ORDER gdbarch method.
 480
 481    The choice of initial value is entirely arbitrary.  During startup,
 482    the function initialize_current_architecture() updates this value
 483    based on default byte-order information extracted from BFD.  */
 484 int target_byte_order = BFD_ENDIAN_BIG;
 485 int target_byte_order_auto = 1;
 486
 487 static const char endian_big[] = "big";
 488 static const char endian_little[] = "little";
 489 static const char endian_auto[] = "auto";
 490 static const char *endian_enum[] =
 491 {
 492   endian_big,
 493   endian_little,
 494   endian_auto,
 495   NULL,
 496 };
 497 static const char *set_endian_string;
 498
 499 /* Called by ``show endian''.  */
 500
 501 static void
 502 show_endian (char *args, int from_tty)
 503 {
 504   if (TARGET_BYTE_ORDER_AUTO)
 505     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 506                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 507   else
 508     printf_unfiltered ("The target is assumed to be %s endian\n",
 509                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 510 }
 511
 512 static void
 513 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 514 {
 515   if (set_endian_string == endian_auto)
 516     {
 517       target_byte_order_auto = 1;
 518     }
 519   else if (set_endian_string == endian_little)
 520     {
 521       target_byte_order_auto = 0;
 522       if (GDB_MULTI_ARCH)
 523         {
 524           struct gdbarch_info info;
 525           gdbarch_info_init (&info);
 526           info.byte_order = BFD_ENDIAN_LITTLE;
 527           if (! gdbarch_update_p (info))
 528             {
 529               printf_unfiltered ("Little endian target not supported by GDB\n");
 530             }
 531         }
 532       else
 533         {
 534           target_byte_order = BFD_ENDIAN_LITTLE;
 535         }
 536     }
 537   else if (set_endian_string == endian_big)
 538     {
 539       target_byte_order_auto = 0;
 540       if (GDB_MULTI_ARCH)
 541         {
 542           struct gdbarch_info info;
 543           gdbarch_info_init (&info);
 544           info.byte_order = BFD_ENDIAN_BIG;
 545           if (! gdbarch_update_p (info))
 546             {
 547               printf_unfiltered ("Big endian target not supported by GDB\n");
 548             }
 549         }
 550       else
 551         {
 552           target_byte_order = BFD_ENDIAN_BIG;
 553         }
 554     }
 555   else
 556     internal_error (__FILE__, __LINE__,
 557                     "set_endian: bad value");
 558   show_endian (NULL, from_tty);
 559 }
 560
 561 /* Set the endianness from a BFD.  */
 562
 563 static void
 564 set_endian_from_file (bfd *abfd)
 565 {
 566   int want;
 567   if (GDB_MULTI_ARCH)
 568     internal_error (__FILE__, __LINE__,
 569                     "set_endian_from_file: not for multi-arch");
 570   if (bfd_big_endian (abfd))
 571     want = BFD_ENDIAN_BIG;
 572   else
 573     want = BFD_ENDIAN_LITTLE;
 574   if (TARGET_BYTE_ORDER_AUTO)
 575     target_byte_order = want;
 576   else if (TARGET_BYTE_ORDER != want)
 577     warning ("%s endian file does not match %s endian target.",
 578              want == BFD_ENDIAN_BIG ? "big" : "little",
 579              TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little");
 580 }
 581
 582
 583 /* Functions to manipulate the architecture of the target */
 584
 585 enum set_arch { set_arch_auto, set_arch_manual };
 586
 587 int target_architecture_auto = 1;
 588
 589 const char *set_architecture_string;
 590
 591 /* Old way of changing the current architecture. */
 592
 593 extern const struct bfd_arch_info bfd_default_arch_struct;
 594 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
 595 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
 596
 597 static int
 598 arch_ok (const struct bfd_arch_info *arch)
 599 {
 600   if (GDB_MULTI_ARCH)
 601     internal_error (__FILE__, __LINE__,
 602                     "arch_ok: not multi-arched");
 603   /* Should be performing the more basic check that the binary is
 604      compatible with GDB. */
 605   /* Check with the target that the architecture is valid. */
 606   return (target_architecture_hook == NULL
 607           || target_architecture_hook (arch));
 608 }
 609
 610 static void
 611 set_arch (const struct bfd_arch_info *arch,
 612           enum set_arch type)
 613 {
 614   if (GDB_MULTI_ARCH)
 615     internal_error (__FILE__, __LINE__,
 616                     "set_arch: not multi-arched");
 617   switch (type)
 618     {
 619     case set_arch_auto:
 620       if (!arch_ok (arch))
 621         warning ("Target may not support %s architecture",
 622                  arch->printable_name);
 623       target_architecture = arch;
 624       break;
 625     case set_arch_manual:
 626       if (!arch_ok (arch))
 627         {
 628           printf_unfiltered ("Target does not support `%s' architecture.\n",
 629                              arch->printable_name);
 630         }
 631       else
 632         {
 633           target_architecture_auto = 0;
 634           target_architecture = arch;
 635         }
 636       break;
 637     }
 638   if (gdbarch_debug)
 639     gdbarch_dump (current_gdbarch, gdb_stdlog);
 640 }
 641
 642 /* Set the architecture from arch/machine (deprecated) */
 643
 644 void
 645 set_architecture_from_arch_mach (enum bfd_architecture arch,
 646                                  unsigned long mach)
 647 {
 648   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
 649   if (GDB_MULTI_ARCH)
 650     internal_error (__FILE__, __LINE__,
 651                     "set_architecture_from_arch_mach: not multi-arched");
 652   if (wanted != NULL)
 653     set_arch (wanted, set_arch_manual);
 654   else
 655     internal_error (__FILE__, __LINE__,
 656                     "gdbarch: hardwired architecture/machine not recognized");
 657 }
 658
 659 /* Set the architecture from a BFD (deprecated) */
 660
 661 static void
 662 set_architecture_from_file (bfd *abfd)
 663 {
 664   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
 665   if (GDB_MULTI_ARCH)
 666     internal_error (__FILE__, __LINE__,
 667                     "set_architecture_from_file: not multi-arched");
 668   if (target_architecture_auto)
 669     {
 670       set_arch (wanted, set_arch_auto);
 671     }
 672   else if (wanted != target_architecture)
 673     {
 674       warning ("%s architecture file may be incompatible with %s target.",
 675                wanted->printable_name,
 676                target_architecture->printable_name);
 677     }
 678 }
 679
 680
 681 /* Called if the user enters ``show architecture'' without an
 682    argument. */
 683
 684 static void
 685 show_architecture (char *args, int from_tty)
 686 {
 687   const char *arch;
 688   arch = TARGET_ARCHITECTURE->printable_name;
 689   if (target_architecture_auto)
 690     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 691   else
 692     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 693 }
 694
 695
 696 /* Called if the user enters ``set architecture'' with or without an
 697    argument. */
 698
 699 static void
 700 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 701 {
 702   if (strcmp (set_architecture_string, "auto") == 0)
 703     {
 704       target_architecture_auto = 1;
 705     }
 706   else if (GDB_MULTI_ARCH)
 707     {
 708       struct gdbarch_info info;
 709       gdbarch_info_init (&info);
 710       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 711       if (info.bfd_arch_info == NULL)
 712         internal_error (__FILE__, __LINE__,
 713                         "set_architecture: bfd_scan_arch failed");
 714       if (gdbarch_update_p (info))
 715         target_architecture_auto = 0;
 716       else
 717         printf_unfiltered ("Architecture `%s' not recognized.\n",
 718                            set_architecture_string);
 719     }
 720   else
 721     {
 722       const struct bfd_arch_info *arch
 723         = bfd_scan_arch (set_architecture_string);
 724       if (arch == NULL)
 725         internal_error (__FILE__, __LINE__,
 726                         "set_architecture: bfd_scan_arch failed");
 727       set_arch (arch, set_arch_manual);
 728     }
 729   show_architecture (NULL, from_tty);
 730 }
 731
 732 /* Set the dynamic target-system-dependent parameters (architecture,
 733    byte-order) using information found in the BFD */
 734
 735 void
 736 set_gdbarch_from_file (bfd *abfd)
 737 {
 738   if (GDB_MULTI_ARCH)
 739     {
 740       struct gdbarch_info info;
 741       gdbarch_info_init (&info);
 742       info.abfd = abfd;
 743       if (! gdbarch_update_p (info))
 744         error ("Architecture of file not recognized.\n");
 745     }
 746   else
 747     {
 748       set_architecture_from_file (abfd);
 749       set_endian_from_file (abfd);
 750     }
 751 }
 752
 753 /* Initialize the current architecture.  Update the ``set
 754    architecture'' command so that it specifies a list of valid
 755    architectures.  */
 756
 757 #ifdef DEFAULT_BFD_ARCH
 758 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 759 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 760 #else
 761 static const bfd_arch_info_type *default_bfd_arch;
 762 #endif
 763
 764 #ifdef DEFAULT_BFD_VEC
 765 extern const bfd_target DEFAULT_BFD_VEC;
 766 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 767 #else
 768 static const bfd_target *default_bfd_vec;
 769 #endif
 770
 771 void
 772 initialize_current_architecture (void)
 773 {
 774   const char **arches = gdbarch_printable_names ();
 775
 776   /* determine a default architecture and byte order. */
 777   struct gdbarch_info info;
 778   gdbarch_info_init (&info);
 779
 780   /* Find a default architecture. */
 781   if (info.bfd_arch_info == NULL
 782       && default_bfd_arch != NULL)
 783     info.bfd_arch_info = default_bfd_arch;
 784   if (info.bfd_arch_info == NULL)
 785     {
 786       /* Choose the architecture by taking the first one
 787          alphabetically. */
 788       const char *chosen = arches[0];
 789       const char **arch;
 790       for (arch = arches; *arch != NULL; arch++)
 791         {
 792           if (strcmp (*arch, chosen) < 0)
 793             chosen = *arch;
 794         }
 795       if (chosen == NULL)
 796         internal_error (__FILE__, __LINE__,
 797                         "initialize_current_architecture: No arch");
 798       info.bfd_arch_info = bfd_scan_arch (chosen);
 799       if (info.bfd_arch_info == NULL)
 800         internal_error (__FILE__, __LINE__,
 801                         "initialize_current_architecture: Arch not found");
 802     }
 803
 804   /* Take several guesses at a byte order.  */
 805   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 806       && default_bfd_vec != NULL)
 807     {
 808       /* Extract BFD's default vector's byte order. */
 809       switch (default_bfd_vec->byteorder)
 810         {
 811         case BFD_ENDIAN_BIG:
 812           info.byte_order = BFD_ENDIAN_BIG;
 813           break;
 814         case BFD_ENDIAN_LITTLE:
 815           info.byte_order = BFD_ENDIAN_LITTLE;
 816           break;
 817         default:
 818           break;
 819         }
 820     }
 821   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 822     {
 823       /* look for ``*el-*'' in the target name. */
 824       const char *chp;
 825       chp = strchr (target_name, '-');
 826       if (chp != NULL
 827           && chp - 2 >= target_name
 828           && strncmp (chp - 2, "el", 2) == 0)
 829         info.byte_order = BFD_ENDIAN_LITTLE;
 830     }
 831   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 832     {
 833       /* Wire it to big-endian!!! */
 834       info.byte_order = BFD_ENDIAN_BIG;
 835     }
 836
 837   if (GDB_MULTI_ARCH)
 838     {
 839       if (! gdbarch_update_p (info))
 840         {
 841           internal_error (__FILE__, __LINE__,
 842                           "initialize_current_architecture: Selection of initial architecture failed");
 843         }
 844     }
 845   else
 846     {
 847       /* If the multi-arch logic comes up with a byte-order (from BFD)
 848          use it for the non-multi-arch case.  */
 849       if (info.byte_order != BFD_ENDIAN_UNKNOWN)
 850         target_byte_order = info.byte_order;
 851       initialize_non_multiarch ();
 852     }
 853
 854   /* Create the ``set architecture'' command appending ``auto'' to the
 855      list of architectures. */
 856   {
 857     struct cmd_list_element *c;
 858     /* Append ``auto''. */
 859     int nr;
 860     for (nr = 0; arches[nr] != NULL; nr++);
 861     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 862     arches[nr + 0] = "auto";
 863     arches[nr + 1] = NULL;
 864     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 865        of ``const char *''.  We just happen to know that the casts are
 866        safe. */
 867     c = add_set_enum_cmd ("architecture", class_support,
 868                           arches, &set_architecture_string,
 869                           "Set architecture of target.",
 870                           &setlist);
 871     set_cmd_sfunc (c, set_architecture);
 872     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 873     /* Don't use set_from_show - need to print both auto/manual and
 874        current setting. */
 875     add_cmd ("architecture", class_support, show_architecture,
 876              "Show the current target architecture", &showlist);
 877   }
 878 }
 879
 880
 881 /* Initialize a gdbarch info to values that will be automatically
 882    overridden.  Note: Originally, this ``struct info'' was initialized
 883    using memset(0).  Unfortunatly, that ran into problems, namely
 884    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 885    can explicitly set each field to a well defined value is used.  */
 886
 887 void
 888 gdbarch_info_init (struct gdbarch_info *info)
 889 {
 890   memset (info, 0, sizeof (struct gdbarch_info));
 891   info->byte_order = BFD_ENDIAN_UNKNOWN;
 892 }
 893
 894 /* */
 895
 896 extern initialize_file_ftype _initialize_gdbarch_utils;
 897
 898 void
 899 _initialize_gdbarch_utils (void)
 900 {
 901   struct cmd_list_element *c;
 902   c = add_set_enum_cmd ("endian", class_support,
 903                         endian_enum, &set_endian_string,
 904                         "Set endianness of target.",
 905                         &setlist);
 906   set_cmd_sfunc (c, set_endian);
 907   /* Don't use set_from_show - need to print both auto/manual and
 908      current setting. */
 909   add_cmd ("endian", class_support, show_endian,
 910            "Show the current byte-order", &showlist);
 911 }