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 /* See arch-utils.h.  */
 247
 248 int
 249 default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
 250 {
 251   return 0;
 252 }
 253
 254 \f
 255 /* Functions to manipulate the endianness of the target.  */
 256
 257 static int target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 258
 259 static const char endian_big[] = "big";
 260 static const char endian_little[] = "little";
 261 static const char endian_auto[] = "auto";
 262 static const char *const endian_enum[] =
 263 {
 264   endian_big,
 265   endian_little,
 266   endian_auto,
 267   NULL,
 268 };
 269 static const char *set_endian_string;
 270
 271 enum bfd_endian
 272 selected_byte_order (void)
 273 {
 274   return target_byte_order_user;
 275 }
 276
 277 /* Called by ``show endian''.  */
 278
 279 static void
 280 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 281              const char *value)
 282 {
 283   if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
 284     if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
 285       fprintf_unfiltered (file, _("The target endianness is set automatically "
 286                                   "(currently big endian)\n"));
 287     else
 288       fprintf_unfiltered (file, _("The target endianness is set automatically "
 289                                   "(currently little endian)\n"));
 290   else
 291     if (target_byte_order_user == BFD_ENDIAN_BIG)
 292       fprintf_unfiltered (file,
 293                           _("The target is assumed to be big endian\n"));
 294     else
 295       fprintf_unfiltered (file,
 296                           _("The target is assumed to be little endian\n"));
 297 }
 298
 299 static void
 300 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
 301 {
 302   struct gdbarch_info info;
 303
 304   gdbarch_info_init (&info);
 305
 306   if (set_endian_string == endian_auto)
 307     {
 308       target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 309       if (! gdbarch_update_p (info))
 310         internal_error (__FILE__, __LINE__,
 311                         _("set_endian: architecture update failed"));
 312     }
 313   else if (set_endian_string == endian_little)
 314     {
 315       info.byte_order = BFD_ENDIAN_LITTLE;
 316       if (! gdbarch_update_p (info))
 317         printf_unfiltered (_("Little endian target not supported by GDB\n"));
 318       else
 319         target_byte_order_user = BFD_ENDIAN_LITTLE;
 320     }
 321   else if (set_endian_string == endian_big)
 322     {
 323       info.byte_order = BFD_ENDIAN_BIG;
 324       if (! gdbarch_update_p (info))
 325         printf_unfiltered (_("Big endian target not supported by GDB\n"));
 326       else
 327         target_byte_order_user = BFD_ENDIAN_BIG;
 328     }
 329   else
 330     internal_error (__FILE__, __LINE__,
 331                     _("set_endian: bad value"));
 332
 333   show_endian (gdb_stdout, from_tty, NULL, NULL);
 334 }
 335
 336 /* Given SELECTED, a currently selected BFD architecture, and
 337    TARGET_DESC, the current target description, return what
 338    architecture to use.
 339
 340    SELECTED may be NULL, in which case we return the architecture
 341    associated with TARGET_DESC.  If SELECTED specifies a variant
 342    of the architecture associtated with TARGET_DESC, return the
 343    more specific of the two.
 344
 345    If SELECTED is a different architecture, but it is accepted as
 346    compatible by the target, we can use the target architecture.
 347
 348    If SELECTED is obviously incompatible, warn the user.  */
 349
 350 static const struct bfd_arch_info *
 351 choose_architecture_for_target (const struct target_desc *target_desc,
 352                                 const struct bfd_arch_info *selected)
 353 {
 354   const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
 355   const struct bfd_arch_info *compat1, *compat2;
 356
 357   if (selected == NULL)
 358     return from_target;
 359
 360   if (from_target == NULL)
 361     return selected;
 362
 363   /* struct bfd_arch_info objects are singletons: that is, there's
 364      supposed to be exactly one instance for a given machine.  So you
 365      can tell whether two are equivalent by comparing pointers.  */
 366   if (from_target == selected)
 367     return selected;
 368
 369   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 370      incompatible.  But if they are compatible, it returns the 'more
 371      featureful' of the two arches.  That is, if A can run code
 372      written for B, but B can't run code written for A, then it'll
 373      return A.
 374
 375      Some targets (e.g. MIPS as of 2006-12-04) don't fully
 376      implement this, instead always returning NULL or the first
 377      argument.  We detect that case by checking both directions.  */
 378
 379   compat1 = selected->compatible (selected, from_target);
 380   compat2 = from_target->compatible (from_target, selected);
 381
 382   if (compat1 == NULL && compat2 == NULL)
 383     {
 384       /* BFD considers the architectures incompatible.  Check our
 385          target description whether it accepts SELECTED as compatible
 386          anyway.  */
 387       if (tdesc_compatible_p (target_desc, selected))
 388         return from_target;
 389
 390       warning (_("Selected architecture %s is not compatible "
 391                  "with reported target architecture %s"),
 392                selected->printable_name, from_target->printable_name);
 393       return selected;
 394     }
 395
 396   if (compat1 == NULL)
 397     return compat2;
 398   if (compat2 == NULL)
 399     return compat1;
 400   if (compat1 == compat2)
 401     return compat1;
 402
 403   /* If the two didn't match, but one of them was a default
 404      architecture, assume the more specific one is correct.  This
 405      handles the case where an executable or target description just
 406      says "mips", but the other knows which MIPS variant.  */
 407   if (compat1->the_default)
 408     return compat2;
 409   if (compat2->the_default)
 410     return compat1;
 411
 412   /* We have no idea which one is better.  This is a bug, but not
 413      a critical problem; warn the user.  */
 414   warning (_("Selected architecture %s is ambiguous with "
 415              "reported target architecture %s"),
 416            selected->printable_name, from_target->printable_name);
 417   return selected;
 418 }
 419
 420 /* Functions to manipulate the architecture of the target.  */
 421
 422 enum set_arch { set_arch_auto, set_arch_manual };
 423
 424 static const struct bfd_arch_info *target_architecture_user;
 425
 426 static const char *set_architecture_string;
 427
 428 const char *
 429 selected_architecture_name (void)
 430 {
 431   if (target_architecture_user == NULL)
 432     return NULL;
 433   else
 434     return set_architecture_string;
 435 }
 436
 437 /* Called if the user enters ``show architecture'' without an
 438    argument.  */
 439
 440 static void
 441 show_architecture (struct ui_file *file, int from_tty,
 442                    struct cmd_list_element *c, const char *value)
 443 {
 444   if (target_architecture_user == NULL)
 445     fprintf_filtered (file, _("The target architecture is set "
 446                               "automatically (currently %s)\n"),
 447                       gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
 448   else
 449     fprintf_filtered (file, _("The target architecture is assumed to be %s\n"),
 450                       set_architecture_string);
 451 }
 452
 453
 454 /* Called if the user enters ``set architecture'' with or without an
 455    argument.  */
 456
 457 static void
 458 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
 459 {
 460   struct gdbarch_info info;
 461
 462   gdbarch_info_init (&info);
 463
 464   if (strcmp (set_architecture_string, "auto") == 0)
 465     {
 466       target_architecture_user = NULL;
 467       if (!gdbarch_update_p (info))
 468         internal_error (__FILE__, __LINE__,
 469                         _("could not select an architecture automatically"));
 470     }
 471   else
 472     {
 473       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 474       if (info.bfd_arch_info == NULL)
 475         internal_error (__FILE__, __LINE__,
 476                         _("set_architecture: bfd_scan_arch failed"));
 477       if (gdbarch_update_p (info))
 478         target_architecture_user = info.bfd_arch_info;
 479       else
 480         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 481                            set_architecture_string);
 482     }
 483   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 484 }
 485
 486 /* Try to select a global architecture that matches "info".  Return
 487    non-zero if the attempt succeeds.  */
 488 int
 489 gdbarch_update_p (struct gdbarch_info info)
 490 {
 491   struct gdbarch *new_gdbarch;
 492
 493   /* Check for the current file.  */
 494   if (info.abfd == NULL)
 495     info.abfd = exec_bfd;
 496   if (info.abfd == NULL)
 497     info.abfd = core_bfd;
 498
 499   /* Check for the current target description.  */
 500   if (info.target_desc == NULL)
 501     info.target_desc = target_current_description ();
 502
 503   new_gdbarch = gdbarch_find_by_info (info);
 504
 505   /* If there no architecture by that name, reject the request.  */
 506   if (new_gdbarch == NULL)
 507     {
 508       if (gdbarch_debug)
 509         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 510                             "Architecture not found\n");
 511       return 0;
 512     }
 513
 514   /* If it is the same old architecture, accept the request (but don't
 515      swap anything).  */
 516   if (new_gdbarch == target_gdbarch ())
 517     {
 518       if (gdbarch_debug)
 519         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 520                             "Architecture %s (%s) unchanged\n",
 521                             host_address_to_string (new_gdbarch),
 522                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 523       return 1;
 524     }
 525
 526   /* It's a new architecture, swap it in.  */
 527   if (gdbarch_debug)
 528     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 529                         "New architecture %s (%s) selected\n",
 530                         host_address_to_string (new_gdbarch),
 531                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 532   set_target_gdbarch (new_gdbarch);
 533
 534   return 1;
 535 }
 536
 537 /* Return the architecture for ABFD.  If no suitable architecture
 538    could be find, return NULL.  */
 539
 540 struct gdbarch *
 541 gdbarch_from_bfd (bfd *abfd)
 542 {
 543   struct gdbarch_info info;
 544   gdbarch_info_init (&info);
 545
 546   info.abfd = abfd;
 547   return gdbarch_find_by_info (info);
 548 }
 549
 550 /* Set the dynamic target-system-dependent parameters (architecture,
 551    byte-order) using information found in the BFD */
 552
 553 void
 554 set_gdbarch_from_file (bfd *abfd)
 555 {
 556   struct gdbarch_info info;
 557   struct gdbarch *gdbarch;
 558
 559   gdbarch_info_init (&info);
 560   info.abfd = abfd;
 561   info.target_desc = target_current_description ();
 562   gdbarch = gdbarch_find_by_info (info);
 563
 564   if (gdbarch == NULL)
 565     error (_("Architecture of file not recognized."));
 566   set_target_gdbarch (gdbarch);
 567 }
 568
 569 /* Initialize the current architecture.  Update the ``set
 570    architecture'' command so that it specifies a list of valid
 571    architectures.  */
 572
 573 #ifdef DEFAULT_BFD_ARCH
 574 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 575 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 576 #else
 577 static const bfd_arch_info_type *default_bfd_arch;
 578 #endif
 579
 580 #ifdef DEFAULT_BFD_VEC
 581 extern const bfd_target DEFAULT_BFD_VEC;
 582 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 583 #else
 584 static const bfd_target *default_bfd_vec;
 585 #endif
 586
 587 static int default_byte_order = BFD_ENDIAN_UNKNOWN;
 588
 589 void
 590 initialize_current_architecture (void)
 591 {
 592   const char **arches = gdbarch_printable_names ();
 593   struct gdbarch_info info;
 594
 595   /* determine a default architecture and byte order.  */
 596   gdbarch_info_init (&info);
 597
 598   /* Find a default architecture.  */
 599   if (default_bfd_arch == NULL)
 600     {
 601       /* Choose the architecture by taking the first one
 602          alphabetically.  */
 603       const char *chosen = arches[0];
 604       const char **arch;
 605       for (arch = arches; *arch != NULL; arch++)
 606         {
 607           if (strcmp (*arch, chosen) < 0)
 608             chosen = *arch;
 609         }
 610       if (chosen == NULL)
 611         internal_error (__FILE__, __LINE__,
 612                         _("initialize_current_architecture: No arch"));
 613       default_bfd_arch = bfd_scan_arch (chosen);
 614       if (default_bfd_arch == NULL)
 615         internal_error (__FILE__, __LINE__,
 616                         _("initialize_current_architecture: Arch not found"));
 617     }
 618
 619   info.bfd_arch_info = default_bfd_arch;
 620
 621   /* Take several guesses at a byte order.  */
 622   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 623       && default_bfd_vec != NULL)
 624     {
 625       /* Extract BFD's default vector's byte order.  */
 626       switch (default_bfd_vec->byteorder)
 627         {
 628         case BFD_ENDIAN_BIG:
 629           default_byte_order = BFD_ENDIAN_BIG;
 630           break;
 631         case BFD_ENDIAN_LITTLE:
 632           default_byte_order = BFD_ENDIAN_LITTLE;
 633           break;
 634         default:
 635           break;
 636         }
 637     }
 638   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 639     {
 640       /* look for ``*el-*'' in the target name.  */
 641       const char *chp;
 642       chp = strchr (target_name, '-');
 643       if (chp != NULL
 644           && chp - 2 >= target_name
 645           && strncmp (chp - 2, "el", 2) == 0)
 646         default_byte_order = BFD_ENDIAN_LITTLE;
 647     }
 648   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 649     {
 650       /* Wire it to big-endian!!! */
 651       default_byte_order = BFD_ENDIAN_BIG;
 652     }
 653
 654   info.byte_order = default_byte_order;
 655   info.byte_order_for_code = info.byte_order;
 656
 657   if (! gdbarch_update_p (info))
 658     internal_error (__FILE__, __LINE__,
 659                     _("initialize_current_architecture: Selection of "
 660                       "initial architecture failed"));
 661
 662   /* Create the ``set architecture'' command appending ``auto'' to the
 663      list of architectures.  */
 664   {
 665     /* Append ``auto''.  */
 666     int nr;
 667     for (nr = 0; arches[nr] != NULL; nr++);
 668     arches = xrealloc (arches, sizeof (char*) * (nr + 2));
 669     arches[nr + 0] = "auto";
 670     arches[nr + 1] = NULL;
 671     add_setshow_enum_cmd ("architecture", class_support,
 672                           arches, &set_architecture_string,
 673                           _("Set architecture of target."),
 674                           _("Show architecture of target."), NULL,
 675                           set_architecture, show_architecture,
 676                           &setlist, &showlist);
 677     add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
 678   }
 679 }
 680
 681
 682 /* Initialize a gdbarch info to values that will be automatically
 683    overridden.  Note: Originally, this ``struct info'' was initialized
 684    using memset(0).  Unfortunately, that ran into problems, namely
 685    BFD_ENDIAN_BIG is zero.  An explicit initialization function that
 686    can explicitly set each field to a well defined value is used.  */
 687
 688 void
 689 gdbarch_info_init (struct gdbarch_info *info)
 690 {
 691   memset (info, 0, sizeof (struct gdbarch_info));
 692   info->byte_order = BFD_ENDIAN_UNKNOWN;
 693   info->byte_order_for_code = info->byte_order;
 694   info->osabi = GDB_OSABI_UNINITIALIZED;
 695 }
 696
 697 /* Similar to init, but this time fill in the blanks.  Information is
 698    obtained from the global "set ..." options and explicitly
 699    initialized INFO fields.  */
 700
 701 void
 702 gdbarch_info_fill (struct gdbarch_info *info)
 703 {
 704   /* "(gdb) set architecture ...".  */
 705   if (info->bfd_arch_info == NULL
 706       && target_architecture_user)
 707     info->bfd_arch_info = target_architecture_user;
 708   /* From the file.  */
 709   if (info->bfd_arch_info == NULL
 710       && info->abfd != NULL
 711       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 712       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 713     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 714   /* From the target.  */
 715   if (info->target_desc != NULL)
 716     info->bfd_arch_info = choose_architecture_for_target
 717                            (info->target_desc, info->bfd_arch_info);
 718   /* From the default.  */
 719   if (info->bfd_arch_info == NULL)
 720     info->bfd_arch_info = default_bfd_arch;
 721
 722   /* "(gdb) set byte-order ...".  */
 723   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 724       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 725     info->byte_order = target_byte_order_user;
 726   /* From the INFO struct.  */
 727   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 728       && info->abfd != NULL)
 729     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 730                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 731                         : BFD_ENDIAN_UNKNOWN);
 732   /* From the default.  */
 733   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 734     info->byte_order = default_byte_order;
 735   info->byte_order_for_code = info->byte_order;
 736
 737   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 738   /* From the manual override, or from file.  */
 739   if (info->osabi == GDB_OSABI_UNINITIALIZED)
 740     info->osabi = gdbarch_lookup_osabi (info->abfd);
 741   /* From the target.  */
 742   if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
 743     info->osabi = tdesc_osabi (info->target_desc);
 744   /* From the configured default.  */
 745 #ifdef GDB_OSABI_DEFAULT
 746   if (info->osabi == GDB_OSABI_UNKNOWN)
 747     info->osabi = GDB_OSABI_DEFAULT;
 748 #endif
 749
 750   /* Must have at least filled in the architecture.  */
 751   gdb_assert (info->bfd_arch_info != NULL);
 752 }
 753
 754 /* Return "current" architecture.  If the target is running, this is
 755    the architecture of the selected frame.  Otherwise, the "current"
 756    architecture defaults to the target architecture.
 757
 758    This function should normally be called solely by the command
 759    interpreter routines to determine the architecture to execute a
 760    command in.  */
 761 struct gdbarch *
 762 get_current_arch (void)
 763 {
 764   if (has_stack_frames ())
 765     return get_frame_arch (get_selected_frame (NULL));
 766   else
 767     return target_gdbarch ();
 768 }
 769
 770 int
 771 default_has_shared_address_space (struct gdbarch *gdbarch)
 772 {
 773   /* Simply say no.  In most unix-like targets each inferior/process
 774      has its own address space.  */
 775   return 0;
 776 }
 777
 778 int
 779 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch,
 780                                   CORE_ADDR addr, int *isize, char **msg)
 781 {
 782   /* We don't know if maybe the target has some way to do fast
 783      tracepoints that doesn't need gdbarch, so always say yes.  */
 784   if (msg)
 785     *msg = NULL;
 786   return 1;
 787 }
 788
 789 void
 790 default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 791                                    int *kindptr)
 792 {
 793   gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr);
 794 }
 795
 796 void
 797 default_gen_return_address (struct gdbarch *gdbarch,
 798                             struct agent_expr *ax, struct axs_value *value,
 799                             CORE_ADDR scope)
 800 {
 801   error (_("This architecture has no method to collect a return address."));
 802 }
 803
 804 int
 805 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
 806                                         struct type *type)
 807 {
 808   /* Usually, the return value's address is stored the in the "first hidden"
 809      parameter if the return value should be passed by reference, as
 810      specified in ABI.  */
 811   return language_pass_by_reference (type);
 812 }
 813
 814 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
 815 {
 816   return 0;
 817 }
 818
 819 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
 820 {
 821   return 0;
 822 }
 823
 824 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 825 {
 826   return 0;
 827 }
 828
 829 /* */
 830
 831 /* -Wmissing-prototypes */
 832 extern initialize_file_ftype _initialize_gdbarch_utils;
 833
 834 void
 835 _initialize_gdbarch_utils (void)
 836 {
 837   add_setshow_enum_cmd ("endian", class_support,
 838                         endian_enum, &set_endian_string,
 839                         _("Set endianness of target."),
 840                         _("Show endianness of target."),
 841                         NULL, set_endian, show_endian,
 842                         &setlist, &showlist);
 843 }