3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998-2000 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 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
375 v:2:REGISTER_SIZE:int:register_size::::0:-1
376 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
377 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
378 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
379 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
380 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
381 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
382 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
383 f:2:DO_REGISTERS_INFO:void:do_registers_info:int reg_nr, int fpregs:reg_nr, fpregs:::do_registers_info::0
384 # MAP a GDB RAW register number onto a simulator register number. See
385 # also include/...-sim.h.
386 f:2:REGISTER_SIM_REGNO:int:register_sim_regno:int reg_nr:reg_nr:::default_register_sim_regno::0
388 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
389 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
390 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
391 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
392 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx::CALL_DUMMY_BREAKPOINT_OFFSET_P
393 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
394 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
395 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
396 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
397 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
398 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
399 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
400 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
401 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
403 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
404 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
405 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
406 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
408 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
409 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
410 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
411 # This function is called when the value of a pseudo-register needs to
412 # be updated. Typically it will be defined on a per-architecture
414 f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
415 # This function is called when the value of a pseudo-register needs to
416 # be set or stored. Typically it will be defined on a
417 # per-architecture basis.
418 f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
420 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
421 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
423 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
424 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
425 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
426 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
427 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
428 f:2:POP_FRAME:void:pop_frame:void:-:::0
430 # I wish that these would just go away....
431 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
432 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
433 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
434 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
435 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
436 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
438 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
439 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
440 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
441 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
443 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
444 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
446 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
447 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
448 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
449 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
450 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
451 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
452 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
453 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
455 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
457 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
458 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
459 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
460 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
461 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
462 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
463 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
464 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
465 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
467 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
468 v:1:EXTRA_STACK_ALIGNMENT_NEEDED:int:extra_stack_alignment_needed::::0:1::0:::
469 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
470 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
472 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
473 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
474 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
475 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
482 exec > new-gdbarch.log
483 function_list |
while do_read
486 ${class} ${macro}(${actual})
487 ${returntype} ${function} ($formal)${attrib}
491 eval echo \"\ \ \ \
${r}=\
${${r}}\"
493 # #fallbackdefault=${fallbackdefault}
494 # #valid_p=${valid_p}
496 if class_is_predicate_p
&& fallback_default_p
498 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
502 if [ "${invalid_p}" = "0" -a "${postdefault}" != "" ]
504 echo "Error: postdefault is useless when invalid_p=0" 1>&2
512 compare_new gdbarch.log
518 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
520 /* Dynamic architecture support for GDB, the GNU debugger.
521 Copyright 1998-1999, Free Software Foundation, Inc.
523 This file is part of GDB.
525 This program is free software; you can redistribute it and/or modify
526 it under the terms of the GNU General Public License as published by
527 the Free Software Foundation; either version 2 of the License, or
528 (at your option) any later version.
530 This program is distributed in the hope that it will be useful,
531 but WITHOUT ANY WARRANTY; without even the implied warranty of
532 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
533 GNU General Public License for more details.
535 You should have received a copy of the GNU General Public License
536 along with this program; if not, write to the Free Software
537 Foundation, Inc., 59 Temple Place - Suite 330,
538 Boston, MA 02111-1307, USA. */
540 /* This file was created with the aid of \`\`gdbarch.sh''.
542 The Bourne shell script \`\`gdbarch.sh'' creates the files
543 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
544 against the existing \`\`gdbarch.[hc]''. Any differences found
547 If editing this file, please also run gdbarch.sh and merge any
548 changes into that script. Conversely, when making sweeping changes
549 to this file, modifying gdbarch.sh and using its output may prove
569 extern struct gdbarch *current_gdbarch;
572 /* If any of the following are defined, the target wasn't correctly
576 #if defined (EXTRA_FRAME_INFO)
577 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
582 #if defined (FRAME_FIND_SAVED_REGS)
583 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
591 printf "/* The following are pre-initialized by GDBARCH. */\n"
592 function_list |
while do_read
597 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
598 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
599 printf "#if GDB_MULTI_ARCH\n"
600 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
601 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
610 printf "/* The following are initialized by the target dependent code. */\n"
611 function_list |
while do_read
615 echo "${comment}" |
sed \
620 if class_is_predicate_p
623 printf "#if defined (${macro})\n"
624 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
625 # printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
626 printf "#define ${macro}_P() (1)\n"
629 printf "/* Default predicate for non- multi-arch targets. */\n"
630 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
631 printf "#define ${macro}_P() (0)\n"
634 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
635 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
636 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
639 if class_is_variable_p
641 if fallback_default_p || class_is_predicate_p
644 printf "/* Default (value) for non- multi-arch platforms. */\n"
645 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
646 echo "#define ${macro} (${fallbackdefault})" \
647 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
651 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
652 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
653 printf "#if GDB_MULTI_ARCH\n"
654 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
655 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
659 if class_is_function_p
661 if fallback_default_p || class_is_predicate_p
664 printf "/* Default (function) for non- multi-arch platforms. */\n"
665 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
666 if [ "${fallbackdefault}" = "0" ]
668 printf "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)\n"
670 # FIXME: Should be passing current_gdbarch through!
671 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
672 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
677 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
678 if [ "${formal}" = "void" ]
680 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
682 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
684 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
685 printf "#if GDB_MULTI_ARCH\n"
686 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
687 if [ "${actual}" = "" ]
689 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
690 elif [ "${actual}" = "-" ]
692 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
694 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
704 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
707 /* Mechanism for co-ordinating the selection of a specific
710 GDB targets (*-tdep.c) can register an interest in a specific
711 architecture. Other GDB components can register a need to maintain
712 per-architecture data.
714 The mechanisms below ensures that there is only a loose connection
715 between the set-architecture command and the various GDB
716 components. Each component can independently register their need
717 to maintain architecture specific data with gdbarch.
721 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
724 The more traditional mega-struct containing architecture specific
725 data for all the various GDB components was also considered. Since
726 GDB is built from a variable number of (fairly independent)
727 components it was determined that the global aproach was not
731 /* Register a new architectural family with GDB.
733 Register support for the specified ARCHITECTURE with GDB. When
734 gdbarch determines that the specified architecture has been
735 selected, the corresponding INIT function is called.
739 The INIT function takes two parameters: INFO which contains the
740 information available to gdbarch about the (possibly new)
741 architecture; ARCHES which is a list of the previously created
742 \`\`struct gdbarch'' for this architecture.
744 The INIT function parameter INFO shall, as far as possible, be
745 pre-initialized with information obtained from INFO.ABFD or
746 previously selected architecture (if similar). INIT shall ensure
747 that the INFO.BYTE_ORDER is non-zero.
749 The INIT function shall return any of: NULL - indicating that it
750 doesn't recognize the selected architecture; an existing \`\`struct
751 gdbarch'' from the ARCHES list - indicating that the new
752 architecture is just a synonym for an earlier architecture (see
753 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
754 - that describes the selected architecture (see gdbarch_alloc()).
756 The DUMP_TDEP function shall print out all target specific values.
757 Care should be taken to ensure that the function works in both the
758 multi-arch and non- multi-arch cases. */
762 struct gdbarch *gdbarch;
763 struct gdbarch_list *next;
768 /* Use default: bfd_arch_unknown (ZERO). */
769 enum bfd_architecture bfd_architecture;
771 /* Use default: NULL (ZERO). */
772 const struct bfd_arch_info *bfd_arch_info;
774 /* Use default: 0 (ZERO). */
777 /* Use default: NULL (ZERO). */
780 /* Use default: NULL (ZERO). */
781 struct gdbarch_tdep_info *tdep_info;
784 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
785 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
787 /* DEPRECATED - use gdbarch_register() */
788 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
790 extern void gdbarch_register (enum bfd_architecture architecture,
791 gdbarch_init_ftype *,
792 gdbarch_dump_tdep_ftype *);
795 /* Return a freshly allocated, NULL terminated, array of the valid
796 architecture names. Since architectures are registered during the
797 _initialize phase this function only returns useful information
798 once initialization has been completed. */
800 extern const char **gdbarch_printable_names (void);
803 /* Helper function. Search the list of ARCHES for a GDBARCH that
804 matches the information provided by INFO. */
806 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
809 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
810 basic initialization using values obtained from the INFO andTDEP
811 parameters. set_gdbarch_*() functions are called to complete the
812 initialization of the object. */
814 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
817 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
818 It is assumed that the caller freeds the \`\`struct
821 extern void gdbarch_free (struct gdbarch *);
824 /* Helper function. Force an update of the current architecture. Used
825 by legacy targets that have added their own target specific
826 architecture manipulation commands.
828 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
829 sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
830 is called. gdbarch_update_p() shall initialize any \`\`default''
831 fields using information obtained from the previous architecture or
832 INFO.ABFD (if specified) before calling the corresponding
833 architectures INIT function.
835 Returns non-zero if the update succeeds */
837 extern int gdbarch_update_p (struct gdbarch_info info);
841 /* Register per-architecture data-pointer.
843 Reserve space for a per-architecture data-pointer. An identifier
844 for the reserved data-pointer is returned. That identifer should
845 be saved in a local static.
847 When a new architecture is selected, INIT() is called. When a
848 previous architecture is re-selected, the per-architecture
849 data-pointer for that previous architecture is restored (INIT() is
852 INIT() shall return the initial value for the per-architecture
853 data-pointer for the current architecture.
855 Multiple registrarants for any architecture are allowed (and
856 strongly encouraged). */
858 typedef void *(gdbarch_data_ftype) (void);
859 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
861 /* Return the value of the per-architecture data-pointer for the
862 current architecture. */
864 extern void *gdbarch_data (struct gdbarch_data*);
868 /* Register per-architecture memory region.
870 Provide a memory-region swap mechanism. Per-architecture memory
871 region are created. These memory regions are swapped whenever the
872 architecture is changed. For a new architecture, the memory region
873 is initialized with zero (0) and the INIT function is called.
875 Memory regions are swapped / initialized in the order that they are
876 registered. NULL DATA and/or INIT values can be specified.
878 New code should use register_gdbarch_data(). */
880 typedef void (gdbarch_swap_ftype) (void);
881 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
882 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
886 /* The target-system-dependent byte order is dynamic */
888 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
889 is selectable at runtime. The user can use the \`\`set endian''
890 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
891 target_byte_order should be auto-detected (from the program image
895 /* Multi-arch GDB is always bi-endian. */
896 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
899 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
900 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
901 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
902 #ifdef TARGET_BYTE_ORDER_SELECTABLE
903 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
905 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
909 extern int target_byte_order;
910 #ifdef TARGET_BYTE_ORDER_SELECTABLE
911 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
912 and expect defs.h to re-define TARGET_BYTE_ORDER. */
913 #undef TARGET_BYTE_ORDER
915 #ifndef TARGET_BYTE_ORDER
916 #define TARGET_BYTE_ORDER (target_byte_order + 0)
919 extern int target_byte_order_auto;
920 #ifndef TARGET_BYTE_ORDER_AUTO
921 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
926 /* The target-system-dependent BFD architecture is dynamic */
928 extern int target_architecture_auto;
929 #ifndef TARGET_ARCHITECTURE_AUTO
930 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
933 extern const struct bfd_arch_info *target_architecture;
934 #ifndef TARGET_ARCHITECTURE
935 #define TARGET_ARCHITECTURE (target_architecture + 0)
939 /* The target-system-dependent disassembler is semi-dynamic */
941 #include "dis-asm.h" /* Get defs for disassemble_info */
943 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
944 unsigned int len, disassemble_info *info);
946 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
947 disassemble_info *info);
949 extern void dis_asm_print_address (bfd_vma addr,
950 disassemble_info *info);
952 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
953 extern disassemble_info tm_print_insn_info;
954 #ifndef TARGET_PRINT_INSN
955 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
957 #ifndef TARGET_PRINT_INSN_INFO
958 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
963 /* Explicit test for D10V architecture.
964 USE of these macro's is *STRONGLY* discouraged. */
966 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
969 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
970 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
971 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
972 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
974 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
975 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
980 /* Set the dynamic target-system-dependent parameters (architecture,
981 byte-order, ...) using information found in the BFD */
983 extern void set_gdbarch_from_file (bfd *);
986 /* Initialize the current architecture to the "first" one we find on
989 extern void initialize_current_architecture (void);
992 /* gdbarch trace variable */
993 extern int gdbarch_debug;
995 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
1000 #../move-if-change new-gdbarch.h gdbarch.h
1001 compare_new gdbarch.h
1008 exec > new-gdbarch.c
1013 #include "arch-utils.h"
1017 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1019 /* Just include everything in sight so that the every old definition
1020 of macro is visible. */
1021 #include "gdb_string.h"
1025 #include "inferior.h"
1026 #include "breakpoint.h"
1027 #include "gdb_wait.h"
1028 #include "gdbcore.h"
1031 #include "gdbthread.h"
1032 #include "annotate.h"
1033 #include "symfile.h" /* for overlay functions */
1037 #include "floatformat.h"
1039 /* Static function declarations */
1041 static void verify_gdbarch (struct gdbarch *gdbarch);
1042 static void init_gdbarch_data (struct gdbarch *);
1043 static void init_gdbarch_swap (struct gdbarch *);
1044 static void swapout_gdbarch_swap (struct gdbarch *);
1045 static void swapin_gdbarch_swap (struct gdbarch *);
1047 /* Convenience macro for allocting typesafe memory. */
1050 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1054 /* Non-zero if we want to trace architecture code. */
1056 #ifndef GDBARCH_DEBUG
1057 #define GDBARCH_DEBUG 0
1059 int gdbarch_debug = GDBARCH_DEBUG;
1063 # gdbarch open the gdbarch object
1065 printf "/* Maintain the struct gdbarch object */\n"
1067 printf "struct gdbarch\n"
1069 printf " /* basic architectural information */\n"
1070 function_list |
while do_read
1074 printf " ${returntype} ${function};\n"
1078 printf " /* target specific vector. */\n"
1079 printf " struct gdbarch_tdep *tdep;\n"
1080 printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1082 printf " /* per-architecture data-pointers */\n"
1083 printf " int nr_data;\n"
1084 printf " void **data;\n"
1086 printf " /* per-architecture swap-regions */\n"
1087 printf " struct gdbarch_swap *swap;\n"
1090 /* Multi-arch values.
1092 When extending this structure you must:
1094 Add the field below.
1096 Declare set/get functions and define the corresponding
1099 gdbarch_alloc(): If zero/NULL is not a suitable default,
1100 initialize the new field.
1102 verify_gdbarch(): Confirm that the target updated the field
1105 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
1108 \`\`startup_gdbarch()'': Append an initial value to the static
1109 variable (base values on the host's c-type system).
1111 get_gdbarch(): Implement the set/get functions (probably using
1112 the macro's as shortcuts).
1117 function_list |
while do_read
1119 if class_is_variable_p
1121 printf " ${returntype} ${function};\n"
1122 elif class_is_function_p
1124 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
1129 # A pre-initialized vector
1133 /* The default architecture uses host values (for want of a better
1137 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1139 printf "struct gdbarch startup_gdbarch =\n"
1141 printf " /* basic architecture information */\n"
1142 function_list |
while do_read
1146 printf " ${staticdefault},\n"
1150 /* target specific vector and its dump routine */
1152 /*per-architecture data-pointers and swap regions */
1154 /* Multi-arch values */
1156 function_list |
while do_read
1158 if class_is_function_p || class_is_variable_p
1160 printf " ${staticdefault},\n"
1164 /* startup_gdbarch() */
1167 struct gdbarch *current_gdbarch = &startup_gdbarch;
1170 # Create a new gdbarch struct
1174 /* Create a new \`\`struct gdbarch'' based on information provided by
1175 \`\`struct gdbarch_info''. */
1180 gdbarch_alloc (const struct gdbarch_info *info,
1181 struct gdbarch_tdep *tdep)
1183 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1184 memset (gdbarch, 0, sizeof (*gdbarch));
1186 gdbarch->tdep = tdep;
1189 function_list |
while do_read
1193 printf " gdbarch->${function} = info->${function};\n"
1197 printf " /* Force the explicit initialization of these. */\n"
1198 function_list |
while do_read
1200 if class_is_function_p || class_is_variable_p
1202 if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1204 printf " gdbarch->${function} = ${predefault};\n"
1209 /* gdbarch_alloc() */
1215 # Free a gdbarch struct.
1219 /* Free a gdbarch struct. This should never happen in normal
1220 operation --- once you've created a gdbarch, you keep it around.
1221 However, if an architecture's init function encounters an error
1222 building the structure, it may need to clean up a partially
1223 constructed gdbarch. */
1226 gdbarch_free (struct gdbarch *arch)
1228 /* At the moment, this is trivial. */
1233 # verify a new architecture
1236 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1240 verify_gdbarch (struct gdbarch *gdbarch)
1242 /* Only perform sanity checks on a multi-arch target. */
1243 if (!GDB_MULTI_ARCH)
1246 if (gdbarch->byte_order == 0)
1247 internal_error ("verify_gdbarch: byte-order unset");
1248 if (gdbarch->bfd_arch_info == NULL)
1249 internal_error ("verify_gdbarch: bfd_arch_info unset");
1250 /* Check those that need to be defined for the given multi-arch level. */
1252 function_list |
while do_read
1254 if class_is_function_p || class_is_variable_p
1256 if [ "${invalid_p}" = "0" ]
1258 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1259 elif class_is_predicate_p
1261 printf " /* Skip verify of ${function}, has predicate */\n"
1262 # FIXME: See do_read for potential simplification
1263 elif [ "${invalid_p}" -a "${postdefault}" ]
1265 printf " if (${invalid_p})\n"
1266 printf " gdbarch->${function} = ${postdefault};\n"
1267 elif [ "${predefault}" -a "${postdefault}" ]
1269 printf " if (gdbarch->${function} == ${predefault})\n"
1270 printf " gdbarch->${function} = ${postdefault};\n"
1271 elif [ "${postdefault}" ]
1273 printf " if (gdbarch->${function} == 0)\n"
1274 printf " gdbarch->${function} = ${postdefault};\n"
1275 elif [ "${invalid_p}" ]
1277 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1278 printf " && (${invalid_p}))\n"
1279 printf " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1280 elif [ "${predefault}" ]
1282 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1283 printf " && (gdbarch->${function} == ${predefault}))\n"
1284 printf " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1292 # dump the structure
1296 /* Print out the details of the current architecture. */
1298 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1299 just happens to match the global variable \`\`current_gdbarch''. That
1300 way macros refering to that variable get the local and not the global
1301 version - ulgh. Once everything is parameterised with gdbarch, this
1305 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1307 fprintf_unfiltered (file,
1308 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1311 function_list |
while do_read
1313 if [ "${returntype}" = "void" ]
1315 printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1316 printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
1318 printf "#ifdef ${macro}\n"
1320 if class_is_function_p
1322 printf " fprintf_unfiltered (file,\n"
1323 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1324 printf " \"${macro}(${actual})\",\n"
1325 printf " XSTRING (${macro} (${actual})));\n"
1327 printf " fprintf_unfiltered (file,\n"
1328 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1329 printf " XSTRING (${macro}));\n"
1333 function_list |
while do_read
1335 printf "#ifdef ${macro}\n"
1336 if [ "${print_p}" = "()" ]
1338 printf " gdbarch_dump_${function} (current_gdbarch);\n"
1339 elif [ "${print_p}" = "0" ]
1341 printf " /* skip print of ${macro}, print_p == 0. */\n"
1342 elif [ "${print_p}" ]
1344 printf " if (${print_p})\n"
1345 printf " fprintf_unfiltered (file,\n"
1346 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1347 printf " ${print});\n"
1348 elif class_is_function_p
1350 printf " if (GDB_MULTI_ARCH)\n"
1351 printf " fprintf_unfiltered (file,\n"
1352 printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1353 printf " (long) current_gdbarch->${function}\n"
1354 printf " /*${macro} ()*/);\n"
1356 printf " fprintf_unfiltered (file,\n"
1357 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1358 printf " ${print});\n"
1363 if (current_gdbarch->dump_tdep != NULL)
1364 current_gdbarch->dump_tdep (current_gdbarch, file);
1372 struct gdbarch_tdep *
1373 gdbarch_tdep (struct gdbarch *gdbarch)
1375 if (gdbarch_debug >= 2)
1376 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1377 return gdbarch->tdep;
1381 function_list |
while do_read
1383 if class_is_predicate_p
1387 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1391 printf " return ${valid_p};\n"
1393 printf "#error \"gdbarch_${function}_p: not defined\"\n"
1397 if class_is_function_p
1400 printf "${returntype}\n"
1401 if [ "${formal}" = "void" ]
1403 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1405 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1408 printf " if (gdbarch->${function} == 0)\n"
1409 printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1410 printf " if (gdbarch_debug >= 2)\n"
1411 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1412 test "${actual}" = "-" && actual
=""
1413 if [ "${returntype}" = "void" ]
1415 printf " gdbarch->${function} (${actual});\n"
1417 printf " return gdbarch->${function} (${actual});\n"
1422 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1423 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1425 printf " gdbarch->${function} = ${function};\n"
1427 elif class_is_variable_p
1430 printf "${returntype}\n"
1431 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1433 if [ "${invalid_p}" = "0" ]
1435 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1436 elif [ "${invalid_p}" ]
1438 printf " if (${invalid_p})\n"
1439 printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1440 elif [ "${predefault}" ]
1442 printf " if (gdbarch->${function} == ${predefault})\n"
1443 printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1445 printf " if (gdbarch_debug >= 2)\n"
1446 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1447 printf " return gdbarch->${function};\n"
1451 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1452 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1454 printf " gdbarch->${function} = ${function};\n"
1456 elif class_is_info_p
1459 printf "${returntype}\n"
1460 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1462 printf " if (gdbarch_debug >= 2)\n"
1463 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1464 printf " return gdbarch->${function};\n"
1469 # All the trailing guff
1473 /* Keep a registrary of per-architecture data-pointers required by GDB
1481 struct gdbarch_data_registration
1483 gdbarch_data_ftype *init;
1484 struct gdbarch_data *data;
1485 struct gdbarch_data_registration *next;
1488 struct gdbarch_data_registrary
1491 struct gdbarch_data_registration *registrations;
1494 struct gdbarch_data_registrary gdbarch_data_registrary =
1499 struct gdbarch_data *
1500 register_gdbarch_data (gdbarch_data_ftype *init)
1502 struct gdbarch_data_registration **curr;
1503 for (curr = &gdbarch_data_registrary.registrations;
1505 curr = &(*curr)->next);
1506 (*curr) = XMALLOC (struct gdbarch_data_registration);
1507 (*curr)->next = NULL;
1508 (*curr)->init = init;
1509 (*curr)->data = XMALLOC (struct gdbarch_data);
1510 (*curr)->data->index = gdbarch_data_registrary.nr++;
1511 return (*curr)->data;
1515 /* Walk through all the registered users initializing each in turn. */
1518 init_gdbarch_data (struct gdbarch *gdbarch)
1520 struct gdbarch_data_registration *rego;
1521 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1522 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1523 for (rego = gdbarch_data_registrary.registrations;
1527 if (rego->data->index < gdbarch->nr_data)
1528 gdbarch->data[rego->data->index] = rego->init ();
1533 /* Return the current value of the specified per-architecture
1537 gdbarch_data (struct gdbarch_data *data)
1539 if (data->index >= current_gdbarch->nr_data)
1540 internal_error ("gdbarch_data: request for non-existant data.");
1541 return current_gdbarch->data[data->index];
1546 /* Keep a registrary of swapped data required by GDB modules. */
1551 struct gdbarch_swap_registration *source;
1552 struct gdbarch_swap *next;
1555 struct gdbarch_swap_registration
1558 unsigned long sizeof_data;
1559 gdbarch_swap_ftype *init;
1560 struct gdbarch_swap_registration *next;
1563 struct gdbarch_swap_registrary
1566 struct gdbarch_swap_registration *registrations;
1569 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1575 register_gdbarch_swap (void *data,
1576 unsigned long sizeof_data,
1577 gdbarch_swap_ftype *init)
1579 struct gdbarch_swap_registration **rego;
1580 for (rego = &gdbarch_swap_registrary.registrations;
1582 rego = &(*rego)->next);
1583 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1584 (*rego)->next = NULL;
1585 (*rego)->init = init;
1586 (*rego)->data = data;
1587 (*rego)->sizeof_data = sizeof_data;
1592 init_gdbarch_swap (struct gdbarch *gdbarch)
1594 struct gdbarch_swap_registration *rego;
1595 struct gdbarch_swap **curr = &gdbarch->swap;
1596 for (rego = gdbarch_swap_registrary.registrations;
1600 if (rego->data != NULL)
1602 (*curr) = XMALLOC (struct gdbarch_swap);
1603 (*curr)->source = rego;
1604 (*curr)->swap = xmalloc (rego->sizeof_data);
1605 (*curr)->next = NULL;
1606 memset (rego->data, 0, rego->sizeof_data);
1607 curr = &(*curr)->next;
1609 if (rego->init != NULL)
1615 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1617 struct gdbarch_swap *curr;
1618 for (curr = gdbarch->swap;
1621 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1625 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1627 struct gdbarch_swap *curr;
1628 for (curr = gdbarch->swap;
1631 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1635 /* Keep a registrary of the architectures known by GDB. */
1637 struct gdbarch_registration
1639 enum bfd_architecture bfd_architecture;
1640 gdbarch_init_ftype *init;
1641 gdbarch_dump_tdep_ftype *dump_tdep;
1642 struct gdbarch_list *arches;
1643 struct gdbarch_registration *next;
1646 static struct gdbarch_registration *gdbarch_registrary = NULL;
1649 append_name (const char ***buf, int *nr, const char *name)
1651 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1657 gdbarch_printable_names (void)
1661 /* Accumulate a list of names based on the registed list of
1663 enum bfd_architecture a;
1665 const char **arches = NULL;
1666 struct gdbarch_registration *rego;
1667 for (rego = gdbarch_registrary;
1671 const struct bfd_arch_info *ap;
1672 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1674 internal_error ("gdbarch_architecture_names: multi-arch unknown");
1677 append_name (&arches, &nr_arches, ap->printable_name);
1682 append_name (&arches, &nr_arches, NULL);
1686 /* Just return all the architectures that BFD knows. Assume that
1687 the legacy architecture framework supports them. */
1688 return bfd_arch_list ();
1693 gdbarch_register (enum bfd_architecture bfd_architecture,
1694 gdbarch_init_ftype *init,
1695 gdbarch_dump_tdep_ftype *dump_tdep)
1697 struct gdbarch_registration **curr;
1698 const struct bfd_arch_info *bfd_arch_info;
1699 /* Check that BFD recognizes this architecture */
1700 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1701 if (bfd_arch_info == NULL)
1703 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1705 /* Check that we haven't seen this architecture before */
1706 for (curr = &gdbarch_registrary;
1708 curr = &(*curr)->next)
1710 if (bfd_architecture == (*curr)->bfd_architecture)
1711 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1712 bfd_arch_info->printable_name);
1716 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1717 bfd_arch_info->printable_name,
1720 (*curr) = XMALLOC (struct gdbarch_registration);
1721 (*curr)->bfd_architecture = bfd_architecture;
1722 (*curr)->init = init;
1723 (*curr)->dump_tdep = dump_tdep;
1724 (*curr)->arches = NULL;
1725 (*curr)->next = NULL;
1726 /* When non- multi-arch, install what ever target dump routine we've
1727 been provided - hopefully that routine has been writen correct
1728 and works regardless of multi-arch. */
1729 if (!GDB_MULTI_ARCH && dump_tdep != NULL
1730 && startup_gdbarch.dump_tdep == NULL)
1731 startup_gdbarch.dump_tdep = dump_tdep;
1735 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1736 gdbarch_init_ftype *init)
1738 gdbarch_register (bfd_architecture, init, NULL);
1742 /* Look for an architecture using gdbarch_info. Base search on only
1743 BFD_ARCH_INFO and BYTE_ORDER. */
1745 struct gdbarch_list *
1746 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1747 const struct gdbarch_info *info)
1749 for (; arches != NULL; arches = arches->next)
1751 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1753 if (info->byte_order != arches->gdbarch->byte_order)
1761 /* Update the current architecture. Return ZERO if the update request
1765 gdbarch_update_p (struct gdbarch_info info)
1767 struct gdbarch *new_gdbarch;
1768 struct gdbarch_list **list;
1769 struct gdbarch_registration *rego;
1771 /* Fill in any missing bits. Most important is the bfd_architecture
1772 which is used to select the target architecture. */
1773 if (info.bfd_architecture == bfd_arch_unknown)
1775 if (info.bfd_arch_info != NULL)
1776 info.bfd_architecture = info.bfd_arch_info->arch;
1777 else if (info.abfd != NULL)
1778 info.bfd_architecture = bfd_get_arch (info.abfd);
1779 /* FIXME - should query BFD for its default architecture. */
1781 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1783 if (info.bfd_arch_info == NULL)
1785 if (target_architecture_auto && info.abfd != NULL)
1786 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1788 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1790 if (info.byte_order == 0)
1792 if (target_byte_order_auto && info.abfd != NULL)
1793 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1794 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1797 info.byte_order = current_gdbarch->byte_order;
1798 /* FIXME - should query BFD for its default byte-order. */
1800 /* A default for abfd? */
1802 /* Find the target that knows about this architecture. */
1803 for (rego = gdbarch_registrary;
1806 if (rego->bfd_architecture == info.bfd_architecture)
1811 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
1817 fprintf_unfiltered (gdb_stdlog,
1818 "gdbarch_update: info.bfd_architecture %d (%s)\\n",
1819 info.bfd_architecture,
1820 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1821 fprintf_unfiltered (gdb_stdlog,
1822 "gdbarch_update: info.bfd_arch_info %s\\n",
1823 (info.bfd_arch_info != NULL
1824 ? info.bfd_arch_info->printable_name
1826 fprintf_unfiltered (gdb_stdlog,
1827 "gdbarch_update: info.byte_order %d (%s)\\n",
1829 (info.byte_order == BIG_ENDIAN ? "big"
1830 : info.byte_order == LITTLE_ENDIAN ? "little"
1832 fprintf_unfiltered (gdb_stdlog,
1833 "gdbarch_update: info.abfd 0x%lx\\n",
1835 fprintf_unfiltered (gdb_stdlog,
1836 "gdbarch_update: info.tdep_info 0x%lx\\n",
1837 (long) info.tdep_info);
1840 /* Ask the target for a replacement architecture. */
1841 new_gdbarch = rego->init (info, rego->arches);
1843 /* Did the target like it? No. Reject the change. */
1844 if (new_gdbarch == NULL)
1847 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
1851 /* Did the architecture change? No. Do nothing. */
1852 if (current_gdbarch == new_gdbarch)
1855 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
1857 new_gdbarch->bfd_arch_info->printable_name);
1861 /* Swap all data belonging to the old target out */
1862 swapout_gdbarch_swap (current_gdbarch);
1864 /* Is this a pre-existing architecture? Yes. Swap it in. */
1865 for (list = ®o->arches;
1867 list = &(*list)->next)
1869 if ((*list)->gdbarch == new_gdbarch)
1872 fprintf_unfiltered (gdb_stdlog,
1873 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
1875 new_gdbarch->bfd_arch_info->printable_name);
1876 current_gdbarch = new_gdbarch;
1877 swapin_gdbarch_swap (new_gdbarch);
1882 /* Append this new architecture to this targets list. */
1883 (*list) = XMALLOC (struct gdbarch_list);
1884 (*list)->next = NULL;
1885 (*list)->gdbarch = new_gdbarch;
1887 /* Switch to this new architecture. Dump it out. */
1888 current_gdbarch = new_gdbarch;
1891 fprintf_unfiltered (gdb_stdlog,
1892 "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
1894 new_gdbarch->bfd_arch_info->printable_name);
1897 /* Check that the newly installed architecture is valid. Plug in
1898 any post init values. */
1899 new_gdbarch->dump_tdep = rego->dump_tdep;
1900 verify_gdbarch (new_gdbarch);
1902 /* Initialize the per-architecture memory (swap) areas.
1903 CURRENT_GDBARCH must be update before these modules are
1905 init_gdbarch_swap (new_gdbarch);
1907 /* Initialize the per-architecture data-pointer of all parties that
1908 registered an interest in this architecture. CURRENT_GDBARCH
1909 must be updated before these modules are called. */
1910 init_gdbarch_data (new_gdbarch);
1913 gdbarch_dump (current_gdbarch, gdb_stdlog);
1921 /* Pointer to the target-dependent disassembly function. */
1922 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1923 disassemble_info tm_print_insn_info;
1926 extern void _initialize_gdbarch (void);
1929 _initialize_gdbarch (void)
1931 struct cmd_list_element *c;
1933 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1934 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1935 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1936 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1937 tm_print_insn_info.print_address_func = dis_asm_print_address;
1939 add_show_from_set (add_set_cmd ("arch",
1942 (char *)&gdbarch_debug,
1943 "Set architecture debugging.\\n\\
1944 When non-zero, architecture debugging is enabled.", &setdebuglist),
1946 c = add_set_cmd ("archdebug",
1949 (char *)&gdbarch_debug,
1950 "Set architecture debugging.\\n\\
1951 When non-zero, architecture debugging is enabled.", &setlist);
1953 deprecate_cmd (c, "set debug arch");
1954 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
1960 #../move-if-change new-gdbarch.c gdbarch.c
1961 compare_new gdbarch.c