X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbarch.sh;h=2958cabcdc7f7f9c417472d9da4eae93ba4c2874;hb=0913ae5ad7ad465e36784ed7fcc8676f3e0e23b7;hp=6d7a578d69de615b7201ef57f6f0788ac2573c2a;hpb=7e35103a303c52a8ae636600db6fcba630758a91;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index 6d7a578d69..2958cabcdc 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -2,7 +2,7 @@ # Architecture commands for GDB, the GNU debugger. # -# Copyright (C) 1998-2012 Free Software Foundation, Inc. +# Copyright (C) 1998-2017 Free Software Foundation, Inc. # # This file is part of GDB. # @@ -340,8 +340,8 @@ function_list () cat <printable_name # -i:int:byte_order:::BFD_ENDIAN_BIG -i:int:byte_order_for_code:::BFD_ENDIAN_BIG +i:enum bfd_endian:byte_order:::BFD_ENDIAN_BIG +i:enum bfd_endian:byte_order_for_code:::BFD_ENDIAN_BIG # i:enum gdb_osabi:osabi:::GDB_OSABI_UNKNOWN # @@ -383,6 +383,11 @@ v:const struct floatformat **:double_format:::::floatformats_ieee_double::pforma v:int:long_double_bit:::8 * sizeof (long double):8*TARGET_CHAR_BIT::0 v:const struct floatformat **:long_double_format:::::floatformats_ieee_double::pformat (gdbarch->long_double_format) +# Returns the floating-point format to be used for values of length LENGTH. +# NAME, if non-NULL, is the type name, which may be used to distinguish +# different target formats of the same length. +m:const struct floatformat **:floatformat_for_type:const char *name, int length:name, length:0:default_floatformat_for_type::0 + # For most targets, a pointer on the target and its representation as an # address in GDB have the same size and "look the same". For such a # target, you need only set gdbarch_ptr_bit and gdbarch_addr_bit @@ -446,6 +451,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 +472,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 @@ -469,27 +481,33 @@ m:const char *:register_name:int regnr:regnr::0 # use "register_type". M:struct type *:register_type:int reg_nr:reg_nr -# See gdbint.texinfo, and PUSH_DUMMY_CALL. M:struct frame_id:dummy_id:struct frame_info *this_frame:this_frame # Implement DUMMY_ID and PUSH_DUMMY_CALL, then delete # deprecated_fp_regnum. v:int:deprecated_fp_regnum:::-1:-1::0 -# See gdbint.texinfo. See infcall.c. M:CORE_ADDR:push_dummy_call:struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr v:int:call_dummy_location::::AT_ENTRY_POINT::0 M:CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache:sp, funaddr, args, nargs, value_type, real_pc, bp_addr, regcache +# Return true if the code of FRAME is writable. +m:int:code_of_frame_writable:struct frame_info *frame:frame::default_code_of_frame_writable::0 + m:void:print_registers_info:struct ui_file *file, struct frame_info *frame, int regnum, int all:file, frame, regnum, all::default_print_registers_info::0 -M:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args +m:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args::default_print_float_info::0 M:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args # MAP a GDB RAW register number onto a simulator register number. See # also include/...-sim.h. m:int:register_sim_regno:int reg_nr:reg_nr::legacy_register_sim_regno::0 m:int:cannot_fetch_register:int regnum:regnum::cannot_register_not::0 m:int:cannot_store_register:int regnum:regnum::cannot_register_not::0 -# setjmp/longjmp support. + +# Determine the address where a longjmp will land and save this address +# in PC. Return nonzero on success. +# +# FRAME corresponds to the longjmp frame. F:int:get_longjmp_target:struct frame_info *frame, CORE_ADDR *pc:frame, pc + # v:int:believe_pcc_promotion::::::: # @@ -497,10 +515,10 @@ m:int:convert_register_p:int regnum, struct type *type:regnum, type:0:generic_co f:int:register_to_value:struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep:frame, regnum, type, buf, optimizedp, unavailablep:0 f:void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf:frame, regnum, type, buf:0 # Construct a value representing the contents of register REGNUM in -# frame FRAME, interpreted as type TYPE. The routine needs to +# frame FRAME_ID, interpreted as type TYPE. The routine needs to # allocate and return a struct value with all value attributes # (but not the value contents) filled in. -f:struct value *:value_from_register:struct type *type, int regnum, struct frame_info *frame:type, regnum, frame::default_value_from_register::0 +m:struct value *:value_from_register:struct type *type, int regnum, struct frame_id frame_id:type, regnum, frame_id::default_value_from_register::0 # m:CORE_ADDR:pointer_to_address:struct type *type, const gdb_byte *buf:type, buf::unsigned_pointer_to_address::0 m:void:address_to_pointer:struct type *type, gdb_byte *buf, CORE_ADDR addr:type, buf, addr::unsigned_address_to_pointer::0 @@ -527,12 +545,35 @@ m:int:return_in_first_hidden_param_p:struct type *type:type::default_return_in_f m:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip:0:0 M:CORE_ADDR:skip_main_prologue:CORE_ADDR ip:ip +# On some platforms, a single function may provide multiple entry points, +# e.g. one that is used for function-pointer calls and a different one +# that is used for direct function calls. +# In order to ensure that breakpoints set on the function will trigger +# no matter via which entry point the function is entered, a platform +# may provide the skip_entrypoint callback. It is called with IP set +# to the main entry point of a function (as determined by the symbol table), +# and should return the address of the innermost entry point, where the +# actual breakpoint needs to be set. Note that skip_entrypoint is used +# by GDB common code even when debugging optimized code, where skip_prologue +# is not used. +M:CORE_ADDR:skip_entrypoint:CORE_ADDR ip:ip + f:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs:0:0 -m:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0: -# Return the adjusted address and kind to use for Z0/Z1 packets. -# KIND is usually the memory length of the breakpoint, but may have a -# different target-specific meaning. -m:void:remote_breakpoint_from_pc:CORE_ADDR *pcptr, int *kindptr:pcptr, kindptr:0:default_remote_breakpoint_from_pc::0 +m:const gdb_byte *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:0:default_breakpoint_from_pc::0 + +# Return the breakpoint kind for this target based on *PCPTR. +m:int:breakpoint_kind_from_pc:CORE_ADDR *pcptr:pcptr::0: + +# Return the software breakpoint from KIND. KIND can have target +# specific meaning like the Z0 kind parameter. +# SIZE is set to the software breakpoint's length in memory. +m:const gdb_byte *:sw_breakpoint_from_kind:int kind, int *size:kind, size::NULL::0 + +# Return the breakpoint kind for this target based on the current +# processor state (e.g. the current instruction mode on ARM) and the +# *PCPTR. In default, it is gdbarch->breakpoint_kind_from_pc. +m:int:breakpoint_kind_from_current_state:struct regcache *regcache, CORE_ADDR *pcptr:regcache, pcptr:0:default_breakpoint_kind_from_current_state::0 + M:CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr m:int:memory_insert_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_insert_breakpoint::0 m:int:memory_remove_breakpoint:struct bp_target_info *bp_tgt:bp_tgt:0:default_memory_remove_breakpoint::0 @@ -582,16 +623,18 @@ 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. # -# A return value of 1 means that the software_single_step breakpoints -# were inserted; 0 means they were not. -F:int:software_single_step:struct frame_info *frame:frame +# Return a vector of addresses on which the software single step +# breakpoints should be inserted. NULL means software single step is +# not used. +# Multiple breakpoints may be inserted for some instructions such as +# conditional branch. However, each implementation must always evaluate +# the condition and only put the breakpoint at the branch destination if +# the condition is true, so that we ensure forward progress when stepping +# past a conditional branch to self. +F:VEC (CORE_ADDR) *:software_single_step:struct regcache *regcache:regcache # Return non-zero if the processor is executing a delay slot and a # further single-step is needed before the instruction finishes. @@ -611,46 +654,102 @@ 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 -f:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym::default_elf_make_msymbol_special::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 +# considered special in some way. For example the MIPS backend uses it +# to interpret \`st_other' information to mark compressed code symbols so +# that they can be treated in the appropriate manner in the processing of +# the main symbol table and DWARF-2 records. +F:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym f:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym::default_coff_make_msymbol_special::0 +# Process a symbol in the main 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 considered special in some way. This is currently used by the +# MIPS backend to make sure compressed code symbols have the ISA bit +# set. This in turn is needed for symbol values seen in GDB to match +# the values used at the runtime by the program itself, for function +# and label references. +f:void:make_symbol_special:struct symbol *sym, struct objfile *objfile:sym, objfile::default_make_symbol_special::0 +# Adjust the address retrieved from a DWARF-2 record other than a line +# entry in a backend-specific way. Normally this hook is supposed to +# return the address passed unchanged, however if that is incorrect for +# any reason, then this hook can be used to fix the address up in the +# required manner. This is currently used by the MIPS backend to make +# sure addresses in FDE, range records, etc. referring to compressed +# code have the ISA bit set, matching line information and the symbol +# table. +f:CORE_ADDR:adjust_dwarf2_addr:CORE_ADDR pc:pc::default_adjust_dwarf2_addr::0 +# Adjust the address updated by a line entry in a backend-specific way. +# Normally this hook is supposed to return the address passed unchanged, +# however in the case of inconsistencies in these records, this hook can +# be used to fix them up in the required manner. This is currently used +# by the MIPS backend to make sure all line addresses in compressed code +# are presented with the ISA bit set, which is not always the case. This +# in turn ensures breakpoint addresses are correctly matched against the +# stop PC. +f:CORE_ADDR:adjust_dwarf2_line:CORE_ADDR addr, int rel:addr, rel::default_adjust_dwarf2_line::0 v:int:cannot_step_breakpoint:::0:0::0 v:int:have_nonsteppable_watchpoint:::0:0::0 F:int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class M:const char *:address_class_type_flags_to_name:int type_flags:type_flags + +# Return the appropriate type_flags for the supplied address class. +# This function should return 1 if the address class was recognized and +# type_flags was set, zero otherwise. M:int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr # Is a register in a group m:int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup::default_register_reggroup_p::0 # Fetch the pointer to the ith function argument. F:CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type -# Return the appropriate register set for a core file section with -# name SECT_NAME and size SECT_SIZE. -M:const struct regset *:regset_from_core_section:const char *sect_name, size_t sect_size:sect_name, sect_size - -# Supported register notes in a core file. -v:struct core_regset_section *:core_regset_sections:const char *name, int len::::::host_address_to_string (gdbarch->core_regset_sections) +# Iterate over all supported register notes in a core file. For each +# supported register note section, the iterator must call CB and pass +# CB_DATA unchanged. If REGCACHE is not NULL, the iterator can limit +# the supported register note sections based on the current register +# values. Otherwise it should enumerate all supported register note +# sections. +M:void:iterate_over_regset_sections:iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache:cb, cb_data, regcache # Create core file notes M:char *:make_corefile_notes:bfd *obfd, int *note_size:obfd, note_size +# The elfcore writer hook to use to write Linux prpsinfo notes to core +# files. Most Linux architectures use the same prpsinfo32 or +# prpsinfo64 layouts, and so won't need to provide this hook, as we +# call the Linux generic routines in bfd to write prpsinfo notes by +# default. +F:char *:elfcore_write_linux_prpsinfo:bfd *obfd, char *note_data, int *note_size, const struct elf_internal_linux_prpsinfo *info:obfd, note_data, note_size, info + # Find core file memory regions M:int:find_memory_regions:find_memory_region_ftype func, void *data:func, data # Read offset OFFSET of TARGET_OBJECT_LIBRARIES formatted shared libraries list from -# core file into buffer READBUF with length LEN. -M:LONGEST:core_xfer_shared_libraries:gdb_byte *readbuf, ULONGEST offset, LONGEST len:readbuf, offset, len +# core file into buffer READBUF with length LEN. Return the number of bytes read +# (zero indicates failure). +# failed, otherwise, return the red length of READBUF. +M:ULONGEST:core_xfer_shared_libraries:gdb_byte *readbuf, ULONGEST offset, ULONGEST len:readbuf, offset, len + +# Read offset OFFSET of TARGET_OBJECT_LIBRARIES_AIX formatted shared +# libraries list from core file into buffer READBUF with length LEN. +# Return the number of bytes read (zero indicates failure). +M:ULONGEST:core_xfer_shared_libraries_aix:gdb_byte *readbuf, ULONGEST offset, ULONGEST len:readbuf, offset, len # 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) @@ -664,7 +763,7 @@ v:int:vtable_function_descriptors:::0:0::0 v:int:vbit_in_delta:::0:0::0 # Advance PC to next instruction in order to skip a permanent breakpoint. -F:void:skip_permanent_breakpoint:struct regcache *regcache:regcache +f:void:skip_permanent_breakpoint:struct regcache *regcache:regcache:default_skip_permanent_breakpoint:default_skip_permanent_breakpoint::0 # The maximum length of an instruction on this architecture in bytes. V:ULONGEST:max_insn_length:::0:0 @@ -694,6 +793,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 @@ -788,6 +891,15 @@ M:int:process_record_signal:struct regcache *regcache, enum gdb_signal signal:re # (target_wait, target_resume, etc.). M:enum gdb_signal:gdb_signal_from_target:int signo:signo +# Signal translation: translate the GDB's internal signal number into +# the inferior's signal (target's) representation. The implementation +# of this method must be host independent. IOW, don't rely on symbols +# of the NAT_FILE header (the nm-*.h files), the host +# header, or similar headers. +# Return the target signal number if found, or -1 if the GDB internal +# signal number is invalid. +M:int:gdb_signal_to_target:enum gdb_signal signal:signal + # Extra signal info inspection. # # Return a type suitable to inspect extra signal information. @@ -801,31 +913,42 @@ M:void:record_special_symbol:struct objfile *objfile, asymbol *sym:objfile, sym # Get architecture-specific system calls information from registers. M:LONGEST:get_syscall_number:ptid_t ptid:ptid +# The filename of the XML syscall for this architecture. +v:const char *:xml_syscall_file:::0:0::0:pstring (gdbarch->xml_syscall_file) + +# Information about system calls from this architecture +v:struct syscalls_info *:syscalls_info:::0:0::0:host_address_to_string (gdbarch->syscalls_info) + # SystemTap related fields and functions. -# Prefix used to mark an integer constant on the architecture's assembly +# A NULL-terminated array of prefixes used to mark an integer constant +# on the architecture's assembly. # For example, on x86 integer constants are written as: # # \$10 ;; integer constant 10 # # in this case, this prefix would be the character \`\$\'. -v:const char *:stap_integer_prefix:::0:0::0:pstring (gdbarch->stap_integer_prefix) +v:const char *const *:stap_integer_prefixes:::0:0::0:pstring_list (gdbarch->stap_integer_prefixes) -# Suffix used to mark an integer constant on the architecture's assembly. -v:const char *:stap_integer_suffix:::0:0::0:pstring (gdbarch->stap_integer_suffix) +# A NULL-terminated array of suffixes used to mark an integer constant +# on the architecture's assembly. +v:const char *const *:stap_integer_suffixes:::0:0::0:pstring_list (gdbarch->stap_integer_suffixes) -# Prefix used to mark a register name on the architecture's assembly. +# A NULL-terminated array of prefixes used to mark a register name on +# the architecture's assembly. # For example, on x86 the register name is written as: # # \%eax ;; register eax # # in this case, this prefix would be the character \`\%\'. -v:const char *:stap_register_prefix:::0:0::0:pstring (gdbarch->stap_register_prefix) +v:const char *const *:stap_register_prefixes:::0:0::0:pstring_list (gdbarch->stap_register_prefixes) -# Suffix used to mark a register name on the architecture's assembly -v:const char *:stap_register_suffix:::0:0::0:pstring (gdbarch->stap_register_suffix) +# A NULL-terminated array of suffixes used to mark a register name on +# the architecture's assembly. +v:const char *const *:stap_register_suffixes:::0:0::0:pstring_list (gdbarch->stap_register_suffixes) -# Prefix used to mark a register indirection on the architecture's assembly. +# A NULL-terminated array of prefixes used to mark a register +# indirection on the architecture's assembly. # For example, on x86 the register indirection is written as: # # \(\%eax\) ;; indirecting eax @@ -834,9 +957,10 @@ v:const char *:stap_register_suffix:::0:0::0:pstring (gdbarch->stap_register_suf # # Please note that we use the indirection prefix also for register # displacement, e.g., \`4\(\%eax\)\' on x86. -v:const char *:stap_register_indirection_prefix:::0:0::0:pstring (gdbarch->stap_register_indirection_prefix) +v:const char *const *:stap_register_indirection_prefixes:::0:0::0:pstring_list (gdbarch->stap_register_indirection_prefixes) -# Suffix used to mark a register indirection on the architecture's assembly. +# A NULL-terminated array of suffixes used to mark a register +# indirection on the architecture's assembly. # For example, on x86 the register indirection is written as: # # \(\%eax\) ;; indirecting eax @@ -845,9 +969,9 @@ v:const char *:stap_register_indirection_prefix:::0:0::0:pstring (gdbarch->stap_ # # Please note that we use the indirection suffix also for register # displacement, e.g., \`4\(\%eax\)\' on x86. -v:const char *:stap_register_indirection_suffix:::0:0::0:pstring (gdbarch->stap_register_indirection_suffix) +v:const char *const *:stap_register_indirection_suffixes:::0:0::0:pstring_list (gdbarch->stap_register_indirection_suffixes) -# Prefix used to name a register using GDB's nomenclature. +# Prefix(es) used to name a register using GDB's nomenclature. # # For example, on PPC a register is represented by a number in the assembly # language (e.g., \`10\' is the 10th general-purpose register). However, @@ -895,6 +1019,21 @@ M:int:stap_is_single_operand:const char *s:s # parser), and should advance the buffer pointer (p->arg). M:int:stap_parse_special_token:struct stap_parse_info *p:p +# DTrace related functions. + +# The expression to compute the NARTGth+1 argument to a DTrace USDT probe. +# NARG must be >= 0. +M:void:dtrace_parse_probe_argument:struct parser_state *pstate, int narg:pstate, narg + +# True if the given ADDR does not contain the instruction sequence +# corresponding to a disabled DTrace is-enabled probe. +M:int:dtrace_probe_is_enabled:CORE_ADDR addr:addr + +# Enable a DTrace is-enabled probe at ADDR. +M:void:dtrace_enable_probe:CORE_ADDR addr:addr + +# Disable a DTrace is-enabled probe at ADDR. +M:void:dtrace_disable_probe:CORE_ADDR addr:addr # True if the list of shared libraries is one and only for all # processes, as opposed to a list of shared libraries per inferior. @@ -913,7 +1052,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 @@ -941,12 +1086,12 @@ v:int:has_dos_based_file_system:::0:0::0 m:void:gen_return_address:struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope:ax, value, scope::default_gen_return_address::0 # Implement the "info proc" command. -M:void:info_proc:char *args, enum info_proc_what what:args, what +M:void:info_proc:const char *args, enum info_proc_what what:args, what # Implement the "info proc" command for core files. Noe that there # are two "info_proc"-like methods on gdbarch -- one for core files, # one for live targets. -M:void:core_info_proc:char *args, enum info_proc_what what:args, what +M:void:core_info_proc:const char *args, enum info_proc_what what:args, what # Iterate over all objfiles in the order that makes the most sense # for the architecture to make global symbol searches. @@ -965,6 +1110,59 @@ m:void:iterate_over_objfiles_in_search_order:iterate_over_objfiles_in_search_ord # Ravenscar arch-dependent ops. v:struct ravenscar_arch_ops *:ravenscar_ops:::NULL:NULL::0:host_address_to_string (gdbarch->ravenscar_ops) + +# Return non-zero if the instruction at ADDR is a call; zero otherwise. +m:int:insn_is_call:CORE_ADDR addr:addr::default_insn_is_call::0 + +# Return non-zero if the instruction at ADDR is a return; zero otherwise. +m:int:insn_is_ret:CORE_ADDR addr:addr::default_insn_is_ret::0 + +# Return non-zero if the instruction at ADDR is a jump; zero otherwise. +m:int:insn_is_jump:CORE_ADDR addr:addr::default_insn_is_jump::0 + +# Read one auxv entry from *READPTR, not reading locations >= ENDPTR. +# Return 0 if *READPTR is already at the end of the buffer. +# Return -1 if there is insufficient buffer for a whole entry. +# Return 1 if an entry was read into *TYPEP and *VALP. +M:int:auxv_parse:gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp:readptr, endptr, typep, valp + +# Print the description of a single auxv entry described by TYPE and VAL +# to FILE. +m:void:print_auxv_entry:struct ui_file *file, CORE_ADDR type, CORE_ADDR val:file, type, val::default_print_auxv_entry::0 + +# Find the address range of the current inferior's vsyscall/vDSO, and +# write it to *RANGE. If the vsyscall's length can't be determined, a +# range with zero length is returned. Returns true if the vsyscall is +# found, false otherwise. +m:int:vsyscall_range:struct mem_range *range:range::default_vsyscall_range::0 + +# Allocate SIZE bytes of PROT protected page aligned memory in inferior. +# PROT has GDB_MMAP_PROT_* bitmask format. +# 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 +# they can override it. Method may also return NULL. +m:char *:gcc_target_options:void:::default_gcc_target_options::0 + +# Return a regular expression that matches names used by this +# architecture in GNU configury triplets. The result is statically +# allocated and must not be freed. The default implementation simply +# 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 } @@ -1018,8 +1216,7 @@ cat <. */ @@ -1061,9 +1258,10 @@ cat <gdbarch'. */ extern struct gdbarch *target_gdbarch (void); -/* The initial, default architecture. It uses host values (for want of a better - choice). */ -extern struct gdbarch startup_gdbarch; - - /* Callback type for the 'iterate_over_objfiles_in_search_order' gdbarch method. */ typedef int (iterate_over_objfiles_in_search_order_cb_ftype) (struct objfile *objfile, void *cb_data); + +/* Callback type for regset section iterators. The callback usually + invokes the REGSET's supply or collect method, to which it must + pass a buffer with at least the given SIZE. SECT_NAME is a BFD + section name, and HUMAN_NAME is used for diagnostic messages. + CB_DATA should have been passed unchanged through the iterator. */ + +typedef void (iterate_over_regset_sections_cb) + (const char *sect_name, int size, const struct regset *regset, + const char *human_name, void *cb_data); EOF # function typedef's @@ -1250,15 +1462,15 @@ struct gdbarch_info const struct bfd_arch_info *bfd_arch_info; /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */ - int byte_order; + enum bfd_endian byte_order; - int byte_order_for_code; + enum bfd_endian byte_order_for_code; /* Use default: NULL (ZERO). */ 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; @@ -1315,6 +1527,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. @@ -1413,15 +1630,13 @@ cat < 0) + { + gdb_assert (offset - 2 < sizeof (ret)); + ret[offset - 2] = '\0'; + } + + return ret; +} + EOF # gdbarch open the gdbarch object @@ -1508,9 +1752,6 @@ cat <obstack = obstack; @@ -1639,6 +1838,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. @@ -1671,7 +1878,6 @@ verify_gdbarch (struct gdbarch *gdbarch) struct ui_file *log; struct cleanup *cleanups; long length; - char *buf; log = mem_fileopen (); cleanups = make_cleanup_ui_file_delete (log); @@ -1717,12 +1923,11 @@ do fi done cat < 0) + std::string buf = ui_file_as_string (log); + if (!buf.empty ()) internal_error (__FILE__, __LINE__, _("verify_gdbarch: the following are invalid ...%s"), - buf); + buf.c_str ()); do_cleanups (cleanups); } EOF @@ -1947,9 +2152,9 @@ gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init, for (curr = &gdbarch_data_registry.registrations; (*curr) != NULL; curr = &(*curr)->next); - (*curr) = XMALLOC (struct gdbarch_data_registration); + (*curr) = XNEW (struct gdbarch_data_registration); (*curr)->next = NULL; - (*curr)->data = XMALLOC (struct gdbarch_data); + (*curr)->data = XNEW (struct gdbarch_data); (*curr)->data->index = gdbarch_data_registry.nr++; (*curr)->data->pre_init = pre_init; (*curr)->data->post_init = post_init; @@ -2049,7 +2254,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; } @@ -2118,7 +2323,7 @@ gdbarch_register (enum bfd_architecture bfd_architecture, bfd_arch_info->printable_name, host_address_to_string (init)); /* Append it */ - (*curr) = XMALLOC (struct gdbarch_registration); + (*curr) = XNEW (struct gdbarch_registration); (*curr)->bfd_architecture = bfd_architecture; (*curr)->init = init; (*curr)->dump_tdep = dump_tdep; @@ -2230,7 +2435,7 @@ gdbarch_find_by_info (struct gdbarch_info info) if (new_gdbarch->initialized_p) { struct gdbarch_list **list; - struct gdbarch_list *this; + struct gdbarch_list *self; if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_find_by_info: " "Previous architecture %s (%s) selected\n", @@ -2242,12 +2447,12 @@ gdbarch_find_by_info (struct gdbarch_info info) list = &(*list)->next); /* It had better be in the list of architectures. */ gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch); - /* Unlink THIS. */ - this = (*list); - (*list) = this->next; - /* Insert THIS at the front. */ - this->next = rego->arches; - rego->arches = this; + /* Unlink SELF. */ + self = (*list); + (*list) = self->next; + /* Insert SELF at the front. */ + self->next = rego->arches; + rego->arches = self; /* Return it. */ return new_gdbarch; } @@ -2262,10 +2467,10 @@ gdbarch_find_by_info (struct gdbarch_info info) /* Insert the new architecture into the front of the architecture list (keep the list sorted Most Recently Used). */ { - struct gdbarch_list *this = XMALLOC (struct gdbarch_list); - this->next = rego->arches; - this->gdbarch = new_gdbarch; - rego->arches = this; + struct gdbarch_list *self = XNEW (struct gdbarch_list); + self->next = rego->arches; + self->gdbarch = new_gdbarch; + rego->arches = self; } /* Check that the newly installed architecture is valid. Plug in