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