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