gdb/arch-utils.c

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