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 2 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, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24
  25 #include "arch-utils.h"
  26 #include "buildsym.h"
  27 #include "gdbcmd.h"
  28 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
  29 #include "gdb_string.h"
  30 #include "regcache.h"
  31 #include "gdb_assert.h"
  32 #include "sim-regno.h"
  33 #include "gdbcore.h"
  34 #include "osabi.h"
  35 #include "target-descriptions.h"
  36
  37 #include "version.h"
  38
  39 #include "floatformat.h"
  40
  41 int
  42 always_use_struct_convention (int gcc_p, struct type *value_type)
  43 {
  44   return 1;
  45 }
  46
  47 enum return_value_convention
  48 legacy_return_value (struct gdbarch *gdbarch, struct type *valtype,
  49                      struct regcache *regcache, gdb_byte *readbuf,
  50                      const gdb_byte *writebuf)
  51 {
  52   /* NOTE: cagney/2004-06-13: The gcc_p parameter to
  53      USE_STRUCT_CONVENTION isn't used.  */
  54   int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
  55                         || TYPE_CODE (valtype) == TYPE_CODE_UNION
  56                         || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
  57                        && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype));
  58
  59   if (writebuf != NULL)
  60     {
  61       gdb_assert (!struct_return);
  62       /* NOTE: cagney/2004-06-13: See stack.c:return_command.  Old
  63          architectures don't expect STORE_RETURN_VALUE to handle small
  64          structures.  Should not be called with such types.  */
  65       gdb_assert (TYPE_CODE (valtype) != TYPE_CODE_STRUCT
  66                   && TYPE_CODE (valtype) != TYPE_CODE_UNION);
  67       STORE_RETURN_VALUE (valtype, regcache, writebuf);
  68     }
  69
  70   if (readbuf != NULL)
  71     {
  72       gdb_assert (!struct_return);
  73       EXTRACT_RETURN_VALUE (valtype, regcache, readbuf);
  74     }
  75
  76   if (struct_return)
  77     return RETURN_VALUE_STRUCT_CONVENTION;
  78   else
  79     return RETURN_VALUE_REGISTER_CONVENTION;
  80 }
  81
  82 int
  83 legacy_register_sim_regno (int regnum)
  84 {
  85   /* Only makes sense to supply raw registers.  */
  86   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  87   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  88      suspected that some GDB/SIM combinations may rely on this
  89      behavour.  The default should be one2one_register_sim_regno
  90      (below).  */
  91   if (REGISTER_NAME (regnum) != NULL
  92       && REGISTER_NAME (regnum)[0] != '\0')
  93     return regnum;
  94   else
  95     return LEGACY_SIM_REGNO_IGNORE;
  96 }
  97
  98 CORE_ADDR
  99 generic_skip_trampoline_code (CORE_ADDR pc)
 100 {
 101   return 0;
 102 }
 103
 104 CORE_ADDR
 105 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 106 {
 107   return 0;
 108 }
 109
 110 int
 111 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 112 {
 113   return 0;
 114 }
 115
 116 int
 117 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 118 {
 119   return 0;
 120 }
 121
 122 void
 123 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 124                                        struct regcache *regcache,
 125                                        CORE_ADDR gdb_addr, int gdb_len,
 126                                        CORE_ADDR * rem_addr, int *rem_len)
 127 {
 128   *rem_addr = gdb_addr;
 129   *rem_len = gdb_len;
 130 }
 131
 132 /* Helper functions for 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 (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 (int regnum)
 181 {
 182   return 0;
 183 }
 184
 185 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 186    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 187    raw.  */
 188
 189 void
 190 legacy_virtual_frame_pointer (CORE_ADDR pc,
 191                               int *frame_regnum,
 192                               LONGEST *frame_offset)
 193 {
 194   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 195      frame pointer of the current PC.  It is assuming that a single
 196      register and an offset can determine this.  I think it should
 197      instead generate a byte code expression as that would work better
 198      with things like Dwarf2's CFI.  */
 199   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 200     *frame_regnum = DEPRECATED_FP_REGNUM;
 201   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 202     *frame_regnum = SP_REGNUM;
 203   else
 204     /* Should this be an internal error?  I guess so, it is reflecting
 205        an architectural limitation in the current design.  */
 206     internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
 207   *frame_offset = 0;
 208 }
 209
 210 \f
 211 int
 212 generic_convert_register_p (int regnum, struct type *type)
 213 {
 214   return 0;
 215 }
 216
 217 int
 218 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 219 {
 220   return 0;
 221 }
 222
 223 int
 224 generic_instruction_nullified (struct gdbarch *gdbarch,
 225                                struct regcache *regcache)
 226 {
 227   return 0;
 228 }
 229
 230 int
 231 default_remote_register_number (struct gdbarch *gdbarch,
 232                                 int regno)
 233 {
 234   return regno;
 235 }
 236
 237 \f
 238 /* Functions to manipulate the endianness of the target.  */
 239
 240 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 241
 242 static const char endian_big[] = "big";
 243 static const char endian_little[] = "little";
 244 static const char endian_auto[] = "auto";
 245 static const char *endian_enum[] =
 246 {
 247   endian_big,
 248   endian_little,
 249   endian_auto,
 250   NULL,
 251 };
 252 static const char *set_endian_string;
 253
 254 enum bfd_endian
 255 selected_byte_order (void)
 256 {
 257   if (target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 258     return TARGET_BYTE_ORDER;
 259   else
 260     return BFD_ENDIAN_UNKNOWN;
 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 (TARGET_BYTE_ORDER == 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 == 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   const char *arch;
 416   arch = TARGET_ARCHITECTURE->printable_name;
 417   if (target_architecture_user == NULL)
 418     fprintf_filtered (file, _("\
 419 The target architecture is set automatically (currently %s)\n"), arch);
 420   else
 421     fprintf_filtered (file, _("\
 422 The target architecture is assumed to be %s\n"), arch);
 423 }
 424
 425
 426 /* Called if the user enters ``set architecture'' with or without an
 427    argument. */
 428
 429 static void
 430 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 431 {
 432   struct gdbarch_info info;
 433
 434   gdbarch_info_init (&info);
 435
 436   if (strcmp (set_architecture_string, "auto") == 0)
 437     {
 438       target_architecture_user = NULL;
 439       if (!gdbarch_update_p (info))
 440         internal_error (__FILE__, __LINE__,
 441                         _("could not select an architecture automatically"));
 442     }
 443   else
 444     {
 445       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 446       if (info.bfd_arch_info == NULL)
 447         internal_error (__FILE__, __LINE__,
 448                         _("set_architecture: bfd_scan_arch failed"));
 449       if (gdbarch_update_p (info))
 450         target_architecture_user = info.bfd_arch_info;
 451       else
 452         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 453                            set_architecture_string);
 454     }
 455   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 456 }
 457
 458 /* Try to select a global architecture that matches "info".  Return
 459    non-zero if the attempt succeds.  */
 460 int
 461 gdbarch_update_p (struct gdbarch_info info)
 462 {
 463   struct gdbarch *new_gdbarch = gdbarch_find_by_info (info);
 464
 465   /* If there no architecture by that name, reject the request.  */
 466   if (new_gdbarch == NULL)
 467     {
 468       if (gdbarch_debug)
 469         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 470                             "Architecture not found\n");
 471       return 0;
 472     }
 473
 474   /* If it is the same old architecture, accept the request (but don't
 475      swap anything).  */
 476   if (new_gdbarch == current_gdbarch)
 477     {
 478       if (gdbarch_debug)
 479         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 480                             "Architecture 0x%08lx (%s) unchanged\n",
 481                             (long) new_gdbarch,
 482                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 483       return 1;
 484     }
 485
 486   /* It's a new architecture, swap it in.  */
 487   if (gdbarch_debug)
 488     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 489                         "New architecture 0x%08lx (%s) selected\n",
 490                         (long) new_gdbarch,
 491                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 492   deprecated_current_gdbarch_select_hack (new_gdbarch);
 493
 494   return 1;
 495 }
 496
 497 /* Return the architecture for ABFD.  If no suitable architecture
 498    could be find, return NULL.  */
 499
 500 struct gdbarch *
 501 gdbarch_from_bfd (bfd *abfd)
 502 {
 503   struct gdbarch *old_gdbarch = current_gdbarch;
 504   struct gdbarch *new_gdbarch;
 505   struct gdbarch_info info;
 506
 507   /* If we call gdbarch_find_by_info without filling in info.abfd,
 508      then it will use the global exec_bfd.  That's fine if we don't
 509      have one of those either.  And that's the only time we should
 510      reach here with a NULL ABFD argument - when we are discarding
 511      the executable.  */
 512   gdb_assert (abfd != NULL || exec_bfd == NULL);
 513
 514   gdbarch_info_init (&info);
 515   info.abfd = abfd;
 516   return gdbarch_find_by_info (info);
 517 }
 518
 519 /* Set the dynamic target-system-dependent parameters (architecture,
 520    byte-order) using information found in the BFD */
 521
 522 void
 523 set_gdbarch_from_file (bfd *abfd)
 524 {
 525   struct gdbarch *gdbarch;
 526
 527   gdbarch = gdbarch_from_bfd (abfd);
 528   if (gdbarch == NULL)
 529     error (_("Architecture of file not recognized."));
 530   deprecated_current_gdbarch_select_hack (gdbarch);
 531 }
 532
 533 /* Initialize the current architecture.  Update the ``set
 534    architecture'' command so that it specifies a list of valid
 535    architectures.  */
 536
 537 #ifdef DEFAULT_BFD_ARCH
 538 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 539 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 540 #else
 541 static const bfd_arch_info_type *default_bfd_arch;
 542 #endif
 543
 544 #ifdef DEFAULT_BFD_VEC
 545 extern const bfd_target DEFAULT_BFD_VEC;
 546 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 547 #else
 548 static const bfd_target *default_bfd_vec;
 549 #endif
 550
 551 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
 552
 553 void
 554 initialize_current_architecture (void)
 555 {
 556   const char **arches = gdbarch_printable_names ();
 557
 558   /* determine a default architecture and byte order. */
 559   struct gdbarch_info info;
 560   gdbarch_info_init (&info);
 561
 562   /* Find a default architecture. */
 563   if (default_bfd_arch == NULL)
 564     {
 565       /* Choose the architecture by taking the first one
 566          alphabetically. */
 567       const char *chosen = arches[0];
 568       const char **arch;
 569       for (arch = arches; *arch != NULL; arch++)
 570         {
 571           if (strcmp (*arch, chosen) < 0)
 572             chosen = *arch;
 573         }
 574       if (chosen == NULL)
 575         internal_error (__FILE__, __LINE__,
 576                         _("initialize_current_architecture: No arch"));
 577       default_bfd_arch = bfd_scan_arch (chosen);
 578       if (default_bfd_arch == NULL)
 579         internal_error (__FILE__, __LINE__,
 580                         _("initialize_current_architecture: Arch not found"));
 581     }
 582
 583   info.bfd_arch_info = default_bfd_arch;
 584
 585   /* Take several guesses at a byte order.  */
 586   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 587       && default_bfd_vec != NULL)
 588     {
 589       /* Extract BFD's default vector's byte order. */
 590       switch (default_bfd_vec->byteorder)
 591         {
 592         case BFD_ENDIAN_BIG:
 593           default_byte_order = BFD_ENDIAN_BIG;
 594           break;
 595         case BFD_ENDIAN_LITTLE:
 596           default_byte_order = BFD_ENDIAN_LITTLE;
 597           break;
 598         default:
 599           break;
 600         }
 601     }
 602   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 603     {
 604       /* look for ``*el-*'' in the target name. */
 605       const char *chp;
 606       chp = strchr (target_name, '-');
 607       if (chp != NULL
 608           && chp - 2 >= target_name
 609           && strncmp (chp - 2, "el", 2) == 0)
 610         default_byte_order = BFD_ENDIAN_LITTLE;
 611     }
 612   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 613     {
 614       /* Wire it to big-endian!!! */
 615       default_byte_order = BFD_ENDIAN_BIG;
 616     }
 617
 618   info.byte_order = default_byte_order;
 619
 620   if (! gdbarch_update_p (info))
 621     internal_error (__FILE__, __LINE__,
 622                     _("initialize_current_architecture: Selection of "
 623                       "initial architecture failed"));
 624
 625   /* Create the ``set architecture'' command appending ``auto'' to the
 626      list of architectures. */
 627   {
 628     struct cmd_list_element *c;
 629     /* Append ``auto''. */
 630     int nr;
 631     for (nr = 0; arches[nr] != NULL; nr++);
 632     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 633     arches[nr + 0] = "auto";
 634     arches[nr + 1] = NULL;
 635     add_setshow_enum_cmd ("architecture", class_support,
 636                           arches, &set_architecture_string, _("\
 637 Set architecture of target."), _("\
 638 Show architecture of target."), NULL,
 639                           set_architecture, show_architecture,
 640                           &setlist, &showlist);
 641     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 642   }
 643 }
 644
 645
 646 /* Initialize a gdbarch info to values that will be automatically
 647    overridden.  Note: Originally, this ``struct info'' was initialized
 648    using memset(0).  Unfortunately, that ran into problems, namely
 649    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 650    can explicitly set each field to a well defined value is used.  */
 651
 652 void
 653 gdbarch_info_init (struct gdbarch_info *info)
 654 {
 655   memset (info, 0, sizeof (struct gdbarch_info));
 656   info->byte_order = BFD_ENDIAN_UNKNOWN;
 657   info->osabi = GDB_OSABI_UNINITIALIZED;
 658 }
 659
 660 /* Similar to init, but this time fill in the blanks.  Information is
 661    obtained from the global "set ..." options and explicitly
 662    initialized INFO fields.  */
 663
 664 void
 665 gdbarch_info_fill (struct gdbarch_info *info)
 666 {
 667   /* Check for the current file.  */
 668   if (info->abfd == NULL)
 669     info->abfd = exec_bfd;
 670
 671   /* Check for the current target description.  */
 672   if (info->target_desc == NULL)
 673     info->target_desc = target_current_description ();
 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
 707   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 708   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 709     info->osabi = gdbarch_lookup_osabi (info->abfd);
 710
 711   /* Must have at least filled in the architecture.  */
 712   gdb_assert (info->bfd_arch_info != NULL);
 713 }
 714
 715 /* */
 716
 717 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 718
 719 void
 720 _initialize_gdbarch_utils (void)
 721 {
 722   struct cmd_list_element *c;
 723   add_setshow_enum_cmd ("endian", class_support,
 724                         endian_enum, &set_endian_string, _("\
 725 Set endianness of target."), _("\
 726 Show endianness of target."), NULL,
 727                         set_endian, show_endian,
 728                         &setlist, &showlist);
 729 }