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