X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbarch.sh;h=366bda154b0f0b9a5340710877f382813f5aaa93;hb=451fbdda72c96478a54f21d5c8a3f14286a4084d;hp=ad013cc367b0c8e43675c306585b1d08dc8533b3;hpb=a72293e2a7d173542d2abc1e1309842501036b56;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index ad013cc367..366bda154b 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -1,7 +1,7 @@ #!/bin/sh -u # Architecture commands for GDB, the GNU debugger. -# Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc. +# Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. # # This file is part of GDB. # @@ -19,13 +19,19 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# Make certain that the script is running in an internationalized +# environment. +LANG=c ; export LANG +LC_ALL=c ; export LC_ALL + + compare_new () { file=$1 if test ! -r ${file} then echo "${file} missing? cp new-${file} ${file}" 1>&2 - elif diff -c ${file} new-${file} + elif diff -u ${file} new-${file} then echo "${file} unchanged" 1>&2 else @@ -76,6 +82,13 @@ EOF fi done + case "${level}" in + 1 ) gt_level=">= GDB_MULTI_ARCH_PARTIAL" ;; + 2 ) gt_level="> GDB_MULTI_ARCH_PARTIAL" ;; + "" ) ;; + * ) error "Error: bad level for ${function}" 1>&2 ; kill $$ ; exit 1 ;; + esac + case "${class}" in m ) staticdefault="${predefault}" ;; M ) staticdefault="0" ;; @@ -84,8 +97,24 @@ EOF # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non- # multi-arch defaults. # test "${predefault}" || predefault=0 + + # come up with a format, use a few guesses for variables + case ":${class}:${fmt}:${print}:" in + :[vV]::: ) + if [ "${returntype}" = int ] + then + fmt="%d" + print="${macro}" + elif [ "${returntype}" = long ] + then + fmt="%ld" + print="${macro}" + fi + ;; + esac test "${fmt}" || fmt="%ld" test "${print}" || print="(long) ${macro}" + case "${invalid_p}" in 0 ) valid_p=1 ;; "" ) @@ -338,7 +367,9 @@ do # Currently unused. - *) exit 1;; + *) + echo "Bad field ${field}" + exit 1;; esac done @@ -349,7 +380,7 @@ function_list () cat <printable_name:TARGET_ARCHITECTURE != NULL # -i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN +i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG # Number of bits in a char or unsigned char for the target machine. # Just like CHAR_BIT in but describes the target machine. # v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0: @@ -368,7 +399,7 @@ v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0 # Number of bits in a double for the target machine. v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0 # Number of bits in a long double for the target machine. -v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0 +v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):8*TARGET_CHAR_BIT::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 TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT @@ -384,12 +415,12 @@ v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT: # Number of bits in a BFD_VMA for the target object file format. v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0 # -v::IEEE_FLOAT:int:ieee_float::::0:0::0::: +# One if \`char' acts like \`signed char', zero if \`unsigned char'. +v::TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1:::: # f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0 f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0 f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0 -f::TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:generic_target_write_fp::0 f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0 f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0 # Function for getting target's idea of a frame pointer. FIXME: GDB's @@ -406,9 +437,14 @@ v:2:NUM_REGS:int:num_regs::::0:-1 # These pseudo-registers may be aliases for other registers, # combinations of other registers, or they may be computed by GDB. v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0::: -v:2:SP_REGNUM:int:sp_regnum::::0:-1 -v:2:FP_REGNUM:int:fp_regnum::::0:-1 -v:2:PC_REGNUM:int:pc_regnum::::0:-1 + +# 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). +v:2:SP_REGNUM:int:sp_regnum::::-1:-1::0 +v:2:FP_REGNUM:int:fp_regnum::::-1:-1::0 +v:2:PC_REGNUM:int:pc_regnum::::-1:-1::0 +v:2:PS_REGNUM:int:ps_regnum::::-1:-1::0 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0 @@ -427,19 +463,29 @@ f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0 v:2:REGISTER_SIZE:int:register_size::::0:-1 v:2:REGISTER_BYTES:int:register_bytes::::0:-1 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0 -f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0 +f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::generic_register_raw_size:0 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1 -f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0 +f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::generic_register_virtual_size:0 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0 f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0 +f:2:PRINT_FLOAT_INFO:void:print_float_info:void::::default_print_float_info::0 # MAP a GDB RAW register number onto a simulator register number. See # also include/...-sim.h. f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0 f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0 f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0 +# setjmp/longjmp support. +F:2:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc::0:0 # +# Non multi-arch DUMMY_FRAMES are a mess (multi-arch ones are not that +# much better but at least they are vaguely consistent). The headers +# and body contain convoluted #if/#else sequences for determine how +# things should be compiled. Instead of trying to mimic that +# behaviour here (and hence entrench it further) gdbarch simply +# reqires that these methods be set up from the word go. This also +# avoids any potential problems with moving beyond multi-arch partial. v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1 v:1:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0 f:2:CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void:::0:0::gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0 @@ -460,19 +506,22 @@ f:2:INIT_FRAME_PC:void:init_frame_pc:int fromleaf, struct frame_info *prev:froml v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::::: v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::::: f:2:COERCE_FLOAT_TO_DOUBLE:int:coerce_float_to_double:struct type *formal, struct type *actual:formal, actual:::default_coerce_float_to_double::0 +# GET_SAVED_REGISTER is like DUMMY_FRAMES. It is at level one as the +# old code has strange #ifdef interaction. So far no one has found +# that default_get_saved_register() is the default they are after. f:1:GET_SAVED_REGISTER:void:get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval::generic_get_saved_register:0 # -f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0 +f:2:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0 f:2:REGISTER_CONVERT_TO_VIRTUAL:void:register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to:::0::0 f:2:REGISTER_CONVERT_TO_RAW:void:register_convert_to_raw:struct type *type, int regnum, char *from, char *to:type, regnum, from, to:::0::0 # This function is called when the value of a pseudo-register needs to # be updated. Typically it will be defined on a per-architecture # basis. -f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0 +F:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum: # This function is called when the value of a pseudo-register needs to # be set or stored. Typically it will be defined on a # per-architecture basis. -f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0 +F:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum: # f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0 f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, void *buf, CORE_ADDR addr:type, buf, addr:::unsigned_address_to_pointer::0 @@ -480,9 +529,9 @@ F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf # f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0 -f:1:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr::0:0 +f:2:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr:::default_push_arguments::0 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0 -F:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0 +F:2:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0 f:2:POP_FRAME:void:pop_frame:void:-:::0 # f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0 @@ -496,7 +545,7 @@ F:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_ f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0 -f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0 +f:2:BREAKPOINT_FROM_PC:const unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1 @@ -508,7 +557,14 @@ f:2:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:CORE_ADDR g v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0 -f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0 +# Define a default FRAME_CHAIN_VALID, in the form that is suitable for +# most targets. If FRAME_CHAIN_VALID returns zero it means that the +# given frame is the outermost one and has no caller. +# +# XXXX - both default and alternate frame_chain_valid functions are +# deprecated. New code should use dummy frames and one of the generic +# functions. +f:2:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe:::func_frame_chain_valid::0 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0 @@ -516,14 +572,14 @@ f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:f f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0 # F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0 -v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0::: +v:2:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0::: F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0 v:2:PARM_BOUNDARY:int:parm_boundary # v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch) v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch) -v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown +v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::default_double_format (gdbarch) f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0 # On some machines there are bits in addresses which are not really # part of the address, but are used by the kernel, the hardware, etc. @@ -535,6 +591,9 @@ f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR ad # sort of generic thing to handle alignment or segmentation (it's # possible it should be in TARGET_READ_PC instead). f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0 +# It is not at all clear why SMASH_TEXT_ADDRESS is not folded into +# ADDR_BITS_REMOVE. +f:2:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0 # FIXME/cagney/2001-01-18: This should be split in two. A target method that indicates if # the target needs software single step. An ISA method to implement it. # @@ -550,6 +609,27 @@ f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generi # trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates # to nonzero if we are current stopped in one of these. f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0 +# Sigtramp is a routine that the kernel calls (which then calls the +# signal handler). On most machines it is a library routine that is +# linked into the executable. +# +# This macro, given a program counter value and the name of the +# function in which that PC resides (which can be null if the name is +# not known), returns nonzero if the PC and name show that we are in +# sigtramp. +# +# On most machines just see if the name is sigtramp (and if we have +# no name, assume we are not in sigtramp). +# +# FIXME: cagney/2002-04-21: The function find_pc_partial_function +# calls find_pc_sect_partial_function() which calls PC_IN_SIGTRAMP. +# This means PC_IN_SIGTRAMP function can't be implemented by doing its +# own local NAME lookup. +# +# FIXME: cagney/2002-04-21: PC_IN_SIGTRAMP is something of a mess. +# Some code also depends on SIGTRAMP_START and SIGTRAMP_END but other +# does not. +f:2:PC_IN_SIGTRAMP:int:pc_in_sigtramp:CORE_ADDR pc, char *name:pc, name:::legacy_pc_in_sigtramp::0 # 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() @@ -560,6 +640,18 @@ f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *na # 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 +# Given a vector of command-line arguments, return a newly allocated +# string which, when passed to the create_inferior function, will be +# parsed (on Unix systems, by the shell) to yield the same vector. +# This function should call error() if the argument vector is not +# representable for this target or if this target does not support +# command-line arguments. +# ARGC is the number of elements in the vector. +# ARGV is an array of strings, one per argument. +m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0 +F:2:DWARF2_BUILD_FRAME_INFO:void:dwarf2_build_frame_info:struct objfile *objfile:objfile:::0 +f:2:ELF_MAKE_MSYMBOL_SPECIAL:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym:::default_elf_make_msymbol_special::0 +f:2:COFF_MAKE_MSYMBOL_SPECIAL:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym:::default_coff_make_msymbol_special::0 EOF } @@ -615,7 +707,7 @@ cat < GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n" printf "#error \"Non multi-arch definition of ${macro}\"\n" printf "#endif\n" printf "#if GDB_MULTI_ARCH\n" - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n" printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n" printf "#endif\n" printf "#endif\n" @@ -751,10 +846,10 @@ do printf "#endif\n" printf "\n" printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n" - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro}_P)\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro}_P)\n" printf "#error \"Non multi-arch definition of ${macro}\"\n" printf "#endif\n" - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro}_P)\n" printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n" printf "#endif\n" fi @@ -773,11 +868,11 @@ do printf "\n" printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n" printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n" - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n" printf "#error \"Non multi-arch definition of ${macro}\"\n" printf "#endif\n" printf "#if GDB_MULTI_ARCH\n" - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n" printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n" printf "#endif\n" printf "#endif\n" @@ -819,11 +914,11 @@ do printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n" if class_is_multiarch_p ; then : else - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n" printf "#error \"Non multi-arch definition of ${macro}\"\n" printf "#endif\n" printf "#if GDB_MULTI_ARCH\n" - printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n" + printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n" if [ "x${actual}" = "x" ] then printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n" @@ -882,10 +977,16 @@ extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch); architecture; ARCHES which is a list of the previously created \`\`struct gdbarch'' for this architecture. - The INIT function parameter INFO shall, as far as possible, be - pre-initialized with information obtained from INFO.ABFD or - previously selected architecture (if similar). INIT shall ensure - that the INFO.BYTE_ORDER is non-zero. + The INFO parameter is, as far as possible, be pre-initialized with + information obtained from INFO.ABFD or the previously selected + architecture. + + The ARCHES parameter is a linked list (sorted most recently used) + of all the previously created architures for this architecture + family. The (possibly NULL) ARCHES->gdbarch can used to access + values from the previously selected architecture for this + architecture family. The global \`\`current_gdbarch'' shall not be + used. The INIT function shall return any of: NULL - indicating that it doesn't recognize the selected architecture; an existing \`\`struct @@ -909,7 +1010,7 @@ struct gdbarch_info /* Use default: NULL (ZERO). */ const struct bfd_arch_info *bfd_arch_info; - /* Use default: 0 (ZERO). */ + /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */ int byte_order; /* Use default: NULL (ZERO). */ @@ -1007,7 +1108,7 @@ extern void set_gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data, void *pointer); -extern void *gdbarch_data (struct gdbarch_data*); +extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *); /* Register per-architecture memory region. @@ -1030,33 +1131,7 @@ extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ /* The target-system-dependent byte order is dynamic */ -/* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness - is selectable at runtime. The user can use the \`\`set endian'' - command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when - target_byte_order should be auto-detected (from the program image - say). */ - -#if GDB_MULTI_ARCH -/* Multi-arch GDB is always bi-endian. */ -#define TARGET_BYTE_ORDER_SELECTABLE_P 1 -#endif - -#ifndef TARGET_BYTE_ORDER_SELECTABLE_P -/* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE - when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */ -#ifdef TARGET_BYTE_ORDER_SELECTABLE -#define TARGET_BYTE_ORDER_SELECTABLE_P 1 -#else -#define TARGET_BYTE_ORDER_SELECTABLE_P 0 -#endif -#endif - extern int target_byte_order; -#ifdef TARGET_BYTE_ORDER_SELECTABLE -/* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE - and expect defs.h to re-define TARGET_BYTE_ORDER. */ -#undef TARGET_BYTE_ORDER -#endif #ifndef TARGET_BYTE_ORDER #define TARGET_BYTE_ORDER (target_byte_order + 0) #endif @@ -1174,16 +1249,10 @@ static void alloc_gdbarch_data (struct gdbarch *); static void init_gdbarch_data (struct gdbarch *); static void free_gdbarch_data (struct gdbarch *); static void init_gdbarch_swap (struct gdbarch *); +static void clear_gdbarch_swap (struct gdbarch *); static void swapout_gdbarch_swap (struct gdbarch *); static void swapin_gdbarch_swap (struct gdbarch *); -/* Convenience macro for allocting typesafe memory. */ - -#ifndef XMALLOC -#define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE)) -#endif - - /* Non-zero if we want to trace architecture code. */ #ifndef GDBARCH_DEBUG @@ -1305,6 +1374,10 @@ void initialize_non_multiarch () { alloc_gdbarch_data (&startup_gdbarch); + /* Ensure that all swap areas are zeroed so that they again think + they are starting from scratch. */ + clear_gdbarch_swap (&startup_gdbarch); + init_gdbarch_swap (&startup_gdbarch); init_gdbarch_data (&startup_gdbarch); } EOF @@ -1400,7 +1473,7 @@ verify_gdbarch (struct gdbarch *gdbarch) log = mem_fileopen (); cleanups = make_cleanup_ui_file_delete (log); /* fundamental */ - if (gdbarch->byte_order == 0) + if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN) fprintf_unfiltered (log, "\n\tbyte-order"); if (gdbarch->bfd_arch_info == NULL) fprintf_unfiltered (log, "\n\tbfd_arch_info"); @@ -1431,12 +1504,12 @@ do printf " gdbarch->${function} = ${postdefault};\n" elif [ -n "${invalid_p}" ] then - printf " if ((GDB_MULTI_ARCH >= ${level})\n" + printf " if ((GDB_MULTI_ARCH ${gt_level})\n" printf " && (${invalid_p}))\n" printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n" elif [ -n "${predefault}" ] then - printf " if ((GDB_MULTI_ARCH >= ${level})\n" + printf " if ((GDB_MULTI_ARCH ${gt_level})\n" printf " && (gdbarch->${function} == ${predefault}))\n" printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n" fi @@ -1483,6 +1556,7 @@ do printf " (long) current_gdbarch->${function});\n" continue fi + # Print the macro definition. printf "#ifdef ${macro}\n" if [ "x${returntype}" = "xvoid" ] then @@ -1500,6 +1574,7 @@ do printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n" printf " XSTRING (${macro}));\n" fi + # Print the architecture vector value if [ "x${returntype}" = "xvoid" ] then printf "#endif\n" @@ -1557,6 +1632,7 @@ do printf "int\n" printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n" printf "{\n" + printf " gdb_assert (gdbarch != NULL);\n" if [ -n "${valid_p}" ] then printf " return ${valid_p};\n" @@ -1576,6 +1652,7 @@ do printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n" fi printf "{\n" + printf " gdb_assert (gdbarch != NULL);\n" printf " if (gdbarch->${function} == 0)\n" printf " internal_error (__FILE__, __LINE__,\n" printf " \"gdbarch: gdbarch_${function} invalid\");\n" @@ -1617,6 +1694,7 @@ do printf "${returntype}\n" printf "gdbarch_${function} (struct gdbarch *gdbarch)\n" printf "{\n" + printf " gdb_assert (gdbarch != NULL);\n" if [ "x${invalid_p}" = "x0" ] then printf " /* Skip verify of ${function}, invalid_p == 0 */\n" @@ -1648,6 +1726,7 @@ do printf "${returntype}\n" printf "gdbarch_${function} (struct gdbarch *gdbarch)\n" printf "{\n" + printf " gdb_assert (gdbarch != NULL);\n" printf " if (gdbarch_debug >= 2)\n" printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n" printf " return gdbarch->${function};\n" @@ -1774,10 +1853,10 @@ set_gdbarch_data (struct gdbarch *gdbarch, data-pointer. */ void * -gdbarch_data (struct gdbarch_data *data) +gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data) { - gdb_assert (data->index < current_gdbarch->nr_data); - return current_gdbarch->data[data->index]; + gdb_assert (data->index < gdbarch->nr_data); + return gdbarch->data[data->index]; } @@ -1826,6 +1905,17 @@ register_gdbarch_swap (void *data, (*rego)->sizeof_data = sizeof_data; } +static void +clear_gdbarch_swap (struct gdbarch *gdbarch) +{ + struct gdbarch_swap *curr; + for (curr = gdbarch->swap; + curr != NULL; + curr = curr->next) + { + memset (curr->source->data, 0, curr->source->sizeof_data); + } +} static void init_gdbarch_swap (struct gdbarch *gdbarch) @@ -1842,7 +1932,6 @@ init_gdbarch_swap (struct gdbarch *gdbarch) (*curr)->source = rego; (*curr)->swap = xmalloc (rego->sizeof_data); (*curr)->next = NULL; - memset (rego->data, 0, rego->sizeof_data); curr = &(*curr)->next; } if (rego->init != NULL) @@ -2008,7 +2097,7 @@ int gdbarch_update_p (struct gdbarch_info info) { struct gdbarch *new_gdbarch; - struct gdbarch_list **list; + struct gdbarch *old_gdbarch; struct gdbarch_registration *rego; /* Fill in missing parts of the INFO struct using a number of @@ -2027,17 +2116,17 @@ gdbarch_update_p (struct gdbarch_info info) info.bfd_arch_info = TARGET_ARCHITECTURE; /* \`\`(gdb) set byte-order ...'' */ - if (info.byte_order == 0 + if (info.byte_order == BFD_ENDIAN_UNKNOWN && !TARGET_BYTE_ORDER_AUTO) info.byte_order = TARGET_BYTE_ORDER; /* From the INFO struct. */ - if (info.byte_order == 0 + if (info.byte_order == BFD_ENDIAN_UNKNOWN && info.abfd != NULL) - info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN - : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN - : 0); + info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG + : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE + : BFD_ENDIAN_UNKNOWN); /* From the current target. */ - if (info.byte_order == 0) + if (info.byte_order == BFD_ENDIAN_UNKNOWN) info.byte_order = TARGET_BYTE_ORDER; /* Must have found some sort of architecture. */ @@ -2053,8 +2142,8 @@ gdbarch_update_p (struct gdbarch_info info) fprintf_unfiltered (gdb_stdlog, "gdbarch_update: info.byte_order %d (%s)\n", info.byte_order, - (info.byte_order == BIG_ENDIAN ? "big" - : info.byte_order == LITTLE_ENDIAN ? "little" + (info.byte_order == BFD_ENDIAN_BIG ? "big" + : info.byte_order == BFD_ENDIAN_LITTLE ? "little" : "default")); fprintf_unfiltered (gdb_stdlog, "gdbarch_update: info.abfd 0x%lx\n", @@ -2077,53 +2166,88 @@ gdbarch_update_p (struct gdbarch_info info) return 0; } + /* Swap the data belonging to the old target out setting the + installed data to zero. This stops the ->init() function trying + to refer to the previous architecture's global data structures. */ + swapout_gdbarch_swap (current_gdbarch); + clear_gdbarch_swap (current_gdbarch); + + /* Save the previously selected architecture, setting the global to + NULL. This stops ->init() trying to use the previous + architecture's configuration. The previous architecture may not + even be of the same architecture family. The most recent + architecture of the same family is found at the head of the + rego->arches list. */ + old_gdbarch = current_gdbarch; + current_gdbarch = NULL; + /* Ask the target for a replacement architecture. */ new_gdbarch = rego->init (info, rego->arches); - /* Did the target like it? No. Reject the change. */ + /* Did the target like it? No. Reject the change and revert to the + old architecture. */ if (new_gdbarch == NULL) { if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n"); + swapin_gdbarch_swap (old_gdbarch); + current_gdbarch = old_gdbarch; return 0; } - /* Did the architecture change? No. Do nothing. */ - if (current_gdbarch == new_gdbarch) + /* Did the architecture change? No. Oops, put the old architecture + back. */ + if (old_gdbarch == new_gdbarch) { if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n", (long) new_gdbarch, new_gdbarch->bfd_arch_info->printable_name); + swapin_gdbarch_swap (old_gdbarch); + current_gdbarch = old_gdbarch; return 1; } - /* Swap all data belonging to the old target out */ - swapout_gdbarch_swap (current_gdbarch); - - /* Is this a pre-existing architecture? Yes. Swap it in. */ - for (list = ®o->arches; - (*list) != NULL; - list = &(*list)->next) - { - if ((*list)->gdbarch == new_gdbarch) - { - if (gdbarch_debug) - fprintf_unfiltered (gdb_stdlog, - "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n", - (long) new_gdbarch, - new_gdbarch->bfd_arch_info->printable_name); - current_gdbarch = new_gdbarch; - swapin_gdbarch_swap (new_gdbarch); - architecture_changed_event (); - return 1; - } - } - - /* Append this new architecture to this targets list. */ - (*list) = XMALLOC (struct gdbarch_list); - (*list)->next = NULL; - (*list)->gdbarch = new_gdbarch; + /* Is this a pre-existing architecture? Yes. Move it to the front + of the list of architectures (keeping the list sorted Most + Recently Used) and then copy it in. */ + { + struct gdbarch_list **list; + for (list = ®o->arches; + (*list) != NULL; + list = &(*list)->next) + { + if ((*list)->gdbarch == new_gdbarch) + { + struct gdbarch_list *this; + if (gdbarch_debug) + fprintf_unfiltered (gdb_stdlog, + "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n", + (long) new_gdbarch, + new_gdbarch->bfd_arch_info->printable_name); + /* Unlink this. */ + this = (*list); + (*list) = this->next; + /* Insert in the front. */ + this->next = rego->arches; + rego->arches = this; + /* Copy the new architecture in. */ + current_gdbarch = new_gdbarch; + swapin_gdbarch_swap (new_gdbarch); + architecture_changed_event (); + return 1; + } + } + } + + /* Prepend this new architecture to 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; + } /* Switch to this new architecture. Dump it out. */ current_gdbarch = new_gdbarch;