gdb/arch-utils.c

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
   4    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., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, 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
  34 #include "osabi.h"
  35
  36 #include "version.h"
  37
  38 #include "floatformat.h"
  39
  40 /* Implementation of extract return value that grubs around in the
  41    register cache.  */
  42 void
  43 legacy_extract_return_value (struct type *type, struct regcache *regcache,
  44                              void *valbuf)
  45 {
  46   char *registers = deprecated_grub_regcache_for_registers (regcache);
  47   bfd_byte *buf = valbuf;
  48   DEPRECATED_EXTRACT_RETURN_VALUE (type, registers, buf); /* OK */
  49 }
  50
  51 /* Implementation of store return value that grubs the register cache.
  52    Takes a local copy of the buffer to avoid const problems.  */
  53 void
  54 legacy_store_return_value (struct type *type, struct regcache *regcache,
  55                            const void *buf)
  56 {
  57   bfd_byte *b = alloca (TYPE_LENGTH (type));
  58   gdb_assert (regcache == current_regcache);
  59   memcpy (b, buf, TYPE_LENGTH (type));
  60   DEPRECATED_STORE_RETURN_VALUE (type, b);
  61 }
  62
  63
  64 int
  65 always_use_struct_convention (int gcc_p, struct type *value_type)
  66 {
  67   return 1;
  68 }
  69
  70
  71 int
  72 legacy_register_sim_regno (int regnum)
  73 {
  74   /* Only makes sense to supply raw registers.  */
  75   gdb_assert (regnum >= 0 && regnum < NUM_REGS);
  76   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  77      suspected that some GDB/SIM combinations may rely on this
  78      behavour.  The default should be one2one_register_sim_regno
  79      (below).  */
  80   if (REGISTER_NAME (regnum) != NULL
  81       && REGISTER_NAME (regnum)[0] != '\0')
  82     return regnum;
  83   else
  84     return LEGACY_SIM_REGNO_IGNORE;
  85 }
  86
  87 int
  88 generic_frameless_function_invocation_not (struct frame_info *fi)
  89 {
  90   return 0;
  91 }
  92
  93 int
  94 generic_return_value_on_stack_not (struct type *type)
  95 {
  96   return 0;
  97 }
  98
  99 CORE_ADDR
 100 generic_skip_trampoline_code (CORE_ADDR pc)
 101 {
 102   return 0;
 103 }
 104
 105 CORE_ADDR
 106 generic_skip_solib_resolver (CORE_ADDR pc)
 107 {
 108   return 0;
 109 }
 110
 111 int
 112 generic_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 113 {
 114   return 0;
 115 }
 116
 117 int
 118 generic_in_solib_return_trampoline (CORE_ADDR pc, char *name)
 119 {
 120   return 0;
 121 }
 122
 123 int
 124 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 125 {
 126   return 0;
 127 }
 128
 129 #if defined (CALL_DUMMY)
 130 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
 131 #else
 132 LONGEST legacy_call_dummy_words[1];
 133 #endif
 134 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
 135
 136 void
 137 generic_remote_translate_xfer_address (struct gdbarch *gdbarch,
 138                                        struct regcache *regcache,
 139                                        CORE_ADDR gdb_addr, int gdb_len,
 140                                        CORE_ADDR * rem_addr, int *rem_len)
 141 {
 142   *rem_addr = gdb_addr;
 143   *rem_len = gdb_len;
 144 }
 145
 146 int
 147 generic_prologue_frameless_p (CORE_ADDR ip)
 148 {
 149   return ip == SKIP_PROLOGUE (ip);
 150 }
 151
 152 /* Helper functions for INNER_THAN */
 153
 154 int
 155 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 156 {
 157   return (lhs < rhs);
 158 }
 159
 160 int
 161 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 162 {
 163   return (lhs > rhs);
 164 }
 165
 166
 167 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
 168
 169 const struct floatformat *
 170 default_float_format (struct gdbarch *gdbarch)
 171 {
 172   int byte_order = gdbarch_byte_order (gdbarch);
 173   switch (byte_order)
 174     {
 175     case BFD_ENDIAN_BIG:
 176       return &floatformat_ieee_single_big;
 177     case BFD_ENDIAN_LITTLE:
 178       return &floatformat_ieee_single_little;
 179     default:
 180       internal_error (__FILE__, __LINE__,
 181                       "default_float_format: bad byte order");
 182     }
 183 }
 184
 185
 186 const struct floatformat *
 187 default_double_format (struct gdbarch *gdbarch)
 188 {
 189   int byte_order = gdbarch_byte_order (gdbarch);
 190   switch (byte_order)
 191     {
 192     case BFD_ENDIAN_BIG:
 193       return &floatformat_ieee_double_big;
 194     case BFD_ENDIAN_LITTLE:
 195       return &floatformat_ieee_double_little;
 196     default:
 197       internal_error (__FILE__, __LINE__,
 198                       "default_double_format: bad byte order");
 199     }
 200 }
 201
 202 /* Misc helper functions for targets. */
 203
 204 int
 205 deprecated_register_convertible_not (int num)
 206 {
 207   return 0;
 208 }
 209
 210
 211 CORE_ADDR
 212 core_addr_identity (CORE_ADDR addr)
 213 {
 214   return addr;
 215 }
 216
 217 CORE_ADDR
 218 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 219                                      struct target_ops *targ)
 220 {
 221   return addr;
 222 }
 223
 224 int
 225 no_op_reg_to_regnum (int reg)
 226 {
 227   return reg;
 228 }
 229
 230 CORE_ADDR
 231 deprecated_init_frame_pc_default (int fromleaf, struct frame_info *prev)
 232 {
 233   if (fromleaf && DEPRECATED_SAVED_PC_AFTER_CALL_P ())
 234     return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev));
 235   else if (get_next_frame (prev) != NULL)
 236     return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev));
 237   else
 238     return read_pc ();
 239 }
 240
 241 void
 242 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 243 {
 244   return;
 245 }
 246
 247 void
 248 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 249 {
 250   return;
 251 }
 252
 253 int
 254 cannot_register_not (int regnum)
 255 {
 256   return 0;
 257 }
 258
 259 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 260    there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
 261    raw.  */
 262
 263 void
 264 legacy_virtual_frame_pointer (CORE_ADDR pc,
 265                               int *frame_regnum,
 266                               LONGEST *frame_offset)
 267 {
 268   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 269      frame pointer of the current PC.  It is assuming that a single
 270      register and an offset can determine this.  I think it should
 271      instead generate a byte code expression as that would work better
 272      with things like Dwarf2's CFI.  */
 273   if (DEPRECATED_FP_REGNUM >= 0 && DEPRECATED_FP_REGNUM < NUM_REGS)
 274     *frame_regnum = DEPRECATED_FP_REGNUM;
 275   else if (SP_REGNUM >= 0 && SP_REGNUM < NUM_REGS)
 276     *frame_regnum = SP_REGNUM;
 277   else
 278     /* Should this be an internal error?  I guess so, it is reflecting
 279        an architectural limitation in the current design.  */
 280     internal_error (__FILE__, __LINE__, "No virtual frame pointer available");
 281   *frame_offset = 0;
 282 }
 283
 284 /* Assume the world is sane, every register's virtual and real size
 285    is identical.  */
 286
 287 int
 288 generic_register_size (int regnum)
 289 {
 290   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 291   if (gdbarch_register_type_p (current_gdbarch))
 292     return TYPE_LENGTH (gdbarch_register_type (current_gdbarch, regnum));
 293   else
 294     /* FIXME: cagney/2003-03-01: Once all architectures implement
 295        gdbarch_register_type(), this entire function can go away.  It
 296        is made obsolete by register_size().  */
 297     return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum)); /* OK */
 298 }
 299
 300 /* Assume all registers are adjacent.  */
 301
 302 int
 303 generic_register_byte (int regnum)
 304 {
 305   int byte;
 306   int i;
 307   gdb_assert (regnum >= 0 && regnum < NUM_REGS + NUM_PSEUDO_REGS);
 308   byte = 0;
 309   for (i = 0; i < regnum; i++)
 310     {
 311       byte += generic_register_size (i);
 312     }
 313   return byte;
 314 }
 315
 316 \f
 317 int
 318 legacy_pc_in_sigtramp (CORE_ADDR pc, char *name)
 319 {
 320 #if !defined (IN_SIGTRAMP)
 321   if (SIGTRAMP_START_P ())
 322     return (pc) >= SIGTRAMP_START (pc) && (pc) < SIGTRAMP_END (pc);
 323   else
 324     return name && strcmp ("_sigtramp", name) == 0;
 325 #else
 326   return IN_SIGTRAMP (pc, name);
 327 #endif
 328 }
 329
 330 int
 331 legacy_convert_register_p (int regnum, struct type *type)
 332 {
 333   return DEPRECATED_REGISTER_CONVERTIBLE (regnum);
 334 }
 335
 336 void
 337 legacy_register_to_value (struct frame_info *frame, int regnum,
 338                           struct type *type, void *to)
 339 {
 340   char from[MAX_REGISTER_SIZE];
 341   get_frame_register (frame, regnum, from);
 342   DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to);
 343 }
 344
 345 void
 346 legacy_value_to_register (struct frame_info *frame, int regnum,
 347                           struct type *type, const void *tmp)
 348 {
 349   char to[MAX_REGISTER_SIZE];
 350   char *from = alloca (TYPE_LENGTH (type));
 351   memcpy (from, from, TYPE_LENGTH (type));
 352   DEPRECATED_REGISTER_CONVERT_TO_RAW (type, regnum, from, to);
 353   put_frame_register (frame, regnum, to);
 354 }
 355
 356 int
 357 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 358 {
 359   if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
 360       && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation, type))
 361     {
 362       CHECK_TYPEDEF (type);
 363
 364       return (TYPE_CODE (type) == TYPE_CODE_STRUCT
 365               || TYPE_CODE (type) == TYPE_CODE_UNION
 366               || TYPE_CODE (type) == TYPE_CODE_SET
 367               || TYPE_CODE (type) == TYPE_CODE_BITSTRING);
 368     }
 369
 370   return 0;
 371 }
 372
 373 \f
 374 /* Functions to manipulate the endianness of the target.  */
 375
 376 /* ``target_byte_order'' is only used when non- multi-arch.
 377    Multi-arch targets obtain the current byte order using the
 378    TARGET_BYTE_ORDER gdbarch method.
 379
 380    The choice of initial value is entirely arbitrary.  During startup,
 381    the function initialize_current_architecture() updates this value
 382    based on default byte-order information extracted from BFD.  */
 383 int target_byte_order = BFD_ENDIAN_BIG;
 384 int target_byte_order_auto = 1;
 385
 386 static const char endian_big[] = "big";
 387 static const char endian_little[] = "little";
 388 static const char endian_auto[] = "auto";
 389 static const char *endian_enum[] =
 390 {
 391   endian_big,
 392   endian_little,
 393   endian_auto,
 394   NULL,
 395 };
 396 static const char *set_endian_string;
 397
 398 /* Called by ``show endian''.  */
 399
 400 static void
 401 show_endian (char *args, int from_tty)
 402 {
 403   if (TARGET_BYTE_ORDER_AUTO)
 404     printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
 405                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 406   else
 407     printf_unfiltered ("The target is assumed to be %s endian\n",
 408                        (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? "big" : "little"));
 409 }
 410
 411 static void
 412 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 413 {
 414   if (set_endian_string == endian_auto)
 415     {
 416       target_byte_order_auto = 1;
 417     }
 418   else if (set_endian_string == endian_little)
 419     {
 420       struct gdbarch_info info;
 421       target_byte_order_auto = 0;
 422       gdbarch_info_init (&info);
 423       info.byte_order = BFD_ENDIAN_LITTLE;
 424       if (! gdbarch_update_p (info))
 425         printf_unfiltered ("Little endian target not supported by GDB\n");
 426     }
 427   else if (set_endian_string == endian_big)
 428     {
 429       struct gdbarch_info info;
 430       target_byte_order_auto = 0;
 431       gdbarch_info_init (&info);
 432       info.byte_order = BFD_ENDIAN_BIG;
 433       if (! gdbarch_update_p (info))
 434         printf_unfiltered ("Big endian target not supported by GDB\n");
 435     }
 436   else
 437     internal_error (__FILE__, __LINE__,
 438                     "set_endian: bad value");
 439   show_endian (NULL, from_tty);
 440 }
 441
 442 /* Functions to manipulate the architecture of the target */
 443
 444 enum set_arch { set_arch_auto, set_arch_manual };
 445
 446 int target_architecture_auto = 1;
 447
 448 const char *set_architecture_string;
 449
 450 /* Called if the user enters ``show architecture'' without an
 451    argument. */
 452
 453 static void
 454 show_architecture (char *args, int from_tty)
 455 {
 456   const char *arch;
 457   arch = TARGET_ARCHITECTURE->printable_name;
 458   if (target_architecture_auto)
 459     printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
 460   else
 461     printf_filtered ("The target architecture is assumed to be %s\n", arch);
 462 }
 463
 464
 465 /* Called if the user enters ``set architecture'' with or without an
 466    argument. */
 467
 468 static void
 469 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 470 {
 471   if (strcmp (set_architecture_string, "auto") == 0)
 472     {
 473       target_architecture_auto = 1;
 474     }
 475   else
 476     {
 477       struct gdbarch_info info;
 478       gdbarch_info_init (&info);
 479       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 480       if (info.bfd_arch_info == NULL)
 481         internal_error (__FILE__, __LINE__,
 482                         "set_architecture: bfd_scan_arch failed");
 483       if (gdbarch_update_p (info))
 484         target_architecture_auto = 0;
 485       else
 486         printf_unfiltered ("Architecture `%s' not recognized.\n",
 487                            set_architecture_string);
 488     }
 489   show_architecture (NULL, from_tty);
 490 }
 491
 492 /* FIXME: kettenis/20031124: Of the functions that follow, only
 493    gdbarch_from_bfd is supposed to survive.  The others will
 494    dissappear since in the future GDB will (hopefully) be truly
 495    multi-arch.  However, for now we're still stuck with the concept of
 496    a single active architecture.  */
 497
 498 /* Make GDBARCH the currently selected architecture.  */
 499
 500 static void
 501 deprecated_select_gdbarch_hack (struct gdbarch *gdbarch)
 502 {
 503   struct gdbarch_info info;
 504
 505   /* FIXME: kettenis/20031024: The only way to select a specific
 506      architecture is to clone its `struct gdbarch_info', and update
 507      according to that copy.  This is gross, but significant work will
 508      need to be done before we can take a more sane approach.  */
 509   gdbarch_info_init (&info);
 510   info.bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 511   info.byte_order = gdbarch_byte_order (gdbarch);
 512   info.osabi = gdbarch_osabi (gdbarch);
 513   gdbarch_update_p (info);
 514   gdb_assert (gdbarch == current_gdbarch);
 515 }
 516
 517 /* Return the architecture for ABFD.  If no suitable architecture
 518    could be find, return NULL.  */
 519
 520 struct gdbarch *
 521 gdbarch_from_bfd (bfd *abfd)
 522 {
 523   struct gdbarch *old_gdbarch = current_gdbarch;
 524   struct gdbarch *new_gdbarch;
 525   struct gdbarch_info info;
 526
 527   /* FIXME: kettenis/20031024: The only way to find the architecture
 528      for a certain BFD is by doing an architecture update.  This
 529      activates the architecture, so we need to reactivate the old
 530      architecture.  This is gross, but significant work will need to
 531      be done before we can take a more sane approach.  */
 532   gdbarch_info_init (&info);
 533   info.abfd = abfd;
 534   if (! gdbarch_update_p (info))
 535     return NULL;
 536
 537   new_gdbarch = current_gdbarch;
 538   deprecated_select_gdbarch_hack (old_gdbarch);
 539   return new_gdbarch;
 540 }
 541
 542 /* Set the dynamic target-system-dependent parameters (architecture,
 543    byte-order) using information found in the BFD */
 544
 545 void
 546 set_gdbarch_from_file (bfd *abfd)
 547 {
 548   struct gdbarch *gdbarch;
 549
 550   gdbarch = gdbarch_from_bfd (abfd);
 551   if (gdbarch == NULL)
 552     error ("Architecture of file not recognized.\n");
 553   deprecated_select_gdbarch_hack (gdbarch);
 554 }
 555
 556 /* Initialize the current architecture.  Update the ``set
 557    architecture'' command so that it specifies a list of valid
 558    architectures.  */
 559
 560 #ifdef DEFAULT_BFD_ARCH
 561 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 562 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 563 #else
 564 static const bfd_arch_info_type *default_bfd_arch;
 565 #endif
 566
 567 #ifdef DEFAULT_BFD_VEC
 568 extern const bfd_target DEFAULT_BFD_VEC;
 569 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 570 #else
 571 static const bfd_target *default_bfd_vec;
 572 #endif
 573
 574 void
 575 initialize_current_architecture (void)
 576 {
 577   const char **arches = gdbarch_printable_names ();
 578
 579   /* determine a default architecture and byte order. */
 580   struct gdbarch_info info;
 581   gdbarch_info_init (&info);
 582
 583   /* Find a default architecture. */
 584   if (info.bfd_arch_info == NULL
 585       && default_bfd_arch != NULL)
 586     info.bfd_arch_info = default_bfd_arch;
 587   if (info.bfd_arch_info == NULL)
 588     {
 589       /* Choose the architecture by taking the first one
 590          alphabetically. */
 591       const char *chosen = arches[0];
 592       const char **arch;
 593       for (arch = arches; *arch != NULL; arch++)
 594         {
 595           if (strcmp (*arch, chosen) < 0)
 596             chosen = *arch;
 597         }
 598       if (chosen == NULL)
 599         internal_error (__FILE__, __LINE__,
 600                         "initialize_current_architecture: No arch");
 601       info.bfd_arch_info = bfd_scan_arch (chosen);
 602       if (info.bfd_arch_info == NULL)
 603         internal_error (__FILE__, __LINE__,
 604                         "initialize_current_architecture: Arch not found");
 605     }
 606
 607   /* Take several guesses at a byte order.  */
 608   if (info.byte_order == BFD_ENDIAN_UNKNOWN
 609       && default_bfd_vec != NULL)
 610     {
 611       /* Extract BFD's default vector's byte order. */
 612       switch (default_bfd_vec->byteorder)
 613         {
 614         case BFD_ENDIAN_BIG:
 615           info.byte_order = BFD_ENDIAN_BIG;
 616           break;
 617         case BFD_ENDIAN_LITTLE:
 618           info.byte_order = BFD_ENDIAN_LITTLE;
 619           break;
 620         default:
 621           break;
 622         }
 623     }
 624   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 625     {
 626       /* look for ``*el-*'' in the target name. */
 627       const char *chp;
 628       chp = strchr (target_name, '-');
 629       if (chp != NULL
 630           && chp - 2 >= target_name
 631           && strncmp (chp - 2, "el", 2) == 0)
 632         info.byte_order = BFD_ENDIAN_LITTLE;
 633     }
 634   if (info.byte_order == BFD_ENDIAN_UNKNOWN)
 635     {
 636       /* Wire it to big-endian!!! */
 637       info.byte_order = BFD_ENDIAN_BIG;
 638     }
 639
 640   if (! gdbarch_update_p (info))
 641     internal_error (__FILE__, __LINE__,
 642                     "initialize_current_architecture: Selection of initial architecture failed");
 643
 644   /* Create the ``set architecture'' command appending ``auto'' to the
 645      list of architectures. */
 646   {
 647     struct cmd_list_element *c;
 648     /* Append ``auto''. */
 649     int nr;
 650     for (nr = 0; arches[nr] != NULL; nr++);
 651     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 652     arches[nr + 0] = "auto";
 653     arches[nr + 1] = NULL;
 654     /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
 655        of ``const char *''.  We just happen to know that the casts are
 656        safe. */
 657     c = add_set_enum_cmd ("architecture", class_support,
 658                           arches, &set_architecture_string,
 659                           "Set architecture of target.",
 660                           &setlist);
 661     set_cmd_sfunc (c, set_architecture);
 662     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 663     /* Don't use set_from_show - need to print both auto/manual and
 664        current setting. */
 665     add_cmd ("architecture", class_support, show_architecture,
 666              "Show the current target architecture", &showlist);
 667   }
 668 }
 669
 670
 671 /* Initialize a gdbarch info to values that will be automatically
 672    overridden.  Note: Originally, this ``struct info'' was initialized
 673    using memset(0).  Unfortunately, that ran into problems, namely
 674    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 675    can explicitly set each field to a well defined value is used.  */
 676
 677 void
 678 gdbarch_info_init (struct gdbarch_info *info)
 679 {
 680   memset (info, 0, sizeof (struct gdbarch_info));
 681   info->byte_order = BFD_ENDIAN_UNKNOWN;
 682   info->osabi = GDB_OSABI_UNINITIALIZED;
 683 }
 684
 685 /* Similar it init, but this time fill in the blanks.  Information is
 686    obtained from the specified architecture, global "set ..." options,
 687    and explicitly initialized INFO fields.  */
 688
 689 void
 690 gdbarch_info_fill (struct gdbarch *gdbarch, struct gdbarch_info *info)
 691 {
 692   /* "(gdb) set architecture ...".  */
 693   if (info->bfd_arch_info == NULL
 694       && !target_architecture_auto
 695       && gdbarch != NULL)
 696     info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 697   if (info->bfd_arch_info == NULL
 698       && info->abfd != NULL
 699       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 700       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 701     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 702   if (info->bfd_arch_info == NULL
 703       && gdbarch != NULL)
 704     info->bfd_arch_info = gdbarch_bfd_arch_info (gdbarch);
 705
 706   /* "(gdb) set byte-order ...".  */
 707   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 708       && !target_byte_order_auto
 709       && gdbarch != NULL)
 710     info->byte_order = gdbarch_byte_order (gdbarch);
 711   /* From the INFO struct.  */
 712   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 713       && info->abfd != NULL)
 714     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 715                        : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 716                        : BFD_ENDIAN_UNKNOWN);
 717   /* From the current target.  */
 718   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 719       && gdbarch != NULL)
 720     info->byte_order = gdbarch_byte_order (gdbarch);
 721
 722   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 723   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 724     info->osabi = gdbarch_lookup_osabi (info->abfd);
 725   if (info->osabi == GDB_OSABI_UNINITIALIZED
 726       && gdbarch != NULL)
 727     info->osabi = gdbarch_osabi (gdbarch);
 728
 729   /* Must have at least filled in the architecture.  */
 730   gdb_assert (info->bfd_arch_info != NULL);
 731 }
 732
 733 /* */
 734
 735 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 736
 737 void
 738 _initialize_gdbarch_utils (void)
 739 {
 740   struct cmd_list_element *c;
 741   c = add_set_enum_cmd ("endian", class_support,
 742                         endian_enum, &set_endian_string,
 743                         "Set endianness of target.",
 744                         &setlist);
 745   set_cmd_sfunc (c, set_endian);
 746   /* Don't use set_from_show - need to print both auto/manual and
 747      current setting. */
 748   add_cmd ("endian", class_support, show_endian,
 749            "Show the current byte-order", &showlist);
 750 }