gdb/arch-utils.c

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright (C) 1998-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21
  22 #include "arch-utils.h"
  23 #include "buildsym.h"
  24 #include "gdbcmd.h"
  25 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et al.  */
  26 #include "infrun.h"
  27 #include "regcache.h"
  28 #include "sim-regno.h"
  29 #include "gdbcore.h"
  30 #include "osabi.h"
  31 #include "target-descriptions.h"
  32 #include "objfiles.h"
  33 #include "language.h"
  34
  35 #include "version.h"
  36
  37 #include "floatformat.h"
  38
  39
  40 struct displaced_step_closure *
  41 simple_displaced_step_copy_insn (struct gdbarch *gdbarch,
  42                                  CORE_ADDR from, CORE_ADDR to,
  43                                  struct regcache *regs)
  44 {
  45   size_t len = gdbarch_max_insn_length (gdbarch);
  46   gdb_byte *buf = xmalloc (len);
  47
  48   read_memory (from, buf, len);
  49   write_memory (to, buf, len);
  50
  51   if (debug_displaced)
  52     {
  53       fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
  54                           paddress (gdbarch, from), paddress (gdbarch, to));
  55       displaced_step_dump_bytes (gdb_stdlog, buf, len);
  56     }
  57
  58   return (struct displaced_step_closure *) buf;
  59 }
  60
  61
  62 void
  63 simple_displaced_step_free_closure (struct gdbarch *gdbarch,
  64                                     struct displaced_step_closure *closure)
  65 {
  66   xfree (closure);
  67 }
  68
  69 int
  70 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
  71                                       struct displaced_step_closure *closure)
  72 {
  73   return !gdbarch_software_single_step_p (gdbarch);
  74 }
  75
  76 CORE_ADDR
  77 displaced_step_at_entry_point (struct gdbarch *gdbarch)
  78 {
  79   CORE_ADDR addr;
  80   int bp_len;
  81
  82   addr = entry_point_address ();
  83
  84   /* Inferior calls also use the entry point as a breakpoint location.
  85      We don't want displaced stepping to interfere with those
  86      breakpoints, so leave space.  */
  87   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
  88   addr += bp_len * 2;
  89
  90   return addr;
  91 }
  92
  93 int
  94 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
  95 {
  96   /* Only makes sense to supply raw registers.  */
  97   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
  98   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  99      suspected that some GDB/SIM combinations may rely on this
 100      behavour.  The default should be one2one_register_sim_regno
 101      (below).  */
 102   if (gdbarch_register_name (gdbarch, regnum) != NULL
 103       && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
 104     return regnum;
 105   else
 106     return LEGACY_SIM_REGNO_IGNORE;
 107 }
 108
 109 CORE_ADDR
 110 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 111 {
 112   return 0;
 113 }
 114
 115 CORE_ADDR
 116 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 117 {
 118   return 0;
 119 }
 120
 121 int
 122 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
 123                                     CORE_ADDR pc, const char *name)
 124 {
 125   return 0;
 126 }
 127
 128 int
 129 generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 130 {
 131   return 0;
 132 }
 133
 134 /* Helper functions for gdbarch_inner_than */
 135
 136 int
 137 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 138 {
 139   return (lhs < rhs);
 140 }
 141
 142 int
 143 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 144 {
 145   return (lhs > rhs);
 146 }
 147
 148 /* Misc helper functions for targets.  */
 149
 150 CORE_ADDR
 151 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
 152 {
 153   return addr;
 154 }
 155
 156 CORE_ADDR
 157 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 158                                      struct target_ops *targ)
 159 {
 160   return addr;
 161 }
 162
 163 int
 164 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 165 {
 166   return reg;
 167 }
 168
 169 void
 170 default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 171 {
 172   return;
 173 }
 174
 175 void
 176 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 177 {
 178   return;
 179 }
 180
 181 int
 182 cannot_register_not (struct gdbarch *gdbarch, int regnum)
 183 {
 184   return 0;
 185 }
 186
 187 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 188    there is an gdbarch_deprecated_fp_regnum and that it is the same,
 189    cooked or raw.  */
 190
 191 void
 192 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
 193                               CORE_ADDR pc,
 194                               int *frame_regnum,
 195                               LONGEST *frame_offset)
 196 {
 197   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 198      frame pointer of the current PC.  It is assuming that a single
 199      register and an offset can determine this.  I think it should
 200      instead generate a byte code expression as that would work better
 201      with things like Dwarf2's CFI.  */
 202   if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
 203       && gdbarch_deprecated_fp_regnum (gdbarch)
 204            < gdbarch_num_regs (gdbarch))
 205     *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
 206   else if (gdbarch_sp_regnum (gdbarch) >= 0
 207            && gdbarch_sp_regnum (gdbarch)
 208                 < gdbarch_num_regs (gdbarch))
 209     *frame_regnum = gdbarch_sp_regnum (gdbarch);
 210   else
 211     /* Should this be an internal error?  I guess so, it is reflecting
 212        an architectural limitation in the current design.  */
 213     internal_error (__FILE__, __LINE__,
 214                     _("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 *const 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
 377          target description whether it accepts SELECTED as compatible
 378          anyway.  */
 379       if (tdesc_compatible_p (target_desc, selected))
 380         return from_target;
 381
 382       warning (_("Selected architecture %s is not compatible "
 383                  "with reported target architecture %s"),
 384                selected->printable_name, from_target->printable_name);
 385       return selected;
 386     }
 387
 388   if (compat1 == NULL)
 389     return compat2;
 390   if (compat2 == NULL)
 391     return compat1;
 392   if (compat1 == compat2)
 393     return compat1;
 394
 395   /* If the two didn't match, but one of them was a default
 396      architecture, assume the more specific one is correct.  This
 397      handles the case where an executable or target description just
 398      says "mips", but the other knows which MIPS variant.  */
 399   if (compat1->the_default)
 400     return compat2;
 401   if (compat2->the_default)
 402     return compat1;
 403
 404   /* We have no idea which one is better.  This is a bug, but not
 405      a critical problem; warn the user.  */
 406   warning (_("Selected architecture %s is ambiguous with "
 407              "reported target architecture %s"),
 408            selected->printable_name, from_target->printable_name);
 409   return selected;
 410 }
 411
 412 /* Functions to manipulate the architecture of the target.  */
 413
 414 enum set_arch { set_arch_auto, set_arch_manual };
 415
 416 static const struct bfd_arch_info *target_architecture_user;
 417
 418 static const char *set_architecture_string;
 419
 420 const char *
 421 selected_architecture_name (void)
 422 {
 423   if (target_architecture_user == NULL)
 424     return NULL;
 425   else
 426     return set_architecture_string;
 427 }
 428
 429 /* Called if the user enters ``show architecture'' without an
 430    argument.  */
 431
 432 static void
 433 show_architecture (struct ui_file *file, int from_tty,
 434                    struct cmd_list_element *c, const char *value)
 435 {
 436   if (target_architecture_user == NULL)
 437     fprintf_filtered (file, _("The target architecture is set "
 438                               "automatically (currently %s)\n"),
 439                       gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
 440   else
 441     fprintf_filtered (file, _("The target architecture is assumed to be %s\n"),
 442                       set_architecture_string);
 443 }
 444
 445
 446 /* Called if the user enters ``set architecture'' with or without an
 447    argument.  */
 448
 449 static void
 450 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 451 {
 452   struct gdbarch_info info;
 453
 454   gdbarch_info_init (&info);
 455
 456   if (strcmp (set_architecture_string, "auto") == 0)
 457     {
 458       target_architecture_user = NULL;
 459       if (!gdbarch_update_p (info))
 460         internal_error (__FILE__, __LINE__,
 461                         _("could not select an architecture automatically"));
 462     }
 463   else
 464     {
 465       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 466       if (info.bfd_arch_info == NULL)
 467         internal_error (__FILE__, __LINE__,
 468                         _("set_architecture: bfd_scan_arch failed"));
 469       if (gdbarch_update_p (info))
 470         target_architecture_user = info.bfd_arch_info;
 471       else
 472         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 473                            set_architecture_string);
 474     }
 475   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 476 }
 477
 478 /* Try to select a global architecture that matches "info".  Return
 479    non-zero if the attempt succeeds.  */
 480 int
 481 gdbarch_update_p (struct gdbarch_info info)
 482 {
 483   struct gdbarch *new_gdbarch;
 484
 485   /* Check for the current file.  */
 486   if (info.abfd == NULL)
 487     info.abfd = exec_bfd;
 488   if (info.abfd == NULL)
 489     info.abfd = core_bfd;
 490
 491   /* Check for the current target description.  */
 492   if (info.target_desc == NULL)
 493     info.target_desc = target_current_description ();
 494
 495   new_gdbarch = gdbarch_find_by_info (info);
 496
 497   /* If there no architecture by that name, reject the request.  */
 498   if (new_gdbarch == NULL)
 499     {
 500       if (gdbarch_debug)
 501         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 502                             "Architecture not found\n");
 503       return 0;
 504     }
 505
 506   /* If it is the same old architecture, accept the request (but don't
 507      swap anything).  */
 508   if (new_gdbarch == target_gdbarch ())
 509     {
 510       if (gdbarch_debug)
 511         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 512                             "Architecture %s (%s) unchanged\n",
 513                             host_address_to_string (new_gdbarch),
 514                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 515       return 1;
 516     }
 517
 518   /* It's a new architecture, swap it in.  */
 519   if (gdbarch_debug)
 520     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 521                         "New architecture %s (%s) selected\n",
 522                         host_address_to_string (new_gdbarch),
 523                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 524   set_target_gdbarch (new_gdbarch);
 525
 526   return 1;
 527 }
 528
 529 /* Return the architecture for ABFD.  If no suitable architecture
 530    could be find, return NULL.  */
 531
 532 struct gdbarch *
 533 gdbarch_from_bfd (bfd *abfd)
 534 {
 535   struct gdbarch_info info;
 536   gdbarch_info_init (&info);
 537
 538   info.abfd = abfd;
 539   return gdbarch_find_by_info (info);
 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_info info;
 549   struct gdbarch *gdbarch;
 550
 551   gdbarch_info_init (&info);
 552   info.abfd = abfd;
 553   info.target_desc = target_current_description ();
 554   gdbarch = gdbarch_find_by_info (info);
 555
 556   if (gdbarch == NULL)
 557     error (_("Architecture of file not recognized."));
 558   set_target_gdbarch (gdbarch);
 559 }
 560
 561 /* Initialize the current architecture.  Update the ``set
 562    architecture'' command so that it specifies a list of valid
 563    architectures.  */
 564
 565 #ifdef DEFAULT_BFD_ARCH
 566 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 567 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 568 #else
 569 static const bfd_arch_info_type *default_bfd_arch;
 570 #endif
 571
 572 #ifdef DEFAULT_BFD_VEC
 573 extern const bfd_target DEFAULT_BFD_VEC;
 574 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 575 #else
 576 static const bfd_target *default_bfd_vec;
 577 #endif
 578
 579 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
 580
 581 void
 582 initialize_current_architecture (void)
 583 {
 584   const char **arches = gdbarch_printable_names ();
 585   struct gdbarch_info info;
 586
 587   /* determine a default architecture and byte order.  */
 588   gdbarch_info_init (&info);
 589
 590   /* Find a default architecture.  */
 591   if (default_bfd_arch == NULL)
 592     {
 593       /* Choose the architecture by taking the first one
 594          alphabetically.  */
 595       const char *chosen = arches[0];
 596       const char **arch;
 597       for (arch = arches; *arch != NULL; arch++)
 598         {
 599           if (strcmp (*arch, chosen) < 0)
 600             chosen = *arch;
 601         }
 602       if (chosen == NULL)
 603         internal_error (__FILE__, __LINE__,
 604                         _("initialize_current_architecture: No arch"));
 605       default_bfd_arch = bfd_scan_arch (chosen);
 606       if (default_bfd_arch == NULL)
 607         internal_error (__FILE__, __LINE__,
 608                         _("initialize_current_architecture: Arch not found"));
 609     }
 610
 611   info.bfd_arch_info = default_bfd_arch;
 612
 613   /* Take several guesses at a byte order.  */
 614   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 615       && default_bfd_vec != NULL)
 616     {
 617       /* Extract BFD's default vector's byte order.  */
 618       switch (default_bfd_vec->byteorder)
 619         {
 620         case BFD_ENDIAN_BIG:
 621           default_byte_order = BFD_ENDIAN_BIG;
 622           break;
 623         case BFD_ENDIAN_LITTLE:
 624           default_byte_order = BFD_ENDIAN_LITTLE;
 625           break;
 626         default:
 627           break;
 628         }
 629     }
 630   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 631     {
 632       /* look for ``*el-*'' in the target name.  */
 633       const char *chp;
 634       chp = strchr (target_name, '-');
 635       if (chp != NULL
 636           && chp - 2 >= target_name
 637           && strncmp (chp - 2, "el", 2) == 0)
 638         default_byte_order = BFD_ENDIAN_LITTLE;
 639     }
 640   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 641     {
 642       /* Wire it to big-endian!!! */
 643       default_byte_order = BFD_ENDIAN_BIG;
 644     }
 645
 646   info.byte_order = default_byte_order;
 647   info.byte_order_for_code = info.byte_order;
 648
 649   if (! gdbarch_update_p (info))
 650     internal_error (__FILE__, __LINE__,
 651                     _("initialize_current_architecture: Selection of "
 652                       "initial architecture failed"));
 653
 654   /* Create the ``set architecture'' command appending ``auto'' to the
 655      list of architectures.  */
 656   {
 657     /* Append ``auto''.  */
 658     int nr;
 659     for (nr = 0; arches[nr] != NULL; nr++);
 660     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 661     arches[nr + 0] = "auto";
 662     arches[nr + 1] = NULL;
 663     add_setshow_enum_cmd ("architecture", class_support,
 664                           arches, &set_architecture_string,
 665                           _("Set architecture of target."),
 666                           _("Show architecture of target."), NULL,
 667                           set_architecture, show_architecture,
 668                           &setlist, &showlist);
 669     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 670   }
 671 }
 672
 673
 674 /* Initialize a gdbarch info to values that will be automatically
 675    overridden.  Note: Originally, this ``struct info'' was initialized
 676    using memset(0).  Unfortunately, that ran into problems, namely
 677    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 678    can explicitly set each field to a well defined value is used.  */
 679
 680 void
 681 gdbarch_info_init (struct gdbarch_info *info)
 682 {
 683   memset (info, 0, sizeof (struct gdbarch_info));
 684   info->byte_order = BFD_ENDIAN_UNKNOWN;
 685   info->byte_order_for_code = info->byte_order;
 686   info->osabi = GDB_OSABI_UNINITIALIZED;
 687 }
 688
 689 /* Similar to init, but this time fill in the blanks.  Information is
 690    obtained from the global "set ..." options and explicitly
 691    initialized INFO fields.  */
 692
 693 void
 694 gdbarch_info_fill (struct gdbarch_info *info)
 695 {
 696   /* "(gdb) set architecture ...".  */
 697   if (info->bfd_arch_info == NULL
 698       && target_architecture_user)
 699     info->bfd_arch_info = target_architecture_user;
 700   /* From the file.  */
 701   if (info->bfd_arch_info == NULL
 702       && info->abfd != NULL
 703       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 704       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 705     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 706   /* From the target.  */
 707   if (info->target_desc != NULL)
 708     info->bfd_arch_info = choose_architecture_for_target
 709                            (info->target_desc, info->bfd_arch_info);
 710   /* From the default.  */
 711   if (info->bfd_arch_info == NULL)
 712     info->bfd_arch_info = default_bfd_arch;
 713
 714   /* "(gdb) set byte-order ...".  */
 715   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 716       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 717     info->byte_order = target_byte_order_user;
 718   /* From the INFO struct.  */
 719   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 720       && info->abfd != NULL)
 721     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 722                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 723                         : BFD_ENDIAN_UNKNOWN);
 724   /* From the default.  */
 725   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 726     info->byte_order = default_byte_order;
 727   info->byte_order_for_code = info->byte_order;
 728
 729   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 730   /* From the manual override, or from file.  */
 731   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 732     info->osabi = gdbarch_lookup_osabi (info->abfd);
 733   /* From the target.  */
 734   if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
 735     info->osabi = tdesc_osabi (info->target_desc);
 736   /* From the configured default.  */
 737 #ifdef GDB_OSABI_DEFAULT
 738   if (info->osabi == GDB_OSABI_UNKNOWN)
 739     info->osabi = GDB_OSABI_DEFAULT;
 740 #endif
 741
 742   /* Must have at least filled in the architecture.  */
 743   gdb_assert (info->bfd_arch_info != NULL);
 744 }
 745
 746 /* Return "current" architecture.  If the target is running, this is
 747    the architecture of the selected frame.  Otherwise, the "current"
 748    architecture defaults to the target architecture.
 749
 750    This function should normally be called solely by the command
 751    interpreter routines to determine the architecture to execute a
 752    command in.  */
 753 struct gdbarch *
 754 get_current_arch (void)
 755 {
 756   if (has_stack_frames ())
 757     return get_frame_arch (get_selected_frame (NULL));
 758   else
 759     return target_gdbarch ();
 760 }
 761
 762 int
 763 default_has_shared_address_space (struct gdbarch *gdbarch)
 764 {
 765   /* Simply say no.  In most unix-like targets each inferior/process
 766      has its own address space.  */
 767   return 0;
 768 }
 769
 770 int
 771 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
 772                                   CORE_ADDR addr, int *isize, char **msg)
 773 {
 774   /* We don't know if maybe the target has some way to do fast
 775      tracepoints that doesn't need gdbarch, so always say yes.  */
 776   if (msg)
 777     *msg = NULL;
 778   return 1;
 779 }
 780
 781 void
 782 default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 783                                    int *kindptr)
 784 {
 785   gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr);
 786 }
 787
 788 void
 789 default_gen_return_address (struct gdbarch *gdbarch,
 790                             struct agent_expr *ax, struct axs_value *value,
 791                             CORE_ADDR scope)
 792 {
 793   error (_("This architecture has no method to collect a return address."));
 794 }
 795
 796 int
 797 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
 798                                         struct type *type)
 799 {
 800   /* Usually, the return value's address is stored the in the "first hidden"
 801      parameter if the return value should be passed by reference, as
 802      specified in ABI.  */
 803   return language_pass_by_reference (type);
 804 }
 805
 806 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
 807 {
 808   return 0;
 809 }
 810
 811 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
 812 {
 813   return 0;
 814 }
 815
 816 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 817 {
 818   return 0;
 819 }
 820
 821 /* */
 822
 823 /* -Wmissing-prototypes */
 824 extern initialize_file_ftype _initialize_gdbarch_utils;
 825
 826 void
 827 _initialize_gdbarch_utils (void)
 828 {
 829   add_setshow_enum_cmd ("endian", class_support,
 830                         endian_enum, &set_endian_string,
 831                         _("Set endianness of target."),
 832                         _("Show endianness of target."),
 833                         NULL, set_endian, show_endian,
 834                         &setlist, &showlist);
 835 }