contrib/gdb-7/gdb/arch-utils.c

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