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