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