1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright (C) 1998-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "arch-utils.h"
25 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et al. */
28 #include "sim-regno.h"
31 #include "target-descriptions.h"
38 #include "floatformat.h"
42 struct displaced_step_closure *
43 simple_displaced_step_copy_insn (struct gdbarch *gdbarch,
44 CORE_ADDR from, CORE_ADDR to,
45 struct regcache *regs)
47 size_t len = gdbarch_max_insn_length (gdbarch);
48 gdb_byte *buf = (gdb_byte *) xmalloc (len);
50 read_memory (from, buf, len);
51 write_memory (to, buf, len);
55 fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
56 paddress (gdbarch, from), paddress (gdbarch, to));
57 displaced_step_dump_bytes (gdb_stdlog, buf, len);
60 return (struct displaced_step_closure *) buf;
65 simple_displaced_step_free_closure (struct gdbarch *gdbarch,
66 struct displaced_step_closure *closure)
72 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
73 struct displaced_step_closure *closure)
75 return !gdbarch_software_single_step_p (gdbarch);
79 displaced_step_at_entry_point (struct gdbarch *gdbarch)
84 addr = entry_point_address ();
86 /* Inferior calls also use the entry point as a breakpoint location.
87 We don't want displaced stepping to interfere with those
88 breakpoints, so leave space. */
89 gdbarch_breakpoint_from_pc (gdbarch, &addr, &bp_len);
96 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
98 /* Only makes sense to supply raw registers. */
99 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
100 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
101 suspected that some GDB/SIM combinations may rely on this
102 behavour. The default should be one2one_register_sim_regno
104 if (gdbarch_register_name (gdbarch, regnum) != NULL
105 && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
108 return LEGACY_SIM_REGNO_IGNORE;
112 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
118 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
124 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
125 CORE_ADDR pc, const char *name)
131 generic_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
137 default_code_of_frame_writable (struct gdbarch *gdbarch,
138 struct frame_info *frame)
143 /* Helper functions for gdbarch_inner_than */
146 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
152 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
157 /* Misc helper functions for targets. */
160 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
166 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
167 struct target_ops *targ)
173 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
179 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
184 /* See arch-utils.h. */
187 default_make_symbol_special (struct symbol *sym, struct objfile *objfile)
192 /* See arch-utils.h. */
195 default_adjust_dwarf2_addr (CORE_ADDR pc)
200 /* See arch-utils.h. */
203 default_adjust_dwarf2_line (CORE_ADDR addr, int rel)
208 /* See arch-utils.h. */
211 default_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op,
212 struct dwarf2_frame_state *fs)
218 cannot_register_not (struct gdbarch *gdbarch, int regnum)
223 /* Legacy version of target_virtual_frame_pointer(). Assumes that
224 there is an gdbarch_deprecated_fp_regnum and that it is the same,
228 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
231 LONGEST *frame_offset)
233 /* FIXME: cagney/2002-09-13: This code is used when identifying the
234 frame pointer of the current PC. It is assuming that a single
235 register and an offset can determine this. I think it should
236 instead generate a byte code expression as that would work better
237 with things like Dwarf2's CFI. */
238 if (gdbarch_deprecated_fp_regnum (gdbarch) >= 0
239 && gdbarch_deprecated_fp_regnum (gdbarch)
240 < gdbarch_num_regs (gdbarch))
241 *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch);
242 else if (gdbarch_sp_regnum (gdbarch) >= 0
243 && gdbarch_sp_regnum (gdbarch)
244 < gdbarch_num_regs (gdbarch))
245 *frame_regnum = gdbarch_sp_regnum (gdbarch);
247 /* Should this be an internal error? I guess so, it is reflecting
248 an architectural limitation in the current design. */
249 internal_error (__FILE__, __LINE__,
250 _("No virtual frame pointer available"));
254 /* Return a floating-point format for a floating-point variable of
255 length LEN in bits. If non-NULL, NAME is the name of its type.
256 If no suitable type is found, return NULL. */
258 const struct floatformat **
259 default_floatformat_for_type (struct gdbarch *gdbarch,
260 const char *name, int len)
262 const struct floatformat **format = NULL;
264 if (len == gdbarch_half_bit (gdbarch))
265 format = gdbarch_half_format (gdbarch);
266 else if (len == gdbarch_float_bit (gdbarch))
267 format = gdbarch_float_format (gdbarch);
268 else if (len == gdbarch_double_bit (gdbarch))
269 format = gdbarch_double_format (gdbarch);
270 else if (len == gdbarch_long_double_bit (gdbarch))
271 format = gdbarch_long_double_format (gdbarch);
272 /* On i386 the 'long double' type takes 96 bits,
273 while the real number of used bits is only 80,
274 both in processor and in memory.
275 The code below accepts the real bit size. */
276 else if (gdbarch_long_double_format (gdbarch) != NULL
277 && len == gdbarch_long_double_format (gdbarch)[0]->totalsize)
278 format = gdbarch_long_double_format (gdbarch);
284 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
291 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
297 generic_instruction_nullified (struct gdbarch *gdbarch,
298 struct regcache *regcache)
304 default_remote_register_number (struct gdbarch *gdbarch,
310 /* See arch-utils.h. */
313 default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
319 /* Functions to manipulate the endianness of the target. */
321 static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN;
323 static const char endian_big[] = "big";
324 static const char endian_little[] = "little";
325 static const char endian_auto[] = "auto";
326 static const char *const endian_enum[] =
333 static const char *set_endian_string;
336 selected_byte_order (void)
338 return target_byte_order_user;
341 /* Called by ``show endian''. */
344 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
347 if (target_byte_order_user == BFD_ENDIAN_UNKNOWN)
348 if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG)
349 fprintf_unfiltered (file, _("The target endianness is set automatically "
350 "(currently big endian)\n"));
352 fprintf_unfiltered (file, _("The target endianness is set automatically "
353 "(currently little endian)\n"));
355 if (target_byte_order_user == BFD_ENDIAN_BIG)
356 fprintf_unfiltered (file,
357 _("The target is assumed to be big endian\n"));
359 fprintf_unfiltered (file,
360 _("The target is assumed to be little endian\n"));
364 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
366 struct gdbarch_info info;
368 gdbarch_info_init (&info);
370 if (set_endian_string == endian_auto)
372 target_byte_order_user = BFD_ENDIAN_UNKNOWN;
373 if (! gdbarch_update_p (info))
374 internal_error (__FILE__, __LINE__,
375 _("set_endian: architecture update failed"));
377 else if (set_endian_string == endian_little)
379 info.byte_order = BFD_ENDIAN_LITTLE;
380 if (! gdbarch_update_p (info))
381 printf_unfiltered (_("Little endian target not supported by GDB\n"));
383 target_byte_order_user = BFD_ENDIAN_LITTLE;
385 else if (set_endian_string == endian_big)
387 info.byte_order = BFD_ENDIAN_BIG;
388 if (! gdbarch_update_p (info))
389 printf_unfiltered (_("Big endian target not supported by GDB\n"));
391 target_byte_order_user = BFD_ENDIAN_BIG;
394 internal_error (__FILE__, __LINE__,
395 _("set_endian: bad value"));
397 show_endian (gdb_stdout, from_tty, NULL, NULL);
400 /* Given SELECTED, a currently selected BFD architecture, and
401 TARGET_DESC, the current target description, return what
404 SELECTED may be NULL, in which case we return the architecture
405 associated with TARGET_DESC. If SELECTED specifies a variant
406 of the architecture associtated with TARGET_DESC, return the
407 more specific of the two.
409 If SELECTED is a different architecture, but it is accepted as
410 compatible by the target, we can use the target architecture.
412 If SELECTED is obviously incompatible, warn the user. */
414 static const struct bfd_arch_info *
415 choose_architecture_for_target (const struct target_desc *target_desc,
416 const struct bfd_arch_info *selected)
418 const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
419 const struct bfd_arch_info *compat1, *compat2;
421 if (selected == NULL)
424 if (from_target == NULL)
427 /* struct bfd_arch_info objects are singletons: that is, there's
428 supposed to be exactly one instance for a given machine. So you
429 can tell whether two are equivalent by comparing pointers. */
430 if (from_target == selected)
433 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
434 incompatible. But if they are compatible, it returns the 'more
435 featureful' of the two arches. That is, if A can run code
436 written for B, but B can't run code written for A, then it'll
439 Some targets (e.g. MIPS as of 2006-12-04) don't fully
440 implement this, instead always returning NULL or the first
441 argument. We detect that case by checking both directions. */
443 compat1 = selected->compatible (selected, from_target);
444 compat2 = from_target->compatible (from_target, selected);
446 if (compat1 == NULL && compat2 == NULL)
448 /* BFD considers the architectures incompatible. Check our
449 target description whether it accepts SELECTED as compatible
451 if (tdesc_compatible_p (target_desc, selected))
454 warning (_("Selected architecture %s is not compatible "
455 "with reported target architecture %s"),
456 selected->printable_name, from_target->printable_name);
464 if (compat1 == compat2)
467 /* If the two didn't match, but one of them was a default
468 architecture, assume the more specific one is correct. This
469 handles the case where an executable or target description just
470 says "mips", but the other knows which MIPS variant. */
471 if (compat1->the_default)
473 if (compat2->the_default)
476 /* We have no idea which one is better. This is a bug, but not
477 a critical problem; warn the user. */
478 warning (_("Selected architecture %s is ambiguous with "
479 "reported target architecture %s"),
480 selected->printable_name, from_target->printable_name);
484 /* Functions to manipulate the architecture of the target. */
486 enum set_arch { set_arch_auto, set_arch_manual };
488 static const struct bfd_arch_info *target_architecture_user;
490 static const char *set_architecture_string;
493 selected_architecture_name (void)
495 if (target_architecture_user == NULL)
498 return set_architecture_string;
501 /* Called if the user enters ``show architecture'' without an
505 show_architecture (struct ui_file *file, int from_tty,
506 struct cmd_list_element *c, const char *value)
508 if (target_architecture_user == NULL)
509 fprintf_filtered (file, _("The target architecture is set "
510 "automatically (currently %s)\n"),
511 gdbarch_bfd_arch_info (get_current_arch ())->printable_name);
513 fprintf_filtered (file, _("The target architecture is assumed to be %s\n"),
514 set_architecture_string);
518 /* Called if the user enters ``set architecture'' with or without an
522 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
524 struct gdbarch_info info;
526 gdbarch_info_init (&info);
528 if (strcmp (set_architecture_string, "auto") == 0)
530 target_architecture_user = NULL;
531 if (!gdbarch_update_p (info))
532 internal_error (__FILE__, __LINE__,
533 _("could not select an architecture automatically"));
537 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
538 if (info.bfd_arch_info == NULL)
539 internal_error (__FILE__, __LINE__,
540 _("set_architecture: bfd_scan_arch failed"));
541 if (gdbarch_update_p (info))
542 target_architecture_user = info.bfd_arch_info;
544 printf_unfiltered (_("Architecture `%s' not recognized.\n"),
545 set_architecture_string);
547 show_architecture (gdb_stdout, from_tty, NULL, NULL);
550 /* Try to select a global architecture that matches "info". Return
551 non-zero if the attempt succeeds. */
553 gdbarch_update_p (struct gdbarch_info info)
555 struct gdbarch *new_gdbarch;
557 /* Check for the current file. */
558 if (info.abfd == NULL)
559 info.abfd = exec_bfd;
560 if (info.abfd == NULL)
561 info.abfd = core_bfd;
563 /* Check for the current target description. */
564 if (info.target_desc == NULL)
565 info.target_desc = target_current_description ();
567 new_gdbarch = gdbarch_find_by_info (info);
569 /* If there no architecture by that name, reject the request. */
570 if (new_gdbarch == NULL)
573 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
574 "Architecture not found\n");
578 /* If it is the same old architecture, accept the request (but don't
580 if (new_gdbarch == target_gdbarch ())
583 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
584 "Architecture %s (%s) unchanged\n",
585 host_address_to_string (new_gdbarch),
586 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
590 /* It's a new architecture, swap it in. */
592 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
593 "New architecture %s (%s) selected\n",
594 host_address_to_string (new_gdbarch),
595 gdbarch_bfd_arch_info (new_gdbarch)->printable_name);
596 set_target_gdbarch (new_gdbarch);
601 /* Return the architecture for ABFD. If no suitable architecture
602 could be find, return NULL. */
605 gdbarch_from_bfd (bfd *abfd)
607 struct gdbarch_info info;
608 gdbarch_info_init (&info);
611 return gdbarch_find_by_info (info);
614 /* Set the dynamic target-system-dependent parameters (architecture,
615 byte-order) using information found in the BFD */
618 set_gdbarch_from_file (bfd *abfd)
620 struct gdbarch_info info;
621 struct gdbarch *gdbarch;
623 gdbarch_info_init (&info);
625 info.target_desc = target_current_description ();
626 gdbarch = gdbarch_find_by_info (info);
629 error (_("Architecture of file not recognized."));
630 set_target_gdbarch (gdbarch);
633 /* Initialize the current architecture. Update the ``set
634 architecture'' command so that it specifies a list of valid
637 #ifdef DEFAULT_BFD_ARCH
638 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
639 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
641 static const bfd_arch_info_type *default_bfd_arch;
644 #ifdef DEFAULT_BFD_VEC
645 extern const bfd_target DEFAULT_BFD_VEC;
646 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
648 static const bfd_target *default_bfd_vec;
651 static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN;
654 initialize_current_architecture (void)
656 const char **arches = gdbarch_printable_names ();
657 struct gdbarch_info info;
659 /* determine a default architecture and byte order. */
660 gdbarch_info_init (&info);
662 /* Find a default architecture. */
663 if (default_bfd_arch == NULL)
665 /* Choose the architecture by taking the first one
667 const char *chosen = arches[0];
669 for (arch = arches; *arch != NULL; arch++)
671 if (strcmp (*arch, chosen) < 0)
675 internal_error (__FILE__, __LINE__,
676 _("initialize_current_architecture: No arch"));
677 default_bfd_arch = bfd_scan_arch (chosen);
678 if (default_bfd_arch == NULL)
679 internal_error (__FILE__, __LINE__,
680 _("initialize_current_architecture: Arch not found"));
683 info.bfd_arch_info = default_bfd_arch;
685 /* Take several guesses at a byte order. */
686 if (default_byte_order == BFD_ENDIAN_UNKNOWN
687 && default_bfd_vec != NULL)
689 /* Extract BFD's default vector's byte order. */
690 switch (default_bfd_vec->byteorder)
693 default_byte_order = BFD_ENDIAN_BIG;
695 case BFD_ENDIAN_LITTLE:
696 default_byte_order = BFD_ENDIAN_LITTLE;
702 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
704 /* look for ``*el-*'' in the target name. */
706 chp = strchr (target_name, '-');
708 && chp - 2 >= target_name
709 && startswith (chp - 2, "el"))
710 default_byte_order = BFD_ENDIAN_LITTLE;
712 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
714 /* Wire it to big-endian!!! */
715 default_byte_order = BFD_ENDIAN_BIG;
718 info.byte_order = default_byte_order;
719 info.byte_order_for_code = info.byte_order;
721 if (! gdbarch_update_p (info))
722 internal_error (__FILE__, __LINE__,
723 _("initialize_current_architecture: Selection of "
724 "initial architecture failed"));
726 /* Create the ``set architecture'' command appending ``auto'' to the
727 list of architectures. */
729 /* Append ``auto''. */
731 for (nr = 0; arches[nr] != NULL; nr++);
732 arches = XRESIZEVEC (const char *, arches, nr + 2);
733 arches[nr + 0] = "auto";
734 arches[nr + 1] = NULL;
735 add_setshow_enum_cmd ("architecture", class_support,
736 arches, &set_architecture_string,
737 _("Set architecture of target."),
738 _("Show architecture of target."), NULL,
739 set_architecture, show_architecture,
740 &setlist, &showlist);
741 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
746 /* Initialize a gdbarch info to values that will be automatically
747 overridden. Note: Originally, this ``struct info'' was initialized
748 using memset(0). Unfortunately, that ran into problems, namely
749 BFD_ENDIAN_BIG is zero. An explicit initialization function that
750 can explicitly set each field to a well defined value is used. */
753 gdbarch_info_init (struct gdbarch_info *info)
755 memset (info, 0, sizeof (struct gdbarch_info));
756 info->byte_order = BFD_ENDIAN_UNKNOWN;
757 info->byte_order_for_code = info->byte_order;
758 info->osabi = GDB_OSABI_UNINITIALIZED;
761 /* Similar to init, but this time fill in the blanks. Information is
762 obtained from the global "set ..." options and explicitly
763 initialized INFO fields. */
766 gdbarch_info_fill (struct gdbarch_info *info)
768 /* "(gdb) set architecture ...". */
769 if (info->bfd_arch_info == NULL
770 && target_architecture_user)
771 info->bfd_arch_info = target_architecture_user;
773 if (info->bfd_arch_info == NULL
774 && info->abfd != NULL
775 && bfd_get_arch (info->abfd) != bfd_arch_unknown
776 && bfd_get_arch (info->abfd) != bfd_arch_obscure)
777 info->bfd_arch_info = bfd_get_arch_info (info->abfd);
778 /* From the target. */
779 if (info->target_desc != NULL)
780 info->bfd_arch_info = choose_architecture_for_target
781 (info->target_desc, info->bfd_arch_info);
782 /* From the default. */
783 if (info->bfd_arch_info == NULL)
784 info->bfd_arch_info = default_bfd_arch;
786 /* "(gdb) set byte-order ...". */
787 if (info->byte_order == BFD_ENDIAN_UNKNOWN
788 && target_byte_order_user != BFD_ENDIAN_UNKNOWN)
789 info->byte_order = target_byte_order_user;
790 /* From the INFO struct. */
791 if (info->byte_order == BFD_ENDIAN_UNKNOWN
792 && info->abfd != NULL)
793 info->byte_order = (bfd_big_endian (info->abfd) ? BFD_ENDIAN_BIG
794 : bfd_little_endian (info->abfd) ? BFD_ENDIAN_LITTLE
795 : BFD_ENDIAN_UNKNOWN);
796 /* From the default. */
797 if (info->byte_order == BFD_ENDIAN_UNKNOWN)
798 info->byte_order = default_byte_order;
799 info->byte_order_for_code = info->byte_order;
801 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
802 /* From the manual override, or from file. */
803 if (info->osabi == GDB_OSABI_UNINITIALIZED)
804 info->osabi = gdbarch_lookup_osabi (info->abfd);
805 /* From the target. */
806 if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL)
807 info->osabi = tdesc_osabi (info->target_desc);
808 /* From the configured default. */
809 #ifdef GDB_OSABI_DEFAULT
810 if (info->osabi == GDB_OSABI_UNKNOWN)
811 info->osabi = GDB_OSABI_DEFAULT;
814 /* Must have at least filled in the architecture. */
815 gdb_assert (info->bfd_arch_info != NULL);
818 /* Return "current" architecture. If the target is running, this is
819 the architecture of the selected frame. Otherwise, the "current"
820 architecture defaults to the target architecture.
822 This function should normally be called solely by the command
823 interpreter routines to determine the architecture to execute a
826 get_current_arch (void)
828 if (has_stack_frames ())
829 return get_frame_arch (get_selected_frame (NULL));
831 return target_gdbarch ();
835 default_has_shared_address_space (struct gdbarch *gdbarch)
837 /* Simply say no. In most unix-like targets each inferior/process
838 has its own address space. */
843 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr,
846 /* We don't know if maybe the target has some way to do fast
847 tracepoints that doesn't need gdbarch, so always say yes. */
854 default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
857 int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
859 return gdbarch_sw_breakpoint_from_kind (gdbarch, kind, lenptr);
862 default_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
863 struct regcache *regcache,
866 return gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
871 default_gen_return_address (struct gdbarch *gdbarch,
872 struct agent_expr *ax, struct axs_value *value,
875 error (_("This architecture has no method to collect a return address."));
879 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
882 /* Usually, the return value's address is stored the in the "first hidden"
883 parameter if the return value should be passed by reference, as
885 return language_pass_by_reference (type);
888 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
893 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
898 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
904 default_skip_permanent_breakpoint (struct regcache *regcache)
906 struct gdbarch *gdbarch = get_regcache_arch (regcache);
907 CORE_ADDR current_pc = regcache_read_pc (regcache);
910 gdbarch_breakpoint_from_pc (gdbarch, ¤t_pc, &bp_len);
911 current_pc += bp_len;
912 regcache_write_pc (regcache, current_pc);
916 default_infcall_mmap (CORE_ADDR size, unsigned prot)
918 error (_("This target does not support inferior memory allocation by mmap."));
922 default_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
924 /* Memory reserved by inferior mmap is kept leaked. */
927 /* -mcmodel=large is used so that no GOT (Global Offset Table) is needed to be
928 created in inferior memory by GDB (normally it is set by ld.so). */
931 default_gcc_target_options (struct gdbarch *gdbarch)
933 return xstrprintf ("-m%d%s", gdbarch_ptr_bit (gdbarch),
934 gdbarch_ptr_bit (gdbarch) == 64 ? " -mcmodel=large" : "");
937 /* gdbarch gnu_triplet_regexp method. */
940 default_gnu_triplet_regexp (struct gdbarch *gdbarch)
942 return gdbarch_bfd_arch_info (gdbarch)->arch_name;
945 /* Default method for gdbarch_addressable_memory_unit_size. By default, a memory byte has
946 a size of 1 octet. */
949 default_addressable_memory_unit_size (struct gdbarch *gdbarch)
955 default_guess_tracepoint_registers (struct gdbarch *gdbarch,
956 struct regcache *regcache,
959 int pc_regno = gdbarch_pc_regnum (gdbarch);
962 /* This guessing code below only works if the PC register isn't
963 a pseudo-register. The value of a pseudo-register isn't stored
964 in the (non-readonly) regcache -- instead it's recomputed
965 (probably from some other cached raw register) whenever the
966 register is read. In this case, a custom method implementation
967 should be used by the architecture. */
968 if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
971 regs = (gdb_byte *) alloca (register_size (gdbarch, pc_regno));
972 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
973 gdbarch_byte_order (gdbarch), addr);
974 regcache_raw_supply (regcache, pc_regno, regs);
978 default_print_insn (bfd_vma memaddr, disassemble_info *info)
980 disassembler_ftype disassemble_fn;
982 if (exec_bfd != NULL)
984 gdb_assert (info->arch == bfd_get_arch (exec_bfd));
985 gdb_assert (info->endian == (bfd_big_endian (exec_bfd)
986 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE));
987 gdb_assert (info->mach == bfd_get_mach (exec_bfd));
989 disassemble_fn = disassembler (info->arch, info->endian == BFD_ENDIAN_BIG,
990 info->mach, exec_bfd);
992 gdb_assert (disassemble_fn != NULL);
993 return (*disassemble_fn) (memaddr, info);
996 /* -Wmissing-prototypes */
997 extern initialize_file_ftype _initialize_gdbarch_utils;
1000 _initialize_gdbarch_utils (void)
1002 add_setshow_enum_cmd ("endian", class_support,
1003 endian_enum, &set_endian_string,
1004 _("Set endianness of target."),
1005 _("Show endianness of target."),
1006 NULL, set_endian, show_endian,
1007 &setlist, &showlist);