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    FROM_TARGET, a BFD architecture reported by the target description,
 324    return what architecture to use.  Either may be NULL; if both are
 325    specified, we use the more specific.  If the two are obviously
 326    incompatible, warn the user.  */
 327
 328 static const struct bfd_arch_info *
 329 choose_architecture_for_target (const struct bfd_arch_info *selected,
 330                                 const struct bfd_arch_info *from_target)
 331 {
 332   const struct bfd_arch_info *compat1, *compat2;
 333
 334   if (selected == NULL)
 335     return from_target;
 336
 337   if (from_target == NULL)
 338     return selected;
 339
 340   /* struct bfd_arch_info objects are singletons: that is, there's
 341      supposed to be exactly one instance for a given machine.  So you
 342      can tell whether two are equivalent by comparing pointers.  */
 343   if (from_target == selected)
 344     return selected;
 345
 346   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 347      incompatible.  But if they are compatible, it returns the 'more
 348      featureful' of the two arches.  That is, if A can run code
 349      written for B, but B can't run code written for A, then it'll
 350      return A.
 351
 352      Some targets (e.g. MIPS as of 2006-12-04) don't fully
 353      implement this, instead always returning NULL or the first
 354      argument.  We detect that case by checking both directions.  */
 355
 356   compat1 = selected->compatible (selected, from_target);
 357   compat2 = from_target->compatible (from_target, selected);
 358
 359   if (compat1 == NULL && compat2 == NULL)
 360     {
 361       warning (_("Selected architecture %s is not compatible "
 362                  "with reported target architecture %s"),
 363                selected->printable_name, from_target->printable_name);
 364       return selected;
 365     }
 366
 367   if (compat1 == NULL)
 368     return compat2;
 369   if (compat2 == NULL)
 370     return compat1;
 371   if (compat1 == compat2)
 372     return compat1;
 373
 374   /* If the two didn't match, but one of them was a default architecture,
 375      assume the more specific one is correct.  This handles the case
 376      where an executable or target description just says "mips", but
 377      the other knows which MIPS variant.  */
 378   if (compat1->the_default)
 379     return compat2;
 380   if (compat2->the_default)
 381     return compat1;
 382
 383   /* We have no idea which one is better.  This is a bug, but not
 384      a critical problem; warn the user.  */
 385   warning (_("Selected architecture %s is ambiguous with "
 386              "reported target architecture %s"),
 387            selected->printable_name, from_target->printable_name);
 388   return selected;
 389 }
 390
 391 /* Functions to manipulate the architecture of the target */
 392
 393 enum set_arch { set_arch_auto, set_arch_manual };
 394
 395 static const struct bfd_arch_info *target_architecture_user;
 396
 397 static const char *set_architecture_string;
 398
 399 const char *
 400 selected_architecture_name (void)
 401 {
 402   if (target_architecture_user == NULL)
 403     return NULL;
 404   else
 405     return set_architecture_string;
 406 }
 407
 408 /* Called if the user enters ``show architecture'' without an
 409    argument. */
 410
 411 static void
 412 show_architecture (struct ui_file *file, int from_tty,
 413                    struct cmd_list_element *c, const char *value)
 414 {
 415   if (target_architecture_user == NULL)
 416     fprintf_filtered (file, _("\
 417 The target architecture is set automatically (currently %s)\n"),
 418                 gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
 419   else
 420     fprintf_filtered (file, _("\
 421 The target architecture is assumed to be %s\n"), set_architecture_string);
 422 }
 423
 424
 425 /* Called if the user enters ``set architecture'' with or without an
 426    argument. */
 427
 428 static void
 429 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 430 {
 431   struct gdbarch_info info;
 432
 433   gdbarch_info_init (&info);
 434
 435   if (strcmp (set_architecture_string, "auto") == 0)
 436     {
 437       target_architecture_user = NULL;
 438       if (!gdbarch_update_p (info))
 439         internal_error (__FILE__, __LINE__,
 440                         _("could not select an architecture automatically"));
 441     }
 442   else
 443     {
 444       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 445       if (info.bfd_arch_info == NULL)
 446         internal_error (__FILE__, __LINE__,
 447                         _("set_architecture: bfd_scan_arch failed"));
 448       if (gdbarch_update_p (info))
 449         target_architecture_user = info.bfd_arch_info;
 450       else
 451         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 452                            set_architecture_string);
 453     }
 454   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 455 }
 456
 457 /* Try to select a global architecture that matches "info".  Return
 458    non-zero if the attempt succeds.  */
 459 int
 460 gdbarch_update_p (struct gdbarch_info info)
 461 {
 462   struct gdbarch *new_gdbarch;
 463
 464   /* Check for the current file.  */
 465   if (info.abfd == NULL)
 466     info.abfd = exec_bfd;
 467   if (info.abfd == NULL)
 468     info.abfd = core_bfd;
 469
 470   /* Check for the current target description.  */
 471   if (info.target_desc == NULL)
 472     info.target_desc = target_current_description ();
 473
 474   new_gdbarch = gdbarch_find_by_info (info);
 475
 476   /* If there no architecture by that name, reject the request.  */
 477   if (new_gdbarch == NULL)
 478     {
 479       if (gdbarch_debug)
 480         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 481                             "Architecture not found\n");
 482       return 0;
 483     }
 484
 485   /* If it is the same old architecture, accept the request (but don't
 486      swap anything).  */
 487   if (new_gdbarch == target_gdbarch)
 488     {
 489       if (gdbarch_debug)
 490         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 491                             "Architecture %s (%s) unchanged\n",
 492                             host_address_to_string (new_gdbarch),
 493                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 494       return 1;
 495     }
 496
 497   /* It's a new architecture, swap it in.  */
 498   if (gdbarch_debug)
 499     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 500                         "New architecture %s (%s) selected\n",
 501                         host_address_to_string (new_gdbarch),
 502                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 503   deprecated_target_gdbarch_select_hack (new_gdbarch);
 504
 505   return 1;
 506 }
 507
 508 /* Return the architecture for ABFD.  If no suitable architecture
 509    could be find, return NULL.  */
 510
 511 struct gdbarch *
 512 gdbarch_from_bfd (bfd *abfd)
 513 {
 514   struct gdbarch_info info;
 515   gdbarch_info_init (&info);
 516   info.abfd = abfd;
 517   return gdbarch_find_by_info (info);
 518 }
 519
 520 /* Set the dynamic target-system-dependent parameters (architecture,
 521    byte-order) using information found in the BFD */
 522
 523 void
 524 set_gdbarch_from_file (bfd *abfd)
 525 {
 526   struct gdbarch_info info;
 527   struct gdbarch *gdbarch;
 528
 529   gdbarch_info_init (&info);
 530   info.abfd = abfd;
 531   info.target_desc = target_current_description ();
 532   gdbarch = gdbarch_find_by_info (info);
 533
 534   if (gdbarch == NULL)
 535     error (_("Architecture of file not recognized."));
 536   deprecated_target_gdbarch_select_hack (gdbarch);
 537 }
 538
 539 /* Initialize the current architecture.  Update the ``set
 540    architecture'' command so that it specifies a list of valid
 541    architectures.  */
 542
 543 #ifdef DEFAULT_BFD_ARCH
 544 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 545 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 546 #else
 547 static const bfd_arch_info_type *default_bfd_arch;
 548 #endif
 549
 550 #ifdef DEFAULT_BFD_VEC
 551 extern const bfd_target DEFAULT_BFD_VEC;
 552 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 553 #else
 554 static const bfd_target *default_bfd_vec;
 555 #endif
 556
 557 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
 558
 559 void
 560 initialize_current_architecture (void)
 561 {
 562   const char **arches = gdbarch_printable_names ();
 563
 564   /* determine a default architecture and byte order. */
 565   struct gdbarch_info info;
 566   gdbarch_info_init (&info);
 567
 568   /* Find a default architecture. */
 569   if (default_bfd_arch == NULL)
 570     {
 571       /* Choose the architecture by taking the first one
 572          alphabetically. */
 573       const char *chosen = arches[0];
 574       const char **arch;
 575       for (arch = arches; *arch != NULL; arch++)
 576         {
 577           if (strcmp (*arch, chosen) < 0)
 578             chosen = *arch;
 579         }
 580       if (chosen == NULL)
 581         internal_error (__FILE__, __LINE__,
 582                         _("initialize_current_architecture: No arch"));
 583       default_bfd_arch = bfd_scan_arch (chosen);
 584       if (default_bfd_arch == NULL)
 585         internal_error (__FILE__, __LINE__,
 586                         _("initialize_current_architecture: Arch not found"));
 587     }
 588
 589   info.bfd_arch_info = default_bfd_arch;
 590
 591   /* Take several guesses at a byte order.  */
 592   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 593       && default_bfd_vec != NULL)
 594     {
 595       /* Extract BFD's default vector's byte order. */
 596       switch (default_bfd_vec->byteorder)
 597         {
 598         case BFD_ENDIAN_BIG:
 599           default_byte_order = BFD_ENDIAN_BIG;
 600           break;
 601         case BFD_ENDIAN_LITTLE:
 602           default_byte_order = BFD_ENDIAN_LITTLE;
 603           break;
 604         default:
 605           break;
 606         }
 607     }
 608   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 609     {
 610       /* look for ``*el-*'' in the target name. */
 611       const char *chp;
 612       chp = strchr (target_name, '-');
 613       if (chp != NULL
 614           && chp - 2 >= target_name
 615           && strncmp (chp - 2, "el", 2) == 0)
 616         default_byte_order = BFD_ENDIAN_LITTLE;
 617     }
 618   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 619     {
 620       /* Wire it to big-endian!!! */
 621       default_byte_order = BFD_ENDIAN_BIG;
 622     }
 623
 624   info.byte_order = default_byte_order;
 625   info.byte_order_for_code = info.byte_order;
 626
 627   if (! gdbarch_update_p (info))
 628     internal_error (__FILE__, __LINE__,
 629                     _("initialize_current_architecture: Selection of "
 630                       "initial architecture failed"));
 631
 632   /* Create the ``set architecture'' command appending ``auto'' to the
 633      list of architectures. */
 634   {
 635     struct cmd_list_element *c;
 636     /* Append ``auto''. */
 637     int nr;
 638     for (nr = 0; arches[nr] != NULL; nr++);
 639     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 640     arches[nr + 0] = "auto";
 641     arches[nr + 1] = NULL;
 642     add_setshow_enum_cmd ("architecture", class_support,
 643                           arches, &set_architecture_string, _("\
 644 Set architecture of target."), _("\
 645 Show architecture of target."), NULL,
 646                           set_architecture, show_architecture,
 647                           &setlist, &showlist);
 648     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 649   }
 650 }
 651
 652
 653 /* Initialize a gdbarch info to values that will be automatically
 654    overridden.  Note: Originally, this ``struct info'' was initialized
 655    using memset(0).  Unfortunately, that ran into problems, namely
 656    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 657    can explicitly set each field to a well defined value is used.  */
 658
 659 void
 660 gdbarch_info_init (struct gdbarch_info *info)
 661 {
 662   memset (info, 0, sizeof (struct gdbarch_info));
 663   info->byte_order = BFD_ENDIAN_UNKNOWN;
 664   info->byte_order_for_code = info->byte_order;
 665   info->osabi = GDB_OSABI_UNINITIALIZED;
 666 }
 667
 668 /* Similar to init, but this time fill in the blanks.  Information is
 669    obtained from the global "set ..." options and explicitly
 670    initialized INFO fields.  */
 671
 672 void
 673 gdbarch_info_fill (struct gdbarch_info *info)
 674 {
 675   /* "(gdb) set architecture ...".  */
 676   if (info->bfd_arch_info == NULL
 677       && target_architecture_user)
 678     info->bfd_arch_info = target_architecture_user;
 679   /* From the file.  */
 680   if (info->bfd_arch_info == NULL
 681       && info->abfd != NULL
 682       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 683       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 684     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 685   /* From the target.  */
 686   if (info->target_desc != NULL)
 687     info->bfd_arch_info = choose_architecture_for_target
 688       (info->bfd_arch_info, tdesc_architecture (info->target_desc));
 689   /* From the default.  */
 690   if (info->bfd_arch_info == NULL)
 691     info->bfd_arch_info = default_bfd_arch;
 692
 693   /* "(gdb) set byte-order ...".  */
 694   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 695       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 696     info->byte_order = target_byte_order_user;
 697   /* From the INFO struct.  */
 698   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 699       && info->abfd != NULL)
 700     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 701                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 702                         : BFD_ENDIAN_UNKNOWN);
 703   /* From the default.  */
 704   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 705     info->byte_order = default_byte_order;
 706   info->byte_order_for_code = info->byte_order;
 707
 708   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 709   /* From the manual override, or from file.  */
 710   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 711     info->osabi = gdbarch_lookup_osabi (info->abfd);
 712   /* From the target.  */
 713   if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
 714     info->osabi = tdesc_osabi (info->target_desc);
 715   /* From the configured default.  */
 716 #ifdef GDB_OSABI_DEFAULT
 717   if (info->osabi == GDB_OSABI_UNKNOWN)
 718     info->osabi = GDB_OSABI_DEFAULT;
 719 #endif
 720
 721   /* Must have at least filled in the architecture.  */
 722   gdb_assert (info->bfd_arch_info != NULL);
 723 }
 724
 725 /* Return "current" architecture.  If the target is running, this is the
 726    architecture of the selected frame.  Otherwise, the "current" architecture
 727    defaults to the target architecture.
 728
 729    This function should normally be called solely by the command interpreter
 730    routines to determine the architecture to execute a command in.  */
 731 struct gdbarch *
 732 get_current_arch (void)
 733 {
 734   if (has_stack_frames ())
 735     return get_frame_arch (get_selected_frame (NULL));
 736   else
 737     return target_gdbarch;
 738 }
 739
 740 /* */
 741
 742 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 743
 744 void
 745 _initialize_gdbarch_utils (void)
 746 {
 747   struct cmd_list_element *c;
 748   add_setshow_enum_cmd ("endian", class_support,
 749                         endian_enum, &set_endian_string, _("\
 750 Set endianness of target."), _("\
 751 Show endianness of target."), NULL,
 752                         set_endian, show_endian,
 753                         &setlist, &showlist);
 754 }