3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 # This file is part of GDB.
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 # Make certain that the script is running in an internationalized
25 LC_ALL
=c
; export LC_ALL
33 echo "${file} missing? cp new-${file} ${file}" 1>&2
34 elif diff -u ${file} new-
${file}
36 echo "${file} unchanged" 1>&2
38 echo "${file} has changed? cp new-${file} ${file}" 1>&2
43 # Format of the input table
44 read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
52 if test "${line}" = ""
55 elif test "${line}" = "#" -a "${comment}" = ""
58 elif expr "${line}" : "#" > /dev
/null
64 # The semantics of IFS varies between different SH's. Some
65 # treat ``::' as three fields while some treat it as just too.
66 # Work around this by eliminating ``::'' ....
67 line
="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
69 OFS
="${IFS}" ; IFS
="[:]"
70 eval read ${read} <<EOF
75 # .... and then going back through each field and strip out those
76 # that ended up with just that space character.
79 if eval test \"\
${${r}}\" = \"\
\"
86 1 ) gt_level
=">= GDB_MULTI_ARCH_PARTIAL" ;;
87 2 ) gt_level
="> GDB_MULTI_ARCH_PARTIAL" ;;
89 * ) error
"Error: bad level for ${function}" 1>&2 ; kill $$
; exit 1 ;;
93 m
) staticdefault
="${predefault}" ;;
94 M
) staticdefault
="0" ;;
95 * ) test "${staticdefault}" || staticdefault
=0 ;;
97 # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
98 # multi-arch defaults.
99 # test "${predefault}" || predefault=0
101 # come up with a format, use a few guesses for variables
102 case ":${class}:${fmt}:${print}:" in
104 if [ "${returntype}" = int
]
108 elif [ "${returntype}" = long
]
115 test "${fmt}" ||
fmt="%ld"
116 test "${print}" || print
="(long) ${macro}"
118 case "${invalid_p}" in
121 if [ -n "${predefault}" ]
123 #invalid_p="gdbarch->${function} == ${predefault}"
124 valid_p
="gdbarch->${function} != ${predefault}"
126 #invalid_p="gdbarch->${function} == 0"
127 valid_p
="gdbarch->${function} != 0"
130 * ) valid_p
="!(${invalid_p})"
133 # PREDEFAULT is a valid fallback definition of MEMBER when
134 # multi-arch is not enabled. This ensures that the
135 # default value, when multi-arch is the same as the
136 # default value when not multi-arch. POSTDEFAULT is
137 # always a valid definition of MEMBER as this again
138 # ensures consistency.
140 if [ -n "${postdefault}" ]
142 fallbackdefault
="${postdefault}"
143 elif [ -n "${predefault}" ]
145 fallbackdefault
="${predefault}"
150 #NOT YET: See gdbarch.log for basic verification of
165 fallback_default_p
()
167 [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
168 ||
[ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
171 class_is_variable_p
()
179 class_is_function_p
()
182 *f
* |
*F
* |
*m
* |
*M
* ) true
;;
187 class_is_multiarch_p
()
195 class_is_predicate_p
()
198 *F
* |
*V
* |
*M
* ) true
;;
212 # dump out/verify the doco
222 # F -> function + predicate
223 # hiding a function + predicate to test function validity
226 # V -> variable + predicate
227 # hiding a variable + predicate to test variables validity
229 # hiding something from the ``struct info'' object
230 # m -> multi-arch function
231 # hiding a multi-arch function (parameterised with the architecture)
232 # M -> multi-arch function + predicate
233 # hiding a multi-arch function + predicate to test function validity
237 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
238 # LEVEL is a predicate on checking that a given method is
239 # initialized (using INVALID_P).
243 # The name of the MACRO that this method is to be accessed by.
247 # For functions, the return type; for variables, the data type
251 # For functions, the member function name; for variables, the
252 # variable name. Member function names are always prefixed with
253 # ``gdbarch_'' for name-space purity.
257 # The formal argument list. It is assumed that the formal
258 # argument list includes the actual name of each list element.
259 # A function with no arguments shall have ``void'' as the
260 # formal argument list.
264 # The list of actual arguments. The arguments specified shall
265 # match the FORMAL list given above. Functions with out
266 # arguments leave this blank.
270 # Any GCC attributes that should be attached to the function
271 # declaration. At present this field is unused.
275 # To help with the GDB startup a static gdbarch object is
276 # created. STATICDEFAULT is the value to insert into that
277 # static gdbarch object. Since this a static object only
278 # simple expressions can be used.
280 # If STATICDEFAULT is empty, zero is used.
284 # An initial value to assign to MEMBER of the freshly
285 # malloc()ed gdbarch object. After initialization, the
286 # freshly malloc()ed object is passed to the target
287 # architecture code for further updates.
289 # If PREDEFAULT is empty, zero is used.
291 # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
292 # INVALID_P are specified, PREDEFAULT will be used as the
293 # default for the non- multi-arch target.
295 # A zero PREDEFAULT function will force the fallback to call
298 # Variable declarations can refer to ``gdbarch'' which will
299 # contain the current architecture. Care should be taken.
303 # A value to assign to MEMBER of the new gdbarch object should
304 # the target architecture code fail to change the PREDEFAULT
307 # If POSTDEFAULT is empty, no post update is performed.
309 # If both INVALID_P and POSTDEFAULT are non-empty then
310 # INVALID_P will be used to determine if MEMBER should be
311 # changed to POSTDEFAULT.
313 # If a non-empty POSTDEFAULT and a zero INVALID_P are
314 # specified, POSTDEFAULT will be used as the default for the
315 # non- multi-arch target (regardless of the value of
318 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
320 # Variable declarations can refer to ``gdbarch'' which will
321 # contain the current architecture. Care should be taken.
325 # A predicate equation that validates MEMBER. Non-zero is
326 # returned if the code creating the new architecture failed to
327 # initialize MEMBER or the initialized the member is invalid.
328 # If POSTDEFAULT is non-empty then MEMBER will be updated to
329 # that value. If POSTDEFAULT is empty then internal_error()
332 # If INVALID_P is empty, a check that MEMBER is no longer
333 # equal to PREDEFAULT is used.
335 # The expression ``0'' disables the INVALID_P check making
336 # PREDEFAULT a legitimate value.
338 # See also PREDEFAULT and POSTDEFAULT.
342 # printf style format string that can be used to print out the
343 # MEMBER. Sometimes "%s" is useful. For functions, this is
344 # ignored and the function address is printed.
346 # If FMT is empty, ``%ld'' is used.
350 # An optional equation that casts MEMBER to a value suitable
351 # for formatting by FMT.
353 # If PRINT is empty, ``(long)'' is used.
357 # An optional indicator for any predicte to wrap around the
360 # () -> Call a custom function to do the dump.
361 # exp -> Wrap print up in ``if (${print_p}) ...
362 # ``'' -> No predicate
364 # If PRINT_P is empty, ``1'' is always used.
371 echo "Bad field ${field}"
379 # See below (DOCO) for description of each field
381 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
383 i:2:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
384 # Number of bits in a char or unsigned char for the target machine.
385 # Just like CHAR_BIT in <limits.h> but describes the target machine.
386 # v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
388 # Number of bits in a short or unsigned short for the target machine.
389 v::TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
390 # Number of bits in an int or unsigned int for the target machine.
391 v::TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
392 # Number of bits in a long or unsigned long for the target machine.
393 v::TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
394 # Number of bits in a long long or unsigned long long for the target
396 v::TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
397 # Number of bits in a float for the target machine.
398 v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
399 # Number of bits in a double for the target machine.
400 v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
401 # Number of bits in a long double for the target machine.
402 v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
403 # For most targets, a pointer on the target and its representation as an
404 # address in GDB have the same size and "look the same". For such a
405 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
406 # / addr_bit will be set from it.
408 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
409 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
411 # ptr_bit is the size of a pointer on the target
412 v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
413 # addr_bit is the size of a target address as represented in gdb
414 v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
415 # Number of bits in a BFD_VMA for the target object file format.
416 v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
418 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
419 v::TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
421 f::TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid::0:generic_target_read_pc::0
422 f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
423 f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
424 f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
425 f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
426 # Function for getting target's idea of a frame pointer. FIXME: GDB's
427 # whole scheme for dealing with "frames" and "frame pointers" needs a
429 f::TARGET_VIRTUAL_FRAME_POINTER:void:virtual_frame_pointer:CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset:pc, frame_regnum, frame_offset::0:legacy_virtual_frame_pointer::0
431 M:::void:pseudo_register_read:struct regcache *regcache, int cookednum, void *buf:regcache, cookednum, buf:
432 M:::void:pseudo_register_write:struct regcache *regcache, int cookednum, const void *buf:regcache, cookednum, buf:
434 v:2:NUM_REGS:int:num_regs::::0:-1
435 # This macro gives the number of pseudo-registers that live in the
436 # register namespace but do not get fetched or stored on the target.
437 # These pseudo-registers may be aliases for other registers,
438 # combinations of other registers, or they may be computed by GDB.
439 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
441 # GDB's standard (or well known) register numbers. These can map onto
442 # a real register or a pseudo (computed) register or not be defined at
444 v:2:SP_REGNUM:int:sp_regnum::::-1:-1::0
445 v:2:FP_REGNUM:int:fp_regnum::::-1:-1::0
446 v:2:PC_REGNUM:int:pc_regnum::::-1:-1::0
447 v:2:PS_REGNUM:int:ps_regnum::::-1:-1::0
448 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
449 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
450 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
451 f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
452 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
453 f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
454 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
455 f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
456 # Convert from an sdb register number to an internal gdb register number.
457 # This should be defined in tm.h, if REGISTER_NAMES is not set up
458 # to map one to one onto the sdb register numbers.
459 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
460 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
461 f:2:REGISTER_NAME:const char *:register_name:int regnr:regnr:::legacy_register_name::0
462 v:2:REGISTER_SIZE:int:register_size::::0:-1
463 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
464 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte::0
465 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size::0
466 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
467 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size::0
468 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
469 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
471 F:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs
472 m:2:PRINT_REGISTERS_INFO: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
473 M:2:PRINT_FLOAT_INFO:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
474 M:2:PRINT_VECTOR_INFO:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
475 # MAP a GDB RAW register number onto a simulator register number. See
476 # also include/...-sim.h.
477 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::legacy_register_sim_regno::0
478 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
479 f:2:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
480 f:2:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
481 # setjmp/longjmp support.
482 F:2:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc::0:0
484 # Non multi-arch DUMMY_FRAMES are a mess (multi-arch ones are not that
485 # much better but at least they are vaguely consistent). The headers
486 # and body contain convoluted #if/#else sequences for determine how
487 # things should be compiled. Instead of trying to mimic that
488 # behaviour here (and hence entrench it further) gdbarch simply
489 # reqires that these methods be set up from the word go. This also
490 # avoids any potential problems with moving beyond multi-arch partial.
491 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
492 v:1:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
493 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
494 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
495 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1:0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
496 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
497 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
498 f:1:PC_IN_CALL_DUMMY:int:pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::0:0
499 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
500 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
501 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
502 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
503 v:2:CALL_DUMMY_STACK_ADJUST:int:call_dummy_stack_adjust::::0:::gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0:0x%08lx::CALL_DUMMY_STACK_ADJUST_P
504 f:2:FIX_CALL_DUMMY:void:fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p:::0
505 f:2:INIT_FRAME_PC_FIRST:void:init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_noop::0
506 f:2:INIT_FRAME_PC:void:init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev:::init_frame_pc_default::0
508 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
509 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
510 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
511 f:2: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_unwind_get_saved_register::0
513 f:2:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
514 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
515 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
517 f:1:CONVERT_REGISTER_P:int:convert_register_p:int regnum:regnum::0:legacy_convert_register_p::0
518 f:1:REGISTER_TO_VALUE:void:register_to_value:int regnum, struct type *type, char *from, char *to:regnum, type, from, to::0:legacy_register_to_value::0
519 f:1:VALUE_TO_REGISTER:void:value_to_register:struct type *type, int regnum, char *from, char *to:type, regnum, from, to::0:legacy_value_to_register::0
521 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
522 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
523 F:2:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
525 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
526 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
527 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
528 F:2:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
529 f:2:POP_FRAME:void:pop_frame:void:-:::0
531 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
533 f::EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regcache *regcache, void *valbuf:type, regcache, valbuf:::legacy_extract_return_value::0
534 f::STORE_RETURN_VALUE:void:store_return_value:struct type *type, struct regcache *regcache, const void *valbuf:type, regcache, valbuf:::legacy_store_return_value::0
535 f::DEPRECATED_EXTRACT_RETURN_VALUE:void:deprecated_extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf
536 f::DEPRECATED_STORE_RETURN_VALUE:void:deprecated_store_return_value:struct type *type, char *valbuf:type, valbuf
538 F:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:struct regcache *regcache:regcache:::0
539 F:2:DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:deprecated_extract_struct_value_address:char *regbuf:regbuf:::0
540 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
542 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
543 F:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
545 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
546 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
547 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
548 f:2:BREAKPOINT_FROM_PC:const unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
549 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
550 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
551 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
552 f::PREPARE_TO_PROCEED:int:prepare_to_proceed:int select_it:select_it::0:default_prepare_to_proceed::0
553 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
555 f:2:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
557 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
558 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
559 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
560 # Define a default FRAME_CHAIN_VALID, in the form that is suitable for
561 # most targets. If FRAME_CHAIN_VALID returns zero it means that the
562 # given frame is the outermost one and has no caller.
564 # XXXX - both default and alternate frame_chain_valid functions are
565 # deprecated. New code should use dummy frames and one of the generic
567 f:2:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe:::generic_func_frame_chain_valid::0
568 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
569 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
570 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
571 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
572 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
574 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
575 M:::CORE_ADDR:frame_align:CORE_ADDR address:address
576 v:2:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
577 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
578 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
579 v:2:PARM_BOUNDARY:int:parm_boundary
581 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
582 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
583 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::default_double_format (gdbarch)
584 f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::core_addr_identity::0
585 # On some machines there are bits in addresses which are not really
586 # part of the address, but are used by the kernel, the hardware, etc.
587 # for special purposes. ADDR_BITS_REMOVE takes out any such bits so
588 # we get a "real" address such as one would find in a symbol table.
589 # This is used only for addresses of instructions, and even then I'm
590 # not sure it's used in all contexts. It exists to deal with there
591 # being a few stray bits in the PC which would mislead us, not as some
592 # sort of generic thing to handle alignment or segmentation (it's
593 # possible it should be in TARGET_READ_PC instead).
594 f:2:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
595 # It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
597 f:2:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0
598 # FIXME/cagney/2001-01-18: This should be split in two. A target method that indicates if
599 # the target needs software single step. An ISA method to implement it.
601 # FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
602 # using the breakpoint system instead of blatting memory directly (as with rs6000).
604 # FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the target can
605 # single step. If not, then implement single step using breakpoints.
606 F:2:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p::0:0
607 f:2:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, disassemble_info *info:vma, info:::legacy_print_insn::0
608 f:2:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
611 # For SVR4 shared libraries, each call goes through a small piece of
612 # trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates
613 # to nonzero if we are currently stopped in one of these.
614 f:2:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
616 # Some systems also have trampoline code for returning from shared libs.
617 f:2:IN_SOLIB_RETURN_TRAMPOLINE:int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_return_trampoline::0
619 # Sigtramp is a routine that the kernel calls (which then calls the
620 # signal handler). On most machines it is a library routine that is
621 # linked into the executable.
623 # This macro, given a program counter value and the name of the
624 # function in which that PC resides (which can be null if the name is
625 # not known), returns nonzero if the PC and name show that we are in
628 # On most machines just see if the name is sigtramp (and if we have
629 # no name, assume we are not in sigtramp).
631 # FIXME: cagney/2002-04-21: The function find_pc_partial_function
632 # calls find_pc_sect_partial_function() which calls PC_IN_SIGTRAMP.
633 # This means PC_IN_SIGTRAMP function can't be implemented by doing its
634 # own local NAME lookup.
636 # FIXME: cagney/2002-04-21: PC_IN_SIGTRAMP is something of a mess.
637 # Some code also depends on SIGTRAMP_START and SIGTRAMP_END but other
639 f:2:PC_IN_SIGTRAMP:int:pc_in_sigtramp:CORE_ADDR pc, char *name:pc, name:::legacy_pc_in_sigtramp::0
640 F:2:SIGTRAMP_START:CORE_ADDR:sigtramp_start:CORE_ADDR pc:pc
641 F::SIGTRAMP_END:CORE_ADDR:sigtramp_end:CORE_ADDR pc:pc
642 # A target might have problems with watchpoints as soon as the stack
643 # frame of the current function has been destroyed. This mostly happens
644 # as the first action in a funtion's epilogue. in_function_epilogue_p()
645 # is defined to return a non-zero value if either the given addr is one
646 # instruction after the stack destroying instruction up to the trailing
647 # return instruction or if we can figure out that the stack frame has
648 # already been invalidated regardless of the value of addr. Targets
649 # which don't suffer from that problem could just let this functionality
651 m:::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
652 # Given a vector of command-line arguments, return a newly allocated
653 # string which, when passed to the create_inferior function, will be
654 # parsed (on Unix systems, by the shell) to yield the same vector.
655 # This function should call error() if the argument vector is not
656 # representable for this target or if this target does not support
657 # command-line arguments.
658 # ARGC is the number of elements in the vector.
659 # ARGV is an array of strings, one per argument.
660 m::CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
661 F:2:DWARF2_BUILD_FRAME_INFO:void:dwarf2_build_frame_info:struct objfile *objfile:objfile:::0
662 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
663 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
664 v::NAME_OF_MALLOC:const char *:name_of_malloc::::"malloc":"malloc"::0
665 v::CANNOT_STEP_BREAKPOINT:int:cannot_step_breakpoint::::0:0::0
666 v::HAVE_NONSTEPPABLE_WATCHPOINT:int:have_nonsteppable_watchpoint::::0:0::0
673 exec > new-gdbarch.log
674 function_list |
while do_read
677 ${class} ${macro}(${actual})
678 ${returntype} ${function} ($formal)${attrib}
682 eval echo \"\ \ \ \
${r}=\
${${r}}\"
684 # #fallbackdefault=${fallbackdefault}
685 # #valid_p=${valid_p}
687 if class_is_predicate_p
&& fallback_default_p
689 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
693 if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
695 echo "Error: postdefault is useless when invalid_p=0" 1>&2
699 if class_is_multiarch_p
701 if class_is_predicate_p
; then :
702 elif test "x${predefault}" = "x"
704 echo "Error: pure multi-arch function must have a predefault" 1>&2
713 compare_new gdbarch.log
719 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
721 /* Dynamic architecture support for GDB, the GNU debugger.
722 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
724 This file is part of GDB.
726 This program is free software; you can redistribute it and/or modify
727 it under the terms of the GNU General Public License as published by
728 the Free Software Foundation; either version 2 of the License, or
729 (at your option) any later version.
731 This program is distributed in the hope that it will be useful,
732 but WITHOUT ANY WARRANTY; without even the implied warranty of
733 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
734 GNU General Public License for more details.
736 You should have received a copy of the GNU General Public License
737 along with this program; if not, write to the Free Software
738 Foundation, Inc., 59 Temple Place - Suite 330,
739 Boston, MA 02111-1307, USA. */
741 /* This file was created with the aid of \`\`gdbarch.sh''.
743 The Bourne shell script \`\`gdbarch.sh'' creates the files
744 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
745 against the existing \`\`gdbarch.[hc]''. Any differences found
748 If editing this file, please also run gdbarch.sh and merge any
749 changes into that script. Conversely, when making sweeping changes
750 to this file, modifying gdbarch.sh and using its output may prove
766 #include "dis-asm.h" /* Get defs for disassemble_info, which unfortunately is a typedef. */
768 /* Pull in function declarations refered to, indirectly, via macros. */
769 #include "value.h" /* For default_coerce_float_to_double which is referenced by a macro. */
770 #include "inferior.h" /* For unsigned_address_to_pointer(). */
776 struct minimal_symbol;
779 extern struct gdbarch *current_gdbarch;
782 /* If any of the following are defined, the target wasn't correctly
786 #if defined (EXTRA_FRAME_INFO)
787 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
792 #if defined (FRAME_FIND_SAVED_REGS)
793 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
797 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
798 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
805 printf "/* The following are pre-initialized by GDBARCH. */\n"
806 function_list |
while do_read
811 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
812 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
813 printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
814 printf "#error \"Non multi-arch definition of ${macro}\"\n"
816 printf "#if GDB_MULTI_ARCH\n"
817 printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n"
818 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
827 printf "/* The following are initialized by the target dependent code. */\n"
828 function_list |
while do_read
830 if [ -n "${comment}" ]
832 echo "${comment}" |
sed \
837 if class_is_multiarch_p
839 if class_is_predicate_p
842 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
845 if class_is_predicate_p
848 printf "#if defined (${macro})\n"
849 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
850 #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
851 printf "#if !defined (${macro}_P)\n"
852 printf "#define ${macro}_P() (1)\n"
856 printf "/* Default predicate for non- multi-arch targets. */\n"
857 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
858 printf "#define ${macro}_P() (0)\n"
861 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
862 printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro}_P)\n"
863 printf "#error \"Non multi-arch definition of ${macro}\"\n"
865 printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro}_P)\n"
866 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
870 if class_is_variable_p
872 if fallback_default_p || class_is_predicate_p
875 printf "/* Default (value) for non- multi-arch platforms. */\n"
876 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
877 echo "#define ${macro} (${fallbackdefault})" \
878 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
882 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
883 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
884 printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
885 printf "#error \"Non multi-arch definition of ${macro}\"\n"
887 printf "#if GDB_MULTI_ARCH\n"
888 printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n"
889 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
893 if class_is_function_p
895 if class_is_multiarch_p
; then :
896 elif fallback_default_p || class_is_predicate_p
899 printf "/* Default (function) for non- multi-arch platforms. */\n"
900 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
901 if [ "x${fallbackdefault}" = "x0" ]
903 printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
905 # FIXME: Should be passing current_gdbarch through!
906 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
907 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
912 if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
914 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
915 elif class_is_multiarch_p
917 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
919 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
921 if [ "x${formal}" = "xvoid" ]
923 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
925 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
927 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
928 if class_is_multiarch_p
; then :
930 printf "#if (GDB_MULTI_ARCH ${gt_level}) && defined (${macro})\n"
931 printf "#error \"Non multi-arch definition of ${macro}\"\n"
933 printf "#if GDB_MULTI_ARCH\n"
934 printf "#if (GDB_MULTI_ARCH ${gt_level}) || !defined (${macro})\n"
935 if [ "x${actual}" = "x" ]
937 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
938 elif [ "x${actual}" = "x-" ]
940 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
942 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
953 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
956 /* Mechanism for co-ordinating the selection of a specific
959 GDB targets (*-tdep.c) can register an interest in a specific
960 architecture. Other GDB components can register a need to maintain
961 per-architecture data.
963 The mechanisms below ensures that there is only a loose connection
964 between the set-architecture command and the various GDB
965 components. Each component can independently register their need
966 to maintain architecture specific data with gdbarch.
970 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
973 The more traditional mega-struct containing architecture specific
974 data for all the various GDB components was also considered. Since
975 GDB is built from a variable number of (fairly independent)
976 components it was determined that the global aproach was not
980 /* Register a new architectural family with GDB.
982 Register support for the specified ARCHITECTURE with GDB. When
983 gdbarch determines that the specified architecture has been
984 selected, the corresponding INIT function is called.
988 The INIT function takes two parameters: INFO which contains the
989 information available to gdbarch about the (possibly new)
990 architecture; ARCHES which is a list of the previously created
991 \`\`struct gdbarch'' for this architecture.
993 The INFO parameter is, as far as possible, be pre-initialized with
994 information obtained from INFO.ABFD or the previously selected
997 The ARCHES parameter is a linked list (sorted most recently used)
998 of all the previously created architures for this architecture
999 family. The (possibly NULL) ARCHES->gdbarch can used to access
1000 values from the previously selected architecture for this
1001 architecture family. The global \`\`current_gdbarch'' shall not be
1004 The INIT function shall return any of: NULL - indicating that it
1005 doesn't recognize the selected architecture; an existing \`\`struct
1006 gdbarch'' from the ARCHES list - indicating that the new
1007 architecture is just a synonym for an earlier architecture (see
1008 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1009 - that describes the selected architecture (see gdbarch_alloc()).
1011 The DUMP_TDEP function shall print out all target specific values.
1012 Care should be taken to ensure that the function works in both the
1013 multi-arch and non- multi-arch cases. */
1017 struct gdbarch *gdbarch;
1018 struct gdbarch_list *next;
1023 /* Use default: NULL (ZERO). */
1024 const struct bfd_arch_info *bfd_arch_info;
1026 /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */
1029 /* Use default: NULL (ZERO). */
1032 /* Use default: NULL (ZERO). */
1033 struct gdbarch_tdep_info *tdep_info;
1036 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1037 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1039 /* DEPRECATED - use gdbarch_register() */
1040 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1042 extern void gdbarch_register (enum bfd_architecture architecture,
1043 gdbarch_init_ftype *,
1044 gdbarch_dump_tdep_ftype *);
1047 /* Return a freshly allocated, NULL terminated, array of the valid
1048 architecture names. Since architectures are registered during the
1049 _initialize phase this function only returns useful information
1050 once initialization has been completed. */
1052 extern const char **gdbarch_printable_names (void);
1055 /* Helper function. Search the list of ARCHES for a GDBARCH that
1056 matches the information provided by INFO. */
1058 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1061 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
1062 basic initialization using values obtained from the INFO andTDEP
1063 parameters. set_gdbarch_*() functions are called to complete the
1064 initialization of the object. */
1066 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1069 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
1070 It is assumed that the caller freeds the \`\`struct
1073 extern void gdbarch_free (struct gdbarch *);
1076 /* Helper function. Force an update of the current architecture.
1078 The actual architecture selected is determined by INFO, \`\`(gdb) set
1079 architecture'' et.al., the existing architecture and BFD's default
1080 architecture. INFO should be initialized to zero and then selected
1081 fields should be updated.
1083 Returns non-zero if the update succeeds */
1085 extern int gdbarch_update_p (struct gdbarch_info info);
1089 /* Register per-architecture data-pointer.
1091 Reserve space for a per-architecture data-pointer. An identifier
1092 for the reserved data-pointer is returned. That identifer should
1093 be saved in a local static variable.
1095 The per-architecture data-pointer is either initialized explicitly
1096 (set_gdbarch_data()) or implicitly (by INIT() via a call to
1097 gdbarch_data()). FREE() is called to delete either an existing
1098 data-pointer overridden by set_gdbarch_data() or when the
1099 architecture object is being deleted.
1101 When a previously created architecture is re-selected, the
1102 per-architecture data-pointer for that previous architecture is
1103 restored. INIT() is not re-called.
1105 Multiple registrarants for any architecture are allowed (and
1106 strongly encouraged). */
1108 struct gdbarch_data;
1110 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
1111 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
1113 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
1114 gdbarch_data_free_ftype *free);
1115 extern void set_gdbarch_data (struct gdbarch *gdbarch,
1116 struct gdbarch_data *data,
1119 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1122 /* Register per-architecture memory region.
1124 Provide a memory-region swap mechanism. Per-architecture memory
1125 region are created. These memory regions are swapped whenever the
1126 architecture is changed. For a new architecture, the memory region
1127 is initialized with zero (0) and the INIT function is called.
1129 Memory regions are swapped / initialized in the order that they are
1130 registered. NULL DATA and/or INIT values can be specified.
1132 New code should use register_gdbarch_data(). */
1134 typedef void (gdbarch_swap_ftype) (void);
1135 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
1136 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
1140 /* The target-system-dependent byte order is dynamic */
1142 extern int target_byte_order;
1143 #ifndef TARGET_BYTE_ORDER
1144 #define TARGET_BYTE_ORDER (target_byte_order + 0)
1147 extern int target_byte_order_auto;
1148 #ifndef TARGET_BYTE_ORDER_AUTO
1149 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
1154 /* The target-system-dependent BFD architecture is dynamic */
1156 extern int target_architecture_auto;
1157 #ifndef TARGET_ARCHITECTURE_AUTO
1158 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
1161 extern const struct bfd_arch_info *target_architecture;
1162 #ifndef TARGET_ARCHITECTURE
1163 #define TARGET_ARCHITECTURE (target_architecture + 0)
1167 /* The target-system-dependent disassembler is semi-dynamic */
1169 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
1170 unsigned int len, disassemble_info *info);
1172 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
1173 disassemble_info *info);
1175 extern void dis_asm_print_address (bfd_vma addr,
1176 disassemble_info *info);
1178 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
1179 extern disassemble_info tm_print_insn_info;
1180 #ifndef TARGET_PRINT_INSN_INFO
1181 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
1186 /* Set the dynamic target-system-dependent parameters (architecture,
1187 byte-order, ...) using information found in the BFD */
1189 extern void set_gdbarch_from_file (bfd *);
1192 /* Initialize the current architecture to the "first" one we find on
1195 extern void initialize_current_architecture (void);
1197 /* For non-multiarched targets, do any initialization of the default
1198 gdbarch object necessary after the _initialize_MODULE functions
1200 extern void initialize_non_multiarch (void);
1202 /* gdbarch trace variable */
1203 extern int gdbarch_debug;
1205 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1210 #../move-if-change new-gdbarch.h gdbarch.h
1211 compare_new gdbarch.h
1218 exec > new-gdbarch.c
1223 #include "arch-utils.h"
1227 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1229 /* Just include everything in sight so that the every old definition
1230 of macro is visible. */
1231 #include "gdb_string.h"
1235 #include "inferior.h"
1236 #include "breakpoint.h"
1237 #include "gdb_wait.h"
1238 #include "gdbcore.h"
1241 #include "gdbthread.h"
1242 #include "annotate.h"
1243 #include "symfile.h" /* for overlay functions */
1244 #include "value.h" /* For old tm.h/nm.h macros. */
1248 #include "floatformat.h"
1250 #include "gdb_assert.h"
1251 #include "gdb_string.h"
1252 #include "gdb-events.h"
1254 /* Static function declarations */
1256 static void verify_gdbarch (struct gdbarch *gdbarch);
1257 static void alloc_gdbarch_data (struct gdbarch *);
1258 static void free_gdbarch_data (struct gdbarch *);
1259 static void init_gdbarch_swap (struct gdbarch *);
1260 static void clear_gdbarch_swap (struct gdbarch *);
1261 static void swapout_gdbarch_swap (struct gdbarch *);
1262 static void swapin_gdbarch_swap (struct gdbarch *);
1264 /* Non-zero if we want to trace architecture code. */
1266 #ifndef GDBARCH_DEBUG
1267 #define GDBARCH_DEBUG 0
1269 int gdbarch_debug = GDBARCH_DEBUG;
1273 # gdbarch open the gdbarch object
1275 printf "/* Maintain the struct gdbarch object */\n"
1277 printf "struct gdbarch\n"
1279 printf " /* Has this architecture been fully initialized? */\n"
1280 printf " int initialized_p;\n"
1281 printf " /* basic architectural information */\n"
1282 function_list |
while do_read
1286 printf " ${returntype} ${function};\n"
1290 printf " /* target specific vector. */\n"
1291 printf " struct gdbarch_tdep *tdep;\n"
1292 printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1294 printf " /* per-architecture data-pointers */\n"
1295 printf " unsigned nr_data;\n"
1296 printf " void **data;\n"
1298 printf " /* per-architecture swap-regions */\n"
1299 printf " struct gdbarch_swap *swap;\n"
1302 /* Multi-arch values.
1304 When extending this structure you must:
1306 Add the field below.
1308 Declare set/get functions and define the corresponding
1311 gdbarch_alloc(): If zero/NULL is not a suitable default,
1312 initialize the new field.
1314 verify_gdbarch(): Confirm that the target updated the field
1317 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1320 \`\`startup_gdbarch()'': Append an initial value to the static
1321 variable (base values on the host's c-type system).
1323 get_gdbarch(): Implement the set/get functions (probably using
1324 the macro's as shortcuts).
1329 function_list |
while do_read
1331 if class_is_variable_p
1333 printf " ${returntype} ${function};\n"
1334 elif class_is_function_p
1336 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
1341 # A pre-initialized vector
1345 /* The default architecture uses host values (for want of a better
1349 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1351 printf "struct gdbarch startup_gdbarch =\n"
1353 printf " 1, /* Always initialized. */\n"
1354 printf " /* basic architecture information */\n"
1355 function_list |
while do_read
1359 printf " ${staticdefault},\n"
1363 /* target specific vector and its dump routine */
1365 /*per-architecture data-pointers and swap regions */
1367 /* Multi-arch values */
1369 function_list |
while do_read
1371 if class_is_function_p || class_is_variable_p
1373 printf " ${staticdefault},\n"
1377 /* startup_gdbarch() */
1380 struct gdbarch *current_gdbarch = &startup_gdbarch;
1382 /* Do any initialization needed for a non-multiarch configuration
1383 after the _initialize_MODULE functions have been run. */
1385 initialize_non_multiarch (void)
1387 alloc_gdbarch_data (&startup_gdbarch);
1388 /* Ensure that all swap areas are zeroed so that they again think
1389 they are starting from scratch. */
1390 clear_gdbarch_swap (&startup_gdbarch);
1391 init_gdbarch_swap (&startup_gdbarch);
1395 # Create a new gdbarch struct
1399 /* Create a new \`\`struct gdbarch'' based on information provided by
1400 \`\`struct gdbarch_info''. */
1405 gdbarch_alloc (const struct gdbarch_info *info,
1406 struct gdbarch_tdep *tdep)
1408 /* NOTE: The new architecture variable is named \`\`current_gdbarch''
1409 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
1410 the current local architecture and not the previous global
1411 architecture. This ensures that the new architectures initial
1412 values are not influenced by the previous architecture. Once
1413 everything is parameterised with gdbarch, this will go away. */
1414 struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
1415 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
1417 alloc_gdbarch_data (current_gdbarch);
1419 current_gdbarch->tdep = tdep;
1422 function_list |
while do_read
1426 printf " current_gdbarch->${function} = info->${function};\n"
1430 printf " /* Force the explicit initialization of these. */\n"
1431 function_list |
while do_read
1433 if class_is_function_p || class_is_variable_p
1435 if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1437 printf " current_gdbarch->${function} = ${predefault};\n"
1442 /* gdbarch_alloc() */
1444 return current_gdbarch;
1448 # Free a gdbarch struct.
1452 /* Free a gdbarch struct. This should never happen in normal
1453 operation --- once you've created a gdbarch, you keep it around.
1454 However, if an architecture's init function encounters an error
1455 building the structure, it may need to clean up a partially
1456 constructed gdbarch. */
1459 gdbarch_free (struct gdbarch *arch)
1461 gdb_assert (arch != NULL);
1462 free_gdbarch_data (arch);
1467 # verify a new architecture
1470 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1474 verify_gdbarch (struct gdbarch *gdbarch)
1476 struct ui_file *log;
1477 struct cleanup *cleanups;
1480 /* Only perform sanity checks on a multi-arch target. */
1481 if (!GDB_MULTI_ARCH)
1483 log = mem_fileopen ();
1484 cleanups = make_cleanup_ui_file_delete (log);
1486 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1487 fprintf_unfiltered (log, "\n\tbyte-order");
1488 if (gdbarch->bfd_arch_info == NULL)
1489 fprintf_unfiltered (log, "\n\tbfd_arch_info");
1490 /* Check those that need to be defined for the given multi-arch level. */
1492 function_list |
while do_read
1494 if class_is_function_p || class_is_variable_p
1496 if [ "x${invalid_p}" = "x0" ]
1498 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1499 elif class_is_predicate_p
1501 printf " /* Skip verify of ${function}, has predicate */\n"
1502 # FIXME: See do_read for potential simplification
1503 elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1505 printf " if (${invalid_p})\n"
1506 printf " gdbarch->${function} = ${postdefault};\n"
1507 elif [ -n "${predefault}" -a -n "${postdefault}" ]
1509 printf " if (gdbarch->${function} == ${predefault})\n"
1510 printf " gdbarch->${function} = ${postdefault};\n"
1511 elif [ -n "${postdefault}" ]
1513 printf " if (gdbarch->${function} == 0)\n"
1514 printf " gdbarch->${function} = ${postdefault};\n"
1515 elif [ -n "${invalid_p}" ]
1517 printf " if ((GDB_MULTI_ARCH ${gt_level})\n"
1518 printf " && (${invalid_p}))\n"
1519 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1520 elif [ -n "${predefault}" ]
1522 printf " if ((GDB_MULTI_ARCH ${gt_level})\n"
1523 printf " && (gdbarch->${function} == ${predefault}))\n"
1524 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1529 buf = ui_file_xstrdup (log, &dummy);
1530 make_cleanup (xfree, buf);
1531 if (strlen (buf) > 0)
1532 internal_error (__FILE__, __LINE__,
1533 "verify_gdbarch: the following are invalid ...%s",
1535 do_cleanups (cleanups);
1539 # dump the structure
1543 /* Print out the details of the current architecture. */
1545 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1546 just happens to match the global variable \`\`current_gdbarch''. That
1547 way macros refering to that variable get the local and not the global
1548 version - ulgh. Once everything is parameterised with gdbarch, this
1552 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1554 fprintf_unfiltered (file,
1555 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1558 function_list |
sort -t: +2 |
while do_read
1560 # multiarch functions don't have macros.
1561 if class_is_multiarch_p
1563 printf " if (GDB_MULTI_ARCH)\n"
1564 printf " fprintf_unfiltered (file,\n"
1565 printf " \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1566 printf " (long) current_gdbarch->${function});\n"
1569 # Print the macro definition.
1570 printf "#ifdef ${macro}\n"
1571 if [ "x${returntype}" = "xvoid" ]
1573 printf "#if GDB_MULTI_ARCH\n"
1574 printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
1576 if class_is_function_p
1578 printf " fprintf_unfiltered (file,\n"
1579 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1580 printf " \"${macro}(${actual})\",\n"
1581 printf " XSTRING (${macro} (${actual})));\n"
1583 printf " fprintf_unfiltered (file,\n"
1584 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1585 printf " XSTRING (${macro}));\n"
1587 # Print the architecture vector value
1588 if [ "x${returntype}" = "xvoid" ]
1592 if [ "x${print_p}" = "x()" ]
1594 printf " gdbarch_dump_${function} (current_gdbarch);\n"
1595 elif [ "x${print_p}" = "x0" ]
1597 printf " /* skip print of ${macro}, print_p == 0. */\n"
1598 elif [ -n "${print_p}" ]
1600 printf " if (${print_p})\n"
1601 printf " fprintf_unfiltered (file,\n"
1602 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1603 printf " ${print});\n"
1604 elif class_is_function_p
1606 printf " if (GDB_MULTI_ARCH)\n"
1607 printf " fprintf_unfiltered (file,\n"
1608 printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1609 printf " (long) current_gdbarch->${function}\n"
1610 printf " /*${macro} ()*/);\n"
1612 printf " fprintf_unfiltered (file,\n"
1613 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1614 printf " ${print});\n"
1619 if (current_gdbarch->dump_tdep != NULL)
1620 current_gdbarch->dump_tdep (current_gdbarch, file);
1628 struct gdbarch_tdep *
1629 gdbarch_tdep (struct gdbarch *gdbarch)
1631 if (gdbarch_debug >= 2)
1632 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1633 return gdbarch->tdep;
1637 function_list |
while do_read
1639 if class_is_predicate_p
1643 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1645 printf " gdb_assert (gdbarch != NULL);\n"
1646 if [ -n "${valid_p}" ]
1648 printf " return ${valid_p};\n"
1650 printf "#error \"gdbarch_${function}_p: not defined\"\n"
1654 if class_is_function_p
1657 printf "${returntype}\n"
1658 if [ "x${formal}" = "xvoid" ]
1660 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1662 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1665 printf " gdb_assert (gdbarch != NULL);\n"
1666 printf " if (gdbarch->${function} == 0)\n"
1667 printf " internal_error (__FILE__, __LINE__,\n"
1668 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1669 printf " if (gdbarch_debug >= 2)\n"
1670 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1671 if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1673 if class_is_multiarch_p
1680 if class_is_multiarch_p
1682 params
="gdbarch, ${actual}"
1687 if [ "x${returntype}" = "xvoid" ]
1689 printf " gdbarch->${function} (${params});\n"
1691 printf " return gdbarch->${function} (${params});\n"
1696 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1697 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1699 printf " gdbarch->${function} = ${function};\n"
1701 elif class_is_variable_p
1704 printf "${returntype}\n"
1705 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1707 printf " gdb_assert (gdbarch != NULL);\n"
1708 if [ "x${invalid_p}" = "x0" ]
1710 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1711 elif [ -n "${invalid_p}" ]
1713 printf " if (${invalid_p})\n"
1714 printf " internal_error (__FILE__, __LINE__,\n"
1715 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1716 elif [ -n "${predefault}" ]
1718 printf " if (gdbarch->${function} == ${predefault})\n"
1719 printf " internal_error (__FILE__, __LINE__,\n"
1720 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1722 printf " if (gdbarch_debug >= 2)\n"
1723 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1724 printf " return gdbarch->${function};\n"
1728 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1729 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1731 printf " gdbarch->${function} = ${function};\n"
1733 elif class_is_info_p
1736 printf "${returntype}\n"
1737 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1739 printf " gdb_assert (gdbarch != NULL);\n"
1740 printf " if (gdbarch_debug >= 2)\n"
1741 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1742 printf " return gdbarch->${function};\n"
1747 # All the trailing guff
1751 /* Keep a registry of per-architecture data-pointers required by GDB
1758 gdbarch_data_init_ftype *init;
1759 gdbarch_data_free_ftype *free;
1762 struct gdbarch_data_registration
1764 struct gdbarch_data *data;
1765 struct gdbarch_data_registration *next;
1768 struct gdbarch_data_registry
1771 struct gdbarch_data_registration *registrations;
1774 struct gdbarch_data_registry gdbarch_data_registry =
1779 struct gdbarch_data *
1780 register_gdbarch_data (gdbarch_data_init_ftype *init,
1781 gdbarch_data_free_ftype *free)
1783 struct gdbarch_data_registration **curr;
1784 /* Append the new registraration. */
1785 for (curr = &gdbarch_data_registry.registrations;
1787 curr = &(*curr)->next);
1788 (*curr) = XMALLOC (struct gdbarch_data_registration);
1789 (*curr)->next = NULL;
1790 (*curr)->data = XMALLOC (struct gdbarch_data);
1791 (*curr)->data->index = gdbarch_data_registry.nr++;
1792 (*curr)->data->init = init;
1793 (*curr)->data->init_p = 1;
1794 (*curr)->data->free = free;
1795 return (*curr)->data;
1799 /* Create/delete the gdbarch data vector. */
1802 alloc_gdbarch_data (struct gdbarch *gdbarch)
1804 gdb_assert (gdbarch->data == NULL);
1805 gdbarch->nr_data = gdbarch_data_registry.nr;
1806 gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1810 free_gdbarch_data (struct gdbarch *gdbarch)
1812 struct gdbarch_data_registration *rego;
1813 gdb_assert (gdbarch->data != NULL);
1814 for (rego = gdbarch_data_registry.registrations;
1818 struct gdbarch_data *data = rego->data;
1819 gdb_assert (data->index < gdbarch->nr_data);
1820 if (data->free != NULL && gdbarch->data[data->index] != NULL)
1822 data->free (gdbarch, gdbarch->data[data->index]);
1823 gdbarch->data[data->index] = NULL;
1826 xfree (gdbarch->data);
1827 gdbarch->data = NULL;
1831 /* Initialize the current value of the specified per-architecture
1835 set_gdbarch_data (struct gdbarch *gdbarch,
1836 struct gdbarch_data *data,
1839 gdb_assert (data->index < gdbarch->nr_data);
1840 if (gdbarch->data[data->index] != NULL)
1842 gdb_assert (data->free != NULL);
1843 data->free (gdbarch, gdbarch->data[data->index]);
1845 gdbarch->data[data->index] = pointer;
1848 /* Return the current value of the specified per-architecture
1852 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
1854 gdb_assert (data->index < gdbarch->nr_data);
1855 /* The data-pointer isn't initialized, call init() to get a value but
1856 only if the architecture initializaiton has completed. Otherwise
1857 punt - hope that the caller knows what they are doing. */
1858 if (gdbarch->data[data->index] == NULL
1859 && gdbarch->initialized_p)
1861 /* Be careful to detect an initialization cycle. */
1862 gdb_assert (data->init_p);
1864 gdb_assert (data->init != NULL);
1865 gdbarch->data[data->index] = data->init (gdbarch);
1867 gdb_assert (gdbarch->data[data->index] != NULL);
1869 return gdbarch->data[data->index];
1874 /* Keep a registry of swapped data required by GDB modules. */
1879 struct gdbarch_swap_registration *source;
1880 struct gdbarch_swap *next;
1883 struct gdbarch_swap_registration
1886 unsigned long sizeof_data;
1887 gdbarch_swap_ftype *init;
1888 struct gdbarch_swap_registration *next;
1891 struct gdbarch_swap_registry
1894 struct gdbarch_swap_registration *registrations;
1897 struct gdbarch_swap_registry gdbarch_swap_registry =
1903 register_gdbarch_swap (void *data,
1904 unsigned long sizeof_data,
1905 gdbarch_swap_ftype *init)
1907 struct gdbarch_swap_registration **rego;
1908 for (rego = &gdbarch_swap_registry.registrations;
1910 rego = &(*rego)->next);
1911 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1912 (*rego)->next = NULL;
1913 (*rego)->init = init;
1914 (*rego)->data = data;
1915 (*rego)->sizeof_data = sizeof_data;
1919 clear_gdbarch_swap (struct gdbarch *gdbarch)
1921 struct gdbarch_swap *curr;
1922 for (curr = gdbarch->swap;
1926 memset (curr->source->data, 0, curr->source->sizeof_data);
1931 init_gdbarch_swap (struct gdbarch *gdbarch)
1933 struct gdbarch_swap_registration *rego;
1934 struct gdbarch_swap **curr = &gdbarch->swap;
1935 for (rego = gdbarch_swap_registry.registrations;
1939 if (rego->data != NULL)
1941 (*curr) = XMALLOC (struct gdbarch_swap);
1942 (*curr)->source = rego;
1943 (*curr)->swap = xmalloc (rego->sizeof_data);
1944 (*curr)->next = NULL;
1945 curr = &(*curr)->next;
1947 if (rego->init != NULL)
1953 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1955 struct gdbarch_swap *curr;
1956 for (curr = gdbarch->swap;
1959 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1963 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1965 struct gdbarch_swap *curr;
1966 for (curr = gdbarch->swap;
1969 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1973 /* Keep a registry of the architectures known by GDB. */
1975 struct gdbarch_registration
1977 enum bfd_architecture bfd_architecture;
1978 gdbarch_init_ftype *init;
1979 gdbarch_dump_tdep_ftype *dump_tdep;
1980 struct gdbarch_list *arches;
1981 struct gdbarch_registration *next;
1984 static struct gdbarch_registration *gdbarch_registry = NULL;
1987 append_name (const char ***buf, int *nr, const char *name)
1989 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1995 gdbarch_printable_names (void)
1999 /* Accumulate a list of names based on the registed list of
2001 enum bfd_architecture a;
2003 const char **arches = NULL;
2004 struct gdbarch_registration *rego;
2005 for (rego = gdbarch_registry;
2009 const struct bfd_arch_info *ap;
2010 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
2012 internal_error (__FILE__, __LINE__,
2013 "gdbarch_architecture_names: multi-arch unknown");
2016 append_name (&arches, &nr_arches, ap->printable_name);
2021 append_name (&arches, &nr_arches, NULL);
2025 /* Just return all the architectures that BFD knows. Assume that
2026 the legacy architecture framework supports them. */
2027 return bfd_arch_list ();
2032 gdbarch_register (enum bfd_architecture bfd_architecture,
2033 gdbarch_init_ftype *init,
2034 gdbarch_dump_tdep_ftype *dump_tdep)
2036 struct gdbarch_registration **curr;
2037 const struct bfd_arch_info *bfd_arch_info;
2038 /* Check that BFD recognizes this architecture */
2039 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2040 if (bfd_arch_info == NULL)
2042 internal_error (__FILE__, __LINE__,
2043 "gdbarch: Attempt to register unknown architecture (%d)",
2046 /* Check that we haven't seen this architecture before */
2047 for (curr = &gdbarch_registry;
2049 curr = &(*curr)->next)
2051 if (bfd_architecture == (*curr)->bfd_architecture)
2052 internal_error (__FILE__, __LINE__,
2053 "gdbarch: Duplicate registraration of architecture (%s)",
2054 bfd_arch_info->printable_name);
2058 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
2059 bfd_arch_info->printable_name,
2062 (*curr) = XMALLOC (struct gdbarch_registration);
2063 (*curr)->bfd_architecture = bfd_architecture;
2064 (*curr)->init = init;
2065 (*curr)->dump_tdep = dump_tdep;
2066 (*curr)->arches = NULL;
2067 (*curr)->next = NULL;
2068 /* When non- multi-arch, install whatever target dump routine we've
2069 been provided - hopefully that routine has been written correctly
2070 and works regardless of multi-arch. */
2071 if (!GDB_MULTI_ARCH && dump_tdep != NULL
2072 && startup_gdbarch.dump_tdep == NULL)
2073 startup_gdbarch.dump_tdep = dump_tdep;
2077 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2078 gdbarch_init_ftype *init)
2080 gdbarch_register (bfd_architecture, init, NULL);
2084 /* Look for an architecture using gdbarch_info. Base search on only
2085 BFD_ARCH_INFO and BYTE_ORDER. */
2087 struct gdbarch_list *
2088 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2089 const struct gdbarch_info *info)
2091 for (; arches != NULL; arches = arches->next)
2093 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2095 if (info->byte_order != arches->gdbarch->byte_order)
2103 /* Update the current architecture. Return ZERO if the update request
2107 gdbarch_update_p (struct gdbarch_info info)
2109 struct gdbarch *new_gdbarch;
2110 struct gdbarch *old_gdbarch;
2111 struct gdbarch_registration *rego;
2113 /* Fill in missing parts of the INFO struct using a number of
2114 sources: \`\`set ...''; INFOabfd supplied; existing target. */
2116 /* \`\`(gdb) set architecture ...'' */
2117 if (info.bfd_arch_info == NULL
2118 && !TARGET_ARCHITECTURE_AUTO)
2119 info.bfd_arch_info = TARGET_ARCHITECTURE;
2120 if (info.bfd_arch_info == NULL
2121 && info.abfd != NULL
2122 && bfd_get_arch (info.abfd) != bfd_arch_unknown
2123 && bfd_get_arch (info.abfd) != bfd_arch_obscure)
2124 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
2125 if (info.bfd_arch_info == NULL)
2126 info.bfd_arch_info = TARGET_ARCHITECTURE;
2128 /* \`\`(gdb) set byte-order ...'' */
2129 if (info.byte_order == BFD_ENDIAN_UNKNOWN
2130 && !TARGET_BYTE_ORDER_AUTO)
2131 info.byte_order = TARGET_BYTE_ORDER;
2132 /* From the INFO struct. */
2133 if (info.byte_order == BFD_ENDIAN_UNKNOWN
2134 && info.abfd != NULL)
2135 info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
2136 : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
2137 : BFD_ENDIAN_UNKNOWN);
2138 /* From the current target. */
2139 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
2140 info.byte_order = TARGET_BYTE_ORDER;
2142 /* Must have found some sort of architecture. */
2143 gdb_assert (info.bfd_arch_info != NULL);
2147 fprintf_unfiltered (gdb_stdlog,
2148 "gdbarch_update: info.bfd_arch_info %s\n",
2149 (info.bfd_arch_info != NULL
2150 ? info.bfd_arch_info->printable_name
2152 fprintf_unfiltered (gdb_stdlog,
2153 "gdbarch_update: info.byte_order %d (%s)\n",
2155 (info.byte_order == BFD_ENDIAN_BIG ? "big"
2156 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2158 fprintf_unfiltered (gdb_stdlog,
2159 "gdbarch_update: info.abfd 0x%lx\n",
2161 fprintf_unfiltered (gdb_stdlog,
2162 "gdbarch_update: info.tdep_info 0x%lx\n",
2163 (long) info.tdep_info);
2166 /* Find the target that knows about this architecture. */
2167 for (rego = gdbarch_registry;
2170 if (rego->bfd_architecture == info.bfd_arch_info->arch)
2175 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
2179 /* Swap the data belonging to the old target out setting the
2180 installed data to zero. This stops the ->init() function trying
2181 to refer to the previous architecture's global data structures. */
2182 swapout_gdbarch_swap (current_gdbarch);
2183 clear_gdbarch_swap (current_gdbarch);
2185 /* Save the previously selected architecture, setting the global to
2186 NULL. This stops ->init() trying to use the previous
2187 architecture's configuration. The previous architecture may not
2188 even be of the same architecture family. The most recent
2189 architecture of the same family is found at the head of the
2190 rego->arches list. */
2191 old_gdbarch = current_gdbarch;
2192 current_gdbarch = NULL;
2194 /* Ask the target for a replacement architecture. */
2195 new_gdbarch = rego->init (info, rego->arches);
2197 /* Did the target like it? No. Reject the change and revert to the
2198 old architecture. */
2199 if (new_gdbarch == NULL)
2202 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
2203 swapin_gdbarch_swap (old_gdbarch);
2204 current_gdbarch = old_gdbarch;
2208 /* Did the architecture change? No. Oops, put the old architecture
2210 if (old_gdbarch == new_gdbarch)
2213 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
2215 new_gdbarch->bfd_arch_info->printable_name);
2216 swapin_gdbarch_swap (old_gdbarch);
2217 current_gdbarch = old_gdbarch;
2221 /* Is this a pre-existing architecture? Yes. Move it to the front
2222 of the list of architectures (keeping the list sorted Most
2223 Recently Used) and then copy it in. */
2225 struct gdbarch_list **list;
2226 for (list = ®o->arches;
2228 list = &(*list)->next)
2230 if ((*list)->gdbarch == new_gdbarch)
2232 struct gdbarch_list *this;
2234 fprintf_unfiltered (gdb_stdlog,
2235 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
2237 new_gdbarch->bfd_arch_info->printable_name);
2240 (*list) = this->next;
2241 /* Insert in the front. */
2242 this->next = rego->arches;
2243 rego->arches = this;
2244 /* Copy the new architecture in. */
2245 current_gdbarch = new_gdbarch;
2246 swapin_gdbarch_swap (new_gdbarch);
2247 architecture_changed_event ();
2253 /* Prepend this new architecture to the architecture list (keep the
2254 list sorted Most Recently Used). */
2256 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
2257 this->next = rego->arches;
2258 this->gdbarch = new_gdbarch;
2259 rego->arches = this;
2262 /* Switch to this new architecture marking it initialized. */
2263 current_gdbarch = new_gdbarch;
2264 current_gdbarch->initialized_p = 1;
2267 fprintf_unfiltered (gdb_stdlog,
2268 "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
2270 new_gdbarch->bfd_arch_info->printable_name);
2273 /* Check that the newly installed architecture is valid. Plug in
2274 any post init values. */
2275 new_gdbarch->dump_tdep = rego->dump_tdep;
2276 verify_gdbarch (new_gdbarch);
2278 /* Initialize the per-architecture memory (swap) areas.
2279 CURRENT_GDBARCH must be update before these modules are
2281 init_gdbarch_swap (new_gdbarch);
2283 /* Initialize the per-architecture data. CURRENT_GDBARCH
2284 must be updated before these modules are called. */
2285 architecture_changed_event ();
2288 gdbarch_dump (current_gdbarch, gdb_stdlog);
2296 /* Pointer to the target-dependent disassembly function. */
2297 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2298 disassemble_info tm_print_insn_info;
2301 extern void _initialize_gdbarch (void);
2304 _initialize_gdbarch (void)
2306 struct cmd_list_element *c;
2308 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2309 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2310 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2311 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2312 tm_print_insn_info.print_address_func = dis_asm_print_address;
2314 add_show_from_set (add_set_cmd ("arch",
2317 (char *)&gdbarch_debug,
2318 "Set architecture debugging.\\n\\
2319 When non-zero, architecture debugging is enabled.", &setdebuglist),
2321 c = add_set_cmd ("archdebug",
2324 (char *)&gdbarch_debug,
2325 "Set architecture debugging.\\n\\
2326 When non-zero, architecture debugging is enabled.", &setlist);
2328 deprecate_cmd (c, "set debug arch");
2329 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2335 #../move-if-change new-gdbarch.c gdbarch.c
2336 compare_new gdbarch.c