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