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