X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Farch-utils.c;h=2129c3b2c388670b6f52e85ba62a1370b9a1dad0;hb=27e4fac77ea57b288ac1e08d936d9a8fdc01a1ee;hp=3014558e0313e72c74dc7f97152249da26ebedee;hpb=24568a2cd9b1422f582b6f9c004ebd67ffadcb90;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c index 3014558e03..2129c3b2c3 100644 --- a/gdb/arch-utils.c +++ b/gdb/arch-utils.c @@ -1,7 +1,6 @@ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008 Free Software Foundation, Inc. + Copyright (C) 1998-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -21,53 +20,31 @@ #include "defs.h" #include "arch-utils.h" -#include "buildsym.h" #include "gdbcmd.h" -#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */ -#include "gdb_string.h" +#include "inferior.h" /* enum CALL_DUMMY_LOCATION et al. */ +#include "infrun.h" #include "regcache.h" -#include "gdb_assert.h" #include "sim-regno.h" #include "gdbcore.h" #include "osabi.h" #include "target-descriptions.h" #include "objfiles.h" +#include "language.h" +#include "symtab.h" -#include "version.h" +#include "gdbsupport/version.h" #include "floatformat.h" +#include "dis-asm.h" -struct displaced_step_closure * -simple_displaced_step_copy_insn (struct gdbarch *gdbarch, - CORE_ADDR from, CORE_ADDR to, - struct regcache *regs) -{ - size_t len = gdbarch_max_insn_length (gdbarch); - gdb_byte *buf = xmalloc (len); - - read_memory (from, buf, len); - write_memory (to, buf, len); - - if (debug_displaced) - { - fprintf_unfiltered (gdb_stdlog, "displaced: copy 0x%s->0x%s: ", - paddr_nz (from), paddr_nz (to)); - displaced_step_dump_bytes (gdb_stdlog, buf, len); - } - - return (struct displaced_step_closure *) buf; -} - - -void -simple_displaced_step_free_closure (struct gdbarch *gdbarch, - struct displaced_step_closure *closure) +int +default_displaced_step_hw_singlestep (struct gdbarch *gdbarch, + struct displaced_step_closure *closure) { - xfree (closure); + return !gdbarch_software_single_step_p (gdbarch); } - CORE_ADDR displaced_step_at_entry_point (struct gdbarch *gdbarch) { @@ -76,10 +53,6 @@ displaced_step_at_entry_point (struct gdbarch *gdbarch) addr = entry_point_address (); - /* Make certain that the address points at real code, and not a - function descriptor. */ - addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target); - /* Inferior calls also use the entry point as a breakpoint location. We don't want displaced stepping to interfere with those breakpoints, so leave space. */ @@ -96,7 +69,7 @@ legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum) gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)); /* NOTE: cagney/2002-05-13: The old code did it this way and it is suspected that some GDB/SIM combinations may rely on this - behavour. The default should be one2one_register_sim_regno + behaviour. The default should be one2one_register_sim_regno (below). */ if (gdbarch_register_name (gdbarch, regnum) != NULL && gdbarch_register_name (gdbarch, regnum)[0] != '\0') @@ -118,17 +91,25 @@ generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) } int -generic_in_solib_return_trampoline (CORE_ADDR pc, char *name) +generic_in_solib_return_trampoline (struct gdbarch *gdbarch, + CORE_ADDR pc, const char *name) { return 0; } int -generic_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) +generic_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc) { return 0; } +int +default_code_of_frame_writable (struct gdbarch *gdbarch, + struct frame_info *frame) +{ + return 1; +} + /* Helper functions for gdbarch_inner_than */ int @@ -143,7 +124,7 @@ core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs) return (lhs > rhs); } -/* Misc helper functions for targets. */ +/* Misc helper functions for targets. */ CORE_ADDR core_addr_identity (struct gdbarch *gdbarch, CORE_ADDR addr) @@ -165,17 +146,44 @@ no_op_reg_to_regnum (struct gdbarch *gdbarch, int reg) } void -default_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) +default_coff_make_msymbol_special (int val, struct minimal_symbol *msym) { return; } +/* See arch-utils.h. */ + void -default_coff_make_msymbol_special (int val, struct minimal_symbol *msym) +default_make_symbol_special (struct symbol *sym, struct objfile *objfile) { return; } +/* See arch-utils.h. */ + +CORE_ADDR +default_adjust_dwarf2_addr (CORE_ADDR pc) +{ + return pc; +} + +/* See arch-utils.h. */ + +CORE_ADDR +default_adjust_dwarf2_line (CORE_ADDR addr, int rel) +{ + return addr; +} + +/* See arch-utils.h. */ + +bool +default_execute_dwarf_cfa_vendor_op (struct gdbarch *gdbarch, gdb_byte op, + struct dwarf2_frame_state *fs) +{ + return false; +} + int cannot_register_not (struct gdbarch *gdbarch, int regnum) { @@ -183,8 +191,8 @@ cannot_register_not (struct gdbarch *gdbarch, int regnum) } /* Legacy version of target_virtual_frame_pointer(). Assumes that - there is an gdbarch_deprecated_fp_regnum and that it is the same, cooked or - raw. */ + there is an gdbarch_deprecated_fp_regnum and that it is the same, + cooked or raw. */ void legacy_virtual_frame_pointer (struct gdbarch *gdbarch, @@ -208,10 +216,39 @@ legacy_virtual_frame_pointer (struct gdbarch *gdbarch, else /* Should this be an internal error? I guess so, it is reflecting an architectural limitation in the current design. */ - internal_error (__FILE__, __LINE__, _("No virtual frame pointer available")); + internal_error (__FILE__, __LINE__, + _("No virtual frame pointer available")); *frame_offset = 0; } +/* Return a floating-point format for a floating-point variable of + length LEN in bits. If non-NULL, NAME is the name of its type. + If no suitable type is found, return NULL. */ + +const struct floatformat ** +default_floatformat_for_type (struct gdbarch *gdbarch, + const char *name, int len) +{ + const struct floatformat **format = NULL; + + if (len == gdbarch_half_bit (gdbarch)) + format = gdbarch_half_format (gdbarch); + else if (len == gdbarch_float_bit (gdbarch)) + format = gdbarch_float_format (gdbarch); + else if (len == gdbarch_double_bit (gdbarch)) + format = gdbarch_double_format (gdbarch); + else if (len == gdbarch_long_double_bit (gdbarch)) + format = gdbarch_long_double_format (gdbarch); + /* On i386 the 'long double' type takes 96 bits, + while the real number of used bits is only 80, + both in processor and in memory. + The code below accepts the real bit size. */ + else if (gdbarch_long_double_format (gdbarch) != NULL + && len == gdbarch_long_double_format (gdbarch)[0]->totalsize) + format = gdbarch_long_double_format (gdbarch); + + return format; +} int generic_convert_register_p (struct gdbarch *gdbarch, int regnum, @@ -240,15 +277,23 @@ default_remote_register_number (struct gdbarch *gdbarch, return regno; } +/* See arch-utils.h. */ + +int +default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range) +{ + return 0; +} + /* Functions to manipulate the endianness of the target. */ -static int target_byte_order_user = BFD_ENDIAN_UNKNOWN; +static enum bfd_endian target_byte_order_user = BFD_ENDIAN_UNKNOWN; static const char endian_big[] = "big"; static const char endian_little[] = "little"; static const char endian_auto[] = "auto"; -static const char *endian_enum[] = +static const char *const endian_enum[] = { endian_big, endian_little, @@ -260,10 +305,7 @@ static const char *set_endian_string; enum bfd_endian selected_byte_order (void) { - if (target_byte_order_user != BFD_ENDIAN_UNKNOWN) - return gdbarch_byte_order (current_gdbarch); - else - return BFD_ENDIAN_UNKNOWN; + return target_byte_order_user; } /* Called by ``show endian''. */ @@ -273,14 +315,14 @@ show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { if (target_byte_order_user == BFD_ENDIAN_UNKNOWN) - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG) fprintf_unfiltered (file, _("The target endianness is set automatically " "(currently big endian)\n")); else fprintf_unfiltered (file, _("The target endianness is set automatically " - "(currently little endian)\n")); + "(currently little endian)\n")); else - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (target_byte_order_user == BFD_ENDIAN_BIG) fprintf_unfiltered (file, _("The target is assumed to be big endian\n")); else @@ -289,7 +331,7 @@ show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c, } static void -set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) +set_endian (const char *ignore_args, int from_tty, struct cmd_list_element *c) { struct gdbarch_info info; @@ -326,15 +368,24 @@ set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) } /* Given SELECTED, a currently selected BFD architecture, and - FROM_TARGET, a BFD architecture reported by the target description, - return what architecture to use. Either may be NULL; if both are - specified, we use the more specific. If the two are obviously - incompatible, warn the user. */ + TARGET_DESC, the current target description, return what + architecture to use. + + SELECTED may be NULL, in which case we return the architecture + associated with TARGET_DESC. If SELECTED specifies a variant + of the architecture associated with TARGET_DESC, return the + more specific of the two. + + If SELECTED is a different architecture, but it is accepted as + compatible by the target, we can use the target architecture. + + If SELECTED is obviously incompatible, warn the user. */ static const struct bfd_arch_info * -choose_architecture_for_target (const struct bfd_arch_info *selected, - const struct bfd_arch_info *from_target) +choose_architecture_for_target (const struct target_desc *target_desc, + const struct bfd_arch_info *selected) { + const struct bfd_arch_info *from_target = tdesc_architecture (target_desc); const struct bfd_arch_info *compat1, *compat2; if (selected == NULL) @@ -364,6 +415,12 @@ choose_architecture_for_target (const struct bfd_arch_info *selected, if (compat1 == NULL && compat2 == NULL) { + /* BFD considers the architectures incompatible. Check our + target description whether it accepts SELECTED as compatible + anyway. */ + if (tdesc_compatible_p (target_desc, selected)) + return from_target; + warning (_("Selected architecture %s is not compatible " "with reported target architecture %s"), selected->printable_name, from_target->printable_name); @@ -377,10 +434,10 @@ choose_architecture_for_target (const struct bfd_arch_info *selected, if (compat1 == compat2) return compat1; - /* If the two didn't match, but one of them was a default architecture, - assume the more specific one is correct. This handles the case - where an executable or target description just says "mips", but - the other knows which MIPS variant. */ + /* If the two didn't match, but one of them was a default + architecture, assume the more specific one is correct. This + handles the case where an executable or target description just + says "mips", but the other knows which MIPS variant. */ if (compat1->the_default) return compat2; if (compat2->the_default) @@ -394,7 +451,7 @@ choose_architecture_for_target (const struct bfd_arch_info *selected, return selected; } -/* Functions to manipulate the architecture of the target */ +/* Functions to manipulate the architecture of the target. */ enum set_arch { set_arch_auto, set_arch_manual }; @@ -412,28 +469,28 @@ selected_architecture_name (void) } /* Called if the user enters ``show architecture'' without an - argument. */ + argument. */ static void show_architecture (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - const char *arch; - arch = gdbarch_bfd_arch_info (current_gdbarch)->printable_name; if (target_architecture_user == NULL) - fprintf_filtered (file, _("\ -The target architecture is set automatically (currently %s)\n"), arch); + fprintf_filtered (file, _("The target architecture is set " + "automatically (currently %s)\n"), + gdbarch_bfd_arch_info (get_current_arch ())->printable_name); else - fprintf_filtered (file, _("\ -The target architecture is assumed to be %s\n"), arch); + fprintf_filtered (file, _("The target architecture is assumed to be %s\n"), + set_architecture_string); } /* Called if the user enters ``set architecture'' with or without an - argument. */ + argument. */ static void -set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c) +set_architecture (const char *ignore_args, + int from_tty, struct cmd_list_element *c) { struct gdbarch_info info; @@ -462,7 +519,7 @@ set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c) } /* Try to select a global architecture that matches "info". Return - non-zero if the attempt succeds. */ + non-zero if the attempt succeeds. */ int gdbarch_update_p (struct gdbarch_info info) { @@ -491,12 +548,12 @@ gdbarch_update_p (struct gdbarch_info info) /* If it is the same old architecture, accept the request (but don't swap anything). */ - if (new_gdbarch == target_gdbarch) + if (new_gdbarch == target_gdbarch ()) { if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " - "Architecture 0x%08lx (%s) unchanged\n", - (long) new_gdbarch, + "Architecture %s (%s) unchanged\n", + host_address_to_string (new_gdbarch), gdbarch_bfd_arch_info (new_gdbarch)->printable_name); return 1; } @@ -504,10 +561,10 @@ gdbarch_update_p (struct gdbarch_info info) /* It's a new architecture, swap it in. */ if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " - "New architecture 0x%08lx (%s) selected\n", - (long) new_gdbarch, + "New architecture %s (%s) selected\n", + host_address_to_string (new_gdbarch), gdbarch_bfd_arch_info (new_gdbarch)->printable_name); - deprecated_current_gdbarch_select_hack (new_gdbarch); + set_target_gdbarch (new_gdbarch); return 1; } @@ -520,6 +577,7 @@ gdbarch_from_bfd (bfd *abfd) { struct gdbarch_info info; gdbarch_info_init (&info); + info.abfd = abfd; return gdbarch_find_by_info (info); } @@ -540,7 +598,7 @@ set_gdbarch_from_file (bfd *abfd) if (gdbarch == NULL) error (_("Architecture of file not recognized.")); - deprecated_current_gdbarch_select_hack (gdbarch); + set_target_gdbarch (gdbarch); } /* Initialize the current architecture. Update the ``set @@ -561,22 +619,22 @@ static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC; static const bfd_target *default_bfd_vec; #endif -static int default_byte_order = BFD_ENDIAN_UNKNOWN; +static enum bfd_endian default_byte_order = BFD_ENDIAN_UNKNOWN; void initialize_current_architecture (void) { const char **arches = gdbarch_printable_names (); - - /* determine a default architecture and byte order. */ struct gdbarch_info info; + + /* determine a default architecture and byte order. */ gdbarch_info_init (&info); - /* Find a default architecture. */ + /* Find a default architecture. */ if (default_bfd_arch == NULL) { /* Choose the architecture by taking the first one - alphabetically. */ + alphabetically. */ const char *chosen = arches[0]; const char **arch; for (arch = arches; *arch != NULL; arch++) @@ -599,7 +657,7 @@ initialize_current_architecture (void) if (default_byte_order == BFD_ENDIAN_UNKNOWN && default_bfd_vec != NULL) { - /* Extract BFD's default vector's byte order. */ + /* Extract BFD's default vector's byte order. */ switch (default_bfd_vec->byteorder) { case BFD_ENDIAN_BIG: @@ -614,12 +672,12 @@ initialize_current_architecture (void) } if (default_byte_order == BFD_ENDIAN_UNKNOWN) { - /* look for ``*el-*'' in the target name. */ + /* look for ``*el-*'' in the target name. */ const char *chp; chp = strchr (target_name, '-'); if (chp != NULL && chp - 2 >= target_name - && strncmp (chp - 2, "el", 2) == 0) + && startswith (chp - 2, "el")) default_byte_order = BFD_ENDIAN_LITTLE; } if (default_byte_order == BFD_ENDIAN_UNKNOWN) @@ -637,19 +695,18 @@ initialize_current_architecture (void) "initial architecture failed")); /* Create the ``set architecture'' command appending ``auto'' to the - list of architectures. */ + list of architectures. */ { - struct cmd_list_element *c; - /* Append ``auto''. */ + /* Append ``auto''. */ int nr; for (nr = 0; arches[nr] != NULL; nr++); - arches = xrealloc (arches, sizeof (char*) * (nr + 2)); + arches = XRESIZEVEC (const char *, arches, nr + 2); arches[nr + 0] = "auto"; arches[nr + 1] = NULL; add_setshow_enum_cmd ("architecture", class_support, - arches, &set_architecture_string, _("\ -Set architecture of target."), _("\ -Show architecture of target."), NULL, + arches, &set_architecture_string, + _("Set architecture of target."), + _("Show architecture of target."), NULL, set_architecture, show_architecture, &setlist, &showlist); add_alias_cmd ("processor", "architecture", class_support, 1, &setlist); @@ -669,7 +726,6 @@ gdbarch_info_init (struct gdbarch_info *info) memset (info, 0, sizeof (struct gdbarch_info)); info->byte_order = BFD_ENDIAN_UNKNOWN; info->byte_order_for_code = info->byte_order; - info->osabi = GDB_OSABI_UNINITIALIZED; } /* Similar to init, but this time fill in the blanks. Information is @@ -692,7 +748,7 @@ gdbarch_info_fill (struct gdbarch_info *info) /* From the target. */ if (info->target_desc != NULL) info->bfd_arch_info = choose_architecture_for_target - (info->bfd_arch_info, tdesc_architecture (info->target_desc)); + (info->target_desc, info->bfd_arch_info); /* From the default. */ if (info->bfd_arch_info == NULL) info->bfd_arch_info = default_bfd_arch; @@ -711,27 +767,250 @@ gdbarch_info_fill (struct gdbarch_info *info) if (info->byte_order == BFD_ENDIAN_UNKNOWN) info->byte_order = default_byte_order; info->byte_order_for_code = info->byte_order; + /* Wire the default to the last selected byte order. */ + default_byte_order = info->byte_order; /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */ - if (info->osabi == GDB_OSABI_UNINITIALIZED) + /* From the manual override, or from file. */ + if (info->osabi == GDB_OSABI_UNKNOWN) info->osabi = gdbarch_lookup_osabi (info->abfd); + /* From the target. */ + + if (info->osabi == GDB_OSABI_UNKNOWN && info->target_desc != NULL) + info->osabi = tdesc_osabi (info->target_desc); + /* From the configured default. */ +#ifdef GDB_OSABI_DEFAULT + if (info->osabi == GDB_OSABI_UNKNOWN) + info->osabi = GDB_OSABI_DEFAULT; +#endif + /* If we still don't know which osabi to pick, pick none. */ + if (info->osabi == GDB_OSABI_UNKNOWN) + info->osabi = GDB_OSABI_NONE; /* Must have at least filled in the architecture. */ gdb_assert (info->bfd_arch_info != NULL); } -/* */ +/* Return "current" architecture. If the target is running, this is + the architecture of the selected frame. Otherwise, the "current" + architecture defaults to the target architecture. -extern initialize_file_ftype _initialize_gdbarch_utils; /* -Wmissing-prototypes */ + This function should normally be called solely by the command + interpreter routines to determine the architecture to execute a + command in. */ +struct gdbarch * +get_current_arch (void) +{ + if (has_stack_frames ()) + return get_frame_arch (get_selected_frame (NULL)); + else + return target_gdbarch (); +} + +int +default_has_shared_address_space (struct gdbarch *gdbarch) +{ + /* Simply say no. In most unix-like targets each inferior/process + has its own address space. */ + return 0; +} + +int +default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, + std::string *msg) +{ + /* We don't know if maybe the target has some way to do fast + tracepoints that doesn't need gdbarch, so always say yes. */ + if (msg) + msg->clear (); + return 1; +} + +const gdb_byte * +default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, + int *lenptr) +{ + int kind = gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr); + + return gdbarch_sw_breakpoint_from_kind (gdbarch, kind, lenptr); +} +int +default_breakpoint_kind_from_current_state (struct gdbarch *gdbarch, + struct regcache *regcache, + CORE_ADDR *pcptr) +{ + return gdbarch_breakpoint_kind_from_pc (gdbarch, pcptr); +} + + +void +default_gen_return_address (struct gdbarch *gdbarch, + struct agent_expr *ax, struct axs_value *value, + CORE_ADDR scope) +{ + error (_("This architecture has no method to collect a return address.")); +} + +int +default_return_in_first_hidden_param_p (struct gdbarch *gdbarch, + struct type *type) +{ + /* Usually, the return value's address is stored the in the "first hidden" + parameter if the return value should be passed by reference, as + specified in ABI. */ + return language_pass_by_reference (type); +} + +int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr) +{ + return 0; +} + +int default_insn_is_ret (struct gdbarch *gdbarch, CORE_ADDR addr) +{ + return 0; +} + +int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr) +{ + return 0; +} + +void +default_skip_permanent_breakpoint (struct regcache *regcache) +{ + struct gdbarch *gdbarch = regcache->arch (); + CORE_ADDR current_pc = regcache_read_pc (regcache); + int bp_len; + + gdbarch_breakpoint_from_pc (gdbarch, ¤t_pc, &bp_len); + current_pc += bp_len; + regcache_write_pc (regcache, current_pc); +} + +CORE_ADDR +default_infcall_mmap (CORE_ADDR size, unsigned prot) +{ + error (_("This target does not support inferior memory allocation by mmap.")); +} + +void +default_infcall_munmap (CORE_ADDR addr, CORE_ADDR size) +{ + /* Memory reserved by inferior mmap is kept leaked. */ +} + +/* -mcmodel=large is used so that no GOT (Global Offset Table) is needed to be + created in inferior memory by GDB (normally it is set by ld.so). */ + +std::string +default_gcc_target_options (struct gdbarch *gdbarch) +{ + return string_printf ("-m%d%s", gdbarch_ptr_bit (gdbarch), + (gdbarch_ptr_bit (gdbarch) == 64 + ? " -mcmodel=large" : "")); +} + +/* gdbarch gnu_triplet_regexp method. */ + +const char * +default_gnu_triplet_regexp (struct gdbarch *gdbarch) +{ + return gdbarch_bfd_arch_info (gdbarch)->arch_name; +} + +/* Default method for gdbarch_addressable_memory_unit_size. By default, a memory byte has + a size of 1 octet. */ + +int +default_addressable_memory_unit_size (struct gdbarch *gdbarch) +{ + return 1; +} + +void +default_guess_tracepoint_registers (struct gdbarch *gdbarch, + struct regcache *regcache, + CORE_ADDR addr) +{ + int pc_regno = gdbarch_pc_regnum (gdbarch); + gdb_byte *regs; + + /* This guessing code below only works if the PC register isn't + a pseudo-register. The value of a pseudo-register isn't stored + in the (non-readonly) regcache -- instead it's recomputed + (probably from some other cached raw register) whenever the + register is read. In this case, a custom method implementation + should be used by the architecture. */ + if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch)) + return; + + regs = (gdb_byte *) alloca (register_size (gdbarch, pc_regno)); + store_unsigned_integer (regs, register_size (gdbarch, pc_regno), + gdbarch_byte_order (gdbarch), addr); + regcache->raw_supply (pc_regno, regs); +} + +int +default_print_insn (bfd_vma memaddr, disassemble_info *info) +{ + disassembler_ftype disassemble_fn; + + disassemble_fn = disassembler (info->arch, info->endian == BFD_ENDIAN_BIG, + info->mach, exec_bfd); + + gdb_assert (disassemble_fn != NULL); + return (*disassemble_fn) (memaddr, info); +} + +/* See arch-utils.h. */ + +CORE_ADDR +gdbarch_skip_prologue_noexcept (gdbarch *gdbarch, CORE_ADDR pc) noexcept +{ + CORE_ADDR new_pc = pc; + + try + { + new_pc = gdbarch_skip_prologue (gdbarch, pc); + } + catch (const gdb_exception &ex) + {} + + return new_pc; +} + +/* See arch-utils.h. */ + +bool +default_in_indirect_branch_thunk (gdbarch *gdbarch, CORE_ADDR pc) +{ + return false; +} + +/* See arch-utils.h. */ + +ULONGEST +default_type_align (struct gdbarch *gdbarch, struct type *type) +{ + return 0; +} + +/* See arch-utils.h. */ + +std::string +default_get_pc_address_flags (frame_info *frame, CORE_ADDR pc) +{ + return ""; +} void _initialize_gdbarch_utils (void) { - struct cmd_list_element *c; add_setshow_enum_cmd ("endian", class_support, - endian_enum, &set_endian_string, _("\ -Set endianness of target."), _("\ -Show endianness of target."), NULL, - set_endian, show_endian, + endian_enum, &set_endian_string, + _("Set endianness of target."), + _("Show endianness of target."), + NULL, set_endian, show_endian, &setlist, &showlist); }