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 = gdbarch_find_by_info (info);
 470
 471   /* If there no architecture by that name, reject the request.  */
 472   if (new_gdbarch == NULL)
 473     {
 474       if (gdbarch_debug)
 475         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 476                             "Architecture not found\n");
 477       return 0;
 478     }
 479
 480   /* If it is the same old architecture, accept the request (but don't
 481      swap anything).  */
 482   if (new_gdbarch == current_gdbarch)
 483     {
 484       if (gdbarch_debug)
 485         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 486                             "Architecture 0x%08lx (%s) unchanged\n",
 487                             (long) new_gdbarch,
 488                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 489       return 1;
 490     }
 491
 492   /* It's a new architecture, swap it in.  */
 493   if (gdbarch_debug)
 494     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 495                         "New architecture 0x%08lx (%s) selected\n",
 496                         (long) new_gdbarch,
 497                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 498   deprecated_current_gdbarch_select_hack (new_gdbarch);
 499
 500   return 1;
 501 }
 502
 503 /* Return the architecture for ABFD.  If no suitable architecture
 504    could be find, return NULL.  */
 505
 506 struct gdbarch *
 507 gdbarch_from_bfd (bfd *abfd)
 508 {
 509   struct gdbarch_info info;
 510
 511   /* If we call gdbarch_find_by_info without filling in info.abfd,
 512      then it will use the global exec_bfd.  That's fine if we don't
 513      have one of those either.  And that's the only time we should
 514      reach here with a NULL ABFD argument - when we are discarding
 515      the executable.  */
 516   gdb_assert (abfd != NULL || exec_bfd == NULL);
 517
 518   gdbarch_info_init (&info);
 519   info.abfd = abfd;
 520   return gdbarch_find_by_info (info);
 521 }
 522
 523 /* Set the dynamic target-system-dependent parameters (architecture,
 524    byte-order) using information found in the BFD */
 525
 526 void
 527 set_gdbarch_from_file (bfd *abfd)
 528 {
 529   struct gdbarch *gdbarch;
 530
 531   gdbarch = gdbarch_from_bfd (abfd);
 532   if (gdbarch == NULL)
 533     error (_("Architecture of file not recognized."));
 534   deprecated_current_gdbarch_select_hack (gdbarch);
 535 }
 536
 537 /* Initialize the current architecture.  Update the ``set
 538    architecture'' command so that it specifies a list of valid
 539    architectures.  */
 540
 541 #ifdef DEFAULT_BFD_ARCH
 542 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 543 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 544 #else
 545 static const bfd_arch_info_type *default_bfd_arch;
 546 #endif
 547
 548 #ifdef DEFAULT_BFD_VEC
 549 extern const bfd_target DEFAULT_BFD_VEC;
 550 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 551 #else
 552 static const bfd_target *default_bfd_vec;
 553 #endif
 554
 555 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
 556
 557 void
 558 initialize_current_architecture (void)
 559 {
 560   const char **arches = gdbarch_printable_names ();
 561
 562   /* determine a default architecture and byte order. */
 563   struct gdbarch_info info;
 564   gdbarch_info_init (&info);
 565
 566   /* Find a default architecture. */
 567   if (default_bfd_arch == NULL)
 568     {
 569       /* Choose the architecture by taking the first one
 570          alphabetically. */
 571       const char *chosen = arches[0];
 572       const char **arch;
 573       for (arch = arches; *arch != NULL; arch++)
 574         {
 575           if (strcmp (*arch, chosen) < 0)
 576             chosen = *arch;
 577         }
 578       if (chosen == NULL)
 579         internal_error (__FILE__, __LINE__,
 580                         _("initialize_current_architecture: No arch"));
 581       default_bfd_arch = bfd_scan_arch (chosen);
 582       if (default_bfd_arch == NULL)
 583         internal_error (__FILE__, __LINE__,
 584                         _("initialize_current_architecture: Arch not found"));
 585     }
 586
 587   info.bfd_arch_info = default_bfd_arch;
 588
 589   /* Take several guesses at a byte order.  */
 590   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 591       && default_bfd_vec != NULL)
 592     {
 593       /* Extract BFD's default vector's byte order. */
 594       switch (default_bfd_vec->byteorder)
 595         {
 596         case BFD_ENDIAN_BIG:
 597           default_byte_order = BFD_ENDIAN_BIG;
 598           break;
 599         case BFD_ENDIAN_LITTLE:
 600           default_byte_order = BFD_ENDIAN_LITTLE;
 601           break;
 602         default:
 603           break;
 604         }
 605     }
 606   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 607     {
 608       /* look for ``*el-*'' in the target name. */
 609       const char *chp;
 610       chp = strchr (target_name, '-');
 611       if (chp != NULL
 612           && chp - 2 >= target_name
 613           && strncmp (chp - 2, "el", 2) == 0)
 614         default_byte_order = BFD_ENDIAN_LITTLE;
 615     }
 616   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 617     {
 618       /* Wire it to big-endian!!! */
 619       default_byte_order = BFD_ENDIAN_BIG;
 620     }
 621
 622   info.byte_order = default_byte_order;
 623
 624   if (! gdbarch_update_p (info))
 625     internal_error (__FILE__, __LINE__,
 626                     _("initialize_current_architecture: Selection of "
 627                       "initial architecture failed"));
 628
 629   /* Create the ``set architecture'' command appending ``auto'' to the
 630      list of architectures. */
 631   {
 632     struct cmd_list_element *c;
 633     /* Append ``auto''. */
 634     int nr;
 635     for (nr = 0; arches[nr] != NULL; nr++);
 636     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 637     arches[nr + 0] = "auto";
 638     arches[nr + 1] = NULL;
 639     add_setshow_enum_cmd ("architecture", class_support,
 640                           arches, &set_architecture_string, _("\
 641 Set architecture of target."), _("\
 642 Show architecture of target."), NULL,
 643                           set_architecture, show_architecture,
 644                           &setlist, &showlist);
 645     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 646   }
 647 }
 648
 649
 650 /* Initialize a gdbarch info to values that will be automatically
 651    overridden.  Note: Originally, this ``struct info'' was initialized
 652    using memset(0).  Unfortunately, that ran into problems, namely
 653    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 654    can explicitly set each field to a well defined value is used.  */
 655
 656 void
 657 gdbarch_info_init (struct gdbarch_info *info)
 658 {
 659   memset (info, 0, sizeof (struct gdbarch_info));
 660   info->byte_order = BFD_ENDIAN_UNKNOWN;
 661   info->osabi = GDB_OSABI_UNINITIALIZED;
 662 }
 663
 664 /* Similar to init, but this time fill in the blanks.  Information is
 665    obtained from the global "set ..." options and explicitly
 666    initialized INFO fields.  */
 667
 668 void
 669 gdbarch_info_fill (struct gdbarch_info *info)
 670 {
 671   /* Check for the current file.  */
 672   if (info->abfd == NULL)
 673     info->abfd = exec_bfd;
 674   if (info->abfd == NULL)
 675     info->abfd = core_bfd;
 676
 677   /* Check for the current target description.  */
 678   if (info->target_desc == NULL)
 679     info->target_desc = target_current_description ();
 680
 681   /* "(gdb) set architecture ...".  */
 682   if (info->bfd_arch_info == NULL
 683       && target_architecture_user)
 684     info->bfd_arch_info = target_architecture_user;
 685   /* From the file.  */
 686   if (info->bfd_arch_info == NULL
 687       && info->abfd != NULL
 688       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 689       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 690     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 691   /* From the target.  */
 692   if (info->target_desc != NULL)
 693     info->bfd_arch_info = choose_architecture_for_target
 694       (info->bfd_arch_info, tdesc_architecture (info->target_desc));
 695   /* From the default.  */
 696   if (info->bfd_arch_info == NULL)
 697     info->bfd_arch_info = default_bfd_arch;
 698
 699   /* "(gdb) set byte-order ...".  */
 700   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 701       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 702     info->byte_order = target_byte_order_user;
 703   /* From the INFO struct.  */
 704   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 705       && info->abfd != NULL)
 706     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 707                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 708                         : BFD_ENDIAN_UNKNOWN);
 709   /* From the default.  */
 710   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 711     info->byte_order = default_byte_order;
 712
 713   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 714   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 715     info->osabi = gdbarch_lookup_osabi (info->abfd);
 716
 717   /* Must have at least filled in the architecture.  */
 718   gdb_assert (info->bfd_arch_info != NULL);
 719 }
 720
 721 /* */
 722
 723 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 724
 725 void
 726 _initialize_gdbarch_utils (void)
 727 {
 728   struct cmd_list_element *c;
 729   add_setshow_enum_cmd ("endian", class_support,
 730                         endian_enum, &set_endian_string, _("\
 731 Set endianness of target."), _("\
 732 Show endianness of target."), NULL,
 733                         set_endian, show_endian,
 734                         &setlist, &showlist);
 735 }