gdb/arch-utils.c

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   4    Free Software Foundation, 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., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24
  25 #include "arch-utils.h"
  26 #include "buildsym.h"
  27 #include "gdbcmd.h"
  28 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
  29 #include "gdb_string.h"
  30 #include "regcache.h"
  31 #include "gdb_assert.h"
  32 #include "sim-regno.h"
  33 #include "gdbcore.h"
  34 #include "osabi.h"
  35 #include "target-descriptions.h"
  36
  37 #include "version.h"
  38
  39 #include "floatformat.h"
  40
  41 int
  42 always_use_struct_convention (int gcc_p, struct type *value_type)
  43 {
  44   return 1;
  45 }
  46
  47 enum return_value_convention
  48 legacy_return_value (struct gdbarch *gdbarch, struct type *valtype,
  49                      struct regcache *regcache, gdb_byte *readbuf,
  50                      const gdb_byte *writebuf)
  51 {
  52   /* NOTE: cagney/2004-06-13: The gcc_p parameter to
  53      USE_STRUCT_CONVENTION isn't used.  */
  54   int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
  55                         || TYPE_CODE (valtype) == TYPE_CODE_UNION
  56                         || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
  57                        && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype));
  58
  59   if (writebuf != NULL)
  60     {
  61       gdb_assert (!struct_return);
  62       /* NOTE: cagney/2004-06-13: See stack.c:return_command.  Old
  63          architectures don't expect STORE_RETURN_VALUE to handle small
  64          structures.  Should not be called with such types.  */
  65       gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT
  66                   && TYPE_CODE (valtype) != TYPE_CODE_UNION);
  67       STORE_RETURN_VALUE (valtype, regcache, writebuf);
  68     }
  69
  70   if (readbuf != NULL)
  71     {
  72       gdb_assert (!struct_return);
  73       EXTRACT_RETURN_VALUE (valtype, regcache, readbuf);
  74     }
  75
  76   if (struct_return)
  77     return RETURN_VALUE_STRUCT_CONVENTION;
  78   else
  79     return RETURN_VALUE_REGISTER_CONVENTION;
  80 }
  81
  82 int
  83 legacy_register_sim_regno (int regnum)
  84 {
  85   /* Only makes sense to supply raw registers.  */
  86   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  87   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  88      suspected that some GDB/SIM combinations may rely on this
  89      behavour.  The default should be one2one_register_sim_regno
  90      (below).  */
  91   if (REGISTER_NAME (regnum) != NULL
  92       && REGISTER_NAME (regnum)[0] != '\0')
  93     return regnum;
  94   else
  95     return LEGACY_SIM_REGNO_IGNORE;
  96 }
  97
  98 CORE_ADDR
  99 generic_skip_trampoline_code (CORE_ADDR pc)
 100 {
 101   return 0;
 102 }
 103
 104 CORE_ADDR
 105 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 106 {
 107   return 0;
 108 }
 109
 110 int
 111 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 112 {
 113   return 0;
 114 }
 115
 116 int
 117 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 118 {
 119   return 0;
 120 }
 121
 122 void
 123 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 124                                        struct regcache *regcache,
 125                                        CORE_ADDR gdb_addr, int gdb_len,
 126                                        CORE_ADDR * rem_addr, int *rem_len)
 127 {
 128   *rem_addr = gdb_addr;
 129   *rem_len = gdb_len;
 130 }
 131
 132 /* Helper functions for INNER_THAN */
 133
 134 int
 135 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 136 {
 137   return (lhs < rhs);
 138 }
 139
 140 int
 141 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 142 {
 143   return (lhs > rhs);
 144 }
 145
 146
 147 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
 148
 149 const struct floatformat *
 150 default_float_format (struct gdbarch *gdbarch)
 151 {
 152   int byte_order = gdbarch_byte_order (gdbarch);
 153   switch (byte_order)
 154     {
 155     case BFD_ENDIAN_BIG:
 156       return &floatformat_ieee_single_big;
 157     case BFD_ENDIAN_LITTLE:
 158       return &floatformat_ieee_single_little;
 159     default:
 160       internal_error (__FILE__, __LINE__,
 161                       _("default_float_format: bad byte order"));
 162     }
 163 }
 164
 165
 166 const struct floatformat *
 167 default_double_format (struct gdbarch *gdbarch)
 168 {
 169   int byte_order = gdbarch_byte_order (gdbarch);
 170   switch (byte_order)
 171     {
 172     case BFD_ENDIAN_BIG:
 173       return &floatformat_ieee_double_big;
 174     case BFD_ENDIAN_LITTLE:
 175       return &floatformat_ieee_double_little;
 176     default:
 177       internal_error (__FILE__, __LINE__,
 178                       _("default_double_format: bad byte order"));
 179     }
 180 }
 181
 182 /* Misc helper functions for targets. */
 183
 184 CORE_ADDR
 185 core_addr_identity (CORE_ADDR addr)
 186 {
 187   return addr;
 188 }
 189
 190 CORE_ADDR
 191 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 192                                      struct target_ops *targ)
 193 {
 194   return addr;
 195 }
 196
 197 int
 198 no_op_reg_to_regnum (int reg)
 199 {
 200   return reg;
 201 }
 202
 203 void
 204 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 205 {
 206   return;
 207 }
 208
 209 void
 210 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 211 {
 212   return;
 213 }
 214
 215 int
 216 cannot_register_not (int regnum)
 217 {
 218   return 0;
 219 }
 220
 221 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 222    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 223    raw.  */
 224
 225 void
 226 legacy_virtual_frame_pointer (CORE_ADDR pc,
 227                               int *frame_regnum,
 228                               LONGEST *frame_offset)
 229 {
 230   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 231      frame pointer of the current PC.  It is assuming that a single
 232      register and an offset can determine this.  I think it should
 233      instead generate a byte code expression as that would work better
 234      with things like Dwarf2's CFI.  */
 235   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 236     *frame_regnum = DEPRECATED_FP_REGNUM;
 237   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 238     *frame_regnum = SP_REGNUM;
 239   else
 240     /* Should this be an internal error?  I guess so, it is reflecting
 241        an architectural limitation in the current design.  */
 242     internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
 243   *frame_offset = 0;
 244 }
 245
 246 /* Assume the world is sane, every register's virtual and real size
 247    is identical.  */
 248
 249 int
 250 generic_register_size (int regnum)
 251 {
 252   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 253   return TYPE_LENGTH (register_type (current_gdbarch, regnum));
 254 }
 255
 256 /* Assume all registers are adjacent.  */
 257
 258 int
 259 generic_register_byte (int regnum)
 260 {
 261   int byte;
 262   int i;
 263   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 264   byte = 0;
 265   for (i = 0; i < regnum; i++)
 266     {
 267       byte += generic_register_size (i);
 268     }
 269   return byte;
 270 }
 271
 272 \f
 273 int
 274 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 275 {
 276 #if defined (DEPRECATED_IN_SIGTRAMP)
 277   return DEPRECATED_IN_SIGTRAMP (pc, name);
 278 #else
 279   return name && strcmp ("_sigtramp", name) == 0;
 280 #endif
 281 }
 282
 283 int
 284 generic_convert_register_p (int regnum, struct type *type)
 285 {
 286   return 0;
 287 }
 288
 289 int
 290 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 291 {
 292   return 0;
 293 }
 294
 295 int
 296 generic_instruction_nullified (struct gdbarch *gdbarch,
 297                                struct regcache *regcache)
 298 {
 299   return 0;
 300 }
 301
 302 \f
 303 /* Functions to manipulate the endianness of the target.  */
 304
 305 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 306
 307 static const char endian_big[] = "big";
 308 static const char endian_little[] = "little";
 309 static const char endian_auto[] = "auto";
 310 static const char *endian_enum[] =
 311 {
 312   endian_big,
 313   endian_little,
 314   endian_auto,
 315   NULL,
 316 };
 317 static const char *set_endian_string;
 318
 319 /* Called by ``show endian''.  */
 320
 321 static void
 322 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 323              const char *value)
 324 {
 325   if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
 326     if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 327       fprintf_unfiltered (file, _("The target endianness is set automatically "
 328                                   "(currently big endian)\n"));
 329     else
 330       fprintf_unfiltered (file, _("The target endianness is set automatically "
 331                            "(currently little endian)\n"));
 332   else
 333     if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 334       fprintf_unfiltered (file,
 335                           _("The target is assumed to be big endian\n"));
 336     else
 337       fprintf_unfiltered (file,
 338                           _("The target is assumed to be little endian\n"));
 339 }
 340
 341 static void
 342 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 343 {
 344   struct gdbarch_info info;
 345
 346   gdbarch_info_init (&info);
 347
 348   if (set_endian_string == endian_auto)
 349     {
 350       target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 351       if (! gdbarch_update_p (info))
 352         internal_error (__FILE__, __LINE__,
 353                         _("set_endian: architecture update failed"));
 354     }
 355   else if (set_endian_string == endian_little)
 356     {
 357       info.byte_order = BFD_ENDIAN_LITTLE;
 358       if (! gdbarch_update_p (info))
 359         printf_unfiltered (_("Little endian target not supported by GDB\n"));
 360       else
 361         target_byte_order_user = BFD_ENDIAN_LITTLE;
 362     }
 363   else if (set_endian_string == endian_big)
 364     {
 365       info.byte_order = BFD_ENDIAN_BIG;
 366       if (! gdbarch_update_p (info))
 367         printf_unfiltered (_("Big endian target not supported by GDB\n"));
 368       else
 369         target_byte_order_user = BFD_ENDIAN_BIG;
 370     }
 371   else
 372     internal_error (__FILE__, __LINE__,
 373                     _("set_endian: bad value"));
 374
 375   show_endian (gdb_stdout, from_tty, NULL, NULL);
 376 }
 377
 378 /* Given SELECTED, a currently selected BFD architecture, and
 379    FROM_TARGET, a BFD architecture reported by the target description,
 380    return what architecture to use.  Either may be NULL; if both are
 381    specified, we use the more specific.  If the two are obviously
 382    incompatible, warn the user.  */
 383
 384 static const struct bfd_arch_info *
 385 choose_architecture_for_target (const struct bfd_arch_info *selected,
 386                                 const struct bfd_arch_info *from_target)
 387 {
 388   const struct bfd_arch_info *compat1, *compat2;
 389
 390   if (selected == NULL)
 391     return from_target;
 392
 393   if (from_target == NULL)
 394     return selected;
 395
 396   /* struct bfd_arch_info objects are singletons: that is, there's
 397      supposed to be exactly one instance for a given machine.  So you
 398      can tell whether two are equivalent by comparing pointers.  */
 399   if (from_target == selected)
 400     return selected;
 401
 402   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 403      incompatible.  But if they are compatible, it returns the 'more
 404      featureful' of the two arches.  That is, if A can run code
 405      written for B, but B can't run code written for A, then it'll
 406      return A.
 407
 408      Some targets (e.g. MIPS as of 2006-12-04) don't fully
 409      implement this, instead always returning NULL or the first
 410      argument.  We detect that case by checking both directions.  */
 411
 412   compat1 = selected->compatible (selected, from_target);
 413   compat2 = from_target->compatible (from_target, selected);
 414
 415   if (compat1 == NULL && compat2 == NULL)
 416     {
 417       warning (_("Selected architecture %s is not compatible "
 418                  "with reported target architecture %s"),
 419                selected->printable_name, from_target->printable_name);
 420       return selected;
 421     }
 422
 423   if (compat1 == NULL)
 424     return compat2;
 425   if (compat2 == NULL)
 426     return compat1;
 427   if (compat1 == compat2)
 428     return compat1;
 429
 430   /* If the two didn't match, but one of them was a default architecture,
 431      assume the more specific one is correct.  This handles the case
 432      where an executable or target description just says "mips", but
 433      the other knows which MIPS variant.  */
 434   if (compat1->the_default)
 435     return compat2;
 436   if (compat2->the_default)
 437     return compat1;
 438
 439   /* We have no idea which one is better.  This is a bug, but not
 440      a critical problem; warn the user.  */
 441   warning (_("Selected architecture %s is ambiguous with "
 442              "reported target architecture %s"),
 443            selected->printable_name, from_target->printable_name);
 444   return selected;
 445 }
 446
 447 /* Functions to manipulate the architecture of the target */
 448
 449 enum set_arch { set_arch_auto, set_arch_manual };
 450
 451 static const struct bfd_arch_info *target_architecture_user;
 452
 453 static const char *set_architecture_string;
 454
 455 const char *
 456 selected_architecture_name (void)
 457 {
 458   if (target_architecture_user == NULL)
 459     return NULL;
 460   else
 461     return set_architecture_string;
 462 }
 463
 464 /* Called if the user enters ``show architecture'' without an
 465    argument. */
 466
 467 static void
 468 show_architecture (struct ui_file *file, int from_tty,
 469                    struct cmd_list_element *c, const char *value)
 470 {
 471   const char *arch;
 472   arch = TARGET_ARCHITECTURE->printable_name;
 473   if (target_architecture_user == NULL)
 474     fprintf_filtered (file, _("\
 475 The target architecture is set automatically (currently %s)\n"), arch);
 476   else
 477     fprintf_filtered (file, _("\
 478 The target architecture is assumed to be %s\n"), arch);
 479 }
 480
 481
 482 /* Called if the user enters ``set architecture'' with or without an
 483    argument. */
 484
 485 static void
 486 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 487 {
 488   struct gdbarch_info info;
 489
 490   gdbarch_info_init (&info);
 491
 492   if (strcmp (set_architecture_string, "auto") == 0)
 493     {
 494       target_architecture_user = NULL;
 495       if (!gdbarch_update_p (info))
 496         internal_error (__FILE__, __LINE__,
 497                         _("could not select an architecture automatically"));
 498     }
 499   else
 500     {
 501       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 502       if (info.bfd_arch_info == NULL)
 503         internal_error (__FILE__, __LINE__,
 504                         _("set_architecture: bfd_scan_arch failed"));
 505       if (gdbarch_update_p (info))
 506         target_architecture_user = info.bfd_arch_info;
 507       else
 508         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 509                            set_architecture_string);
 510     }
 511   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 512 }
 513
 514 /* Try to select a global architecture that matches "info".  Return
 515    non-zero if the attempt succeds.  */
 516 int
 517 gdbarch_update_p (struct gdbarch_info info)
 518 {
 519   struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
 520
 521   /* If there no architecture by that name, reject the request.  */
 522   if (new_gdbarch == NULL)
 523     {
 524       if (gdbarch_debug)
 525         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 526                             "Architecture not found\n");
 527       return 0;
 528     }
 529
 530   /* If it is the same old architecture, accept the request (but don't
 531      swap anything).  */
 532   if (new_gdbarch == current_gdbarch)
 533     {
 534       if (gdbarch_debug)
 535         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 536                             "Architecture 0x%08lx (%s) unchanged\n",
 537                             (long) new_gdbarch,
 538                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 539       return 1;
 540     }
 541
 542   /* It's a new architecture, swap it in.  */
 543   if (gdbarch_debug)
 544     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 545                         "New architecture 0x%08lx (%s) selected\n",
 546                         (long) new_gdbarch,
 547                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 548   deprecated_current_gdbarch_select_hack (new_gdbarch);
 549
 550   return 1;
 551 }
 552
 553 /* Return the architecture for ABFD.  If no suitable architecture
 554    could be find, return NULL.  */
 555
 556 struct gdbarch *
 557 gdbarch_from_bfd (bfd *abfd)
 558 {
 559   struct gdbarch *old_gdbarch = current_gdbarch;
 560   struct gdbarch *new_gdbarch;
 561   struct gdbarch_info info;
 562
 563   /* If we call gdbarch_find_by_info without filling in info.abfd,
 564      then it will use the global exec_bfd.  That's fine if we don't
 565      have one of those either.  And that's the only time we should
 566      reach here with a NULL ABFD argument - when we are discarding
 567      the executable.  */
 568   gdb_assert (abfd != NULL || exec_bfd == NULL);
 569
 570   gdbarch_info_init (&info);
 571   info.abfd = abfd;
 572   return gdbarch_find_by_info (info);
 573 }
 574
 575 /* Set the dynamic target-system-dependent parameters (architecture,
 576    byte-order) using information found in the BFD */
 577
 578 void
 579 set_gdbarch_from_file (bfd *abfd)
 580 {
 581   struct gdbarch *gdbarch;
 582
 583   gdbarch = gdbarch_from_bfd (abfd);
 584   if (gdbarch == NULL)
 585     error (_("Architecture of file not recognized."));
 586   deprecated_current_gdbarch_select_hack (gdbarch);
 587 }
 588
 589 /* Initialize the current architecture.  Update the ``set
 590    architecture'' command so that it specifies a list of valid
 591    architectures.  */
 592
 593 #ifdef DEFAULT_BFD_ARCH
 594 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 595 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 596 #else
 597 static const bfd_arch_info_type *default_bfd_arch;
 598 #endif
 599
 600 #ifdef DEFAULT_BFD_VEC
 601 extern const bfd_target DEFAULT_BFD_VEC;
 602 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 603 #else
 604 static const bfd_target *default_bfd_vec;
 605 #endif
 606
 607 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
 608
 609 void
 610 initialize_current_architecture (void)
 611 {
 612   const char **arches = gdbarch_printable_names ();
 613
 614   /* determine a default architecture and byte order. */
 615   struct gdbarch_info info;
 616   gdbarch_info_init (&info);
 617
 618   /* Find a default architecture. */
 619   if (default_bfd_arch == NULL)
 620     {
 621       /* Choose the architecture by taking the first one
 622          alphabetically. */
 623       const char *chosen = arches[0];
 624       const char **arch;
 625       for (arch = arches; *arch != NULL; arch++)
 626         {
 627           if (strcmp (*arch, chosen) < 0)
 628             chosen = *arch;
 629         }
 630       if (chosen == NULL)
 631         internal_error (__FILE__, __LINE__,
 632                         _("initialize_current_architecture: No arch"));
 633       default_bfd_arch = bfd_scan_arch (chosen);
 634       if (default_bfd_arch == NULL)
 635         internal_error (__FILE__, __LINE__,
 636                         _("initialize_current_architecture: Arch not found"));
 637     }
 638
 639   info.bfd_arch_info = default_bfd_arch;
 640
 641   /* Take several guesses at a byte order.  */
 642   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 643       && default_bfd_vec != NULL)
 644     {
 645       /* Extract BFD's default vector's byte order. */
 646       switch (default_bfd_vec->byteorder)
 647         {
 648         case BFD_ENDIAN_BIG:
 649           default_byte_order = BFD_ENDIAN_BIG;
 650           break;
 651         case BFD_ENDIAN_LITTLE:
 652           default_byte_order = BFD_ENDIAN_LITTLE;
 653           break;
 654         default:
 655           break;
 656         }
 657     }
 658   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 659     {
 660       /* look for ``*el-*'' in the target name. */
 661       const char *chp;
 662       chp = strchr (target_name, '-');
 663       if (chp != NULL
 664           && chp - 2 >= target_name
 665           && strncmp (chp - 2, "el", 2) == 0)
 666         default_byte_order = BFD_ENDIAN_LITTLE;
 667     }
 668   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 669     {
 670       /* Wire it to big-endian!!! */
 671       default_byte_order = BFD_ENDIAN_BIG;
 672     }
 673
 674   info.byte_order = default_byte_order;
 675
 676   if (! gdbarch_update_p (info))
 677     internal_error (__FILE__, __LINE__,
 678                     _("initialize_current_architecture: Selection of "
 679                       "initial architecture failed"));
 680
 681   /* Create the ``set architecture'' command appending ``auto'' to the
 682      list of architectures. */
 683   {
 684     struct cmd_list_element *c;
 685     /* Append ``auto''. */
 686     int nr;
 687     for (nr = 0; arches[nr] != NULL; nr++);
 688     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 689     arches[nr + 0] = "auto";
 690     arches[nr + 1] = NULL;
 691     add_setshow_enum_cmd ("architecture", class_support,
 692                           arches, &set_architecture_string, _("\
 693 Set architecture of target."), _("\
 694 Show architecture of target."), NULL,
 695                           set_architecture, show_architecture,
 696                           &setlist, &showlist);
 697     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 698   }
 699 }
 700
 701
 702 /* Initialize a gdbarch info to values that will be automatically
 703    overridden.  Note: Originally, this ``struct info'' was initialized
 704    using memset(0).  Unfortunately, that ran into problems, namely
 705    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 706    can explicitly set each field to a well defined value is used.  */
 707
 708 void
 709 gdbarch_info_init (struct gdbarch_info *info)
 710 {
 711   memset (info, 0, sizeof (struct gdbarch_info));
 712   info->byte_order = BFD_ENDIAN_UNKNOWN;
 713   info->osabi = GDB_OSABI_UNINITIALIZED;
 714 }
 715
 716 /* Similar to init, but this time fill in the blanks.  Information is
 717    obtained from the global "set ..." options and explicitly
 718    initialized INFO fields.  */
 719
 720 void
 721 gdbarch_info_fill (struct gdbarch_info *info)
 722 {
 723   /* Check for the current file.  */
 724   if (info->abfd == NULL)
 725     info->abfd = exec_bfd;
 726
 727   /* Check for the current target description.  */
 728   if (info->target_desc == NULL)
 729     info->target_desc = target_current_description ();
 730
 731   /* "(gdb) set architecture ...".  */
 732   if (info->bfd_arch_info == NULL
 733       && target_architecture_user)
 734     info->bfd_arch_info = target_architecture_user;
 735   /* From the file.  */
 736   if (info->bfd_arch_info == NULL
 737       && info->abfd != NULL
 738       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 739       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 740     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 741   /* From the target.  */
 742   if (info->target_desc != NULL)
 743     info->bfd_arch_info = choose_architecture_for_target
 744       (info->bfd_arch_info, tdesc_architecture (info->target_desc));
 745   /* From the default.  */
 746   if (info->bfd_arch_info == NULL)
 747     info->bfd_arch_info = default_bfd_arch;
 748
 749   /* "(gdb) set byte-order ...".  */
 750   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 751       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 752     info->byte_order = target_byte_order_user;
 753   /* From the INFO struct.  */
 754   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 755       && info->abfd != NULL)
 756     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 757                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 758                         : BFD_ENDIAN_UNKNOWN);
 759   /* From the default.  */
 760   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 761     info->byte_order = default_byte_order;
 762
 763   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 764   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 765     info->osabi = gdbarch_lookup_osabi (info->abfd);
 766
 767   /* Must have at least filled in the architecture.  */
 768   gdb_assert (info->bfd_arch_info != NULL);
 769 }
 770
 771 /* */
 772
 773 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 774
 775 void
 776 _initialize_gdbarch_utils (void)
 777 {
 778   struct cmd_list_element *c;
 779   add_setshow_enum_cmd ("endian", class_support,
 780                         endian_enum, &set_endian_string, _("\
 781 Set endianness of target."), _("\
 782 Show endianness of target."), NULL,
 783                         set_endian, show_endian,
 784                         &setlist, &showlist);
 785 }