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