gdb/arch-utils.c

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