gdb/arch-utils.c

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