3 # Architecture commands for GDB, the GNU debugger.
5 # Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
9 # This file is part of GDB.
11 # This program is free software; you can redistribute it and/or modify
12 # it under the terms of the GNU General Public License as published by
13 # the Free Software Foundation; either version 2 of the License, or
14 # (at your option) any later version.
16 # This program is distributed in the hope that it will be useful,
17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 # GNU General Public License for more details.
21 # You should have received a copy of the GNU General Public License
22 # along with this program; if not, write to the Free Software
23 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 # Make certain that the script is running in an internationalized
28 LC_ALL
=c
; export LC_ALL
36 echo "${file} missing? cp new-${file} ${file}" 1>&2
37 elif diff -u ${file} new-
${file}
39 echo "${file} unchanged" 1>&2
41 echo "${file} has changed? cp new-${file} ${file}" 1>&2
46 # Format of the input table
47 read="class macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
55 if test "${line}" = ""
58 elif test "${line}" = "#" -a "${comment}" = ""
61 elif expr "${line}" : "#" > /dev
/null
67 # The semantics of IFS varies between different SH's. Some
68 # treat ``::' as three fields while some treat it as just too.
69 # Work around this by eliminating ``::'' ....
70 line
="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
72 OFS
="${IFS}" ; IFS
="[:]"
73 eval read ${read} <<EOF
78 # .... and then going back through each field and strip out those
79 # that ended up with just that space character.
82 if eval test \"\
${${r}}\" = \"\
\"
89 m
) staticdefault
="${predefault}" ;;
90 M
) staticdefault
="0" ;;
91 * ) test "${staticdefault}" || staticdefault
=0 ;;
94 # come up with a format, use a few guesses for variables
95 case ":${class}:${fmt}:${print}:" in
97 if [ "${returntype}" = int
]
101 elif [ "${returntype}" = long
]
108 test "${fmt}" ||
fmt="%ld"
109 test "${print}" || print
="(long) ${macro}"
113 case "${invalid_p}" in
115 if test -n "${predefault}"
117 #invalid_p="gdbarch->${function} == ${predefault}"
118 predicate
="gdbarch->${function} != ${predefault}"
119 elif class_is_variable_p
121 predicate
="gdbarch->${function} != 0"
122 elif class_is_function_p
124 predicate
="gdbarch->${function} != NULL"
128 echo "Predicate function ${function} with invalid_p." 1>&2
135 # PREDEFAULT is a valid fallback definition of MEMBER when
136 # multi-arch is not enabled. This ensures that the
137 # default value, when multi-arch is the same as the
138 # default value when not multi-arch. POSTDEFAULT is
139 # always a valid definition of MEMBER as this again
140 # ensures consistency.
142 if [ -n "${postdefault}" ]
144 fallbackdefault
="${postdefault}"
145 elif [ -n "${predefault}" ]
147 fallbackdefault
="${predefault}"
152 #NOT YET: See gdbarch.log for basic verification of
167 fallback_default_p
()
169 [ -n "${postdefault}" -a "x${invalid_p}" != "x0" ] \
170 ||
[ -n "${predefault}" -a "x${invalid_p}" = "x0" ]
173 class_is_variable_p
()
181 class_is_function_p
()
184 *f
* |
*F
* |
*m
* |
*M
* ) true
;;
189 class_is_multiarch_p
()
197 class_is_predicate_p
()
200 *F
* |
*V
* |
*M
* ) true
;;
214 # dump out/verify the doco
224 # F -> function + predicate
225 # hiding a function + predicate to test function validity
228 # V -> variable + predicate
229 # hiding a variable + predicate to test variables validity
231 # hiding something from the ``struct info'' object
232 # m -> multi-arch function
233 # hiding a multi-arch function (parameterised with the architecture)
234 # M -> multi-arch function + predicate
235 # hiding a multi-arch function + predicate to test function validity
239 # The name of the MACRO that this method is to be accessed by.
243 # For functions, the return type; for variables, the data type
247 # For functions, the member function name; for variables, the
248 # variable name. Member function names are always prefixed with
249 # ``gdbarch_'' for name-space purity.
253 # The formal argument list. It is assumed that the formal
254 # argument list includes the actual name of each list element.
255 # A function with no arguments shall have ``void'' as the
256 # formal argument list.
260 # The list of actual arguments. The arguments specified shall
261 # match the FORMAL list given above. Functions with out
262 # arguments leave this blank.
266 # Any GCC attributes that should be attached to the function
267 # declaration. At present this field is unused.
271 # To help with the GDB startup a static gdbarch object is
272 # created. STATICDEFAULT is the value to insert into that
273 # static gdbarch object. Since this a static object only
274 # simple expressions can be used.
276 # If STATICDEFAULT is empty, zero is used.
280 # An initial value to assign to MEMBER of the freshly
281 # malloc()ed gdbarch object. After initialization, the
282 # freshly malloc()ed object is passed to the target
283 # architecture code for further updates.
285 # If PREDEFAULT is empty, zero is used.
287 # A non-empty PREDEFAULT, an empty POSTDEFAULT and a zero
288 # INVALID_P are specified, PREDEFAULT will be used as the
289 # default for the non- multi-arch target.
291 # A zero PREDEFAULT function will force the fallback to call
294 # Variable declarations can refer to ``gdbarch'' which will
295 # contain the current architecture. Care should be taken.
299 # A value to assign to MEMBER of the new gdbarch object should
300 # the target architecture code fail to change the PREDEFAULT
303 # If POSTDEFAULT is empty, no post update is performed.
305 # If both INVALID_P and POSTDEFAULT are non-empty then
306 # INVALID_P will be used to determine if MEMBER should be
307 # changed to POSTDEFAULT.
309 # If a non-empty POSTDEFAULT and a zero INVALID_P are
310 # specified, POSTDEFAULT will be used as the default for the
311 # non- multi-arch target (regardless of the value of
314 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
316 # Variable declarations can refer to ``current_gdbarch'' which
317 # will contain the current architecture. Care should be
322 # A predicate equation that validates MEMBER. Non-zero is
323 # returned if the code creating the new architecture failed to
324 # initialize MEMBER or the initialized the member is invalid.
325 # If POSTDEFAULT is non-empty then MEMBER will be updated to
326 # that value. If POSTDEFAULT is empty then internal_error()
329 # If INVALID_P is empty, a check that MEMBER is no longer
330 # equal to PREDEFAULT is used.
332 # The expression ``0'' disables the INVALID_P check making
333 # PREDEFAULT a legitimate value.
335 # See also PREDEFAULT and POSTDEFAULT.
339 # printf style format string that can be used to print out the
340 # MEMBER. Sometimes "%s" is useful. For functions, this is
341 # ignored and the function address is printed.
343 # If FMT is empty, ``%ld'' is used.
347 # An optional equation that casts MEMBER to a value suitable
348 # for formatting by FMT.
350 # If PRINT is empty, ``(long)'' is used.
354 # An optional indicator for any predicte to wrap around the
357 # () -> Call a custom function to do the dump.
358 # exp -> Wrap print up in ``if (${print_p}) ...
359 # ``'' -> No predicate
361 # If PRINT_P is empty, ``1'' is always used.
368 echo "Bad field ${field}"
376 # See below (DOCO) for description of each field
378 i:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
380 i:TARGET_BYTE_ORDER:int:byte_order::::BFD_ENDIAN_BIG
382 i:TARGET_OSABI:enum gdb_osabi:osabi::::GDB_OSABI_UNKNOWN
383 # Number of bits in a char or unsigned char for the target machine.
384 # Just like CHAR_BIT in <limits.h> but describes the target machine.
385 # v:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
387 # Number of bits in a short or unsigned short for the target machine.
388 v:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
389 # Number of bits in an int or unsigned int for the target machine.
390 v:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
391 # Number of bits in a long or unsigned long for the target machine.
392 v:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
393 # Number of bits in a long long or unsigned long long for the target
395 v:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
396 # Number of bits in a float for the target machine.
397 v:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
398 # Number of bits in a double for the target machine.
399 v:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
400 # Number of bits in a long double for the target machine.
401 v:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):8*TARGET_CHAR_BIT::0
402 # For most targets, a pointer on the target and its representation as an
403 # address in GDB have the same size and "look the same". For such a
404 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
405 # / addr_bit will be set from it.
407 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
408 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
410 # ptr_bit is the size of a pointer on the target
411 v:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
412 # addr_bit is the size of a target address as represented in gdb
413 v:TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
414 # Number of bits in a BFD_VMA for the target object file format.
415 v:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
417 # One if \`char' acts like \`signed char', zero if \`unsigned char'.
418 v:TARGET_CHAR_SIGNED:int:char_signed::::1:-1:1::::
420 F:TARGET_READ_PC:CORE_ADDR:read_pc:ptid_t ptid:ptid
421 f:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, ptid_t ptid:val, ptid::0:generic_target_write_pc::0
422 # UNWIND_SP is a direct replacement for TARGET_READ_SP.
423 F:TARGET_READ_SP:CORE_ADDR:read_sp:void
424 # Function for getting target's idea of a frame pointer. FIXME: GDB's
425 # whole scheme for dealing with "frames" and "frame pointers" needs a
427 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
429 M::void:pseudo_register_read:struct regcache *regcache, int cookednum, void *buf:regcache, cookednum, buf
430 M::void:pseudo_register_write:struct regcache *regcache, int cookednum, const void *buf:regcache, cookednum, buf
432 v:NUM_REGS:int:num_regs::::0:-1
433 # This macro gives the number of pseudo-registers that live in the
434 # register namespace but do not get fetched or stored on the target.
435 # These pseudo-registers may be aliases for other registers,
436 # combinations of other registers, or they may be computed by GDB.
437 v:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
439 # GDB's standard (or well known) register numbers. These can map onto
440 # a real register or a pseudo (computed) register or not be defined at
442 # SP_REGNUM will hopefully be replaced by UNWIND_SP.
443 v:SP_REGNUM:int:sp_regnum::::-1:-1::0
444 v:PC_REGNUM:int:pc_regnum::::-1:-1::0
445 v:PS_REGNUM:int:ps_regnum::::-1:-1::0
446 v:FP0_REGNUM:int:fp0_regnum::::0:-1::0
447 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
448 f:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
449 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
450 f:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
451 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
452 f:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
453 # Convert from an sdb register number to an internal gdb register number.
454 f:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
455 f:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
456 f:REGISTER_NAME:const char *:register_name:int regnr:regnr
458 # REGISTER_TYPE is a direct replacement for DEPRECATED_REGISTER_VIRTUAL_TYPE.
459 M:REGISTER_TYPE:struct type *:register_type:int reg_nr:reg_nr
460 # REGISTER_TYPE is a direct replacement for DEPRECATED_REGISTER_VIRTUAL_TYPE.
461 F:DEPRECATED_REGISTER_VIRTUAL_TYPE:struct type *:deprecated_register_virtual_type:int reg_nr:reg_nr
462 # DEPRECATED_REGISTER_BYTES can be deleted. The value is computed
463 # from REGISTER_TYPE.
464 v:DEPRECATED_REGISTER_BYTES:int:deprecated_register_bytes
465 # If the value returned by DEPRECATED_REGISTER_BYTE agrees with the
466 # register offsets computed using just REGISTER_TYPE, this can be
467 # deleted. See: maint print registers. NOTE: cagney/2002-05-02: This
468 # function with predicate has a valid (callable) initial value. As a
469 # consequence, even when the predicate is false, the corresponding
470 # function works. This simplifies the migration process - old code,
471 # calling DEPRECATED_REGISTER_BYTE, doesn't need to be modified.
472 F:DEPRECATED_REGISTER_BYTE:int:deprecated_register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte
473 # If all registers have identical raw and virtual sizes and those
474 # sizes agree with the value computed from REGISTER_TYPE,
475 # DEPRECATED_REGISTER_RAW_SIZE can be deleted. See: maint print
477 F:DEPRECATED_REGISTER_RAW_SIZE:int:deprecated_register_raw_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
478 # If all registers have identical raw and virtual sizes and those
479 # sizes agree with the value computed from REGISTER_TYPE,
480 # DEPRECATED_REGISTER_VIRTUAL_SIZE can be deleted. See: maint print
482 F:DEPRECATED_REGISTER_VIRTUAL_SIZE:int:deprecated_register_virtual_size:int reg_nr:reg_nr::generic_register_size:generic_register_size
484 # See gdbint.texinfo, and PUSH_DUMMY_CALL.
485 M:UNWIND_DUMMY_ID:struct frame_id:unwind_dummy_id:struct frame_info *info:info
486 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
487 # SAVE_DUMMY_FRAME_TOS.
488 F:DEPRECATED_SAVE_DUMMY_FRAME_TOS:void:deprecated_save_dummy_frame_tos:CORE_ADDR sp:sp
489 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
490 # DEPRECATED_FP_REGNUM.
491 v:DEPRECATED_FP_REGNUM:int:deprecated_fp_regnum::::-1:-1::0
492 # Implement UNWIND_DUMMY_ID and PUSH_DUMMY_CALL, then delete
493 # DEPRECATED_TARGET_READ_FP.
494 F:DEPRECATED_TARGET_READ_FP:CORE_ADDR:deprecated_target_read_fp:void
496 # See gdbint.texinfo. See infcall.c. New, all singing all dancing,
497 # replacement for DEPRECATED_PUSH_ARGUMENTS.
498 M:PUSH_DUMMY_CALL:CORE_ADDR:push_dummy_call:struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:function, regcache, bp_addr, nargs, args, sp, struct_return, struct_addr
499 # PUSH_DUMMY_CALL is a direct replacement for DEPRECATED_PUSH_ARGUMENTS.
500 F:DEPRECATED_PUSH_ARGUMENTS:CORE_ADDR:deprecated_push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr
501 # Implement PUSH_RETURN_ADDRESS, and then merge in
502 # DEPRECATED_PUSH_RETURN_ADDRESS.
503 F:DEPRECATED_PUSH_RETURN_ADDRESS:CORE_ADDR:deprecated_push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp
504 # Implement PUSH_DUMMY_CALL, then merge in DEPRECATED_DUMMY_WRITE_SP.
505 F:DEPRECATED_DUMMY_WRITE_SP:void:deprecated_dummy_write_sp:CORE_ADDR val:val
506 # DEPRECATED_REGISTER_SIZE can be deleted.
507 v:DEPRECATED_REGISTER_SIZE:int:deprecated_register_size
508 v:CALL_DUMMY_LOCATION:int:call_dummy_location:::::AT_ENTRY_POINT::0
509 M:PUSH_DUMMY_CODE:CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr
511 F:DEPRECATED_DO_REGISTERS_INFO:void:deprecated_do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs
512 m: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
513 M:PRINT_FLOAT_INFO:void:print_float_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
514 M:PRINT_VECTOR_INFO:void:print_vector_info:struct ui_file *file, struct frame_info *frame, const char *args:file, frame, args
515 # MAP a GDB RAW register number onto a simulator register number. See
516 # also include/...-sim.h.
517 f:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::legacy_register_sim_regno::0
518 F:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes
519 f:CANNOT_FETCH_REGISTER:int:cannot_fetch_register:int regnum:regnum:::cannot_register_not::0
520 f:CANNOT_STORE_REGISTER:int:cannot_store_register:int regnum:regnum:::cannot_register_not::0
521 # setjmp/longjmp support.
522 F:GET_LONGJMP_TARGET:int:get_longjmp_target:CORE_ADDR *pc:pc
523 F:DEPRECATED_INIT_FRAME_PC:CORE_ADDR:deprecated_init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev
525 v:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
526 F:DEPRECATED_GET_SAVED_REGISTER:void:deprecated_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
528 f:CONVERT_REGISTER_P:int:convert_register_p:int regnum, struct type *type:regnum, type::0:generic_convert_register_p::0
529 f:REGISTER_TO_VALUE:void:register_to_value:struct frame_info *frame, int regnum, struct type *type, void *buf:frame, regnum, type, buf::0
530 f:VALUE_TO_REGISTER:void:value_to_register:struct frame_info *frame, int regnum, struct type *type, const void *buf:frame, regnum, type, buf::0
532 f:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, const void *buf:type, buf:::unsigned_pointer_to_address::0
533 f:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, void *buf, CORE_ADDR addr:type, buf, addr:::unsigned_address_to_pointer::0
534 F:INTEGER_TO_ADDRESS:CORE_ADDR:integer_to_address:struct type *type, void *buf:type, buf
536 F:DEPRECATED_POP_FRAME:void:deprecated_pop_frame:void:-
537 # NOTE: cagney/2003-03-24: Replaced by PUSH_ARGUMENTS.
538 F:DEPRECATED_STORE_STRUCT_RETURN:void:deprecated_store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp
540 # It has been suggested that this, well actually its predecessor,
541 # should take the type/value of the function to be called and not the
542 # return type. This is left as an exercise for the reader.
544 M::enum return_value_convention:return_value:struct type *valtype, struct regcache *regcache, void *readbuf, const void *writebuf:valtype, regcache, readbuf, writebuf
546 # The deprecated methods EXTRACT_RETURN_VALUE, STORE_RETURN_VALUE and
547 # USE_STRUCT_CONVENTION have all been folded into RETURN_VALUE.
549 f:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, struct regcache *regcache, void *valbuf:type, regcache, valbuf:::legacy_extract_return_value::0
550 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
551 f:DEPRECATED_EXTRACT_RETURN_VALUE:void:deprecated_extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf
552 f:DEPRECATED_STORE_RETURN_VALUE:void:deprecated_store_return_value:struct type *type, char *valbuf:type, valbuf
553 f:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::generic_use_struct_convention::0
555 # As of 2004-01-17 only the 32-bit SPARC ABI has been identified as an
556 # ABI suitable for the implementation of a robust extract
557 # struct-convention return-value address method (the sparc saves the
558 # address in the callers frame). All the other cases so far examined,
559 # the DEPRECATED_EXTRACT_STRUCT_VALUE implementation has been
560 # erreneous - the code was incorrectly assuming that the return-value
561 # address, stored in a register, was preserved across the entire
564 # For the moment retain DEPRECATED_EXTRACT_STRUCT_VALUE as a marker of
565 # the ABIs that are still to be analyzed - perhaps this should simply
566 # be deleted. The commented out extract_returned_value_address method
567 # is provided as a starting point for the 32-bit SPARC. It, or
568 # something like it, along with changes to both infcmd.c and stack.c
569 # will be needed for that case to work. NB: It is passed the callers
570 # frame since it is only after the callee has returned that this
573 #M::CORE_ADDR:extract_returned_value_address:struct frame_info *caller_frame:caller_frame
574 F:DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:deprecated_extract_struct_value_address:struct regcache *regcache:regcache
576 F:DEPRECATED_FRAME_INIT_SAVED_REGS:void:deprecated_frame_init_saved_regs:struct frame_info *frame:frame
577 F:DEPRECATED_INIT_EXTRA_FRAME_INFO:void:deprecated_init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame
579 f:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
580 f:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
581 f:BREAKPOINT_FROM_PC:const unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::0:
582 M:ADJUST_BREAKPOINT_ADDRESS:CORE_ADDR:adjust_breakpoint_address:CORE_ADDR bpaddr:bpaddr
583 f:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
584 f:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
585 v:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:::0
586 v:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:::0
588 m:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:struct regcache *regcache, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:regcache, gdb_addr, gdb_len, rem_addr, rem_len:::generic_remote_translate_xfer_address::0
590 v:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:::0
591 # DEPRECATED_FRAMELESS_FUNCTION_INVOCATION is not needed. The new
592 # frame code works regardless of the type of frame - frameless,
593 # stackless, or normal.
594 F:DEPRECATED_FRAMELESS_FUNCTION_INVOCATION:int:deprecated_frameless_function_invocation:struct frame_info *fi:fi
595 F:DEPRECATED_FRAME_CHAIN:CORE_ADDR:deprecated_frame_chain:struct frame_info *frame:frame
596 F:DEPRECATED_FRAME_CHAIN_VALID:int:deprecated_frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe
597 # DEPRECATED_FRAME_SAVED_PC has been replaced by UNWIND_PC. Please
598 # note, per UNWIND_PC's doco, that while the two have similar
599 # interfaces they have very different underlying implementations.
600 F:DEPRECATED_FRAME_SAVED_PC:CORE_ADDR:deprecated_frame_saved_pc:struct frame_info *fi:fi
601 M:UNWIND_PC:CORE_ADDR:unwind_pc:struct frame_info *next_frame:next_frame
602 M:UNWIND_SP:CORE_ADDR:unwind_sp:struct frame_info *next_frame:next_frame
603 # DEPRECATED_FRAME_ARGS_ADDRESS as been replaced by the per-frame
604 # frame-base. Enable frame-base before frame-unwind.
605 F:DEPRECATED_FRAME_ARGS_ADDRESS:CORE_ADDR:deprecated_frame_args_address:struct frame_info *fi:fi::get_frame_base:get_frame_base
606 # DEPRECATED_FRAME_LOCALS_ADDRESS as been replaced by the per-frame
607 # frame-base. Enable frame-base before frame-unwind.
608 F:DEPRECATED_FRAME_LOCALS_ADDRESS:CORE_ADDR:deprecated_frame_locals_address:struct frame_info *fi:fi::get_frame_base:get_frame_base
609 F:DEPRECATED_SAVED_PC_AFTER_CALL:CORE_ADDR:deprecated_saved_pc_after_call:struct frame_info *frame:frame
610 F:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame
612 # DEPRECATED_STACK_ALIGN has been replaced by an initial aligning call
613 # to frame_align and the requirement that methods such as
614 # push_dummy_call and frame_red_zone_size maintain correct stack/frame
616 F:DEPRECATED_STACK_ALIGN:CORE_ADDR:deprecated_stack_align:CORE_ADDR sp:sp
617 M::CORE_ADDR:frame_align:CORE_ADDR address:address
618 # DEPRECATED_REG_STRUCT_HAS_ADDR has been replaced by
619 # stabs_argument_has_addr.
620 F:DEPRECATED_REG_STRUCT_HAS_ADDR:int:deprecated_reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type
621 m::int:stabs_argument_has_addr:struct type *type:type:::default_stabs_argument_has_addr::0
622 v:FRAME_RED_ZONE_SIZE:int:frame_red_zone_size
624 v:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (current_gdbarch)::%s:(TARGET_FLOAT_FORMAT)->name
625 v:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (current_gdbarch)::%s:(TARGET_DOUBLE_FORMAT)->name
626 v:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::default_double_format (current_gdbarch)::%s:(TARGET_LONG_DOUBLE_FORMAT)->name
627 m::CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr, struct target_ops *targ:addr, targ:::convert_from_func_ptr_addr_identity::0
628 # On some machines there are bits in addresses which are not really
629 # part of the address, but are used by the kernel, the hardware, etc.
630 # for special purposes. ADDR_BITS_REMOVE takes out any such bits so
631 # we get a "real" address such as one would find in a symbol table.
632 # This is used only for addresses of instructions, and even then I'm
633 # not sure it's used in all contexts. It exists to deal with there
634 # being a few stray bits in the PC which would mislead us, not as some
635 # sort of generic thing to handle alignment or segmentation (it's
636 # possible it should be in TARGET_READ_PC instead).
637 f:ADDR_BITS_REMOVE:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr:::core_addr_identity::0
638 # It is not at all clear why SMASH_TEXT_ADDRESS is not folded into
640 f:SMASH_TEXT_ADDRESS:CORE_ADDR:smash_text_address:CORE_ADDR addr:addr:::core_addr_identity::0
641 # FIXME/cagney/2001-01-18: This should be split in two. A target method that indicates if
642 # the target needs software single step. An ISA method to implement it.
644 # FIXME/cagney/2001-01-18: This should be replaced with something that inserts breakpoints
645 # using the breakpoint system instead of blatting memory directly (as with rs6000).
647 # FIXME/cagney/2001-01-18: The logic is backwards. It should be asking if the target can
648 # single step. If not, then implement single step using breakpoints.
649 F:SOFTWARE_SINGLE_STEP:void:software_single_step:enum target_signal sig, int insert_breakpoints_p:sig, insert_breakpoints_p
650 # FIXME: cagney/2003-08-28: Need to find a better way of selecting the
651 # disassembler. Perhaphs objdump can handle it?
652 f:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info:::0:
653 f:SKIP_TRAMPOLINE_CODE:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc:::generic_skip_trampoline_code::0
656 # If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER
657 # evaluates non-zero, this is the address where the debugger will place
658 # a step-resume breakpoint to get us past the dynamic linker.
659 m:SKIP_SOLIB_RESOLVER:CORE_ADDR:skip_solib_resolver:CORE_ADDR pc:pc:::generic_skip_solib_resolver::0
660 # For SVR4 shared libraries, each call goes through a small piece of
661 # trampoline code in the ".plt" section. IN_SOLIB_CALL_TRAMPOLINE evaluates
662 # to nonzero if we are currently stopped in one of these.
663 f:IN_SOLIB_CALL_TRAMPOLINE:int:in_solib_call_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_call_trampoline::0
665 # Some systems also have trampoline code for returning from shared libs.
666 f:IN_SOLIB_RETURN_TRAMPOLINE:int:in_solib_return_trampoline:CORE_ADDR pc, char *name:pc, name:::generic_in_solib_return_trampoline::0
668 # A target might have problems with watchpoints as soon as the stack
669 # frame of the current function has been destroyed. This mostly happens
670 # as the first action in a funtion's epilogue. in_function_epilogue_p()
671 # is defined to return a non-zero value if either the given addr is one
672 # instruction after the stack destroying instruction up to the trailing
673 # return instruction or if we can figure out that the stack frame has
674 # already been invalidated regardless of the value of addr. Targets
675 # which don't suffer from that problem could just let this functionality
677 m::int:in_function_epilogue_p:CORE_ADDR addr:addr::0:generic_in_function_epilogue_p::0
678 # Given a vector of command-line arguments, return a newly allocated
679 # string which, when passed to the create_inferior function, will be
680 # parsed (on Unix systems, by the shell) to yield the same vector.
681 # This function should call error() if the argument vector is not
682 # representable for this target or if this target does not support
683 # command-line arguments.
684 # ARGC is the number of elements in the vector.
685 # ARGV is an array of strings, one per argument.
686 m:CONSTRUCT_INFERIOR_ARGUMENTS:char *:construct_inferior_arguments:int argc, char **argv:argc, argv:::construct_inferior_arguments::0
687 f:ELF_MAKE_MSYMBOL_SPECIAL:void:elf_make_msymbol_special:asymbol *sym, struct minimal_symbol *msym:sym, msym:::default_elf_make_msymbol_special::0
688 f:COFF_MAKE_MSYMBOL_SPECIAL:void:coff_make_msymbol_special:int val, struct minimal_symbol *msym:val, msym:::default_coff_make_msymbol_special::0
689 v:NAME_OF_MALLOC:const char *:name_of_malloc::::"malloc":"malloc"::0:%s:NAME_OF_MALLOC
690 v:CANNOT_STEP_BREAKPOINT:int:cannot_step_breakpoint::::0:0::0
691 v:HAVE_NONSTEPPABLE_WATCHPOINT:int:have_nonsteppable_watchpoint::::0:0::0
692 F:ADDRESS_CLASS_TYPE_FLAGS:int:address_class_type_flags:int byte_size, int dwarf2_addr_class:byte_size, dwarf2_addr_class
693 M:ADDRESS_CLASS_TYPE_FLAGS_TO_NAME:const char *:address_class_type_flags_to_name:int type_flags:type_flags
694 M:ADDRESS_CLASS_NAME_TO_TYPE_FLAGS:int:address_class_name_to_type_flags:const char *name, int *type_flags_ptr:name, type_flags_ptr
695 # Is a register in a group
696 m::int:register_reggroup_p:int regnum, struct reggroup *reggroup:regnum, reggroup:::default_register_reggroup_p::0
697 # Fetch the pointer to the ith function argument.
698 F:FETCH_POINTER_ARGUMENT:CORE_ADDR:fetch_pointer_argument:struct frame_info *frame, int argi, struct type *type:frame, argi, type
700 # Return the appropriate register set for a core file section with
701 # name SECT_NAME and size SECT_SIZE.
702 M::const struct regset *:regset_from_core_section:const char *sect_name, size_t sect_size:sect_name, sect_size
709 exec > new-gdbarch.log
710 function_list |
while do_read
713 ${class} ${macro}(${actual})
714 ${returntype} ${function} ($formal)${attrib}
718 eval echo \"\ \ \ \
${r}=\
${${r}}\"
720 if class_is_predicate_p
&& fallback_default_p
722 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
726 if [ "x${invalid_p}" = "x0" -a -n "${postdefault}" ]
728 echo "Error: postdefault is useless when invalid_p=0" 1>&2
732 if class_is_multiarch_p
734 if class_is_predicate_p
; then :
735 elif test "x${predefault}" = "x"
737 echo "Error: pure multi-arch function must have a predefault" 1>&2
746 compare_new gdbarch.log
752 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
754 /* Dynamic architecture support for GDB, the GNU debugger.
756 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
757 Software Foundation, Inc.
759 This file is part of GDB.
761 This program is free software; you can redistribute it and/or modify
762 it under the terms of the GNU General Public License as published by
763 the Free Software Foundation; either version 2 of the License, or
764 (at your option) any later version.
766 This program is distributed in the hope that it will be useful,
767 but WITHOUT ANY WARRANTY; without even the implied warranty of
768 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
769 GNU General Public License for more details.
771 You should have received a copy of the GNU General Public License
772 along with this program; if not, write to the Free Software
773 Foundation, Inc., 59 Temple Place - Suite 330,
774 Boston, MA 02111-1307, USA. */
776 /* This file was created with the aid of \`\`gdbarch.sh''.
778 The Bourne shell script \`\`gdbarch.sh'' creates the files
779 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
780 against the existing \`\`gdbarch.[hc]''. Any differences found
783 If editing this file, please also run gdbarch.sh and merge any
784 changes into that script. Conversely, when making sweeping changes
785 to this file, modifying gdbarch.sh and using its output may prove
806 struct minimal_symbol;
810 struct disassemble_info;
814 extern struct gdbarch *current_gdbarch;
816 /* If any of the following are defined, the target wasn't correctly
819 #if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PURE) && defined (GDB_TM_FILE)
820 #error "GDB_TM_FILE: Pure multi-arch targets do not have a tm.h file."
827 printf "/* The following are pre-initialized by GDBARCH. */\n"
828 function_list |
while do_read
833 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
834 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
835 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
836 printf "#error \"Non multi-arch definition of ${macro}\"\n"
838 printf "#if !defined (${macro})\n"
839 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
847 printf "/* The following are initialized by the target dependent code. */\n"
848 function_list |
while do_read
850 if [ -n "${comment}" ]
852 echo "${comment}" |
sed \
857 if class_is_multiarch_p
859 if class_is_predicate_p
862 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
865 if class_is_predicate_p
868 printf "#if defined (${macro})\n"
869 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
870 #printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
871 printf "#if !defined (${macro}_P)\n"
872 printf "#define ${macro}_P() (1)\n"
876 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
877 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro}_P)\n"
878 printf "#error \"Non multi-arch definition of ${macro}\"\n"
880 printf "#if !defined (${macro}_P)\n"
881 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
885 if class_is_variable_p
888 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
889 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
890 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
891 printf "#error \"Non multi-arch definition of ${macro}\"\n"
893 printf "#if !defined (${macro})\n"
894 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
897 if class_is_function_p
900 if [ "x${formal}" = "xvoid" ] && class_is_multiarch_p
902 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch);\n"
903 elif class_is_multiarch_p
905 printf "typedef ${returntype} (gdbarch_${function}_ftype) (struct gdbarch *gdbarch, ${formal});\n"
907 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
909 if [ "x${formal}" = "xvoid" ]
911 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
913 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
915 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
916 if class_is_multiarch_p
; then :
918 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
919 printf "#error \"Non multi-arch definition of ${macro}\"\n"
921 if [ "x${actual}" = "x" ]
923 d
="#define ${macro}() (gdbarch_${function} (current_gdbarch))"
924 elif [ "x${actual}" = "x-" ]
926 d
="#define ${macro} (gdbarch_${function} (current_gdbarch))"
928 d
="#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
930 printf "#if !defined (${macro})\n"
931 if [ "x${actual}" = "x" ]
933 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
934 elif [ "x${actual}" = "x-" ]
936 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
938 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
948 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
951 /* Mechanism for co-ordinating the selection of a specific
954 GDB targets (*-tdep.c) can register an interest in a specific
955 architecture. Other GDB components can register a need to maintain
956 per-architecture data.
958 The mechanisms below ensures that there is only a loose connection
959 between the set-architecture command and the various GDB
960 components. Each component can independently register their need
961 to maintain architecture specific data with gdbarch.
965 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
968 The more traditional mega-struct containing architecture specific
969 data for all the various GDB components was also considered. Since
970 GDB is built from a variable number of (fairly independent)
971 components it was determined that the global aproach was not
975 /* Register a new architectural family with GDB.
977 Register support for the specified ARCHITECTURE with GDB. When
978 gdbarch determines that the specified architecture has been
979 selected, the corresponding INIT function is called.
983 The INIT function takes two parameters: INFO which contains the
984 information available to gdbarch about the (possibly new)
985 architecture; ARCHES which is a list of the previously created
986 \`\`struct gdbarch'' for this architecture.
988 The INFO parameter is, as far as possible, be pre-initialized with
989 information obtained from INFO.ABFD or the previously selected
992 The ARCHES parameter is a linked list (sorted most recently used)
993 of all the previously created architures for this architecture
994 family. The (possibly NULL) ARCHES->gdbarch can used to access
995 values from the previously selected architecture for this
996 architecture family. The global \`\`current_gdbarch'' shall not be
999 The INIT function shall return any of: NULL - indicating that it
1000 doesn't recognize the selected architecture; an existing \`\`struct
1001 gdbarch'' from the ARCHES list - indicating that the new
1002 architecture is just a synonym for an earlier architecture (see
1003 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
1004 - that describes the selected architecture (see gdbarch_alloc()).
1006 The DUMP_TDEP function shall print out all target specific values.
1007 Care should be taken to ensure that the function works in both the
1008 multi-arch and non- multi-arch cases. */
1012 struct gdbarch *gdbarch;
1013 struct gdbarch_list *next;
1018 /* Use default: NULL (ZERO). */
1019 const struct bfd_arch_info *bfd_arch_info;
1021 /* Use default: BFD_ENDIAN_UNKNOWN (NB: is not ZERO). */
1024 /* Use default: NULL (ZERO). */
1027 /* Use default: NULL (ZERO). */
1028 struct gdbarch_tdep_info *tdep_info;
1030 /* Use default: GDB_OSABI_UNINITIALIZED (-1). */
1031 enum gdb_osabi osabi;
1034 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
1035 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
1037 /* DEPRECATED - use gdbarch_register() */
1038 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
1040 extern void gdbarch_register (enum bfd_architecture architecture,
1041 gdbarch_init_ftype *,
1042 gdbarch_dump_tdep_ftype *);
1045 /* Return a freshly allocated, NULL terminated, array of the valid
1046 architecture names. Since architectures are registered during the
1047 _initialize phase this function only returns useful information
1048 once initialization has been completed. */
1050 extern const char **gdbarch_printable_names (void);
1053 /* Helper function. Search the list of ARCHES for a GDBARCH that
1054 matches the information provided by INFO. */
1056 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
1059 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
1060 basic initialization using values obtained from the INFO andTDEP
1061 parameters. set_gdbarch_*() functions are called to complete the
1062 initialization of the object. */
1064 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
1067 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
1068 It is assumed that the caller freeds the \`\`struct
1071 extern void gdbarch_free (struct gdbarch *);
1074 /* Helper function. Allocate memory from the \`\`struct gdbarch''
1075 obstack. The memory is freed when the corresponding architecture
1078 extern void *gdbarch_obstack_zalloc (struct gdbarch *gdbarch, long size);
1079 #define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), (NR) * sizeof (TYPE)))
1080 #define GDBARCH_OBSTACK_ZALLOC(GDBARCH, TYPE) ((TYPE *) gdbarch_obstack_zalloc ((GDBARCH), sizeof (TYPE)))
1083 /* Helper function. Force an update of the current architecture.
1085 The actual architecture selected is determined by INFO, \`\`(gdb) set
1086 architecture'' et.al., the existing architecture and BFD's default
1087 architecture. INFO should be initialized to zero and then selected
1088 fields should be updated.
1090 Returns non-zero if the update succeeds */
1092 extern int gdbarch_update_p (struct gdbarch_info info);
1095 /* Helper function. Find an architecture matching info.
1097 INFO should be initialized using gdbarch_info_init, relevant fields
1098 set, and then finished using gdbarch_info_fill.
1100 Returns the corresponding architecture, or NULL if no matching
1101 architecture was found. "current_gdbarch" is not updated. */
1103 extern struct gdbarch *gdbarch_find_by_info (struct gdbarch_info info);
1106 /* Helper function. Set the global "current_gdbarch" to "gdbarch".
1108 FIXME: kettenis/20031124: Of the functions that follow, only
1109 gdbarch_from_bfd is supposed to survive. The others will
1110 dissappear since in the future GDB will (hopefully) be truly
1111 multi-arch. However, for now we're still stuck with the concept of
1112 a single active architecture. */
1114 extern void deprecated_current_gdbarch_select_hack (struct gdbarch *gdbarch);
1117 /* Register per-architecture data-pointer.
1119 Reserve space for a per-architecture data-pointer. An identifier
1120 for the reserved data-pointer is returned. That identifer should
1121 be saved in a local static variable.
1123 Memory for the per-architecture data shall be allocated using
1124 gdbarch_obstack_zalloc. That memory will be deleted when the
1125 corresponding architecture object is deleted.
1127 When a previously created architecture is re-selected, the
1128 per-architecture data-pointer for that previous architecture is
1129 restored. INIT() is not re-called.
1131 Multiple registrarants for any architecture are allowed (and
1132 strongly encouraged). */
1134 struct gdbarch_data;
1136 typedef void *(gdbarch_data_pre_init_ftype) (struct obstack *obstack);
1137 extern struct gdbarch_data *gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *init);
1138 typedef void *(gdbarch_data_post_init_ftype) (struct gdbarch *gdbarch);
1139 extern struct gdbarch_data *gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *init);
1140 extern void deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1141 struct gdbarch_data *data,
1144 extern void *gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *);
1148 /* Register per-architecture memory region.
1150 Provide a memory-region swap mechanism. Per-architecture memory
1151 region are created. These memory regions are swapped whenever the
1152 architecture is changed. For a new architecture, the memory region
1153 is initialized with zero (0) and the INIT function is called.
1155 Memory regions are swapped / initialized in the order that they are
1156 registered. NULL DATA and/or INIT values can be specified.
1158 New code should use gdbarch_data_register_*(). */
1160 typedef void (gdbarch_swap_ftype) (void);
1161 extern void deprecated_register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
1162 #define DEPRECATED_REGISTER_GDBARCH_SWAP(VAR) deprecated_register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
1166 /* Set the dynamic target-system-dependent parameters (architecture,
1167 byte-order, ...) using information found in the BFD */
1169 extern void set_gdbarch_from_file (bfd *);
1172 /* Initialize the current architecture to the "first" one we find on
1175 extern void initialize_current_architecture (void);
1177 /* gdbarch trace variable */
1178 extern int gdbarch_debug;
1180 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1185 #../move-if-change new-gdbarch.h gdbarch.h
1186 compare_new gdbarch.h
1193 exec > new-gdbarch.c
1198 #include "arch-utils.h"
1201 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1204 #include "floatformat.h"
1206 #include "gdb_assert.h"
1207 #include "gdb_string.h"
1208 #include "gdb-events.h"
1209 #include "reggroups.h"
1211 #include "gdb_obstack.h"
1213 /* Static function declarations */
1215 static void alloc_gdbarch_data (struct gdbarch *);
1217 /* Non-zero if we want to trace architecture code. */
1219 #ifndef GDBARCH_DEBUG
1220 #define GDBARCH_DEBUG 0
1222 int gdbarch_debug = GDBARCH_DEBUG;
1226 # gdbarch open the gdbarch object
1228 printf "/* Maintain the struct gdbarch object */\n"
1230 printf "struct gdbarch\n"
1232 printf " /* Has this architecture been fully initialized? */\n"
1233 printf " int initialized_p;\n"
1235 printf " /* An obstack bound to the lifetime of the architecture. */\n"
1236 printf " struct obstack *obstack;\n"
1238 printf " /* basic architectural information */\n"
1239 function_list |
while do_read
1243 printf " ${returntype} ${function};\n"
1247 printf " /* target specific vector. */\n"
1248 printf " struct gdbarch_tdep *tdep;\n"
1249 printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1251 printf " /* per-architecture data-pointers */\n"
1252 printf " unsigned nr_data;\n"
1253 printf " void **data;\n"
1255 printf " /* per-architecture swap-regions */\n"
1256 printf " struct gdbarch_swap *swap;\n"
1259 /* Multi-arch values.
1261 When extending this structure you must:
1263 Add the field below.
1265 Declare set/get functions and define the corresponding
1268 gdbarch_alloc(): If zero/NULL is not a suitable default,
1269 initialize the new field.
1271 verify_gdbarch(): Confirm that the target updated the field
1274 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1277 \`\`startup_gdbarch()'': Append an initial value to the static
1278 variable (base values on the host's c-type system).
1280 get_gdbarch(): Implement the set/get functions (probably using
1281 the macro's as shortcuts).
1286 function_list |
while do_read
1288 if class_is_variable_p
1290 printf " ${returntype} ${function};\n"
1291 elif class_is_function_p
1293 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
1298 # A pre-initialized vector
1302 /* The default architecture uses host values (for want of a better
1306 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1308 printf "struct gdbarch startup_gdbarch =\n"
1310 printf " 1, /* Always initialized. */\n"
1311 printf " NULL, /* The obstack. */\n"
1312 printf " /* basic architecture information */\n"
1313 function_list |
while do_read
1317 printf " ${staticdefault}, /* ${function} */\n"
1321 /* target specific vector and its dump routine */
1323 /*per-architecture data-pointers and swap regions */
1325 /* Multi-arch values */
1327 function_list |
while do_read
1329 if class_is_function_p || class_is_variable_p
1331 printf " ${staticdefault}, /* ${function} */\n"
1335 /* startup_gdbarch() */
1338 struct gdbarch *current_gdbarch = &startup_gdbarch;
1341 # Create a new gdbarch struct
1344 /* Create a new \`\`struct gdbarch'' based on information provided by
1345 \`\`struct gdbarch_info''. */
1350 gdbarch_alloc (const struct gdbarch_info *info,
1351 struct gdbarch_tdep *tdep)
1353 /* NOTE: The new architecture variable is named \`\`current_gdbarch''
1354 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
1355 the current local architecture and not the previous global
1356 architecture. This ensures that the new architectures initial
1357 values are not influenced by the previous architecture. Once
1358 everything is parameterised with gdbarch, this will go away. */
1359 struct gdbarch *current_gdbarch;
1361 /* Create an obstack for allocating all the per-architecture memory,
1362 then use that to allocate the architecture vector. */
1363 struct obstack *obstack = XMALLOC (struct obstack);
1364 obstack_init (obstack);
1365 current_gdbarch = obstack_alloc (obstack, sizeof (*current_gdbarch));
1366 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
1367 current_gdbarch->obstack = obstack;
1369 alloc_gdbarch_data (current_gdbarch);
1371 current_gdbarch->tdep = tdep;
1374 function_list |
while do_read
1378 printf " current_gdbarch->${function} = info->${function};\n"
1382 printf " /* Force the explicit initialization of these. */\n"
1383 function_list |
while do_read
1385 if class_is_function_p || class_is_variable_p
1387 if [ -n "${predefault}" -a "x${predefault}" != "x0" ]
1389 printf " current_gdbarch->${function} = ${predefault};\n"
1394 /* gdbarch_alloc() */
1396 return current_gdbarch;
1400 # Free a gdbarch struct.
1404 /* Allocate extra space using the per-architecture obstack. */
1407 gdbarch_obstack_zalloc (struct gdbarch *arch, long size)
1409 void *data = obstack_alloc (arch->obstack, size);
1410 memset (data, 0, size);
1415 /* Free a gdbarch struct. This should never happen in normal
1416 operation --- once you've created a gdbarch, you keep it around.
1417 However, if an architecture's init function encounters an error
1418 building the structure, it may need to clean up a partially
1419 constructed gdbarch. */
1422 gdbarch_free (struct gdbarch *arch)
1424 struct obstack *obstack;
1425 gdb_assert (arch != NULL);
1426 gdb_assert (!arch->initialized_p);
1427 obstack = arch->obstack;
1428 obstack_free (obstack, 0); /* Includes the ARCH. */
1433 # verify a new architecture
1437 /* Ensure that all values in a GDBARCH are reasonable. */
1439 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1440 just happens to match the global variable \`\`current_gdbarch''. That
1441 way macros refering to that variable get the local and not the global
1442 version - ulgh. Once everything is parameterised with gdbarch, this
1446 verify_gdbarch (struct gdbarch *current_gdbarch)
1448 struct ui_file *log;
1449 struct cleanup *cleanups;
1452 log = mem_fileopen ();
1453 cleanups = make_cleanup_ui_file_delete (log);
1455 if (current_gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
1456 fprintf_unfiltered (log, "\n\tbyte-order");
1457 if (current_gdbarch->bfd_arch_info == NULL)
1458 fprintf_unfiltered (log, "\n\tbfd_arch_info");
1459 /* Check those that need to be defined for the given multi-arch level. */
1461 function_list |
while do_read
1463 if class_is_function_p || class_is_variable_p
1465 if [ "x${invalid_p}" = "x0" ]
1467 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1468 elif class_is_predicate_p
1470 printf " /* Skip verify of ${function}, has predicate */\n"
1471 # FIXME: See do_read for potential simplification
1472 elif [ -n "${invalid_p}" -a -n "${postdefault}" ]
1474 printf " if (${invalid_p})\n"
1475 printf " current_gdbarch->${function} = ${postdefault};\n"
1476 elif [ -n "${predefault}" -a -n "${postdefault}" ]
1478 printf " if (current_gdbarch->${function} == ${predefault})\n"
1479 printf " current_gdbarch->${function} = ${postdefault};\n"
1480 elif [ -n "${postdefault}" ]
1482 printf " if (current_gdbarch->${function} == 0)\n"
1483 printf " current_gdbarch->${function} = ${postdefault};\n"
1484 elif [ -n "${invalid_p}" ]
1486 printf " if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)\n"
1487 printf " && (${invalid_p}))\n"
1488 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1489 elif [ -n "${predefault}" ]
1491 printf " if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)\n"
1492 printf " && (current_gdbarch->${function} == ${predefault}))\n"
1493 printf " fprintf_unfiltered (log, \"\\\\n\\\\t${function}\");\n"
1498 buf = ui_file_xstrdup (log, &dummy);
1499 make_cleanup (xfree, buf);
1500 if (strlen (buf) > 0)
1501 internal_error (__FILE__, __LINE__,
1502 "verify_gdbarch: the following are invalid ...%s",
1504 do_cleanups (cleanups);
1508 # dump the structure
1512 /* Print out the details of the current architecture. */
1514 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1515 just happens to match the global variable \`\`current_gdbarch''. That
1516 way macros refering to that variable get the local and not the global
1517 version - ulgh. Once everything is parameterised with gdbarch, this
1521 gdbarch_dump (struct gdbarch *current_gdbarch, struct ui_file *file)
1523 fprintf_unfiltered (file,
1524 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1527 function_list |
sort -t: -k 2 |
while do_read
1529 # First the predicate
1530 if class_is_predicate_p
1532 if class_is_multiarch_p
1534 printf " fprintf_unfiltered (file,\n"
1535 printf " \"gdbarch_dump: gdbarch_${function}_p() = %%d\\\\n\",\n"
1536 printf " gdbarch_${function}_p (current_gdbarch));\n"
1538 printf "#ifdef ${macro}_P\n"
1539 printf " fprintf_unfiltered (file,\n"
1540 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1541 printf " \"${macro}_P()\",\n"
1542 printf " XSTRING (${macro}_P ()));\n"
1543 printf " fprintf_unfiltered (file,\n"
1544 printf " \"gdbarch_dump: ${macro}_P() = %%d\\\\n\",\n"
1545 printf " ${macro}_P ());\n"
1549 # multiarch functions don't have macros.
1550 if class_is_multiarch_p
1552 printf " fprintf_unfiltered (file,\n"
1553 printf " \"gdbarch_dump: ${function} = 0x%%08lx\\\\n\",\n"
1554 printf " (long) current_gdbarch->${function});\n"
1557 # Print the macro definition.
1558 printf "#ifdef ${macro}\n"
1559 if class_is_function_p
1561 printf " fprintf_unfiltered (file,\n"
1562 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1563 printf " \"${macro}(${actual})\",\n"
1564 printf " XSTRING (${macro} (${actual})));\n"
1566 printf " fprintf_unfiltered (file,\n"
1567 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1568 printf " XSTRING (${macro}));\n"
1570 if [ "x${print_p}" = "x()" ]
1572 printf " gdbarch_dump_${function} (current_gdbarch);\n"
1573 elif [ "x${print_p}" = "x0" ]
1575 printf " /* skip print of ${macro}, print_p == 0. */\n"
1576 elif [ -n "${print_p}" ]
1578 printf " if (${print_p})\n"
1579 printf " fprintf_unfiltered (file,\n"
1580 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1581 printf " ${print});\n"
1582 elif class_is_function_p
1584 printf " fprintf_unfiltered (file,\n"
1585 printf " \"gdbarch_dump: ${macro} = <0x%%08lx>\\\\n\",\n"
1586 printf " (long) current_gdbarch->${function}\n"
1587 printf " /*${macro} ()*/);\n"
1589 printf " fprintf_unfiltered (file,\n"
1590 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1591 printf " ${print});\n"
1596 if (current_gdbarch->dump_tdep != NULL)
1597 current_gdbarch->dump_tdep (current_gdbarch, file);
1605 struct gdbarch_tdep *
1606 gdbarch_tdep (struct gdbarch *gdbarch)
1608 if (gdbarch_debug >= 2)
1609 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1610 return gdbarch->tdep;
1614 function_list |
while do_read
1616 if class_is_predicate_p
1620 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1622 printf " gdb_assert (gdbarch != NULL);\n"
1623 printf " return ${predicate};\n"
1626 if class_is_function_p
1629 printf "${returntype}\n"
1630 if [ "x${formal}" = "xvoid" ]
1632 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1634 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1637 printf " gdb_assert (gdbarch != NULL);\n"
1638 printf " gdb_assert (gdbarch->${function} != NULL);\n"
1639 if class_is_predicate_p
&& test -n "${predefault}"
1641 # Allow a call to a function with a predicate.
1642 printf " /* Do not check predicate: ${predicate}, allow call. */\n"
1644 printf " if (gdbarch_debug >= 2)\n"
1645 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1646 if [ "x${actual}" = "x-" -o "x${actual}" = "x" ]
1648 if class_is_multiarch_p
1655 if class_is_multiarch_p
1657 params
="gdbarch, ${actual}"
1662 if [ "x${returntype}" = "xvoid" ]
1664 printf " gdbarch->${function} (${params});\n"
1666 printf " return gdbarch->${function} (${params});\n"
1671 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1672 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1674 printf " gdbarch->${function} = ${function};\n"
1676 elif class_is_variable_p
1679 printf "${returntype}\n"
1680 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1682 printf " gdb_assert (gdbarch != NULL);\n"
1683 if [ "x${invalid_p}" = "x0" ]
1685 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1686 elif [ -n "${invalid_p}" ]
1688 printf " /* Check variable is valid. */\n"
1689 printf " gdb_assert (!(${invalid_p}));\n"
1690 elif [ -n "${predefault}" ]
1692 printf " /* Check variable changed from pre-default. */\n"
1693 printf " gdb_assert (gdbarch->${function} != ${predefault});\n"
1695 printf " if (gdbarch_debug >= 2)\n"
1696 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1697 printf " return gdbarch->${function};\n"
1701 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1702 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1704 printf " gdbarch->${function} = ${function};\n"
1706 elif class_is_info_p
1709 printf "${returntype}\n"
1710 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1712 printf " gdb_assert (gdbarch != NULL);\n"
1713 printf " if (gdbarch_debug >= 2)\n"
1714 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1715 printf " return gdbarch->${function};\n"
1720 # All the trailing guff
1724 /* Keep a registry of per-architecture data-pointers required by GDB
1731 gdbarch_data_pre_init_ftype *pre_init;
1732 gdbarch_data_post_init_ftype *post_init;
1735 struct gdbarch_data_registration
1737 struct gdbarch_data *data;
1738 struct gdbarch_data_registration *next;
1741 struct gdbarch_data_registry
1744 struct gdbarch_data_registration *registrations;
1747 struct gdbarch_data_registry gdbarch_data_registry =
1752 static struct gdbarch_data *
1753 gdbarch_data_register (gdbarch_data_pre_init_ftype *pre_init,
1754 gdbarch_data_post_init_ftype *post_init)
1756 struct gdbarch_data_registration **curr;
1757 /* Append the new registraration. */
1758 for (curr = &gdbarch_data_registry.registrations;
1760 curr = &(*curr)->next);
1761 (*curr) = XMALLOC (struct gdbarch_data_registration);
1762 (*curr)->next = NULL;
1763 (*curr)->data = XMALLOC (struct gdbarch_data);
1764 (*curr)->data->index = gdbarch_data_registry.nr++;
1765 (*curr)->data->pre_init = pre_init;
1766 (*curr)->data->post_init = post_init;
1767 (*curr)->data->init_p = 1;
1768 return (*curr)->data;
1771 struct gdbarch_data *
1772 gdbarch_data_register_pre_init (gdbarch_data_pre_init_ftype *pre_init)
1774 return gdbarch_data_register (pre_init, NULL);
1777 struct gdbarch_data *
1778 gdbarch_data_register_post_init (gdbarch_data_post_init_ftype *post_init)
1780 return gdbarch_data_register (NULL, post_init);
1783 /* Create/delete the gdbarch data vector. */
1786 alloc_gdbarch_data (struct gdbarch *gdbarch)
1788 gdb_assert (gdbarch->data == NULL);
1789 gdbarch->nr_data = gdbarch_data_registry.nr;
1790 gdbarch->data = GDBARCH_OBSTACK_CALLOC (gdbarch, gdbarch->nr_data, void *);
1793 /* Initialize the current value of the specified per-architecture
1797 deprecated_set_gdbarch_data (struct gdbarch *gdbarch,
1798 struct gdbarch_data *data,
1801 gdb_assert (data->index < gdbarch->nr_data);
1802 gdb_assert (gdbarch->data[data->index] == NULL);
1803 gdb_assert (data->pre_init == NULL);
1804 gdbarch->data[data->index] = pointer;
1807 /* Return the current value of the specified per-architecture
1811 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
1813 gdb_assert (data->index < gdbarch->nr_data);
1814 if (gdbarch->data[data->index] == NULL)
1816 /* The data-pointer isn't initialized, call init() to get a
1818 if (data->pre_init != NULL)
1819 /* Mid architecture creation: pass just the obstack, and not
1820 the entire architecture, as that way it isn't possible for
1821 pre-init code to refer to undefined architecture
1823 gdbarch->data[data->index] = data->pre_init (gdbarch->obstack);
1824 else if (gdbarch->initialized_p
1825 && data->post_init != NULL)
1826 /* Post architecture creation: pass the entire architecture
1827 (as all fields are valid), but be careful to also detect
1828 recursive references. */
1830 gdb_assert (data->init_p);
1832 gdbarch->data[data->index] = data->post_init (gdbarch);
1836 /* The architecture initialization hasn't completed - punt -
1837 hope that the caller knows what they are doing. Once
1838 deprecated_set_gdbarch_data has been initialized, this can be
1839 changed to an internal error. */
1841 gdb_assert (gdbarch->data[data->index] != NULL);
1843 return gdbarch->data[data->index];
1848 /* Keep a registry of swapped data required by GDB modules. */
1853 struct gdbarch_swap_registration *source;
1854 struct gdbarch_swap *next;
1857 struct gdbarch_swap_registration
1860 unsigned long sizeof_data;
1861 gdbarch_swap_ftype *init;
1862 struct gdbarch_swap_registration *next;
1865 struct gdbarch_swap_registry
1868 struct gdbarch_swap_registration *registrations;
1871 struct gdbarch_swap_registry gdbarch_swap_registry =
1877 deprecated_register_gdbarch_swap (void *data,
1878 unsigned long sizeof_data,
1879 gdbarch_swap_ftype *init)
1881 struct gdbarch_swap_registration **rego;
1882 for (rego = &gdbarch_swap_registry.registrations;
1884 rego = &(*rego)->next);
1885 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1886 (*rego)->next = NULL;
1887 (*rego)->init = init;
1888 (*rego)->data = data;
1889 (*rego)->sizeof_data = sizeof_data;
1893 current_gdbarch_swap_init_hack (void)
1895 struct gdbarch_swap_registration *rego;
1896 struct gdbarch_swap **curr = ¤t_gdbarch->swap;
1897 for (rego = gdbarch_swap_registry.registrations;
1901 if (rego->data != NULL)
1903 (*curr) = GDBARCH_OBSTACK_ZALLOC (current_gdbarch,
1904 struct gdbarch_swap);
1905 (*curr)->source = rego;
1906 (*curr)->swap = gdbarch_obstack_zalloc (current_gdbarch,
1908 (*curr)->next = NULL;
1909 curr = &(*curr)->next;
1911 if (rego->init != NULL)
1916 static struct gdbarch *
1917 current_gdbarch_swap_out_hack (void)
1919 struct gdbarch *old_gdbarch = current_gdbarch;
1920 struct gdbarch_swap *curr;
1922 gdb_assert (old_gdbarch != NULL);
1923 for (curr = old_gdbarch->swap;
1927 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1928 memset (curr->source->data, 0, curr->source->sizeof_data);
1930 current_gdbarch = NULL;
1935 current_gdbarch_swap_in_hack (struct gdbarch *new_gdbarch)
1937 struct gdbarch_swap *curr;
1939 gdb_assert (current_gdbarch == NULL);
1940 for (curr = new_gdbarch->swap;
1943 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1944 current_gdbarch = new_gdbarch;
1948 /* Keep a registry of the architectures known by GDB. */
1950 struct gdbarch_registration
1952 enum bfd_architecture bfd_architecture;
1953 gdbarch_init_ftype *init;
1954 gdbarch_dump_tdep_ftype *dump_tdep;
1955 struct gdbarch_list *arches;
1956 struct gdbarch_registration *next;
1959 static struct gdbarch_registration *gdbarch_registry = NULL;
1962 append_name (const char ***buf, int *nr, const char *name)
1964 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1970 gdbarch_printable_names (void)
1972 /* Accumulate a list of names based on the registed list of
1974 enum bfd_architecture a;
1976 const char **arches = NULL;
1977 struct gdbarch_registration *rego;
1978 for (rego = gdbarch_registry;
1982 const struct bfd_arch_info *ap;
1983 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1985 internal_error (__FILE__, __LINE__,
1986 "gdbarch_architecture_names: multi-arch unknown");
1989 append_name (&arches, &nr_arches, ap->printable_name);
1994 append_name (&arches, &nr_arches, NULL);
2000 gdbarch_register (enum bfd_architecture bfd_architecture,
2001 gdbarch_init_ftype *init,
2002 gdbarch_dump_tdep_ftype *dump_tdep)
2004 struct gdbarch_registration **curr;
2005 const struct bfd_arch_info *bfd_arch_info;
2006 /* Check that BFD recognizes this architecture */
2007 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
2008 if (bfd_arch_info == NULL)
2010 internal_error (__FILE__, __LINE__,
2011 "gdbarch: Attempt to register unknown architecture (%d)",
2014 /* Check that we haven't seen this architecture before */
2015 for (curr = &gdbarch_registry;
2017 curr = &(*curr)->next)
2019 if (bfd_architecture == (*curr)->bfd_architecture)
2020 internal_error (__FILE__, __LINE__,
2021 "gdbarch: Duplicate registraration of architecture (%s)",
2022 bfd_arch_info->printable_name);
2026 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
2027 bfd_arch_info->printable_name,
2030 (*curr) = XMALLOC (struct gdbarch_registration);
2031 (*curr)->bfd_architecture = bfd_architecture;
2032 (*curr)->init = init;
2033 (*curr)->dump_tdep = dump_tdep;
2034 (*curr)->arches = NULL;
2035 (*curr)->next = NULL;
2039 register_gdbarch_init (enum bfd_architecture bfd_architecture,
2040 gdbarch_init_ftype *init)
2042 gdbarch_register (bfd_architecture, init, NULL);
2046 /* Look for an architecture using gdbarch_info. Base search on only
2047 BFD_ARCH_INFO and BYTE_ORDER. */
2049 struct gdbarch_list *
2050 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
2051 const struct gdbarch_info *info)
2053 for (; arches != NULL; arches = arches->next)
2055 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
2057 if (info->byte_order != arches->gdbarch->byte_order)
2059 if (info->osabi != arches->gdbarch->osabi)
2067 /* Find an architecture that matches the specified INFO. Create a new
2068 architecture if needed. Return that new architecture. Assumes
2069 that there is no current architecture. */
2071 static struct gdbarch *
2072 find_arch_by_info (struct gdbarch *old_gdbarch, struct gdbarch_info info)
2074 struct gdbarch *new_gdbarch;
2075 struct gdbarch_registration *rego;
2077 /* The existing architecture has been swapped out - all this code
2078 works from a clean slate. */
2079 gdb_assert (current_gdbarch == NULL);
2081 /* Fill in missing parts of the INFO struct using a number of
2082 sources: "set ..."; INFOabfd supplied; and the existing
2084 gdbarch_info_fill (old_gdbarch, &info);
2086 /* Must have found some sort of architecture. */
2087 gdb_assert (info.bfd_arch_info != NULL);
2091 fprintf_unfiltered (gdb_stdlog,
2092 "find_arch_by_info: info.bfd_arch_info %s\n",
2093 (info.bfd_arch_info != NULL
2094 ? info.bfd_arch_info->printable_name
2096 fprintf_unfiltered (gdb_stdlog,
2097 "find_arch_by_info: info.byte_order %d (%s)\n",
2099 (info.byte_order == BFD_ENDIAN_BIG ? "big"
2100 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
2102 fprintf_unfiltered (gdb_stdlog,
2103 "find_arch_by_info: info.osabi %d (%s)\n",
2104 info.osabi, gdbarch_osabi_name (info.osabi));
2105 fprintf_unfiltered (gdb_stdlog,
2106 "find_arch_by_info: info.abfd 0x%lx\n",
2108 fprintf_unfiltered (gdb_stdlog,
2109 "find_arch_by_info: info.tdep_info 0x%lx\n",
2110 (long) info.tdep_info);
2113 /* Find the tdep code that knows about this architecture. */
2114 for (rego = gdbarch_registry;
2117 if (rego->bfd_architecture == info.bfd_arch_info->arch)
2122 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2123 "No matching architecture\n");
2127 /* Ask the tdep code for an architecture that matches "info". */
2128 new_gdbarch = rego->init (info, rego->arches);
2130 /* Did the tdep code like it? No. Reject the change and revert to
2131 the old architecture. */
2132 if (new_gdbarch == NULL)
2135 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2136 "Target rejected architecture\n");
2140 /* Is this a pre-existing architecture (as determined by already
2141 being initialized)? Move it to the front of the architecture
2142 list (keeping the list sorted Most Recently Used). */
2143 if (new_gdbarch->initialized_p)
2145 struct gdbarch_list **list;
2146 struct gdbarch_list *this;
2148 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2149 "Previous architecture 0x%08lx (%s) selected\n",
2151 new_gdbarch->bfd_arch_info->printable_name);
2152 /* Find the existing arch in the list. */
2153 for (list = ®o->arches;
2154 (*list) != NULL && (*list)->gdbarch != new_gdbarch;
2155 list = &(*list)->next);
2156 /* It had better be in the list of architectures. */
2157 gdb_assert ((*list) != NULL && (*list)->gdbarch == new_gdbarch);
2160 (*list) = this->next;
2161 /* Insert THIS at the front. */
2162 this->next = rego->arches;
2163 rego->arches = this;
2168 /* It's a new architecture. */
2170 fprintf_unfiltered (gdb_stdlog, "find_arch_by_info: "
2171 "New architecture 0x%08lx (%s) selected\n",
2173 new_gdbarch->bfd_arch_info->printable_name);
2175 /* Insert the new architecture into the front of the architecture
2176 list (keep the list sorted Most Recently Used). */
2178 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
2179 this->next = rego->arches;
2180 this->gdbarch = new_gdbarch;
2181 rego->arches = this;
2184 /* Check that the newly installed architecture is valid. Plug in
2185 any post init values. */
2186 new_gdbarch->dump_tdep = rego->dump_tdep;
2187 verify_gdbarch (new_gdbarch);
2188 new_gdbarch->initialized_p = 1;
2190 /* Initialize any per-architecture swap areas. This phase requires
2191 a valid global CURRENT_GDBARCH. Set it momentarially, and then
2192 swap the entire architecture out. */
2193 current_gdbarch = new_gdbarch;
2194 current_gdbarch_swap_init_hack ();
2195 current_gdbarch_swap_out_hack ();
2198 gdbarch_dump (new_gdbarch, gdb_stdlog);
2204 gdbarch_find_by_info (struct gdbarch_info info)
2206 /* Save the previously selected architecture, setting the global to
2207 NULL. This stops things like gdbarch->init() trying to use the
2208 previous architecture's configuration. The previous architecture
2209 may not even be of the same architecture family. The most recent
2210 architecture of the same family is found at the head of the
2211 rego->arches list. */
2212 struct gdbarch *old_gdbarch = current_gdbarch_swap_out_hack ();
2214 /* Find the specified architecture. */
2215 struct gdbarch *new_gdbarch = find_arch_by_info (old_gdbarch, info);
2217 /* Restore the existing architecture. */
2218 gdb_assert (current_gdbarch == NULL);
2219 current_gdbarch_swap_in_hack (old_gdbarch);
2224 /* Make the specified architecture current, swapping the existing one
2228 deprecated_current_gdbarch_select_hack (struct gdbarch *new_gdbarch)
2230 gdb_assert (new_gdbarch != NULL);
2231 gdb_assert (current_gdbarch != NULL);
2232 gdb_assert (new_gdbarch->initialized_p);
2233 current_gdbarch_swap_out_hack ();
2234 current_gdbarch_swap_in_hack (new_gdbarch);
2235 architecture_changed_event ();
2238 extern void _initialize_gdbarch (void);
2241 _initialize_gdbarch (void)
2243 struct cmd_list_element *c;
2245 add_show_from_set (add_set_cmd ("arch",
2248 (char *)&gdbarch_debug,
2249 "Set architecture debugging.\\n\\
2250 When non-zero, architecture debugging is enabled.", &setdebuglist),
2252 c = add_set_cmd ("archdebug",
2255 (char *)&gdbarch_debug,
2256 "Set architecture debugging.\\n\\
2257 When non-zero, architecture debugging is enabled.", &setlist);
2259 deprecate_cmd (c, "set debug arch");
2260 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2266 #../move-if-change new-gdbarch.c gdbarch.c
2267 compare_new gdbarch.c