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"
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)
46 size_t len = gdbarch_max_insn_length (gdbarch);
47 gdb_byte *buf = (gdb_byte *) xmalloc (len);
49 read_memory (from, buf, len);
50 write_memory (to, buf, len);
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);
59 return (struct displaced_step_closure *) buf;
64 simple_displaced_step_free_closure (struct gdbarch *gdbarch,
65 struct displaced_step_closure *closure)
71 default_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
72 struct displaced_step_closure *closure)
74 return !gdbarch_software_single_step_p (gdbarch);
78 displaced_step_at_entry_point (struct gdbarch *gdbarch)
83 addr = entry_point_address ();
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);
95 legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum)
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
103 if (gdbarch_register_name (gdbarch, regnum) != NULL
104 && gdbarch_register_name (gdbarch, regnum)[0] != '\0')
107 return LEGACY_SIM_REGNO_IGNORE;
111 generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
117 generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
123 generic_in_solib_return_trampoline (struct gdbarch *gdbarch,
124 CORE_ADDR pc, const char *name)
130 generic_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
136 default_code_of_frame_writable (struct gdbarch *gdbarch,
137 struct frame_info *frame)
142 /* Helper functions for gdbarch_inner_than */
145 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
151 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
156 /* Misc helper functions for targets. */
159 core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr)
165 convert_from_func_ptr_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr,
166 struct target_ops *targ)
172 no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg)
178 default_coff_make_msymbol_special (int val, struct minimal_symbol *msym)
183 /* See arch-utils.h. */
186 default_make_symbol_special (struct symbol *sym, struct objfile *objfile)
191 /* See arch-utils.h. */
194 default_adjust_dwarf2_addr (CORE_ADDR pc)
199 /* See arch-utils.h. */
202 default_adjust_dwarf2_line (CORE_ADDR addr, int rel)
208 cannot_register_not (struct gdbarch *gdbarch, int regnum)
213 /* Legacy version of target_virtual_frame_pointer(). Assumes that
214 there is an gdbarch_deprecated_fp_regnum and that it is the same,
218 legacy_virtual_frame_pointer (struct gdbarch *gdbarch,
221 LONGEST *frame_offset)
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);
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"));
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. */
248 const struct floatformat **
249 default_floatformat_for_type (struct gdbarch *gdbarch,
250 const char *name, int len)
252 const struct floatformat **format = NULL;
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);
274 generic_convert_register_p (struct gdbarch *gdbarch, int regnum,
281 default_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
287 generic_instruction_nullified (struct gdbarch *gdbarch,
288 struct regcache *regcache)
294 default_remote_register_number (struct gdbarch *gdbarch,
300 /* See arch-utils.h. */
303 default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range)
309 /* Functions to manipulate the endianness of the target. */
311 static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN;
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[] =
323 static const char *set_endian_string;
326 selected_byte_order (void)
328 return target_byte_order_user;
331 /* Called by ``show endian''. */
334 show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c,
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"));
342 fprintf_unfiltered (file, _("The target endianness is set automatically "
343 "(currently little endian)\n"));
345 if (target_byte_order_user == BFD_ENDIAN_BIG)
346 fprintf_unfiltered (file,
347 _("The target is assumed to be big endian\n"));
349 fprintf_unfiltered (file,
350 _("The target is assumed to be little endian\n"));
354 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
356 struct gdbarch_info info;
358 gdbarch_info_init (&info);
360 if (set_endian_string == endian_auto)
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"));
367 else if (set_endian_string == endian_little)
369 info.byte_order = BFD_ENDIAN_LITTLE;
370 if (! gdbarch_update_p (info))
371 printf_unfiltered (_("Little endian target not supported by GDB\n"));
373 target_byte_order_user = BFD_ENDIAN_LITTLE;
375 else if (set_endian_string == endian_big)
377 info.byte_order = BFD_ENDIAN_BIG;
378 if (! gdbarch_update_p (info))
379 printf_unfiltered (_("Big endian target not supported by GDB\n"));
381 target_byte_order_user = BFD_ENDIAN_BIG;
384 internal_error (__FILE__, __LINE__,
385 _("set_endian: bad value"));
387 show_endian (gdb_stdout, from_tty, NULL, NULL);
390 /* Given SELECTED, a currently selected BFD architecture, and
391 TARGET_DESC, the current target description, return what
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.
399 If SELECTED is a different architecture, but it is accepted as
400 compatible by the target, we can use the target architecture.
402 If SELECTED is obviously incompatible, warn the user. */
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)
408 const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
409 const struct bfd_arch_info *compat1, *compat2;
411 if (selected == NULL)
414 if (from_target == NULL)
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)
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
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. */
433 compat1 = selected->compatible (selected, from_target);
434 compat2 = from_target->compatible (from_target, selected);
436 if (compat1 == NULL && compat2 == NULL)
438 /* BFD considers the architectures incompatible. Check our
439 target description whether it accepts SELECTED as compatible
441 if (tdesc_compatible_p (target_desc, selected))
444 warning (_("Selected architecture %s is not compatible "
445 "with reported target architecture %s"),
446 selected->printable_name, from_target->printable_name);
454 if (compat1 == compat2)
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)
463 if (compat2->the_default)
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);
474 /* Functions to manipulate the architecture of the target. */
476 enum set_arch { set_arch_auto, set_arch_manual };
478 static const struct bfd_arch_info *target_architecture_user;
480 static const char *set_architecture_string;
483 selected_architecture_name (void)
485 if (target_architecture_user == NULL)
488 return set_architecture_string;
491 /* Called if the user enters ``show architecture'' without an
495 show_architecture (struct ui_file *file, int from_tty,
496 struct cmd_list_element *c, const char *value)
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);
503 fprintf_filtered (file, _("The target architecture is assumed to be %s\n"),
504 set_architecture_string);
508 /* Called if the user enters ``set architecture'' with or without an
512 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
514 struct gdbarch_info info;
516 gdbarch_info_init (&info);
518 if (strcmp (set_architecture_string, "auto") == 0)
520 target_architecture_user = NULL;
521 if (!gdbarch_update_p (info))
522 internal_error (__FILE__, __LINE__,
523 _("could not select an architecture automatically"));
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;
534 printf_unfiltered (_("Architecture `%s' not recognized.\n"),
535 set_architecture_string);
537 show_architecture (gdb_stdout, from_tty, NULL, NULL);
540 /* Try to select a global architecture that matches "info". Return
541 non-zero if the attempt succeeds. */
543 gdbarch_update_p (struct gdbarch_info info)
545 struct gdbarch *new_gdbarch;
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;
553 /* Check for the current target description. */
554 if (info.target_desc == NULL)
555 info.target_desc = target_current_description ();
557 new_gdbarch = gdbarch_find_by_info (info);
559 /* If there no architecture by that name, reject the request. */
560 if (new_gdbarch == NULL)
563 fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
564 "Architecture not found\n");
568 /* If it is the same old architecture, accept the request (but don't
570 if (new_gdbarch == target_gdbarch ())
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);
580 /* It's a new architecture, swap it in. */
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);
591 /* Return the architecture for ABFD. If no suitable architecture
592 could be find, return NULL. */
595 gdbarch_from_bfd (bfd *abfd)
597 struct gdbarch_info info;
598 gdbarch_info_init (&info);
601 return gdbarch_find_by_info (info);
604 /* Set the dynamic target-system-dependent parameters (architecture,
605 byte-order) using information found in the BFD */
608 set_gdbarch_from_file (bfd *abfd)
610 struct gdbarch_info info;
611 struct gdbarch *gdbarch;
613 gdbarch_info_init (&info);
615 info.target_desc = target_current_description ();
616 gdbarch = gdbarch_find_by_info (info);
619 error (_("Architecture of file not recognized."));
620 set_target_gdbarch (gdbarch);
623 /* Initialize the current architecture. Update the ``set
624 architecture'' command so that it specifies a list of valid
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;
631 static const bfd_arch_info_type *default_bfd_arch;
634 #ifdef DEFAULT_BFD_VEC
635 extern const bfd_target DEFAULT_BFD_VEC;
636 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
638 static const bfd_target *default_bfd_vec;
641 static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN;
644 initialize_current_architecture (void)
646 const char **arches = gdbarch_printable_names ();
647 struct gdbarch_info info;
649 /* determine a default architecture and byte order. */
650 gdbarch_info_init (&info);
652 /* Find a default architecture. */
653 if (default_bfd_arch == NULL)
655 /* Choose the architecture by taking the first one
657 const char *chosen = arches[0];
659 for (arch = arches; *arch != NULL; arch++)
661 if (strcmp (*arch, chosen) < 0)
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"));
673 info.bfd_arch_info = default_bfd_arch;
675 /* Take several guesses at a byte order. */
676 if (default_byte_order == BFD_ENDIAN_UNKNOWN
677 && default_bfd_vec != NULL)
679 /* Extract BFD's default vector's byte order. */
680 switch (default_bfd_vec->byteorder)
683 default_byte_order = BFD_ENDIAN_BIG;
685 case BFD_ENDIAN_LITTLE:
686 default_byte_order = BFD_ENDIAN_LITTLE;
692 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
694 /* look for ``*el-*'' in the target name. */
696 chp = strchr (target_name, '-');
698 && chp - 2 >= target_name
699 && startswith (chp - 2, "el"))
700 default_byte_order = BFD_ENDIAN_LITTLE;
702 if (default_byte_order == BFD_ENDIAN_UNKNOWN)
704 /* Wire it to big-endian!!! */
705 default_byte_order = BFD_ENDIAN_BIG;
708 info.byte_order = default_byte_order;
709 info.byte_order_for_code = info.byte_order;
711 if (! gdbarch_update_p (info))
712 internal_error (__FILE__, __LINE__,
713 _("initialize_current_architecture: Selection of "
714 "initial architecture failed"));
716 /* Create the ``set architecture'' command appending ``auto'' to the
717 list of architectures. */
719 /* Append ``auto''. */
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);
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. */
743 gdbarch_info_init (struct gdbarch_info *info)
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;
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. */
756 gdbarch_info_fill (struct gdbarch_info *info)
758 /* "(gdb) set architecture ...". */
759 if (info->bfd_arch_info == NULL
760 && target_architecture_user)
761 info->bfd_arch_info = target_architecture_user;
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;
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;
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;
804 /* Must have at least filled in the architecture. */
805 gdb_assert (info->bfd_arch_info != NULL);
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.
812 This function should normally be called solely by the command
813 interpreter routines to determine the architecture to execute a
816 get_current_arch (void)
818 if (has_stack_frames ())
819 return get_frame_arch (get_selected_frame (NULL));
821 return target_gdbarch ();
825 default_has_shared_address_space (struct gdbarch *gdbarch)
827 /* Simply say no. In most unix-like targets each inferior/process
828 has its own address space. */
833 default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr,
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. */
844 default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
847 int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
849 return gdbarch_sw_breakpoint_from_kind (gdbarch, kind, lenptr);
852 default_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
853 struct regcache *regcache,
856 return gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr);
861 default_gen_return_address (struct gdbarch *gdbarch,
862 struct agent_expr *ax, struct axs_value *value,
865 error (_("This architecture has no method to collect a return address."));
869 default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
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
875 return language_pass_by_reference (type);
878 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
883 int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr)
888 int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
894 default_skip_permanent_breakpoint (struct regcache *regcache)
896 struct gdbarch *gdbarch = get_regcache_arch (regcache);
897 CORE_ADDR current_pc = regcache_read_pc (regcache);
900 gdbarch_breakpoint_from_pc (gdbarch, ¤t_pc, &bp_len);
901 current_pc += bp_len;
902 regcache_write_pc (regcache, current_pc);
906 default_infcall_mmap (CORE_ADDR size, unsigned prot)
908 error (_("This target does not support inferior memory allocation by mmap."));
912 default_infcall_munmap (CORE_ADDR addr, CORE_ADDR size)
914 /* Memory reserved by inferior mmap is kept leaked. */
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). */
921 default_gcc_target_options (struct gdbarch *gdbarch)
923 return xstrprintf ("-m%d%s", gdbarch_ptr_bit (gdbarch),
924 gdbarch_ptr_bit (gdbarch) == 64 ? " -mcmodel=large" : "");
927 /* gdbarch gnu_triplet_regexp method. */
930 default_gnu_triplet_regexp (struct gdbarch *gdbarch)
932 return gdbarch_bfd_arch_info (gdbarch)->arch_name;
935 /* Default method for gdbarch_addressable_memory_unit_size. By default, a memory byte has
936 a size of 1 octet. */
939 default_addressable_memory_unit_size (struct gdbarch *gdbarch)
945 default_guess_tracepoint_registers (struct gdbarch *gdbarch,
946 struct regcache *regcache,
949 int pc_regno = gdbarch_pc_regnum (gdbarch);
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))
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);
967 /* -Wmissing-prototypes */
968 extern initialize_file_ftype _initialize_gdbarch_utils;
971 _initialize_gdbarch_utils (void)
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);