3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998, 1999, 2000, 2001 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.
27 echo "${file} missing? cp new-${file} ${file}" 1>&2
28 elif diff -c ${file} new-
${file}
30 echo "${file} unchanged" 1>&2
32 echo "${file} has changed? cp new-${file} ${file}" 1>&2
37 # Format of the input table
38 read="class level macro returntype function formal actual attrib staticdefault predefault postdefault invalid_p fmt print print_p description"
46 if test "${line}" = ""
49 elif test "${line}" = "#" -a "${comment}" = ""
52 elif expr "${line}" : "#" > /dev
/null
58 # The semantics of IFS varies between different SH's. Some
59 # treat ``::' as three fields while some treat it as just too.
60 # Work around this by eliminating ``::'' ....
61 line
="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"
63 OFS
="${IFS}" ; IFS
="[:]"
64 eval read ${read} <<EOF
69 # .... and then going back through each field and strip out those
70 # that ended up with just that space character.
73 if eval test \"\
${${r}}\" = \"\
\"
79 test "${staticdefault}" || staticdefault
=0
80 # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
81 # multi-arch defaults.
82 # test "${predefault}" || predefault=0
83 test "${fmt}" ||
fmt="%ld"
84 test "${print}" || print
="(long) ${macro}"
85 case "${invalid_p}" in
88 if [ "${predefault}" ]
90 #invalid_p="gdbarch->${function} == ${predefault}"
91 valid_p
="gdbarch->${function} != ${predefault}"
93 #invalid_p="gdbarch->${function} == 0"
94 valid_p
="gdbarch->${function} != 0"
97 * ) valid_p
="!(${invalid_p})"
100 # PREDEFAULT is a valid fallback definition of MEMBER when
101 # multi-arch is not enabled. This ensures that the
102 # default value, when multi-arch is the same as the
103 # default value when not multi-arch. POSTDEFAULT is
104 # always a valid definition of MEMBER as this again
105 # ensures consistency.
107 if [ "${postdefault}" != "" ]
109 fallbackdefault
="${postdefault}"
110 elif [ "${predefault}" != "" ]
112 fallbackdefault
="${predefault}"
117 #NOT YET: See gdbarch.log for basic verification of
132 fallback_default_p
()
134 [ "${postdefault}" != "" -a "${invalid_p}" != "0" ] \
135 ||
[ "${predefault}" != "" -a "${invalid_p}" = "0" ]
138 class_is_variable_p
()
140 [ "${class}" = "v" -o "${class}" = "V" ]
143 class_is_function_p
()
145 [ "${class}" = "f" -o "${class}" = "F" ]
148 class_is_predicate_p
()
150 [ "${class}" = "F" -o "${class}" = "V" ]
159 # dump out/verify the doco
169 # F -> function + predicate
170 # hiding a function + predicate to test function validity
173 # V -> variable + predicate
174 # hiding a variable + predicate to test variables validity
176 # hiding something from the ``struct info'' object
180 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
181 # LEVEL is a predicate on checking that a given method is
182 # initialized (using INVALID_P).
186 # The name of the MACRO that this method is to be accessed by.
190 # For functions, the return type; for variables, the data type
194 # For functions, the member function name; for variables, the
195 # variable name. Member function names are always prefixed with
196 # ``gdbarch_'' for name-space purity.
200 # The formal argument list. It is assumed that the formal
201 # argument list includes the actual name of each list element.
202 # A function with no arguments shall have ``void'' as the
203 # formal argument list.
207 # The list of actual arguments. The arguments specified shall
208 # match the FORMAL list given above. Functions with out
209 # arguments leave this blank.
213 # Any GCC attributes that should be attached to the function
214 # declaration. At present this field is unused.
218 # To help with the GDB startup a static gdbarch object is
219 # created. STATICDEFAULT is the value to insert into that
220 # static gdbarch object. Since this a static object only
221 # simple expressions can be used.
223 # If STATICDEFAULT is empty, zero is used.
227 # A initial value to assign to MEMBER of the freshly
228 # malloc()ed gdbarch object. After the gdbarch object has
229 # been initialized using PREDEFAULT, it is passed to the
230 # target code for further updates.
232 # If PREDEFAULT is empty, zero is used.
234 # When POSTDEFAULT is empty, a non-empty PREDEFAULT and a zero
235 # INVALID_P will be used as default values when when
236 # multi-arch is disabled. Specify a zero PREDEFAULT function
237 # to make that fallback call internal_error().
239 # Variable declarations can refer to ``gdbarch'' which will
240 # contain the current architecture. Care should be taken.
244 # A value to assign to MEMBER of the new gdbarch object should
245 # the target code fail to change the PREDEFAULT value. Also
246 # use POSTDEFAULT as the fallback value for the non-
249 # If POSTDEFAULT is empty, no post update is performed.
251 # If both INVALID_P and POSTDEFAULT are non-empty then
252 # INVALID_P will be used to determine if MEMBER should be
253 # changed to POSTDEFAULT.
255 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
257 # Variable declarations can refer to ``gdbarch'' which will
258 # contain the current architecture. Care should be taken.
262 # A predicate equation that validates MEMBER. Non-zero is
263 # returned if the code creating the new architecture failed to
264 # initialize MEMBER or the initialized the member is invalid.
265 # If POSTDEFAULT is non-empty then MEMBER will be updated to
266 # that value. If POSTDEFAULT is empty then internal_error()
269 # If INVALID_P is empty, a check that MEMBER is no longer
270 # equal to PREDEFAULT is used.
272 # The expression ``0'' disables the INVALID_P check making
273 # PREDEFAULT a legitimate value.
275 # See also PREDEFAULT and POSTDEFAULT.
279 # printf style format string that can be used to print out the
280 # MEMBER. Sometimes "%s" is useful. For functions, this is
281 # ignored and the function address is printed.
283 # If FMT is empty, ``%ld'' is used.
287 # An optional equation that casts MEMBER to a value suitable
288 # for formatting by FMT.
290 # If PRINT is empty, ``(long)'' is used.
294 # An optional indicator for any predicte to wrap around the
297 # () -> Call a custom function to do the dump.
298 # exp -> Wrap print up in ``if (${print_p}) ...
299 # ``'' -> No predicate
301 # If PRINT_P is empty, ``1'' is always used.
314 # See below (DOCO) for description of each field
316 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
318 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
319 # Number of bits in a char or unsigned char for the target machine.
320 # Just like CHAR_BIT in <limits.h> but describes the target machine.
321 # v::TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):8::0:
323 # Number of bits in a short or unsigned short for the target machine.
324 v::TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):2*TARGET_CHAR_BIT::0
325 # Number of bits in an int or unsigned int for the target machine.
326 v::TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):4*TARGET_CHAR_BIT::0
327 # Number of bits in a long or unsigned long for the target machine.
328 v::TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):4*TARGET_CHAR_BIT::0
329 # Number of bits in a long long or unsigned long long for the target
331 v::TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):2*TARGET_LONG_BIT::0
332 # Number of bits in a float for the target machine.
333 v::TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):4*TARGET_CHAR_BIT::0
334 # Number of bits in a double for the target machine.
335 v::TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):8*TARGET_CHAR_BIT::0
336 # Number of bits in a long double for the target machine.
337 v::TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):2*TARGET_DOUBLE_BIT::0
338 # For most targets, a pointer on the target and its representation as an
339 # address in GDB have the same size and "look the same". For such a
340 # target, you need only set TARGET_PTR_BIT / ptr_bit and TARGET_ADDR_BIT
341 # / addr_bit will be set from it.
343 # If TARGET_PTR_BIT and TARGET_ADDR_BIT are different, you'll probably
344 # also need to set POINTER_TO_ADDRESS and ADDRESS_TO_POINTER as well.
346 # ptr_bit is the size of a pointer on the target
347 v::TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):TARGET_INT_BIT::0
348 # addr_bit is the size of a target address as represented in gdb
349 v::TARGET_ADDR_BIT:int:addr_bit::::8 * sizeof (void*):0:TARGET_PTR_BIT:
350 # Number of bits in a BFD_VMA for the target object file format.
351 v::TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
353 v::IEEE_FLOAT:int:ieee_float::::0:0::0:::
355 f::TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:generic_target_read_pc::0
356 f::TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:generic_target_write_pc::0
357 f::TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:generic_target_read_fp::0
358 f::TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:generic_target_write_fp::0
359 f::TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:generic_target_read_sp::0
360 f::TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:generic_target_write_sp::0
362 v:2:NUM_REGS:int:num_regs::::0:-1
363 # This macro gives the number of pseudo-registers that live in the
364 # register namespace but do not get fetched or stored on the target.
365 # These pseudo-registers may be aliases for other registers,
366 # combinations of other registers, or they may be computed by GDB.
367 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
368 v:2:SP_REGNUM:int:sp_regnum::::0:-1
369 v:2:FP_REGNUM:int:fp_regnum::::0:-1
370 v:2:PC_REGNUM:int:pc_regnum::::0:-1
371 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
372 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
373 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
374 # Convert stab register number (from \`r\' declaration) to a gdb REGNUM.
375 f:2:STAB_REG_TO_REGNUM:int:stab_reg_to_regnum:int stab_regnr:stab_regnr:::no_op_reg_to_regnum::0
376 # Provide a default mapping from a ecoff register number to a gdb REGNUM.
377 f:2:ECOFF_REG_TO_REGNUM:int:ecoff_reg_to_regnum:int ecoff_regnr:ecoff_regnr:::no_op_reg_to_regnum::0
378 # Provide a default mapping from a DWARF register number to a gdb REGNUM.
379 f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no_op_reg_to_regnum::0
380 # Convert from an sdb register number to an internal gdb register number.
381 # This should be defined in tm.h, if REGISTER_NAMES is not set up
382 # to map one to one onto the sdb register numbers.
383 f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
384 f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
385 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
386 v:2:REGISTER_SIZE:int:register_size::::0:-1
387 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
388 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
389 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
390 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
391 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
392 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
393 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
394 f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
395 # MAP a GDB RAW register number onto a simulator register number. See
396 # also include/...-sim.h.
397 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
398 F:2:REGISTER_BYTES_OK:int:register_bytes_ok:long nr_bytes:nr_bytes::0:0
400 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
401 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
402 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
403 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
404 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
405 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
406 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
407 f:2: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
408 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
409 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
410 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
411 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
412 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
413 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
415 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
416 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
417 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
418 f:1:GET_SAVED_REGISTER:void:get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval::generic_get_saved_register:0
420 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
421 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
422 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
423 # This function is called when the value of a pseudo-register needs to
424 # be updated. Typically it will be defined on a per-architecture
426 f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
427 # This function is called when the value of a pseudo-register needs to
428 # be set or stored. Typically it will be defined on a
429 # per-architecture basis.
430 f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
432 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
433 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
435 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
436 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
437 f:1:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr::0:0
438 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
439 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
440 f:2:POP_FRAME:void:pop_frame:void:-:::0
442 # I wish that these would just go away....
443 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
444 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
445 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
446 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
447 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
448 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
450 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
451 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
452 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
453 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
455 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
456 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
458 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
459 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
460 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
461 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
462 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
463 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
464 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
465 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
467 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
469 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
470 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
471 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
472 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
473 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
474 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
475 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
476 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
477 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
479 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
480 v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
481 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
482 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
483 v:2:PARM_BOUNDARY:int:parm_boundary
485 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
486 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
487 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
488 f:2:CONVERT_FROM_FUNC_PTR_ADDR:CORE_ADDR:convert_from_func_ptr_addr:CORE_ADDR addr:addr:::default_convert_from_func_ptr_addr::0
495 exec > new-gdbarch.log
496 function_list |
while do_read
499 ${class} ${macro}(${actual})
500 ${returntype} ${function} ($formal)${attrib}
504 eval echo \"\ \ \ \
${r}=\
${${r}}\"
506 # #fallbackdefault=${fallbackdefault}
507 # #valid_p=${valid_p}
509 if class_is_predicate_p
&& fallback_default_p
511 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
515 if [ "${invalid_p}" = "0" -a "${postdefault}" != "" ]
517 echo "Error: postdefault is useless when invalid_p=0" 1>&2
525 compare_new gdbarch.log
531 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
533 /* Dynamic architecture support for GDB, the GNU debugger.
534 Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
536 This file is part of GDB.
538 This program is free software; you can redistribute it and/or modify
539 it under the terms of the GNU General Public License as published by
540 the Free Software Foundation; either version 2 of the License, or
541 (at your option) any later version.
543 This program is distributed in the hope that it will be useful,
544 but WITHOUT ANY WARRANTY; without even the implied warranty of
545 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
546 GNU General Public License for more details.
548 You should have received a copy of the GNU General Public License
549 along with this program; if not, write to the Free Software
550 Foundation, Inc., 59 Temple Place - Suite 330,
551 Boston, MA 02111-1307, USA. */
553 /* This file was created with the aid of \`\`gdbarch.sh''.
555 The Bourne shell script \`\`gdbarch.sh'' creates the files
556 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
557 against the existing \`\`gdbarch.[hc]''. Any differences found
560 If editing this file, please also run gdbarch.sh and merge any
561 changes into that script. Conversely, when making sweeping changes
562 to this file, modifying gdbarch.sh and using its output may prove
582 extern struct gdbarch *current_gdbarch;
585 /* If any of the following are defined, the target wasn't correctly
589 #if defined (EXTRA_FRAME_INFO)
590 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
595 #if defined (FRAME_FIND_SAVED_REGS)
596 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
604 printf "/* The following are pre-initialized by GDBARCH. */\n"
605 function_list |
while do_read
610 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
611 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
612 printf "#if GDB_MULTI_ARCH\n"
613 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
614 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
623 printf "/* The following are initialized by the target dependent code. */\n"
624 function_list |
while do_read
628 echo "${comment}" |
sed \
633 if class_is_predicate_p
636 printf "#if defined (${macro})\n"
637 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
638 # printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
639 printf "#define ${macro}_P() (1)\n"
642 printf "/* Default predicate for non- multi-arch targets. */\n"
643 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
644 printf "#define ${macro}_P() (0)\n"
647 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
648 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
649 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
652 if class_is_variable_p
654 if fallback_default_p || class_is_predicate_p
657 printf "/* Default (value) for non- multi-arch platforms. */\n"
658 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
659 echo "#define ${macro} (${fallbackdefault})" \
660 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
664 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
665 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
666 printf "#if GDB_MULTI_ARCH\n"
667 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
668 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
672 if class_is_function_p
674 if fallback_default_p || class_is_predicate_p
677 printf "/* Default (function) for non- multi-arch platforms. */\n"
678 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
679 if [ "${fallbackdefault}" = "0" ]
681 printf "#define ${macro}(${actual}) (internal_error (__FILE__, __LINE__, \"${macro}\"), 0)\n"
683 # FIXME: Should be passing current_gdbarch through!
684 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
685 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
690 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
691 if [ "${formal}" = "void" ]
693 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
695 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
697 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
698 printf "#if GDB_MULTI_ARCH\n"
699 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
700 if [ "${actual}" = "" ]
702 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
703 elif [ "${actual}" = "-" ]
705 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
707 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
717 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
720 /* Mechanism for co-ordinating the selection of a specific
723 GDB targets (*-tdep.c) can register an interest in a specific
724 architecture. Other GDB components can register a need to maintain
725 per-architecture data.
727 The mechanisms below ensures that there is only a loose connection
728 between the set-architecture command and the various GDB
729 components. Each component can independently register their need
730 to maintain architecture specific data with gdbarch.
734 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
737 The more traditional mega-struct containing architecture specific
738 data for all the various GDB components was also considered. Since
739 GDB is built from a variable number of (fairly independent)
740 components it was determined that the global aproach was not
744 /* Register a new architectural family with GDB.
746 Register support for the specified ARCHITECTURE with GDB. When
747 gdbarch determines that the specified architecture has been
748 selected, the corresponding INIT function is called.
752 The INIT function takes two parameters: INFO which contains the
753 information available to gdbarch about the (possibly new)
754 architecture; ARCHES which is a list of the previously created
755 \`\`struct gdbarch'' for this architecture.
757 The INIT function parameter INFO shall, as far as possible, be
758 pre-initialized with information obtained from INFO.ABFD or
759 previously selected architecture (if similar). INIT shall ensure
760 that the INFO.BYTE_ORDER is non-zero.
762 The INIT function shall return any of: NULL - indicating that it
763 doesn't recognize the selected architecture; an existing \`\`struct
764 gdbarch'' from the ARCHES list - indicating that the new
765 architecture is just a synonym for an earlier architecture (see
766 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
767 - that describes the selected architecture (see gdbarch_alloc()).
769 The DUMP_TDEP function shall print out all target specific values.
770 Care should be taken to ensure that the function works in both the
771 multi-arch and non- multi-arch cases. */
775 struct gdbarch *gdbarch;
776 struct gdbarch_list *next;
781 /* Use default: bfd_arch_unknown (ZERO). */
782 enum bfd_architecture bfd_architecture;
784 /* Use default: NULL (ZERO). */
785 const struct bfd_arch_info *bfd_arch_info;
787 /* Use default: 0 (ZERO). */
790 /* Use default: NULL (ZERO). */
793 /* Use default: NULL (ZERO). */
794 struct gdbarch_tdep_info *tdep_info;
797 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
798 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
800 /* DEPRECATED - use gdbarch_register() */
801 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
803 extern void gdbarch_register (enum bfd_architecture architecture,
804 gdbarch_init_ftype *,
805 gdbarch_dump_tdep_ftype *);
808 /* Return a freshly allocated, NULL terminated, array of the valid
809 architecture names. Since architectures are registered during the
810 _initialize phase this function only returns useful information
811 once initialization has been completed. */
813 extern const char **gdbarch_printable_names (void);
816 /* Helper function. Search the list of ARCHES for a GDBARCH that
817 matches the information provided by INFO. */
819 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
822 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
823 basic initialization using values obtained from the INFO andTDEP
824 parameters. set_gdbarch_*() functions are called to complete the
825 initialization of the object. */
827 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
830 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
831 It is assumed that the caller freeds the \`\`struct
834 extern void gdbarch_free (struct gdbarch *);
837 /* Helper function. Force an update of the current architecture. Used
838 by legacy targets that have added their own target specific
839 architecture manipulation commands.
841 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
842 sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
843 is called. gdbarch_update_p() shall initialize any \`\`default''
844 fields using information obtained from the previous architecture or
845 INFO.ABFD (if specified) before calling the corresponding
846 architectures INIT function.
848 Returns non-zero if the update succeeds */
850 extern int gdbarch_update_p (struct gdbarch_info info);
854 /* Register per-architecture data-pointer.
856 Reserve space for a per-architecture data-pointer. An identifier
857 for the reserved data-pointer is returned. That identifer should
858 be saved in a local static variable.
860 The per-architecture data-pointer can be initialized in one of two
861 ways: The value can be set explicitly using a call to
862 set_gdbarch_data(); the value can be set implicitly using the value
863 returned by a non-NULL INIT() callback. INIT(), when non-NULL is
864 called after the basic architecture vector has been created.
866 When a previously created architecture is re-selected, the
867 per-architecture data-pointer for that previous architecture is
868 restored. INIT() is not called.
870 During initialization, multiple assignments of the data-pointer are
871 allowed, non-NULL values are deleted by calling FREE(). If the
872 architecture is deleted using gdbarch_free() all non-NULL data
873 pointers are also deleted using FREE().
875 Multiple registrarants for any architecture are allowed (and
876 strongly encouraged). */
880 typedef void *(gdbarch_data_init_ftype) (struct gdbarch *gdbarch);
881 typedef void (gdbarch_data_free_ftype) (struct gdbarch *gdbarch,
883 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_init_ftype *init,
884 gdbarch_data_free_ftype *free);
885 extern void set_gdbarch_data (struct gdbarch *gdbarch,
886 struct gdbarch_data *data,
889 extern void *gdbarch_data (struct gdbarch_data*);
892 /* Register per-architecture memory region.
894 Provide a memory-region swap mechanism. Per-architecture memory
895 region are created. These memory regions are swapped whenever the
896 architecture is changed. For a new architecture, the memory region
897 is initialized with zero (0) and the INIT function is called.
899 Memory regions are swapped / initialized in the order that they are
900 registered. NULL DATA and/or INIT values can be specified.
902 New code should use register_gdbarch_data(). */
904 typedef void (gdbarch_swap_ftype) (void);
905 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
906 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
910 /* The target-system-dependent byte order is dynamic */
912 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
913 is selectable at runtime. The user can use the \`\`set endian''
914 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
915 target_byte_order should be auto-detected (from the program image
919 /* Multi-arch GDB is always bi-endian. */
920 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
923 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
924 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
925 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
926 #ifdef TARGET_BYTE_ORDER_SELECTABLE
927 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
929 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
933 extern int target_byte_order;
934 #ifdef TARGET_BYTE_ORDER_SELECTABLE
935 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
936 and expect defs.h to re-define TARGET_BYTE_ORDER. */
937 #undef TARGET_BYTE_ORDER
939 #ifndef TARGET_BYTE_ORDER
940 #define TARGET_BYTE_ORDER (target_byte_order + 0)
943 extern int target_byte_order_auto;
944 #ifndef TARGET_BYTE_ORDER_AUTO
945 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
950 /* The target-system-dependent BFD architecture is dynamic */
952 extern int target_architecture_auto;
953 #ifndef TARGET_ARCHITECTURE_AUTO
954 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
957 extern const struct bfd_arch_info *target_architecture;
958 #ifndef TARGET_ARCHITECTURE
959 #define TARGET_ARCHITECTURE (target_architecture + 0)
963 /* The target-system-dependent disassembler is semi-dynamic */
965 #include "dis-asm.h" /* Get defs for disassemble_info */
967 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
968 unsigned int len, disassemble_info *info);
970 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
971 disassemble_info *info);
973 extern void dis_asm_print_address (bfd_vma addr,
974 disassemble_info *info);
976 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
977 extern disassemble_info tm_print_insn_info;
978 #ifndef TARGET_PRINT_INSN
979 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
981 #ifndef TARGET_PRINT_INSN_INFO
982 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
987 /* Explicit test for D10V architecture.
988 USE of these macro's is *STRONGLY* discouraged. */
990 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
993 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
994 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
995 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
996 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error (__FILE__, __LINE__, "gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
998 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
999 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
1004 /* Set the dynamic target-system-dependent parameters (architecture,
1005 byte-order, ...) using information found in the BFD */
1007 extern void set_gdbarch_from_file (bfd *);
1010 /* Initialize the current architecture to the "first" one we find on
1013 extern void initialize_current_architecture (void);
1016 /* gdbarch trace variable */
1017 extern int gdbarch_debug;
1019 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1024 #../move-if-change new-gdbarch.h gdbarch.h
1025 compare_new gdbarch.h
1032 exec > new-gdbarch.c
1037 #include "arch-utils.h"
1041 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1043 /* Just include everything in sight so that the every old definition
1044 of macro is visible. */
1045 #include "gdb_string.h"
1049 #include "inferior.h"
1050 #include "breakpoint.h"
1051 #include "gdb_wait.h"
1052 #include "gdbcore.h"
1055 #include "gdbthread.h"
1056 #include "annotate.h"
1057 #include "symfile.h" /* for overlay functions */
1061 #include "floatformat.h"
1063 #include "gdb_assert.h"
1065 /* Static function declarations */
1067 static void verify_gdbarch (struct gdbarch *gdbarch);
1068 static void alloc_gdbarch_data (struct gdbarch *);
1069 static void init_gdbarch_data (struct gdbarch *);
1070 static void free_gdbarch_data (struct gdbarch *);
1071 static void init_gdbarch_swap (struct gdbarch *);
1072 static void swapout_gdbarch_swap (struct gdbarch *);
1073 static void swapin_gdbarch_swap (struct gdbarch *);
1075 /* Convenience macro for allocting typesafe memory. */
1078 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1082 /* Non-zero if we want to trace architecture code. */
1084 #ifndef GDBARCH_DEBUG
1085 #define GDBARCH_DEBUG 0
1087 int gdbarch_debug = GDBARCH_DEBUG;
1091 # gdbarch open the gdbarch object
1093 printf "/* Maintain the struct gdbarch object */\n"
1095 printf "struct gdbarch\n"
1097 printf " /* basic architectural information */\n"
1098 function_list |
while do_read
1102 printf " ${returntype} ${function};\n"
1106 printf " /* target specific vector. */\n"
1107 printf " struct gdbarch_tdep *tdep;\n"
1108 printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1110 printf " /* per-architecture data-pointers */\n"
1111 printf " unsigned nr_data;\n"
1112 printf " void **data;\n"
1114 printf " /* per-architecture swap-regions */\n"
1115 printf " struct gdbarch_swap *swap;\n"
1118 /* Multi-arch values.
1120 When extending this structure you must:
1122 Add the field below.
1124 Declare set/get functions and define the corresponding
1127 gdbarch_alloc(): If zero/NULL is not a suitable default,
1128 initialize the new field.
1130 verify_gdbarch(): Confirm that the target updated the field
1133 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1136 \`\`startup_gdbarch()'': Append an initial value to the static
1137 variable (base values on the host's c-type system).
1139 get_gdbarch(): Implement the set/get functions (probably using
1140 the macro's as shortcuts).
1145 function_list |
while do_read
1147 if class_is_variable_p
1149 printf " ${returntype} ${function};\n"
1150 elif class_is_function_p
1152 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
1157 # A pre-initialized vector
1161 /* The default architecture uses host values (for want of a better
1165 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1167 printf "struct gdbarch startup_gdbarch =\n"
1169 printf " /* basic architecture information */\n"
1170 function_list |
while do_read
1174 printf " ${staticdefault},\n"
1178 /* target specific vector and its dump routine */
1180 /*per-architecture data-pointers and swap regions */
1182 /* Multi-arch values */
1184 function_list |
while do_read
1186 if class_is_function_p || class_is_variable_p
1188 printf " ${staticdefault},\n"
1192 /* startup_gdbarch() */
1195 struct gdbarch *current_gdbarch = &startup_gdbarch;
1198 # Create a new gdbarch struct
1202 /* Create a new \`\`struct gdbarch'' based on information provided by
1203 \`\`struct gdbarch_info''. */
1208 gdbarch_alloc (const struct gdbarch_info *info,
1209 struct gdbarch_tdep *tdep)
1211 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1212 memset (gdbarch, 0, sizeof (*gdbarch));
1214 alloc_gdbarch_data (gdbarch);
1216 gdbarch->tdep = tdep;
1219 function_list |
while do_read
1223 printf " gdbarch->${function} = info->${function};\n"
1227 printf " /* Force the explicit initialization of these. */\n"
1228 function_list |
while do_read
1230 if class_is_function_p || class_is_variable_p
1232 if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1234 printf " gdbarch->${function} = ${predefault};\n"
1239 /* gdbarch_alloc() */
1245 # Free a gdbarch struct.
1249 /* Free a gdbarch struct. This should never happen in normal
1250 operation --- once you've created a gdbarch, you keep it around.
1251 However, if an architecture's init function encounters an error
1252 building the structure, it may need to clean up a partially
1253 constructed gdbarch. */
1256 gdbarch_free (struct gdbarch *arch)
1258 gdb_assert (arch != NULL);
1259 free_gdbarch_data (arch);
1264 # verify a new architecture
1267 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1271 verify_gdbarch (struct gdbarch *gdbarch)
1273 /* Only perform sanity checks on a multi-arch target. */
1274 if (!GDB_MULTI_ARCH)
1277 if (gdbarch->byte_order == 0)
1278 internal_error (__FILE__, __LINE__,
1279 "verify_gdbarch: byte-order unset");
1280 if (gdbarch->bfd_arch_info == NULL)
1281 internal_error (__FILE__, __LINE__,
1282 "verify_gdbarch: bfd_arch_info unset");
1283 /* Check those that need to be defined for the given multi-arch level. */
1285 function_list |
while do_read
1287 if class_is_function_p || class_is_variable_p
1289 if [ "${invalid_p}" = "0" ]
1291 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1292 elif class_is_predicate_p
1294 printf " /* Skip verify of ${function}, has predicate */\n"
1295 # FIXME: See do_read for potential simplification
1296 elif [ "${invalid_p}" -a "${postdefault}" ]
1298 printf " if (${invalid_p})\n"
1299 printf " gdbarch->${function} = ${postdefault};\n"
1300 elif [ "${predefault}" -a "${postdefault}" ]
1302 printf " if (gdbarch->${function} == ${predefault})\n"
1303 printf " gdbarch->${function} = ${postdefault};\n"
1304 elif [ "${postdefault}" ]
1306 printf " if (gdbarch->${function} == 0)\n"
1307 printf " gdbarch->${function} = ${postdefault};\n"
1308 elif [ "${invalid_p}" ]
1310 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1311 printf " && (${invalid_p}))\n"
1312 printf " internal_error (__FILE__, __LINE__,\n"
1313 printf " \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1314 elif [ "${predefault}" ]
1316 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1317 printf " && (gdbarch->${function} == ${predefault}))\n"
1318 printf " internal_error (__FILE__, __LINE__,\n"
1319 printf " \"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1327 # dump the structure
1331 /* Print out the details of the current architecture. */
1333 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1334 just happens to match the global variable \`\`current_gdbarch''. That
1335 way macros refering to that variable get the local and not the global
1336 version - ulgh. Once everything is parameterised with gdbarch, this
1340 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1342 fprintf_unfiltered (file,
1343 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1346 function_list |
while do_read
1348 if [ "${returntype}" = "void" ]
1350 printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1351 printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
1353 printf "#ifdef ${macro}\n"
1355 if class_is_function_p
1357 printf " fprintf_unfiltered (file,\n"
1358 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1359 printf " \"${macro}(${actual})\",\n"
1360 printf " XSTRING (${macro} (${actual})));\n"
1362 printf " fprintf_unfiltered (file,\n"
1363 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1364 printf " XSTRING (${macro}));\n"
1368 function_list |
while do_read
1370 printf "#ifdef ${macro}\n"
1371 if [ "${print_p}" = "()" ]
1373 printf " gdbarch_dump_${function} (current_gdbarch);\n"
1374 elif [ "${print_p}" = "0" ]
1376 printf " /* skip print of ${macro}, print_p == 0. */\n"
1377 elif [ "${print_p}" ]
1379 printf " if (${print_p})\n"
1380 printf " fprintf_unfiltered (file,\n"
1381 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1382 printf " ${print});\n"
1383 elif class_is_function_p
1385 printf " if (GDB_MULTI_ARCH)\n"
1386 printf " fprintf_unfiltered (file,\n"
1387 printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1388 printf " (long) current_gdbarch->${function}\n"
1389 printf " /*${macro} ()*/);\n"
1391 printf " fprintf_unfiltered (file,\n"
1392 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1393 printf " ${print});\n"
1398 if (current_gdbarch->dump_tdep != NULL)
1399 current_gdbarch->dump_tdep (current_gdbarch, file);
1407 struct gdbarch_tdep *
1408 gdbarch_tdep (struct gdbarch *gdbarch)
1410 if (gdbarch_debug >= 2)
1411 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1412 return gdbarch->tdep;
1416 function_list |
while do_read
1418 if class_is_predicate_p
1422 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1426 printf " return ${valid_p};\n"
1428 printf "#error \"gdbarch_${function}_p: not defined\"\n"
1432 if class_is_function_p
1435 printf "${returntype}\n"
1436 if [ "${formal}" = "void" ]
1438 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1440 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1443 printf " if (gdbarch->${function} == 0)\n"
1444 printf " internal_error (__FILE__, __LINE__,\n"
1445 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1446 printf " if (gdbarch_debug >= 2)\n"
1447 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1448 test "${actual}" = "-" && actual
=""
1449 if [ "${returntype}" = "void" ]
1451 printf " gdbarch->${function} (${actual});\n"
1453 printf " return gdbarch->${function} (${actual});\n"
1458 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1459 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1461 printf " gdbarch->${function} = ${function};\n"
1463 elif class_is_variable_p
1466 printf "${returntype}\n"
1467 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1469 if [ "${invalid_p}" = "0" ]
1471 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1472 elif [ "${invalid_p}" ]
1474 printf " if (${invalid_p})\n"
1475 printf " internal_error (__FILE__, __LINE__,\n"
1476 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1477 elif [ "${predefault}" ]
1479 printf " if (gdbarch->${function} == ${predefault})\n"
1480 printf " internal_error (__FILE__, __LINE__,\n"
1481 printf " \"gdbarch: gdbarch_${function} invalid\");\n"
1483 printf " if (gdbarch_debug >= 2)\n"
1484 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1485 printf " return gdbarch->${function};\n"
1489 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1490 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1492 printf " gdbarch->${function} = ${function};\n"
1494 elif class_is_info_p
1497 printf "${returntype}\n"
1498 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1500 printf " if (gdbarch_debug >= 2)\n"
1501 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1502 printf " return gdbarch->${function};\n"
1507 # All the trailing guff
1511 /* Keep a registry of per-architecture data-pointers required by GDB
1517 gdbarch_data_init_ftype *init;
1518 gdbarch_data_free_ftype *free;
1521 struct gdbarch_data_registration
1523 struct gdbarch_data *data;
1524 struct gdbarch_data_registration *next;
1527 struct gdbarch_data_registry
1530 struct gdbarch_data_registration *registrations;
1533 struct gdbarch_data_registry gdbarch_data_registry =
1538 struct gdbarch_data *
1539 register_gdbarch_data (gdbarch_data_init_ftype *init,
1540 gdbarch_data_free_ftype *free)
1542 struct gdbarch_data_registration **curr;
1543 for (curr = &gdbarch_data_registry.registrations;
1545 curr = &(*curr)->next);
1546 (*curr) = XMALLOC (struct gdbarch_data_registration);
1547 (*curr)->next = NULL;
1548 (*curr)->data = XMALLOC (struct gdbarch_data);
1549 (*curr)->data->index = gdbarch_data_registry.nr++;
1550 (*curr)->data->init = init;
1551 (*curr)->data->free = free;
1552 return (*curr)->data;
1556 /* Walk through all the registered users initializing each in turn. */
1559 init_gdbarch_data (struct gdbarch *gdbarch)
1561 struct gdbarch_data_registration *rego;
1562 for (rego = gdbarch_data_registry.registrations;
1566 struct gdbarch_data *data = rego->data;
1567 gdb_assert (data->index < gdbarch->nr_data);
1568 if (data->init != NULL)
1570 void *pointer = data->init (gdbarch);
1571 set_gdbarch_data (gdbarch, data, pointer);
1576 /* Create/delete the gdbarch data vector. */
1579 alloc_gdbarch_data (struct gdbarch *gdbarch)
1581 gdb_assert (gdbarch->data == NULL);
1582 gdbarch->nr_data = gdbarch_data_registry.nr;
1583 gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
1587 free_gdbarch_data (struct gdbarch *gdbarch)
1589 struct gdbarch_data_registration *rego;
1590 gdb_assert (gdbarch->data != NULL);
1591 for (rego = gdbarch_data_registry.registrations;
1595 struct gdbarch_data *data = rego->data;
1596 gdb_assert (data->index < gdbarch->nr_data);
1597 if (data->free != NULL && gdbarch->data[data->index] != NULL)
1599 data->free (gdbarch, gdbarch->data[data->index]);
1600 gdbarch->data[data->index] = NULL;
1603 xfree (gdbarch->data);
1604 gdbarch->data = NULL;
1608 /* Initialize the current value of thee specified per-architecture
1612 set_gdbarch_data (struct gdbarch *gdbarch,
1613 struct gdbarch_data *data,
1616 gdb_assert (data->index < gdbarch->nr_data);
1617 if (data->free != NULL && gdbarch->data[data->index] != NULL)
1618 data->free (gdbarch, gdbarch->data[data->index]);
1619 gdbarch->data[data->index] = pointer;
1622 /* Return the current value of the specified per-architecture
1626 gdbarch_data (struct gdbarch_data *data)
1628 gdb_assert (data->index < current_gdbarch->nr_data);
1629 return current_gdbarch->data[data->index];
1634 /* Keep a registry of swapped data required by GDB modules. */
1639 struct gdbarch_swap_registration *source;
1640 struct gdbarch_swap *next;
1643 struct gdbarch_swap_registration
1646 unsigned long sizeof_data;
1647 gdbarch_swap_ftype *init;
1648 struct gdbarch_swap_registration *next;
1651 struct gdbarch_swap_registry
1654 struct gdbarch_swap_registration *registrations;
1657 struct gdbarch_swap_registry gdbarch_swap_registry =
1663 register_gdbarch_swap (void *data,
1664 unsigned long sizeof_data,
1665 gdbarch_swap_ftype *init)
1667 struct gdbarch_swap_registration **rego;
1668 for (rego = &gdbarch_swap_registry.registrations;
1670 rego = &(*rego)->next);
1671 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1672 (*rego)->next = NULL;
1673 (*rego)->init = init;
1674 (*rego)->data = data;
1675 (*rego)->sizeof_data = sizeof_data;
1680 init_gdbarch_swap (struct gdbarch *gdbarch)
1682 struct gdbarch_swap_registration *rego;
1683 struct gdbarch_swap **curr = &gdbarch->swap;
1684 for (rego = gdbarch_swap_registry.registrations;
1688 if (rego->data != NULL)
1690 (*curr) = XMALLOC (struct gdbarch_swap);
1691 (*curr)->source = rego;
1692 (*curr)->swap = xmalloc (rego->sizeof_data);
1693 (*curr)->next = NULL;
1694 memset (rego->data, 0, rego->sizeof_data);
1695 curr = &(*curr)->next;
1697 if (rego->init != NULL)
1703 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1705 struct gdbarch_swap *curr;
1706 for (curr = gdbarch->swap;
1709 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1713 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1715 struct gdbarch_swap *curr;
1716 for (curr = gdbarch->swap;
1719 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1723 /* Keep a registry of the architectures known by GDB. */
1725 struct gdbarch_registration
1727 enum bfd_architecture bfd_architecture;
1728 gdbarch_init_ftype *init;
1729 gdbarch_dump_tdep_ftype *dump_tdep;
1730 struct gdbarch_list *arches;
1731 struct gdbarch_registration *next;
1734 static struct gdbarch_registration *gdbarch_registry = NULL;
1737 append_name (const char ***buf, int *nr, const char *name)
1739 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1745 gdbarch_printable_names (void)
1749 /* Accumulate a list of names based on the registed list of
1751 enum bfd_architecture a;
1753 const char **arches = NULL;
1754 struct gdbarch_registration *rego;
1755 for (rego = gdbarch_registry;
1759 const struct bfd_arch_info *ap;
1760 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1762 internal_error (__FILE__, __LINE__,
1763 "gdbarch_architecture_names: multi-arch unknown");
1766 append_name (&arches, &nr_arches, ap->printable_name);
1771 append_name (&arches, &nr_arches, NULL);
1775 /* Just return all the architectures that BFD knows. Assume that
1776 the legacy architecture framework supports them. */
1777 return bfd_arch_list ();
1782 gdbarch_register (enum bfd_architecture bfd_architecture,
1783 gdbarch_init_ftype *init,
1784 gdbarch_dump_tdep_ftype *dump_tdep)
1786 struct gdbarch_registration **curr;
1787 const struct bfd_arch_info *bfd_arch_info;
1788 /* Check that BFD recognizes this architecture */
1789 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1790 if (bfd_arch_info == NULL)
1792 internal_error (__FILE__, __LINE__,
1793 "gdbarch: Attempt to register unknown architecture (%d)",
1796 /* Check that we haven't seen this architecture before */
1797 for (curr = &gdbarch_registry;
1799 curr = &(*curr)->next)
1801 if (bfd_architecture == (*curr)->bfd_architecture)
1802 internal_error (__FILE__, __LINE__,
1803 "gdbarch: Duplicate registraration of architecture (%s)",
1804 bfd_arch_info->printable_name);
1808 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1809 bfd_arch_info->printable_name,
1812 (*curr) = XMALLOC (struct gdbarch_registration);
1813 (*curr)->bfd_architecture = bfd_architecture;
1814 (*curr)->init = init;
1815 (*curr)->dump_tdep = dump_tdep;
1816 (*curr)->arches = NULL;
1817 (*curr)->next = NULL;
1818 /* When non- multi-arch, install whatever target dump routine we've
1819 been provided - hopefully that routine has been written correctly
1820 and works regardless of multi-arch. */
1821 if (!GDB_MULTI_ARCH && dump_tdep != NULL
1822 && startup_gdbarch.dump_tdep == NULL)
1823 startup_gdbarch.dump_tdep = dump_tdep;
1827 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1828 gdbarch_init_ftype *init)
1830 gdbarch_register (bfd_architecture, init, NULL);
1834 /* Look for an architecture using gdbarch_info. Base search on only
1835 BFD_ARCH_INFO and BYTE_ORDER. */
1837 struct gdbarch_list *
1838 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1839 const struct gdbarch_info *info)
1841 for (; arches != NULL; arches = arches->next)
1843 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1845 if (info->byte_order != arches->gdbarch->byte_order)
1853 /* Update the current architecture. Return ZERO if the update request
1857 gdbarch_update_p (struct gdbarch_info info)
1859 struct gdbarch *new_gdbarch;
1860 struct gdbarch_list **list;
1861 struct gdbarch_registration *rego;
1863 /* Fill in any missing bits. Most important is the bfd_architecture
1864 which is used to select the target architecture. */
1865 if (info.bfd_architecture == bfd_arch_unknown)
1867 if (info.bfd_arch_info != NULL)
1868 info.bfd_architecture = info.bfd_arch_info->arch;
1869 else if (info.abfd != NULL)
1870 info.bfd_architecture = bfd_get_arch (info.abfd);
1871 /* FIXME - should query BFD for its default architecture. */
1873 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1875 if (info.bfd_arch_info == NULL)
1877 if (target_architecture_auto && info.abfd != NULL)
1878 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1880 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1882 if (info.byte_order == 0)
1884 if (target_byte_order_auto && info.abfd != NULL)
1885 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1886 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1889 info.byte_order = current_gdbarch->byte_order;
1890 /* FIXME - should query BFD for its default byte-order. */
1892 /* A default for abfd? */
1894 /* Find the target that knows about this architecture. */
1895 for (rego = gdbarch_registry;
1898 if (rego->bfd_architecture == info.bfd_architecture)
1903 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
1909 fprintf_unfiltered (gdb_stdlog,
1910 "gdbarch_update: info.bfd_architecture %d (%s)\\n",
1911 info.bfd_architecture,
1912 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1913 fprintf_unfiltered (gdb_stdlog,
1914 "gdbarch_update: info.bfd_arch_info %s\\n",
1915 (info.bfd_arch_info != NULL
1916 ? info.bfd_arch_info->printable_name
1918 fprintf_unfiltered (gdb_stdlog,
1919 "gdbarch_update: info.byte_order %d (%s)\\n",
1921 (info.byte_order == BIG_ENDIAN ? "big"
1922 : info.byte_order == LITTLE_ENDIAN ? "little"
1924 fprintf_unfiltered (gdb_stdlog,
1925 "gdbarch_update: info.abfd 0x%lx\\n",
1927 fprintf_unfiltered (gdb_stdlog,
1928 "gdbarch_update: info.tdep_info 0x%lx\\n",
1929 (long) info.tdep_info);
1932 /* Ask the target for a replacement architecture. */
1933 new_gdbarch = rego->init (info, rego->arches);
1935 /* Did the target like it? No. Reject the change. */
1936 if (new_gdbarch == NULL)
1939 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
1943 /* Did the architecture change? No. Do nothing. */
1944 if (current_gdbarch == new_gdbarch)
1947 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
1949 new_gdbarch->bfd_arch_info->printable_name);
1953 /* Swap all data belonging to the old target out */
1954 swapout_gdbarch_swap (current_gdbarch);
1956 /* Is this a pre-existing architecture? Yes. Swap it in. */
1957 for (list = ®o->arches;
1959 list = &(*list)->next)
1961 if ((*list)->gdbarch == new_gdbarch)
1964 fprintf_unfiltered (gdb_stdlog,
1965 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
1967 new_gdbarch->bfd_arch_info->printable_name);
1968 current_gdbarch = new_gdbarch;
1969 swapin_gdbarch_swap (new_gdbarch);
1974 /* Append this new architecture to this targets list. */
1975 (*list) = XMALLOC (struct gdbarch_list);
1976 (*list)->next = NULL;
1977 (*list)->gdbarch = new_gdbarch;
1979 /* Switch to this new architecture. Dump it out. */
1980 current_gdbarch = new_gdbarch;
1983 fprintf_unfiltered (gdb_stdlog,
1984 "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
1986 new_gdbarch->bfd_arch_info->printable_name);
1989 /* Check that the newly installed architecture is valid. Plug in
1990 any post init values. */
1991 new_gdbarch->dump_tdep = rego->dump_tdep;
1992 verify_gdbarch (new_gdbarch);
1994 /* Initialize the per-architecture memory (swap) areas.
1995 CURRENT_GDBARCH must be update before these modules are
1997 init_gdbarch_swap (new_gdbarch);
1999 /* Initialize the per-architecture data-pointer of all parties that
2000 registered an interest in this architecture. CURRENT_GDBARCH
2001 must be updated before these modules are called. */
2002 init_gdbarch_data (new_gdbarch);
2005 gdbarch_dump (current_gdbarch, gdb_stdlog);
2013 /* Pointer to the target-dependent disassembly function. */
2014 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2015 disassemble_info tm_print_insn_info;
2018 extern void _initialize_gdbarch (void);
2021 _initialize_gdbarch (void)
2023 struct cmd_list_element *c;
2025 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2026 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2027 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2028 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2029 tm_print_insn_info.print_address_func = dis_asm_print_address;
2031 add_show_from_set (add_set_cmd ("arch",
2034 (char *)&gdbarch_debug,
2035 "Set architecture debugging.\\n\\
2036 When non-zero, architecture debugging is enabled.", &setdebuglist),
2038 c = add_set_cmd ("archdebug",
2041 (char *)&gdbarch_debug,
2042 "Set architecture debugging.\\n\\
2043 When non-zero, architecture debugging is enabled.", &setlist);
2045 deprecate_cmd (c, "set debug arch");
2046 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2052 #../move-if-change new-gdbarch.c gdbarch.c
2053 compare_new gdbarch.c