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