X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbarch.sh;h=37f59b7b93a39f2d554008a3e461c876ab4888ce;hb=173981bc49c9e8fce9271cb47714952dbe2ec627;hp=0f303a439899402949aadf3aa0be06e9fbd07004;hpb=8a526fa69afd8ea7d2e303f80c03f9eb46211390;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index 0f303a4398..37f59b7b93 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -2,7 +2,7 @@ # Architecture commands for GDB, the GNU debugger. # -# Copyright (C) 1998-2015 Free Software Foundation, Inc. +# Copyright (C) 1998-2016 Free Software Foundation, Inc. # # This file is part of GDB. # @@ -446,6 +446,12 @@ M:int:ax_pseudo_register_collect:struct agent_expr *ax, int reg:ax, reg # Return -1 if something goes wrong, 0 otherwise. M:int:ax_pseudo_register_push_stack:struct agent_expr *ax, int reg:ax, reg +# Some targets/architectures can do extra processing/display of +# segmentation faults. E.g., Intel MPX boundary faults. +# Call the architecture dependent function to handle the fault. +# UIOUT is the output stream where the handler will place information. +M:void:handle_segmentation_fault:struct ui_out *uiout:uiout + # GDB's standard (or well known) register numbers. These can map onto # a real register or a pseudo (computed) register or not be defined at # all (-1). @@ -461,6 +467,7 @@ m:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr::no_op_reg_to_regnum::0 # Convert from an sdb register number to an internal gdb register number. m:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr::no_op_reg_to_regnum::0 # Provide a default mapping from a DWARF2 register number to a gdb REGNUM. +# Return -1 for bad REGNUM. Note: Several targets get this wrong. m:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr::no_op_reg_to_regnum::0 m:const char *:register_name:int regnr:regnr::0 @@ -598,10 +605,6 @@ m:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr::core_addr_identity::0 # indicates if the target needs software single step. An ISA method to # implement it. # -# FIXME/cagney/2001-01-18: This should be replaced with something that inserts -# breakpoints using the breakpoint system instead of blatting memory directly -# (as with rs6000). -# # FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the # target can single step. If not, then implement single step using breakpoints. # @@ -627,14 +630,14 @@ m:int:in_solib_return_trampoline:CORE_ADDR pc, const char *name:pc, name::generi # A target might have problems with watchpoints as soon as the stack # frame of the current function has been destroyed. This mostly happens -# as the first action in a funtion's epilogue. in_function_epilogue_p() +# as the first action in a function's epilogue. stack_frame_destroyed_p() # is defined to return a non-zero value if either the given addr is one # instruction after the stack destroying instruction up to the trailing # return instruction or if we can figure out that the stack frame has # already been invalidated regardless of the value of addr. Targets # which don't suffer from that problem could just let this functionality # untouched. -m:int:in_function_epilogue_p:CORE_ADDR addr:addr:0:generic_in_function_epilogue_p::0 +m:int:stack_frame_destroyed_p:CORE_ADDR addr:addr:0:generic_stack_frame_destroyed_p::0 # Process an ELF symbol in the minimal symbol table in a backend-specific # way. Normally this hook is supposed to do nothing, however if required, # then this hook can be used to apply tranformations to symbols that are @@ -720,6 +723,9 @@ M:ULONGEST:core_xfer_shared_libraries_aix:gdb_byte *readbuf, ULONGEST offset, UL # How the core target converts a PTID from a core file to a string. M:char *:core_pid_to_str:ptid_t ptid:ptid +# How the core target extracts the name of a thread from a core file. +M:const char *:core_thread_name:struct thread_info *thr:thr + # BFD target to use when generating a core file. V:const char *:gcore_bfd_target:::0:0:::pstring (gdbarch->gcore_bfd_target) @@ -763,6 +769,10 @@ V:ULONGEST:max_insn_length:::0:0 # If your architecture doesn't need to adjust instructions before # single-stepping them, consider using simple_displaced_step_copy_insn # here. +# +# If the instruction cannot execute out of line, return NULL. The +# core falls back to stepping past the instruction in-line instead in +# that case. M:struct displaced_step_closure *:displaced_step_copy_insn:CORE_ADDR from, CORE_ADDR to, struct regcache *regs:from, to, regs # Return true if GDB should use hardware single-stepping to execute @@ -1018,7 +1028,13 @@ v:int:has_global_breakpoints:::0:0::0 m:int:has_shared_address_space:void:::default_has_shared_address_space::0 # True if a fast tracepoint can be set at an address. -m:int:fast_tracepoint_valid_at:CORE_ADDR addr, int *isize, char **msg:addr, isize, msg::default_fast_tracepoint_valid_at::0 +m:int:fast_tracepoint_valid_at:CORE_ADDR addr, char **msg:addr, msg::default_fast_tracepoint_valid_at::0 + +# Guess register state based on tracepoint location. Used for tracepoints +# where no registers have been collected, but there's only one location, +# allowing us to guess the PC value, and perhaps some other registers. +# On entry, regcache has all registers marked as unavailable. +m:void:guess_tracepoint_registers:struct regcache *regcache, CORE_ADDR addr:regcache, addr::default_guess_tracepoint_registers::0 # Return the "auto" target charset. f:const char *:auto_charset:void::default_auto_charset:default_auto_charset::0 @@ -1097,6 +1113,10 @@ m:int:vsyscall_range:struct mem_range *range:range::default_vsyscall_range::0 # Throw an error if it is not possible. Returned address is always valid. f:CORE_ADDR:infcall_mmap:CORE_ADDR size, unsigned prot:size, prot::default_infcall_mmap::0 +# Deallocate SIZE bytes of memory at ADDR in inferior from gdbarch_infcall_mmap. +# Print a warning if it is not possible. +f:void:infcall_munmap:CORE_ADDR addr, CORE_ADDR size:addr, size::default_infcall_munmap::0 + # Return string (caller has to use xfree for it) with options for GCC # to produce code for this target, typically "-m64", "-m32" or "-m31". # These options are put before CU's DW_AT_producer compilation options so that @@ -1109,6 +1129,12 @@ m:char *:gcc_target_options:void:::default_gcc_target_options::0 # returns the BFD architecture name, which is correct in nearly every # case. m:const char *:gnu_triplet_regexp:void:::default_gnu_triplet_regexp::0 + +# Return the size in 8-bit bytes of an addressable memory unit on this +# architecture. This corresponds to the number of 8-bit bytes associated to +# each address in memory. +m:int:addressable_memory_unit_size:void:::default_addressable_memory_unit_size::0 + EOF } @@ -1162,7 +1188,7 @@ cat <. */ @@ -1223,7 +1249,6 @@ struct target_desc; struct objfile; struct symbol; struct displaced_step_closure; -struct core_regset_section; struct syscall; struct agent_expr; struct axs_value; @@ -1233,6 +1258,8 @@ struct ravenscar_arch_ops; struct elf_internal_linux_prpsinfo; struct mem_range; struct syscalls_info; +struct thread_info; +struct ui_out; #include "regcache.h" @@ -1415,7 +1442,7 @@ struct gdbarch_info bfd *abfd; /* Use default: NULL (ZERO). */ - struct gdbarch_tdep_info *tdep_info; + void *tdep_info; /* Use default: GDB_OSABI_UNINITIALIZED (-1). */ enum gdb_osabi osabi; @@ -1472,6 +1499,11 @@ extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size); #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE))) #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE))) +/* Duplicate STRING, returning an equivalent string that's allocated on the + obstack associated with GDBARCH. The string is freed when the corresponding + architecture is also freed. */ + +extern char *gdbarch_obstack_strdup (struct gdbarch *arch, const char *string); /* Helper function. Force an update of the current architecture. @@ -1727,7 +1759,7 @@ gdbarch_alloc (const struct gdbarch_info *info, then use that to allocate the architecture vector. */ struct obstack *obstack = XNEW (struct obstack); obstack_init (obstack); - gdbarch = obstack_alloc (obstack, sizeof (*gdbarch)); + gdbarch = XOBNEW (obstack, struct gdbarch); memset (gdbarch, 0, sizeof (*gdbarch)); gdbarch->obstack = obstack; @@ -1777,6 +1809,14 @@ gdbarch_obstack_zalloc (struct gdbarch *arch, long size) return data; } +/* See gdbarch.h. */ + +char * +gdbarch_obstack_strdup (struct gdbarch *arch, const char *string) +{ + return obstack_strdup (arch->obstack, string); +} + /* Free a gdbarch struct. This should never happen in normal operation --- once you've created a gdbarch, you keep it around. @@ -2187,7 +2227,7 @@ static struct gdbarch_registration *gdbarch_registry = NULL; static void append_name (const char ***buf, int *nr, const char *name) { - *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1)); + *buf = XRESIZEVEC (const char *, *buf, *nr + 1); (*buf)[*nr] = name; *nr += 1; }