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