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