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    2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22
  23 #include "arch-utils.h"
  24 #include "buildsym.h"
  25 #include "gdbcmd.h"
  26 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et.al. */
  27 #include "gdb_string.h"
  28 #include "regcache.h"
  29 #include "gdb_assert.h"
  30 #include "sim-regno.h"
  31 #include "gdbcore.h"
  32 #include "osabi.h"
  33 #include "target-descriptions.h"
  34 #include "objfiles.h"
  35
  36 #include "version.h"
  37
  38 #include "floatformat.h"
  39
  40
  41 struct displaced_step_closure *
  42 simple_displaced_step_copy_insn (struct gdbarch *gdbarch,
  43                                  CORE_ADDR from, CORE_ADDR to,
  44                                  struct regcache *regs)
  45 {
  46   size_t len = gdbarch_max_insn_length (gdbarch);
  47   gdb_byte *buf = xmalloc (len);
  48
  49   read_memory (from, buf, len);
  50   write_memory (to, buf, len);
  51
  52   if (debug_displaced)
  53     {
  54       fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
  55                           paddress (gdbarch, from), paddress (gdbarch, to));
  56       displaced_step_dump_bytes (gdb_stdlog, buf, len);
  57     }
  58
  59   return (struct displaced_step_closure *) buf;
  60 }
  61
  62
  63 void
  64 simple_displaced_step_free_closure (struct gdbarch *gdbarch,
  65                                     struct displaced_step_closure *closure)
  66 {
  67   xfree (closure);
  68 }
  69
  70 int
  71 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
  72                                       struct displaced_step_closure *closure)
  73 {
  74   return !gdbarch_software_single_step_p (gdbarch);
  75 }
  76
  77 CORE_ADDR
  78 displaced_step_at_entry_point (struct gdbarch *gdbarch)
  79 {
  80   CORE_ADDR addr;
  81   int bp_len;
  82
  83   addr = entry_point_address ();
  84
  85   /* Inferior calls also use the entry point as a breakpoint location.
  86      We don't want displaced stepping to interfere with those
  87      breakpoints, so leave space.  */
  88   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
  89   addr += bp_len * 2;
  90
  91   return addr;
  92 }
  93
  94 int
  95 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
  96 {
  97   /* Only makes sense to supply raw registers.  */
  98   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
  99   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
 100      suspected that some GDB/SIM combinations may rely on this
 101      behavour.  The default should be one2one_register_sim_regno
 102      (below).  */
 103   if (gdbarch_register_name (gdbarch, regnum) != NULL
 104       && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
 105     return regnum;
 106   else
 107     return LEGACY_SIM_REGNO_IGNORE;
 108 }
 109
 110 CORE_ADDR
 111 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 112 {
 113   return 0;
 114 }
 115
 116 CORE_ADDR
 117 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 118 {
 119   return 0;
 120 }
 121
 122 int
 123 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
 124                                     CORE_ADDR pc, char *name)
 125 {
 126   return 0;
 127 }
 128
 129 int
 130 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 131 {
 132   return 0;
 133 }
 134
 135 /* Helper functions for gdbarch_inner_than */
 136
 137 int
 138 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 139 {
 140   return (lhs < rhs);
 141 }
 142
 143 int
 144 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 145 {
 146   return (lhs > rhs);
 147 }
 148
 149 /* Misc helper functions for targets. */
 150
 151 CORE_ADDR
 152 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
 153 {
 154   return addr;
 155 }
 156
 157 CORE_ADDR
 158 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 159                                      struct target_ops *targ)
 160 {
 161   return addr;
 162 }
 163
 164 int
 165 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 166 {
 167   return reg;
 168 }
 169
 170 void
 171 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 172 {
 173   return;
 174 }
 175
 176 void
 177 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 178 {
 179   return;
 180 }
 181
 182 int
 183 cannot_register_not (struct gdbarch *gdbarch, int regnum)
 184 {
 185   return 0;
 186 }
 187
 188 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 189    there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or
 190    raw.  */
 191
 192 void
 193 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
 194                               CORE_ADDR pc,
 195                               int *frame_regnum,
 196                               LONGEST *frame_offset)
 197 {
 198   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 199      frame pointer of the current PC.  It is assuming that a single
 200      register and an offset can determine this.  I think it should
 201      instead generate a byte code expression as that would work better
 202      with things like Dwarf2's CFI.  */
 203   if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
 204       && gdbarch_deprecated_fp_regnum (gdbarch)
 205            < gdbarch_num_regs (gdbarch))
 206     *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
 207   else if (gdbarch_sp_regnum (gdbarch) >= 0
 208            && gdbarch_sp_regnum (gdbarch)
 209                 < gdbarch_num_regs (gdbarch))
 210     *frame_regnum = gdbarch_sp_regnum (gdbarch);
 211   else
 212     /* Should this be an internal error?  I guess so, it is reflecting
 213        an architectural limitation in the current design.  */
 214     internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
 215   *frame_offset = 0;
 216 }
 217
 218 \f
 219 int
 220 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
 221                             struct type *type)
 222 {
 223   return 0;
 224 }
 225
 226 int
 227 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 228 {
 229   return 0;
 230 }
 231
 232 int
 233 generic_instruction_nullified (struct gdbarch *gdbarch,
 234                                struct regcache *regcache)
 235 {
 236   return 0;
 237 }
 238
 239 int
 240 default_remote_register_number (struct gdbarch *gdbarch,
 241                                 int regno)
 242 {
 243   return regno;
 244 }
 245
 246 \f
 247 /* Functions to manipulate the endianness of the target.  */
 248
 249 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 250
 251 static const char endian_big[] = "big";
 252 static const char endian_little[] = "little";
 253 static const char endian_auto[] = "auto";
 254 static const char *endian_enum[] =
 255 {
 256   endian_big,
 257   endian_little,
 258   endian_auto,
 259   NULL,
 260 };
 261 static const char *set_endian_string;
 262
 263 enum bfd_endian
 264 selected_byte_order (void)
 265 {
 266   return target_byte_order_user;
 267 }
 268
 269 /* Called by ``show endian''.  */
 270
 271 static void
 272 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 273              const char *value)
 274 {
 275   if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
 276     if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
 277       fprintf_unfiltered (file, _("The target endianness is set automatically "
 278                                   "(currently big endian)\n"));
 279     else
 280       fprintf_unfiltered (file, _("The target endianness is set automatically "
 281                            "(currently little endian)\n"));
 282   else
 283     if (target_byte_order_user == BFD_ENDIAN_BIG)
 284       fprintf_unfiltered (file,
 285                           _("The target is assumed to be big endian\n"));
 286     else
 287       fprintf_unfiltered (file,
 288                           _("The target is assumed to be little endian\n"));
 289 }
 290
 291 static void
 292 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 293 {
 294   struct gdbarch_info info;
 295
 296   gdbarch_info_init (&info);
 297
 298   if (set_endian_string == endian_auto)
 299     {
 300       target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 301       if (! gdbarch_update_p (info))
 302         internal_error (__FILE__, __LINE__,
 303                         _("set_endian: architecture update failed"));
 304     }
 305   else if (set_endian_string == endian_little)
 306     {
 307       info.byte_order = BFD_ENDIAN_LITTLE;
 308       if (! gdbarch_update_p (info))
 309         printf_unfiltered (_("Little endian target not supported by GDB\n"));
 310       else
 311         target_byte_order_user = BFD_ENDIAN_LITTLE;
 312     }
 313   else if (set_endian_string == endian_big)
 314     {
 315       info.byte_order = BFD_ENDIAN_BIG;
 316       if (! gdbarch_update_p (info))
 317         printf_unfiltered (_("Big endian target not supported by GDB\n"));
 318       else
 319         target_byte_order_user = BFD_ENDIAN_BIG;
 320     }
 321   else
 322     internal_error (__FILE__, __LINE__,
 323                     _("set_endian: bad value"));
 324
 325   show_endian (gdb_stdout, from_tty, NULL, NULL);
 326 }
 327
 328 /* Given SELECTED, a currently selected BFD architecture, and
 329    TARGET_DESC, the current target description, return what
 330    architecture to use.
 331
 332    SELECTED may be NULL, in which case we return the architecture
 333    associated with TARGET_DESC.  If SELECTED specifies a variant
 334    of the architecture associtated with TARGET_DESC, return the
 335    more specific of the two.
 336
 337    If SELECTED is a different architecture, but it is accepted as
 338    compatible by the target, we can use the target architecture.
 339
 340    If SELECTED is obviously incompatible, warn the user.  */
 341
 342 static const struct bfd_arch_info *
 343 choose_architecture_for_target (const struct target_desc *target_desc,
 344                                 const struct bfd_arch_info *selected)
 345 {
 346   const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
 347   const struct bfd_arch_info *compat1, *compat2;
 348
 349   if (selected == NULL)
 350     return from_target;
 351
 352   if (from_target == NULL)
 353     return selected;
 354
 355   /* struct bfd_arch_info objects are singletons: that is, there's
 356      supposed to be exactly one instance for a given machine.  So you
 357      can tell whether two are equivalent by comparing pointers.  */
 358   if (from_target == selected)
 359     return selected;
 360
 361   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 362      incompatible.  But if they are compatible, it returns the 'more
 363      featureful' of the two arches.  That is, if A can run code
 364      written for B, but B can't run code written for A, then it'll
 365      return A.
 366
 367      Some targets (e.g. MIPS as of 2006-12-04) don't fully
 368      implement this, instead always returning NULL or the first
 369      argument.  We detect that case by checking both directions.  */
 370
 371   compat1 = selected->compatible (selected, from_target);
 372   compat2 = from_target->compatible (from_target, selected);
 373
 374   if (compat1 == NULL && compat2 == NULL)
 375     {
 376       /* BFD considers the architectures incompatible.  Check our target
 377          description whether it accepts SELECTED as compatible anyway.  */
 378       if (tdesc_compatible_p (target_desc, selected))
 379         return from_target;
 380
 381       warning (_("Selected architecture %s is not compatible "
 382                  "with reported target architecture %s"),
 383                selected->printable_name, from_target->printable_name);
 384       return selected;
 385     }
 386
 387   if (compat1 == NULL)
 388     return compat2;
 389   if (compat2 == NULL)
 390     return compat1;
 391   if (compat1 == compat2)
 392     return compat1;
 393
 394   /* If the two didn't match, but one of them was a default architecture,
 395      assume the more specific one is correct.  This handles the case
 396      where an executable or target description just says "mips", but
 397      the other knows which MIPS variant.  */
 398   if (compat1->the_default)
 399     return compat2;
 400   if (compat2->the_default)
 401     return compat1;
 402
 403   /* We have no idea which one is better.  This is a bug, but not
 404      a critical problem; warn the user.  */
 405   warning (_("Selected architecture %s is ambiguous with "
 406              "reported target architecture %s"),
 407            selected->printable_name, from_target->printable_name);
 408   return selected;
 409 }
 410
 411 /* Functions to manipulate the architecture of the target */
 412
 413 enum set_arch { set_arch_auto, set_arch_manual };
 414
 415 static const struct bfd_arch_info *target_architecture_user;
 416
 417 static const char *set_architecture_string;
 418
 419 const char *
 420 selected_architecture_name (void)
 421 {
 422   if (target_architecture_user == NULL)
 423     return NULL;
 424   else
 425     return set_architecture_string;
 426 }
 427
 428 /* Called if the user enters ``show architecture'' without an
 429    argument. */
 430
 431 static void
 432 show_architecture (struct ui_file *file, int from_tty,
 433                    struct cmd_list_element *c, const char *value)
 434 {
 435   if (target_architecture_user == NULL)
 436     fprintf_filtered (file, _("\
 437 The target architecture is set automatically (currently %s)\n"),
 438                 gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
 439   else
 440     fprintf_filtered (file, _("\
 441 The target architecture is assumed to be %s\n"), set_architecture_string);
 442 }
 443
 444
 445 /* Called if the user enters ``set architecture'' with or without an
 446    argument. */
 447
 448 static void
 449 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 450 {
 451   struct gdbarch_info info;
 452
 453   gdbarch_info_init (&info);
 454
 455   if (strcmp (set_architecture_string, "auto") == 0)
 456     {
 457       target_architecture_user = NULL;
 458       if (!gdbarch_update_p (info))
 459         internal_error (__FILE__, __LINE__,
 460                         _("could not select an architecture automatically"));
 461     }
 462   else
 463     {
 464       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 465       if (info.bfd_arch_info == NULL)
 466         internal_error (__FILE__, __LINE__,
 467                         _("set_architecture: bfd_scan_arch failed"));
 468       if (gdbarch_update_p (info))
 469         target_architecture_user = info.bfd_arch_info;
 470       else
 471         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 472                            set_architecture_string);
 473     }
 474   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 475 }
 476
 477 /* Try to select a global architecture that matches "info".  Return
 478    non-zero if the attempt succeds.  */
 479 int
 480 gdbarch_update_p (struct gdbarch_info info)
 481 {
 482   struct gdbarch *new_gdbarch;
 483
 484   /* Check for the current file.  */
 485   if (info.abfd == NULL)
 486     info.abfd = exec_bfd;
 487   if (info.abfd == NULL)
 488     info.abfd = core_bfd;
 489
 490   /* Check for the current target description.  */
 491   if (info.target_desc == NULL)
 492     info.target_desc = target_current_description ();
 493
 494   new_gdbarch = gdbarch_find_by_info (info);
 495
 496   /* If there no architecture by that name, reject the request.  */
 497   if (new_gdbarch == NULL)
 498     {
 499       if (gdbarch_debug)
 500         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 501                             "Architecture not found\n");
 502       return 0;
 503     }
 504
 505   /* If it is the same old architecture, accept the request (but don't
 506      swap anything).  */
 507   if (new_gdbarch == target_gdbarch)
 508     {
 509       if (gdbarch_debug)
 510         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 511                             "Architecture %s (%s) unchanged\n",
 512                             host_address_to_string (new_gdbarch),
 513                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 514       return 1;
 515     }
 516
 517   /* It's a new architecture, swap it in.  */
 518   if (gdbarch_debug)
 519     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 520                         "New architecture %s (%s) selected\n",
 521                         host_address_to_string (new_gdbarch),
 522                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 523   deprecated_target_gdbarch_select_hack (new_gdbarch);
 524
 525   return 1;
 526 }
 527
 528 /* Return the architecture for ABFD.  If no suitable architecture
 529    could be find, return NULL.  */
 530
 531 struct gdbarch *
 532 gdbarch_from_bfd (bfd *abfd)
 533 {
 534   struct gdbarch_info info;
 535   gdbarch_info_init (&info);
 536   info.abfd = abfd;
 537   return gdbarch_find_by_info (info);
 538 }
 539
 540 /* Set the dynamic target-system-dependent parameters (architecture,
 541    byte-order) using information found in the BFD */
 542
 543 void
 544 set_gdbarch_from_file (bfd *abfd)
 545 {
 546   struct gdbarch_info info;
 547   struct gdbarch *gdbarch;
 548
 549   gdbarch_info_init (&info);
 550   info.abfd = abfd;
 551   info.target_desc = target_current_description ();
 552   gdbarch = gdbarch_find_by_info (info);
 553
 554   if (gdbarch == NULL)
 555     error (_("Architecture of file not recognized."));
 556   deprecated_target_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   info.byte_order_for_code = info.byte_order;
 646
 647   if (! gdbarch_update_p (info))
 648     internal_error (__FILE__, __LINE__,
 649                     _("initialize_current_architecture: Selection of "
 650                       "initial architecture failed"));
 651
 652   /* Create the ``set architecture'' command appending ``auto'' to the
 653      list of architectures. */
 654   {
 655     struct cmd_list_element *c;
 656     /* Append ``auto''. */
 657     int nr;
 658     for (nr = 0; arches[nr] != NULL; nr++);
 659     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 660     arches[nr + 0] = "auto";
 661     arches[nr + 1] = NULL;
 662     add_setshow_enum_cmd ("architecture", class_support,
 663                           arches, &set_architecture_string, _("\
 664 Set architecture of target."), _("\
 665 Show architecture of target."), NULL,
 666                           set_architecture, show_architecture,
 667                           &setlist, &showlist);
 668     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 669   }
 670 }
 671
 672
 673 /* Initialize a gdbarch info to values that will be automatically
 674    overridden.  Note: Originally, this ``struct info'' was initialized
 675    using memset(0).  Unfortunately, that ran into problems, namely
 676    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 677    can explicitly set each field to a well defined value is used.  */
 678
 679 void
 680 gdbarch_info_init (struct gdbarch_info *info)
 681 {
 682   memset (info, 0, sizeof (struct gdbarch_info));
 683   info->byte_order = BFD_ENDIAN_UNKNOWN;
 684   info->byte_order_for_code = info->byte_order;
 685   info->osabi = GDB_OSABI_UNINITIALIZED;
 686 }
 687
 688 /* Similar to init, but this time fill in the blanks.  Information is
 689    obtained from the global "set ..." options and explicitly
 690    initialized INFO fields.  */
 691
 692 void
 693 gdbarch_info_fill (struct gdbarch_info *info)
 694 {
 695   /* "(gdb) set architecture ...".  */
 696   if (info->bfd_arch_info == NULL
 697       && target_architecture_user)
 698     info->bfd_arch_info = target_architecture_user;
 699   /* From the file.  */
 700   if (info->bfd_arch_info == NULL
 701       && info->abfd != NULL
 702       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 703       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 704     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 705   /* From the target.  */
 706   if (info->target_desc != NULL)
 707     info->bfd_arch_info = choose_architecture_for_target
 708                            (info->target_desc, info->bfd_arch_info);
 709   /* From the default.  */
 710   if (info->bfd_arch_info == NULL)
 711     info->bfd_arch_info = default_bfd_arch;
 712
 713   /* "(gdb) set byte-order ...".  */
 714   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 715       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 716     info->byte_order = target_byte_order_user;
 717   /* From the INFO struct.  */
 718   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 719       && info->abfd != NULL)
 720     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 721                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 722                         : BFD_ENDIAN_UNKNOWN);
 723   /* From the default.  */
 724   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 725     info->byte_order = default_byte_order;
 726   info->byte_order_for_code = info->byte_order;
 727
 728   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 729   /* From the manual override, or from file.  */
 730   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 731     info->osabi = gdbarch_lookup_osabi (info->abfd);
 732   /* From the target.  */
 733   if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
 734     info->osabi = tdesc_osabi (info->target_desc);
 735   /* From the configured default.  */
 736 #ifdef GDB_OSABI_DEFAULT
 737   if (info->osabi == GDB_OSABI_UNKNOWN)
 738     info->osabi = GDB_OSABI_DEFAULT;
 739 #endif
 740
 741   /* Must have at least filled in the architecture.  */
 742   gdb_assert (info->bfd_arch_info != NULL);
 743 }
 744
 745 /* Return "current" architecture.  If the target is running, this is the
 746    architecture of the selected frame.  Otherwise, the "current" architecture
 747    defaults to the target architecture.
 748
 749    This function should normally be called solely by the command interpreter
 750    routines to determine the architecture to execute a command in.  */
 751 struct gdbarch *
 752 get_current_arch (void)
 753 {
 754   if (has_stack_frames ())
 755     return get_frame_arch (get_selected_frame (NULL));
 756   else
 757     return target_gdbarch;
 758 }
 759
 760 int
 761 default_has_shared_address_space (struct gdbarch *gdbarch)
 762 {
 763   /* Simply say no.  In most unix-like targets each inferior/process
 764      has its own address space.  */
 765   return 0;
 766 }
 767
 768 int
 769 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
 770                                   CORE_ADDR addr, int *isize, char **msg)
 771 {
 772   /* We don't know if maybe the target has some way to do fast
 773      tracepoints that doesn't need gdbarch, so always say yes.  */
 774   if (msg)
 775     *msg = NULL;
 776   return 1;
 777 }
 778
 779 void
 780 default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 781                                    int *kindptr)
 782 {
 783   gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr);
 784 }
 785
 786 /* */
 787
 788 extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */
 789
 790 void
 791 _initialize_gdbarch_utils (void)
 792 {
 793   struct cmd_list_element *c;
 794   add_setshow_enum_cmd ("endian", class_support,
 795                         endian_enum, &set_endian_string, _("\
 796 Set endianness of target."), _("\
 797 Show endianness of target."), NULL,
 798                         set_endian, show_endian,
 799                         &setlist, &showlist);
 800 }