gdb/arch-utils.c

   1 /* Dynamic architecture support for GDB, the GNU debugger.
   2
   3    Copyright (C) 1998-2021 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 "gdbcmd.h"
  24 #include "inferior.h"           /* enum CALL_DUMMY_LOCATION et al.  */
  25 #include "infrun.h"
  26 #include "regcache.h"
  27 #include "sim-regno.h"
  28 #include "gdbcore.h"
  29 #include "osabi.h"
  30 #include "target-descriptions.h"
  31 #include "objfiles.h"
  32 #include "language.h"
  33 #include "symtab.h"
  34
  35 #include "gdbsupport/version.h"
  36
  37 #include "floatformat.h"
  38
  39 #include "dis-asm.h"
  40
  41 bool
  42 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch)
  43 {
  44   return !gdbarch_software_single_step_p (gdbarch);
  45 }
  46
  47 CORE_ADDR
  48 displaced_step_at_entry_point (struct gdbarch *gdbarch)
  49 {
  50   CORE_ADDR addr;
  51   int bp_len;
  52
  53   addr = entry_point_address ();
  54
  55   /* Inferior calls also use the entry point as a breakpoint location.
  56      We don't want displaced stepping to interfere with those
  57      breakpoints, so leave space.  */
  58   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
  59   addr += bp_len * 2;
  60
  61   return addr;
  62 }
  63
  64 int
  65 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
  66 {
  67   /* Only makes sense to supply raw registers.  */
  68   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
  69   /* NOTE: cagney/2002-05-13: The old code did it this way and it is
  70      suspected that some GDB/SIM combinations may rely on this
  71      behaviour.  The default should be one2one_register_sim_regno
  72      (below).  */
  73   if (gdbarch_register_name (gdbarch, regnum) != NULL
  74       && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
  75     return regnum;
  76   else
  77     return LEGACY_SIM_REGNO_IGNORE;
  78 }
  79
  80
  81 /* See arch-utils.h */
  82
  83 std::string
  84 default_memtag_to_string (struct gdbarch *gdbarch, struct value *tag)
  85 {
  86   error (_("This architecture has no method to convert a memory tag to"
  87            " a string."));
  88 }
  89
  90 /* See arch-utils.h */
  91
  92 bool
  93 default_tagged_address_p (struct gdbarch *gdbarch, struct value *address)
  94 {
  95   /* By default, assume the address is untagged.  */
  96   return false;
  97 }
  98
  99 /* See arch-utils.h */
 100
 101 bool
 102 default_memtag_matches_p (struct gdbarch *gdbarch, struct value *address)
 103 {
 104   /* By default, assume the tags match.  */
 105   return true;
 106 }
 107
 108 /* See arch-utils.h */
 109
 110 bool
 111 default_set_memtags (struct gdbarch *gdbarch, struct value *address,
 112                      size_t length, const gdb::byte_vector &tags,
 113                      memtag_type tag_type)
 114 {
 115   /* By default, return true (successful);  */
 116   return true;
 117 }
 118
 119 /* See arch-utils.h */
 120
 121 struct value *
 122 default_get_memtag (struct gdbarch *gdbarch, struct value *address,
 123                     memtag_type tag_type)
 124 {
 125   /* By default, return no tag.  */
 126   return nullptr;
 127 }
 128
 129 CORE_ADDR
 130 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 131 {
 132   return 0;
 133 }
 134
 135 CORE_ADDR
 136 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 137 {
 138   return 0;
 139 }
 140
 141 int
 142 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
 143                                     CORE_ADDR pc, const char *name)
 144 {
 145   return 0;
 146 }
 147
 148 int
 149 generic_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 150 {
 151   return 0;
 152 }
 153
 154 int
 155 default_code_of_frame_writable (struct gdbarch *gdbarch,
 156                                 struct frame_info *frame)
 157 {
 158   return 1;
 159 }
 160
 161 /* Helper functions for gdbarch_inner_than */
 162
 163 int
 164 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
 165 {
 166   return (lhs < rhs);
 167 }
 168
 169 int
 170 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
 171 {
 172   return (lhs > rhs);
 173 }
 174
 175 /* Misc helper functions for targets.  */
 176
 177 CORE_ADDR
 178 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
 179 {
 180   return addr;
 181 }
 182
 183 CORE_ADDR
 184 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
 185                                      struct target_ops *targ)
 186 {
 187   return addr;
 188 }
 189
 190 int
 191 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 192 {
 193   return reg;
 194 }
 195
 196 void
 197 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
 198 {
 199   return;
 200 }
 201
 202 /* See arch-utils.h.  */
 203
 204 void
 205 default_make_symbol_special (struct symbol *sym, struct objfile *objfile)
 206 {
 207   return;
 208 }
 209
 210 /* See arch-utils.h.  */
 211
 212 CORE_ADDR
 213 default_adjust_dwarf2_addr (CORE_ADDR pc)
 214 {
 215   return pc;
 216 }
 217
 218 /* See arch-utils.h.  */
 219
 220 CORE_ADDR
 221 default_adjust_dwarf2_line (CORE_ADDR addr, int rel)
 222 {
 223   return addr;
 224 }
 225
 226 /* See arch-utils.h.  */
 227
 228 bool
 229 default_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op,
 230                                      struct dwarf2_frame_state *fs)
 231 {
 232   return false;
 233 }
 234
 235 int
 236 cannot_register_not (struct gdbarch *gdbarch, int regnum)
 237 {
 238   return 0;
 239 }
 240
 241 /* Legacy version of target_virtual_frame_pointer().  Assumes that
 242    there is an gdbarch_deprecated_fp_regnum and that it is the same,
 243    cooked or raw.  */
 244
 245 void
 246 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
 247                               CORE_ADDR pc,
 248                               int *frame_regnum,
 249                               LONGEST *frame_offset)
 250 {
 251   /* FIXME: cagney/2002-09-13: This code is used when identifying the
 252      frame pointer of the current PC.  It is assuming that a single
 253      register and an offset can determine this.  I think it should
 254      instead generate a byte code expression as that would work better
 255      with things like Dwarf2's CFI.  */
 256   if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
 257       && gdbarch_deprecated_fp_regnum (gdbarch)
 258            < gdbarch_num_regs (gdbarch))
 259     *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
 260   else if (gdbarch_sp_regnum (gdbarch) >= 0
 261            && gdbarch_sp_regnum (gdbarch)
 262                 < gdbarch_num_regs (gdbarch))
 263     *frame_regnum = gdbarch_sp_regnum (gdbarch);
 264   else
 265     /* Should this be an internal error?  I guess so, it is reflecting
 266        an architectural limitation in the current design.  */
 267     internal_error (__FILE__, __LINE__,
 268                     _("No virtual frame pointer available"));
 269   *frame_offset = 0;
 270 }
 271
 272 /* Return a floating-point format for a floating-point variable of
 273    length LEN in bits.  If non-NULL, NAME is the name of its type.
 274    If no suitable type is found, return NULL.  */
 275
 276 const struct floatformat **
 277 default_floatformat_for_type (struct gdbarch *gdbarch,
 278                               const char *name, int len)
 279 {
 280   const struct floatformat **format = NULL;
 281
 282   /* Check if this is a bfloat16 type.  It has the same size as the
 283      IEEE half float type, so we use the base type name to tell them
 284      apart.  */
 285   if (name != nullptr && strcmp (name, "__bf16") == 0
 286       && len == gdbarch_bfloat16_bit (gdbarch))
 287     format = gdbarch_bfloat16_format (gdbarch);
 288   else if (len == gdbarch_half_bit (gdbarch))
 289     format = gdbarch_half_format (gdbarch);
 290   else if (len == gdbarch_float_bit (gdbarch))
 291     format = gdbarch_float_format (gdbarch);
 292   else if (len == gdbarch_double_bit (gdbarch))
 293     format = gdbarch_double_format (gdbarch);
 294   else if (len == gdbarch_long_double_bit (gdbarch))
 295     format = gdbarch_long_double_format (gdbarch);
 296   /* On i386 the 'long double' type takes 96 bits,
 297      while the real number of used bits is only 80,
 298      both in processor and in memory.
 299      The code below accepts the real bit size.  */
 300   else if (gdbarch_long_double_format (gdbarch) != NULL
 301            && len == gdbarch_long_double_format (gdbarch)[0]->totalsize)
 302     format = gdbarch_long_double_format (gdbarch);
 303
 304   return format;
 305 }
 306 \f
 307 int
 308 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
 309                             struct type *type)
 310 {
 311   return 0;
 312 }
 313
 314 int
 315 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 316 {
 317   return 0;
 318 }
 319
 320 int
 321 generic_instruction_nullified (struct gdbarch *gdbarch,
 322                                struct regcache *regcache)
 323 {
 324   return 0;
 325 }
 326
 327 int
 328 default_remote_register_number (struct gdbarch *gdbarch,
 329                                 int regno)
 330 {
 331   return regno;
 332 }
 333
 334 /* See arch-utils.h.  */
 335
 336 int
 337 default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
 338 {
 339   return 0;
 340 }
 341
 342 \f
 343 /* Functions to manipulate the endianness of the target.  */
 344
 345 static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 346
 347 static const char endian_big[] = "big";
 348 static const char endian_little[] = "little";
 349 static const char endian_auto[] = "auto";
 350 static const char *const endian_enum[] =
 351 {
 352   endian_big,
 353   endian_little,
 354   endian_auto,
 355   NULL,
 356 };
 357 static const char *set_endian_string;
 358
 359 enum bfd_endian
 360 selected_byte_order (void)
 361 {
 362   return target_byte_order_user;
 363 }
 364
 365 /* Called by ``show endian''.  */
 366
 367 static void
 368 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 369              const char *value)
 370 {
 371   if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
 372     if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
 373       fprintf_unfiltered (file, _("The target endianness is set automatically "
 374                                   "(currently big endian).\n"));
 375     else
 376       fprintf_unfiltered (file, _("The target endianness is set automatically "
 377                                   "(currently little endian).\n"));
 378   else
 379     if (target_byte_order_user == BFD_ENDIAN_BIG)
 380       fprintf_unfiltered (file,
 381                           _("The target is set to big endian.\n"));
 382     else
 383       fprintf_unfiltered (file,
 384                           _("The target is set to little endian.\n"));
 385 }
 386
 387 static void
 388 set_endian (const char *ignore_args, int from_tty, struct cmd_list_element *c)
 389 {
 390   struct gdbarch_info info;
 391
 392   if (set_endian_string == endian_auto)
 393     {
 394       target_byte_order_user = BFD_ENDIAN_UNKNOWN;
 395       if (! gdbarch_update_p (info))
 396         internal_error (__FILE__, __LINE__,
 397                         _("set_endian: architecture update failed"));
 398     }
 399   else if (set_endian_string == endian_little)
 400     {
 401       info.byte_order = BFD_ENDIAN_LITTLE;
 402       if (! gdbarch_update_p (info))
 403         printf_unfiltered (_("Little endian target not supported by GDB\n"));
 404       else
 405         target_byte_order_user = BFD_ENDIAN_LITTLE;
 406     }
 407   else if (set_endian_string == endian_big)
 408     {
 409       info.byte_order = BFD_ENDIAN_BIG;
 410       if (! gdbarch_update_p (info))
 411         printf_unfiltered (_("Big endian target not supported by GDB\n"));
 412       else
 413         target_byte_order_user = BFD_ENDIAN_BIG;
 414     }
 415   else
 416     internal_error (__FILE__, __LINE__,
 417                     _("set_endian: bad value"));
 418
 419   show_endian (gdb_stdout, from_tty, NULL, NULL);
 420 }
 421
 422 /* Given SELECTED, a currently selected BFD architecture, and
 423    TARGET_DESC, the current target description, return what
 424    architecture to use.
 425
 426    SELECTED may be NULL, in which case we return the architecture
 427    associated with TARGET_DESC.  If SELECTED specifies a variant
 428    of the architecture associated with TARGET_DESC, return the
 429    more specific of the two.
 430
 431    If SELECTED is a different architecture, but it is accepted as
 432    compatible by the target, we can use the target architecture.
 433
 434    If SELECTED is obviously incompatible, warn the user.  */
 435
 436 static const struct bfd_arch_info *
 437 choose_architecture_for_target (const struct target_desc *target_desc,
 438                                 const struct bfd_arch_info *selected)
 439 {
 440   const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
 441   const struct bfd_arch_info *compat1, *compat2;
 442
 443   if (selected == NULL)
 444     return from_target;
 445
 446   if (from_target == NULL)
 447     return selected;
 448
 449   /* struct bfd_arch_info objects are singletons: that is, there's
 450      supposed to be exactly one instance for a given machine.  So you
 451      can tell whether two are equivalent by comparing pointers.  */
 452   if (from_target == selected)
 453     return selected;
 454
 455   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 456      incompatible.  But if they are compatible, it returns the 'more
 457      featureful' of the two arches.  That is, if A can run code
 458      written for B, but B can't run code written for A, then it'll
 459      return A.
 460
 461      Some targets (e.g. MIPS as of 2006-12-04) don't fully
 462      implement this, instead always returning NULL or the first
 463      argument.  We detect that case by checking both directions.  */
 464
 465   compat1 = selected->compatible (selected, from_target);
 466   compat2 = from_target->compatible (from_target, selected);
 467
 468   if (compat1 == NULL && compat2 == NULL)
 469     {
 470       /* BFD considers the architectures incompatible.  Check our
 471          target description whether it accepts SELECTED as compatible
 472          anyway.  */
 473       if (tdesc_compatible_p (target_desc, selected))
 474         return from_target;
 475
 476       warning (_("Selected architecture %s is not compatible "
 477                  "with reported target architecture %s"),
 478                selected->printable_name, from_target->printable_name);
 479       return selected;
 480     }
 481
 482   if (compat1 == NULL)
 483     return compat2;
 484   if (compat2 == NULL)
 485     return compat1;
 486   if (compat1 == compat2)
 487     return compat1;
 488
 489   /* If the two didn't match, but one of them was a default
 490      architecture, assume the more specific one is correct.  This
 491      handles the case where an executable or target description just
 492      says "mips", but the other knows which MIPS variant.  */
 493   if (compat1->the_default)
 494     return compat2;
 495   if (compat2->the_default)
 496     return compat1;
 497
 498   /* We have no idea which one is better.  This is a bug, but not
 499      a critical problem; warn the user.  */
 500   warning (_("Selected architecture %s is ambiguous with "
 501              "reported target architecture %s"),
 502            selected->printable_name, from_target->printable_name);
 503   return selected;
 504 }
 505
 506 /* Functions to manipulate the architecture of the target.  */
 507
 508 enum set_arch { set_arch_auto, set_arch_manual };
 509
 510 static const struct bfd_arch_info *target_architecture_user;
 511
 512 static const char *set_architecture_string;
 513
 514 const char *
 515 selected_architecture_name (void)
 516 {
 517   if (target_architecture_user == NULL)
 518     return NULL;
 519   else
 520     return set_architecture_string;
 521 }
 522
 523 /* Called if the user enters ``show architecture'' without an
 524    argument.  */
 525
 526 static void
 527 show_architecture (struct ui_file *file, int from_tty,
 528                    struct cmd_list_element *c, const char *value)
 529 {
 530   if (target_architecture_user == NULL)
 531     fprintf_filtered (file, _("The target architecture is set to "
 532                               "\"auto\" (currently \"%s\").\n"),
 533                       gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
 534   else
 535     fprintf_filtered (file, _("The target architecture is set to \"%s\".\n"),
 536                       set_architecture_string);
 537 }
 538
 539
 540 /* Called if the user enters ``set architecture'' with or without an
 541    argument.  */
 542
 543 static void
 544 set_architecture (const char *ignore_args,
 545                   int from_tty, struct cmd_list_element *c)
 546 {
 547   struct gdbarch_info info;
 548
 549   if (strcmp (set_architecture_string, "auto") == 0)
 550     {
 551       target_architecture_user = NULL;
 552       if (!gdbarch_update_p (info))
 553         internal_error (__FILE__, __LINE__,
 554                         _("could not select an architecture automatically"));
 555     }
 556   else
 557     {
 558       info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
 559       if (info.bfd_arch_info == NULL)
 560         internal_error (__FILE__, __LINE__,
 561                         _("set_architecture: bfd_scan_arch failed"));
 562       if (gdbarch_update_p (info))
 563         target_architecture_user = info.bfd_arch_info;
 564       else
 565         printf_unfiltered (_("Architecture `%s' not recognized.\n"),
 566                            set_architecture_string);
 567     }
 568   show_architecture (gdb_stdout, from_tty, NULL, NULL);
 569 }
 570
 571 /* Try to select a global architecture that matches "info".  Return
 572    non-zero if the attempt succeeds.  */
 573 int
 574 gdbarch_update_p (struct gdbarch_info info)
 575 {
 576   struct gdbarch *new_gdbarch;
 577
 578   /* Check for the current file.  */
 579   if (info.abfd == NULL)
 580     info.abfd = current_program_space->exec_bfd ();
 581   if (info.abfd == NULL)
 582     info.abfd = core_bfd;
 583
 584   /* Check for the current target description.  */
 585   if (info.target_desc == NULL)
 586     info.target_desc = target_current_description ();
 587
 588   new_gdbarch = gdbarch_find_by_info (info);
 589
 590   /* If there no architecture by that name, reject the request.  */
 591   if (new_gdbarch == NULL)
 592     {
 593       if (gdbarch_debug)
 594         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 595                             "Architecture not found\n");
 596       return 0;
 597     }
 598
 599   /* If it is the same old architecture, accept the request (but don't
 600      swap anything).  */
 601   if (new_gdbarch == target_gdbarch ())
 602     {
 603       if (gdbarch_debug)
 604         fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 605                             "Architecture %s (%s) unchanged\n",
 606                             host_address_to_string (new_gdbarch),
 607                             gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 608       return 1;
 609     }
 610
 611   /* It's a new architecture, swap it in.  */
 612   if (gdbarch_debug)
 613     fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
 614                         "New architecture %s (%s) selected\n",
 615                         host_address_to_string (new_gdbarch),
 616                         gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
 617   set_target_gdbarch (new_gdbarch);
 618
 619   return 1;
 620 }
 621
 622 /* Return the architecture for ABFD.  If no suitable architecture
 623    could be find, return NULL.  */
 624
 625 struct gdbarch *
 626 gdbarch_from_bfd (bfd *abfd)
 627 {
 628   struct gdbarch_info info;
 629
 630   info.abfd = abfd;
 631   return gdbarch_find_by_info (info);
 632 }
 633
 634 /* Set the dynamic target-system-dependent parameters (architecture,
 635    byte-order) using information found in the BFD */
 636
 637 void
 638 set_gdbarch_from_file (bfd *abfd)
 639 {
 640   struct gdbarch_info info;
 641   struct gdbarch *gdbarch;
 642
 643   info.abfd = abfd;
 644   info.target_desc = target_current_description ();
 645   gdbarch = gdbarch_find_by_info (info);
 646
 647   if (gdbarch == NULL)
 648     error (_("Architecture of file not recognized."));
 649   set_target_gdbarch (gdbarch);
 650 }
 651
 652 /* Initialize the current architecture.  Update the ``set
 653    architecture'' command so that it specifies a list of valid
 654    architectures.  */
 655
 656 #ifdef DEFAULT_BFD_ARCH
 657 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
 658 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
 659 #else
 660 static const bfd_arch_info_type *default_bfd_arch;
 661 #endif
 662
 663 #ifdef DEFAULT_BFD_VEC
 664 extern const bfd_target DEFAULT_BFD_VEC;
 665 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
 666 #else
 667 static const bfd_target *default_bfd_vec;
 668 #endif
 669
 670 static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN;
 671
 672 /* Printable names of architectures.  Used as the enum list of the
 673    "set arch" command.  */
 674 static std::vector<const char *> arches;
 675
 676 void
 677 initialize_current_architecture (void)
 678 {
 679   arches = gdbarch_printable_names ();
 680
 681   /* Find a default architecture.  */
 682   if (default_bfd_arch == NULL)
 683     {
 684       /* Choose the architecture by taking the first one
 685          alphabetically.  */
 686       const char *chosen = arches[0];
 687
 688       for (const char *arch : arches)
 689         {
 690           if (strcmp (arch, chosen) < 0)
 691             chosen = arch;
 692         }
 693
 694       if (chosen == NULL)
 695         internal_error (__FILE__, __LINE__,
 696                         _("initialize_current_architecture: No arch"));
 697
 698       default_bfd_arch = bfd_scan_arch (chosen);
 699       if (default_bfd_arch == NULL)
 700         internal_error (__FILE__, __LINE__,
 701                         _("initialize_current_architecture: Arch not found"));
 702     }
 703
 704   gdbarch_info info;
 705   info.bfd_arch_info = default_bfd_arch;
 706
 707   /* Take several guesses at a byte order.  */
 708   if (default_byte_order == BFD_ENDIAN_UNKNOWN
 709       && default_bfd_vec != NULL)
 710     {
 711       /* Extract BFD's default vector's byte order.  */
 712       switch (default_bfd_vec->byteorder)
 713         {
 714         case BFD_ENDIAN_BIG:
 715           default_byte_order = BFD_ENDIAN_BIG;
 716           break;
 717         case BFD_ENDIAN_LITTLE:
 718           default_byte_order = BFD_ENDIAN_LITTLE;
 719           break;
 720         default:
 721           break;
 722         }
 723     }
 724   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 725     {
 726       /* look for ``*el-*'' in the target name.  */
 727       const char *chp;
 728       chp = strchr (target_name, '-');
 729       if (chp != NULL
 730           && chp - 2 >= target_name
 731           && startswith (chp - 2, "el"))
 732         default_byte_order = BFD_ENDIAN_LITTLE;
 733     }
 734   if (default_byte_order == BFD_ENDIAN_UNKNOWN)
 735     {
 736       /* Wire it to big-endian!!! */
 737       default_byte_order = BFD_ENDIAN_BIG;
 738     }
 739
 740   info.byte_order = default_byte_order;
 741   info.byte_order_for_code = info.byte_order;
 742
 743   if (! gdbarch_update_p (info))
 744     internal_error (__FILE__, __LINE__,
 745                     _("initialize_current_architecture: Selection of "
 746                       "initial architecture failed"));
 747
 748   /* Create the ``set architecture'' command appending ``auto'' to the
 749      list of architectures.  */
 750   {
 751     /* Append ``auto''.  */
 752     arches.push_back ("auto");
 753     arches.push_back (nullptr);
 754     set_show_commands architecture_cmds
 755       = add_setshow_enum_cmd ("architecture", class_support,
 756                               arches.data (), &set_architecture_string,
 757                               _("Set architecture of target."),
 758                               _("Show architecture of target."), NULL,
 759                               set_architecture, show_architecture,
 760                               &setlist, &showlist);
 761     add_alias_cmd ("processor", architecture_cmds.set, class_support, 1,
 762                    &setlist);
 763   }
 764 }
 765
 766 /* Similar to init, but this time fill in the blanks.  Information is
 767    obtained from the global "set ..." options and explicitly
 768    initialized INFO fields.  */
 769
 770 void
 771 gdbarch_info_fill (struct gdbarch_info *info)
 772 {
 773   /* "(gdb) set architecture ...".  */
 774   if (info->bfd_arch_info == NULL
 775       && target_architecture_user)
 776     info->bfd_arch_info = target_architecture_user;
 777   /* From the file.  */
 778   if (info->bfd_arch_info == NULL
 779       && info->abfd != NULL
 780       && bfd_get_arch (info->abfd) != bfd_arch_unknown
 781       && bfd_get_arch (info->abfd) != bfd_arch_obscure)
 782     info->bfd_arch_info = bfd_get_arch_info (info->abfd);
 783   /* From the target.  */
 784   if (info->target_desc != NULL)
 785     info->bfd_arch_info = choose_architecture_for_target
 786                            (info->target_desc, info->bfd_arch_info);
 787   /* From the default.  */
 788   if (info->bfd_arch_info == NULL)
 789     info->bfd_arch_info = default_bfd_arch;
 790
 791   /* "(gdb) set byte-order ...".  */
 792   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 793       && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
 794     info->byte_order = target_byte_order_user;
 795   /* From the INFO struct.  */
 796   if (info->byte_order == BFD_ENDIAN_UNKNOWN
 797       && info->abfd != NULL)
 798     info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
 799                         : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
 800                         : BFD_ENDIAN_UNKNOWN);
 801   /* From the default.  */
 802   if (info->byte_order == BFD_ENDIAN_UNKNOWN)
 803     info->byte_order = default_byte_order;
 804   info->byte_order_for_code = info->byte_order;
 805   /* Wire the default to the last selected byte order.  */
 806   default_byte_order = info->byte_order;
 807
 808   /* "(gdb) set osabi ...".  Handled by gdbarch_lookup_osabi.  */
 809   /* From the manual override, or from file.  */
 810   if (info->osabi == GDB_OSABI_UNKNOWN)
 811     info->osabi = gdbarch_lookup_osabi (info->abfd);
 812   /* From the target.  */
 813
 814   if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
 815     info->osabi = tdesc_osabi (info->target_desc);
 816   /* From the configured default.  */
 817 #ifdef GDB_OSABI_DEFAULT
 818   if (info->osabi == GDB_OSABI_UNKNOWN)
 819     info->osabi = GDB_OSABI_DEFAULT;
 820 #endif
 821   /* If we still don't know which osabi to pick, pick none.  */
 822   if (info->osabi == GDB_OSABI_UNKNOWN)
 823     info->osabi = GDB_OSABI_NONE;
 824
 825   /* Must have at least filled in the architecture.  */
 826   gdb_assert (info->bfd_arch_info != NULL);
 827 }
 828
 829 /* Return "current" architecture.  If the target is running, this is
 830    the architecture of the selected frame.  Otherwise, the "current"
 831    architecture defaults to the target architecture.
 832
 833    This function should normally be called solely by the command
 834    interpreter routines to determine the architecture to execute a
 835    command in.  */
 836 struct gdbarch *
 837 get_current_arch (void)
 838 {
 839   if (has_stack_frames ())
 840     return get_frame_arch (get_selected_frame (NULL));
 841   else
 842     return target_gdbarch ();
 843 }
 844
 845 int
 846 default_has_shared_address_space (struct gdbarch *gdbarch)
 847 {
 848   /* Simply say no.  In most unix-like targets each inferior/process
 849      has its own address space.  */
 850   return 0;
 851 }
 852
 853 int
 854 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr,
 855                                   std::string *msg)
 856 {
 857   /* We don't know if maybe the target has some way to do fast
 858      tracepoints that doesn't need gdbarch, so always say yes.  */
 859   if (msg)
 860     msg->clear ();
 861   return 1;
 862 }
 863
 864 const gdb_byte *
 865 default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 866                             int *lenptr)
 867 {
 868   int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
 869
 870   return gdbarch_sw_breakpoint_from_kind (gdbarch, kind, lenptr);
 871 }
 872 int
 873 default_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
 874                                             struct regcache *regcache,
 875                                             CORE_ADDR *pcptr)
 876 {
 877   return gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
 878 }
 879
 880
 881 void
 882 default_gen_return_address (struct gdbarch *gdbarch,
 883                             struct agent_expr *ax, struct axs_value *value,
 884                             CORE_ADDR scope)
 885 {
 886   error (_("This architecture has no method to collect a return address."));
 887 }
 888
 889 int
 890 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
 891                                         struct type *type)
 892 {
 893   /* Usually, the return value's address is stored the in the "first hidden"
 894      parameter if the return value should be passed by reference, as
 895      specified in ABI.  */
 896   return !(language_pass_by_reference (type).trivially_copyable);
 897 }
 898
 899 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
 900 {
 901   return 0;
 902 }
 903
 904 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
 905 {
 906   return 0;
 907 }
 908
 909 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 910 {
 911   return 0;
 912 }
 913
 914 /*  See arch-utils.h.  */
 915
 916 bool
 917 default_program_breakpoint_here_p (struct gdbarch *gdbarch,
 918                                    CORE_ADDR address)
 919 {
 920   int len;
 921   const gdb_byte *bpoint = gdbarch_breakpoint_from_pc (gdbarch, &address, &len);
 922
 923   /* Software breakpoints unsupported?  */
 924   if (bpoint == nullptr)
 925     return false;
 926
 927   gdb_byte *target_mem = (gdb_byte *) alloca (len);
 928
 929   /* Enable the automatic memory restoration from breakpoints while
 930      we read the memory.  Otherwise we may find temporary breakpoints, ones
 931      inserted by GDB, and flag them as permanent breakpoints.  */
 932   scoped_restore restore_memory
 933     = make_scoped_restore_show_memory_breakpoints (0);
 934
 935   if (target_read_memory (address, target_mem, len) == 0)
 936     {
 937       /* Check if this is a breakpoint instruction for this architecture,
 938          including ones used by GDB.  */
 939       if (memcmp (target_mem, bpoint, len) == 0)
 940         return true;
 941     }
 942
 943   return false;
 944 }
 945
 946 void
 947 default_skip_permanent_breakpoint (struct regcache *regcache)
 948 {
 949   struct gdbarch *gdbarch = regcache->arch ();
 950   CORE_ADDR current_pc = regcache_read_pc (regcache);
 951   int bp_len;
 952
 953   gdbarch_breakpoint_from_pc (gdbarch, &current_pc, &bp_len);
 954   current_pc += bp_len;
 955   regcache_write_pc (regcache, current_pc);
 956 }
 957
 958 CORE_ADDR
 959 default_infcall_mmap (CORE_ADDR size, unsigned prot)
 960 {
 961   error (_("This target does not support inferior memory allocation by mmap."));
 962 }
 963
 964 void
 965 default_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
 966 {
 967   /* Memory reserved by inferior mmap is kept leaked.  */
 968 }
 969
 970 /* -mcmodel=large is used so that no GOT (Global Offset Table) is needed to be
 971    created in inferior memory by GDB (normally it is set by ld.so).  */
 972
 973 std::string
 974 default_gcc_target_options (struct gdbarch *gdbarch)
 975 {
 976   return string_printf ("-m%d%s", gdbarch_ptr_bit (gdbarch),
 977                         (gdbarch_ptr_bit (gdbarch) == 64
 978                          ? " -mcmodel=large" : ""));
 979 }
 980
 981 /* gdbarch gnu_triplet_regexp method.  */
 982
 983 const char *
 984 default_gnu_triplet_regexp (struct gdbarch *gdbarch)
 985 {
 986   return gdbarch_bfd_arch_info (gdbarch)->arch_name;
 987 }
 988
 989 /* Default method for gdbarch_addressable_memory_unit_size.  The default is
 990    based on the bits_per_byte defined in the bfd library for the current
 991    architecture, this is usually 8-bits, and so this function will usually
 992    return 1 indicating 1 byte is 1 octet.  */
 993
 994 int
 995 default_addressable_memory_unit_size (struct gdbarch *gdbarch)
 996 {
 997   return gdbarch_bfd_arch_info (gdbarch)->bits_per_byte / 8;
 998 }
 999
1000 void
1001 default_guess_tracepoint_registers (struct gdbarch *gdbarch,
1002                                     struct regcache *regcache,
1003                                     CORE_ADDR addr)
1004 {
1005   int pc_regno = gdbarch_pc_regnum (gdbarch);
1006   gdb_byte *regs;
1007
1008   /* This guessing code below only works if the PC register isn't
1009      a pseudo-register.  The value of a pseudo-register isn't stored
1010      in the (non-readonly) regcache -- instead it's recomputed
1011      (probably from some other cached raw register) whenever the
1012      register is read.  In this case, a custom method implementation
1013      should be used by the architecture.  */
1014   if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
1015     return;
1016
1017   regs = (gdb_byte *) alloca (register_size (gdbarch, pc_regno));
1018   store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
1019                           gdbarch_byte_order (gdbarch), addr);
1020   regcache->raw_supply (pc_regno, regs);
1021 }
1022
1023 int
1024 default_print_insn (bfd_vma memaddr, disassemble_info *info)
1025 {
1026   disassembler_ftype disassemble_fn;
1027
1028   disassemble_fn = disassembler (info->arch, info->endian == BFD_ENDIAN_BIG,
1029                                  info->mach, current_program_space->exec_bfd ());
1030
1031   gdb_assert (disassemble_fn != NULL);
1032   return (*disassemble_fn) (memaddr, info);
1033 }
1034
1035 /* See arch-utils.h.  */
1036
1037 CORE_ADDR
1038 gdbarch_skip_prologue_noexcept (gdbarch *gdbarch, CORE_ADDR pc) noexcept
1039 {
1040   CORE_ADDR new_pc = pc;
1041
1042   try
1043     {
1044       new_pc = gdbarch_skip_prologue (gdbarch, pc);
1045     }
1046   catch (const gdb_exception &ex)
1047     {}
1048
1049   return new_pc;
1050 }
1051
1052 /* See arch-utils.h.  */
1053
1054 bool
1055 default_in_indirect_branch_thunk (gdbarch *gdbarch, CORE_ADDR pc)
1056 {
1057   return false;
1058 }
1059
1060 /* See arch-utils.h.  */
1061
1062 ULONGEST
1063 default_type_align (struct gdbarch *gdbarch, struct type *type)
1064 {
1065   return 0;
1066 }
1067
1068 /* See arch-utils.h.  */
1069
1070 std::string
1071 default_get_pc_address_flags (frame_info *frame, CORE_ADDR pc)
1072 {
1073   return "";
1074 }
1075
1076 /* See arch-utils.h.  */
1077 void
1078 default_read_core_file_mappings
1079   (struct gdbarch *gdbarch,
1080    struct bfd *cbfd,
1081    read_core_file_mappings_pre_loop_ftype pre_loop_cb,
1082    read_core_file_mappings_loop_ftype loop_cb)
1083 {
1084 }
1085
1086 void _initialize_gdbarch_utils ();
1087 void
1088 _initialize_gdbarch_utils ()
1089 {
1090   add_setshow_enum_cmd ("endian", class_support,
1091                         endian_enum, &set_endian_string,
1092                         _("Set endianness of target."),
1093                         _("Show endianness of target."),
1094                         NULL, set_endian, show_endian,
1095                         &setlist, &showlist);
1096 }