X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Farch-utils.c;h=c75a79757ea24ff852231c3d381ebae39766e83d;hb=7ee8c127555c89781bcd9451cdea54884f6ac155;hp=32d48a744fae2ba43f74c27f04cd43018313ae7a;hpb=32d0add0a654c1204ab71dc8a55d9374538c4b33;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c index 32d48a744f..c75a79757e 100644 --- a/gdb/arch-utils.c +++ b/gdb/arch-utils.c @@ -1,6 +1,6 @@ /* Dynamic architecture support for GDB, the GNU debugger. - Copyright (C) 1998-2015 Free Software Foundation, Inc. + Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of GDB. @@ -20,7 +20,6 @@ #include "defs.h" #include "arch-utils.h" -#include "buildsym.h" #include "gdbcmd.h" #include "inferior.h" /* enum CALL_DUMMY_LOCATION et al. */ #include "infrun.h" @@ -33,43 +32,14 @@ #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 %s->%s: ", - paddress (gdbarch, from), paddress (gdbarch, 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) -{ - xfree (closure); -} - -int -default_displaced_step_hw_singlestep (struct gdbarch *gdbarch, - struct displaced_step_closure *closure) +bool +default_displaced_step_hw_singlestep (struct gdbarch *gdbarch) { return !gdbarch_software_single_step_p (gdbarch); } @@ -98,7 +68,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') @@ -107,6 +77,55 @@ legacy_register_sim_regno (struct gdbarch *gdbarch, int regnum) return LEGACY_SIM_REGNO_IGNORE; } + +/* See arch-utils.h */ + +std::string +default_memtag_to_string (struct gdbarch *gdbarch, struct value *tag) +{ + error (_("This architecture has no method to convert a memory tag to" + " a string.")); +} + +/* See arch-utils.h */ + +bool +default_tagged_address_p (struct gdbarch *gdbarch, struct value *address) +{ + /* By default, assume the address is untagged. */ + return false; +} + +/* See arch-utils.h */ + +bool +default_memtag_matches_p (struct gdbarch *gdbarch, struct value *address) +{ + /* By default, assume the tags match. */ + return true; +} + +/* See arch-utils.h */ + +bool +default_set_memtags (struct gdbarch *gdbarch, struct value *address, + size_t length, const gdb::byte_vector &tags, + memtag_type tag_type) +{ + /* By default, return true (successful); */ + return true; +} + +/* See arch-utils.h */ + +struct value * +default_get_memtag (struct gdbarch *gdbarch, struct value *address, + memtag_type tag_type) +{ + /* By default, return no tag. */ + return nullptr; +} + CORE_ADDR generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { @@ -127,11 +146,18 @@ generic_in_solib_return_trampoline (struct gdbarch *gdbarch, } 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 @@ -197,6 +223,15 @@ 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) { @@ -224,7 +259,7 @@ legacy_virtual_frame_pointer (struct gdbarch *gdbarch, *frame_regnum = gdbarch_deprecated_fp_regnum (gdbarch); else if (gdbarch_sp_regnum (gdbarch) >= 0 && gdbarch_sp_regnum (gdbarch) - < gdbarch_num_regs (gdbarch)) + < gdbarch_num_regs (gdbarch)) *frame_regnum = gdbarch_sp_regnum (gdbarch); else /* Should this be an internal error? I guess so, it is reflecting @@ -234,6 +269,40 @@ legacy_virtual_frame_pointer (struct gdbarch *gdbarch, *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; + + /* Check if this is a bfloat16 type. It has the same size as the + IEEE half float type, so we use the base type name to tell them + apart. */ + if (name != nullptr && strcmp (name, "__bf16") == 0 + && len == gdbarch_bfloat16_bit (gdbarch)) + format = gdbarch_bfloat16_format (gdbarch); + else 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, @@ -273,7 +342,7 @@ default_vsyscall_range (struct gdbarch *gdbarch, struct mem_range *range) /* 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"; @@ -302,21 +371,21 @@ show_endian (struct ui_file *file, int from_tty, struct cmd_list_element *c, if (target_byte_order_user == BFD_ENDIAN_UNKNOWN) if (gdbarch_byte_order (get_current_arch ()) == BFD_ENDIAN_BIG) fprintf_unfiltered (file, _("The target endianness is set automatically " - "(currently big endian)\n")); + "(currently big endian).\n")); else fprintf_unfiltered (file, _("The target endianness is set automatically " - "(currently little endian)\n")); + "(currently little endian).\n")); else if (target_byte_order_user == BFD_ENDIAN_BIG) fprintf_unfiltered (file, - _("The target is assumed to be big endian\n")); + _("The target is set to big endian.\n")); else fprintf_unfiltered (file, - _("The target is assumed to be little endian\n")); + _("The target is set to little endian.\n")); } 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; @@ -358,7 +427,7 @@ set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c) SELECTED may be NULL, in which case we return the architecture associated with TARGET_DESC. If SELECTED specifies a variant - of the architecture associtated with TARGET_DESC, return the + 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 @@ -461,11 +530,11 @@ show_architecture (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { if (target_architecture_user == NULL) - fprintf_filtered (file, _("The target architecture is set " - "automatically (currently %s)\n"), + fprintf_filtered (file, _("The target architecture is set to " + "\"auto\" (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"), + fprintf_filtered (file, _("The target architecture is set to \"%s\".\n"), set_architecture_string); } @@ -474,7 +543,8 @@ show_architecture (struct ui_file *file, int from_tty, 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; @@ -511,7 +581,7 @@ gdbarch_update_p (struct gdbarch_info info) /* Check for the current file. */ if (info.abfd == NULL) - info.abfd = exec_bfd; + info.abfd = current_program_space->exec_bfd (); if (info.abfd == NULL) info.abfd = core_bfd; @@ -603,7 +673,7 @@ 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) @@ -661,7 +731,7 @@ initialize_current_architecture (void) 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) @@ -684,16 +754,18 @@ initialize_current_architecture (void) /* 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, - set_architecture, show_architecture, - &setlist, &showlist); - add_alias_cmd ("processor", "architecture", class_support, 1, &setlist); + set_show_commands architecture_cmds + = add_setshow_enum_cmd ("architecture", class_support, + arches, &set_architecture_string, + _("Set architecture of target."), + _("Show architecture of target."), NULL, + set_architecture, show_architecture, + &setlist, &showlist); + add_alias_cmd ("processor", architecture_cmds.set, class_support, 1, + &setlist); } } @@ -710,7 +782,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 @@ -752,12 +823,15 @@ 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. */ /* From the manual override, or from file. */ - if (info->osabi == GDB_OSABI_UNINITIALIZED) + 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. */ @@ -765,6 +839,9 @@ gdbarch_info_fill (struct gdbarch_info *info) 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); @@ -795,23 +872,33 @@ default_has_shared_address_space (struct gdbarch *gdbarch) } int -default_fast_tracepoint_valid_at (struct gdbarch *gdbarch, - CORE_ADDR addr, int *isize, char **msg) +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 = NULL; + msg->clear (); return 1; } -void -default_remote_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, - int *kindptr) +const gdb_byte * +default_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, + int *lenptr) { - gdbarch_breakpoint_from_pc (gdbarch, pcptr, kindptr); + 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, @@ -827,7 +914,7 @@ default_return_in_first_hidden_param_p (struct gdbarch *gdbarch, /* 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); + return !(language_pass_by_reference (type).trivially_copyable); } int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr) @@ -845,15 +932,46 @@ int default_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr) return 0; } +/* See arch-utils.h. */ + +bool +default_program_breakpoint_here_p (struct gdbarch *gdbarch, + CORE_ADDR address) +{ + int len; + const gdb_byte *bpoint = gdbarch_breakpoint_from_pc (gdbarch, &address, &len); + + /* Software breakpoints unsupported? */ + if (bpoint == nullptr) + return false; + + gdb_byte *target_mem = (gdb_byte *) alloca (len); + + /* Enable the automatic memory restoration from breakpoints while + we read the memory. Otherwise we may find temporary breakpoints, ones + inserted by GDB, and flag them as permanent breakpoints. */ + scoped_restore restore_memory + = make_scoped_restore_show_memory_breakpoints (0); + + if (target_read_memory (address, target_mem, len) == 0) + { + /* Check if this is a breakpoint instruction for this architecture, + including ones used by GDB. */ + if (memcmp (target_mem, bpoint, len) == 0) + return true; + } + + return false; +} + void default_skip_permanent_breakpoint (struct regcache *regcache) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); CORE_ADDR current_pc = regcache_read_pc (regcache); - const gdb_byte *bp_insn; int bp_len; - bp_insn = gdbarch_breakpoint_from_pc (gdbarch, ¤t_pc, &bp_len); + gdbarch_breakpoint_from_pc (gdbarch, ¤t_pc, &bp_len); current_pc += bp_len; regcache_write_pc (regcache, current_pc); } @@ -864,14 +982,21 @@ 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). */ -char * +std::string default_gcc_target_options (struct gdbarch *gdbarch) { - return xstrprintf ("-m%d%s", gdbarch_ptr_bit (gdbarch), - gdbarch_ptr_bit (gdbarch) == 64 ? " -mcmodel=large" : ""); + return string_printf ("-m%d%s", gdbarch_ptr_bit (gdbarch), + (gdbarch_ptr_bit (gdbarch) == 64 + ? " -mcmodel=large" : "")); } /* gdbarch gnu_triplet_regexp method. */ @@ -882,11 +1007,111 @@ default_gnu_triplet_regexp (struct gdbarch *gdbarch) return gdbarch_bfd_arch_info (gdbarch)->arch_name; } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_gdbarch_utils; +/* Default method for gdbarch_addressable_memory_unit_size. The default is + based on the bits_per_byte defined in the bfd library for the current + architecture, this is usually 8-bits, and so this function will usually + return 1 indicating 1 byte is 1 octet. */ + +int +default_addressable_memory_unit_size (struct gdbarch *gdbarch) +{ + return gdbarch_bfd_arch_info (gdbarch)->bits_per_byte / 8; +} + +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, current_program_space->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 ""; +} + +/* See arch-utils.h. */ +void +default_read_core_file_mappings (struct gdbarch *gdbarch, + struct bfd *cbfd, + gdb::function_view + pre_loop_cb, + gdb::function_view + loop_cb) +{ +} +void _initialize_gdbarch_utils (); void -_initialize_gdbarch_utils (void) +_initialize_gdbarch_utils () { add_setshow_enum_cmd ("endian", class_support, endian_enum, &set_endian_string,