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
481 exec > new-gdbarch.log
482 function_list |
while do_read
485 ${class} ${macro}(${actual})
486 ${returntype} ${function} ($formal)${attrib}
490 eval echo \"\ \ \ \
${r}=\
${${r}}\"
492 # #fallbackdefault=${fallbackdefault}
493 # #valid_p=${valid_p}
495 if class_is_predicate_p
&& fallback_default_p
497 echo "Error: predicate function ${macro} can not have a non- multi-arch default" 1>&2
501 if [ "${invalid_p}" = "0" -a "${postdefault}" != "" ]
503 echo "Error: postdefault is useless when invalid_p=0" 1>&2
511 compare_new gdbarch.log
517 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
519 /* Dynamic architecture support for GDB, the GNU debugger.
520 Copyright 1998-1999, Free Software Foundation, Inc.
522 This file is part of GDB.
524 This program is free software; you can redistribute it and/or modify
525 it under the terms of the GNU General Public License as published by
526 the Free Software Foundation; either version 2 of the License, or
527 (at your option) any later version.
529 This program is distributed in the hope that it will be useful,
530 but WITHOUT ANY WARRANTY; without even the implied warranty of
531 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
532 GNU General Public License for more details.
534 You should have received a copy of the GNU General Public License
535 along with this program; if not, write to the Free Software
536 Foundation, Inc., 59 Temple Place - Suite 330,
537 Boston, MA 02111-1307, USA. */
539 /* This file was created with the aid of \`\`gdbarch.sh''.
541 The Bourne shell script \`\`gdbarch.sh'' creates the files
542 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
543 against the existing \`\`gdbarch.[hc]''. Any differences found
546 If editing this file, please also run gdbarch.sh and merge any
547 changes into that script. Conversely, when making sweeping changes
548 to this file, modifying gdbarch.sh and using its output may prove
568 extern struct gdbarch *current_gdbarch;
571 /* If any of the following are defined, the target wasn't correctly
575 #if defined (EXTRA_FRAME_INFO)
576 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
581 #if defined (FRAME_FIND_SAVED_REGS)
582 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
590 printf "/* The following are pre-initialized by GDBARCH. */\n"
591 function_list |
while do_read
596 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
597 printf "/* set_gdbarch_${function}() - not applicable - pre-initialized. */\n"
598 printf "#if GDB_MULTI_ARCH\n"
599 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
600 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
609 printf "/* The following are initialized by the target dependent code. */\n"
610 function_list |
while do_read
614 echo "${comment}" |
sed \
619 if class_is_predicate_p
622 printf "#if defined (${macro})\n"
623 printf "/* Legacy for systems yet to multi-arch ${macro} */\n"
624 # printf "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})\n"
625 printf "#define ${macro}_P() (1)\n"
628 printf "/* Default predicate for non- multi-arch targets. */\n"
629 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)\n"
630 printf "#define ${macro}_P() (0)\n"
633 printf "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);\n"
634 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)\n"
635 printf "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))\n"
638 if class_is_variable_p
640 if fallback_default_p || class_is_predicate_p
643 printf "/* Default (value) for non- multi-arch platforms. */\n"
644 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
645 echo "#define ${macro} (${fallbackdefault})" \
646 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
650 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
651 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});\n"
652 printf "#if GDB_MULTI_ARCH\n"
653 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
654 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
658 if class_is_function_p
660 if fallback_default_p || class_is_predicate_p
663 printf "/* Default (function) for non- multi-arch platforms. */\n"
664 printf "#if (!GDB_MULTI_ARCH) && !defined (${macro})\n"
665 if [ "${fallbackdefault}" = "0" ]
667 printf "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)\n"
669 # FIXME: Should be passing current_gdbarch through!
670 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
671 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
676 printf "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});\n"
677 if [ "${formal}" = "void" ]
679 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);\n"
681 printf "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});\n"
683 printf "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});\n"
684 printf "#if GDB_MULTI_ARCH\n"
685 printf "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})\n"
686 if [ "${actual}" = "" ]
688 printf "#define ${macro}() (gdbarch_${function} (current_gdbarch))\n"
689 elif [ "${actual}" = "-" ]
691 printf "#define ${macro} (gdbarch_${function} (current_gdbarch))\n"
693 printf "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))\n"
703 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
706 /* Mechanism for co-ordinating the selection of a specific
709 GDB targets (*-tdep.c) can register an interest in a specific
710 architecture. Other GDB components can register a need to maintain
711 per-architecture data.
713 The mechanisms below ensures that there is only a loose connection
714 between the set-architecture command and the various GDB
715 components. Each component can independently register their need
716 to maintain architecture specific data with gdbarch.
720 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
723 The more traditional mega-struct containing architecture specific
724 data for all the various GDB components was also considered. Since
725 GDB is built from a variable number of (fairly independent)
726 components it was determined that the global aproach was not
730 /* Register a new architectural family with GDB.
732 Register support for the specified ARCHITECTURE with GDB. When
733 gdbarch determines that the specified architecture has been
734 selected, the corresponding INIT function is called.
738 The INIT function takes two parameters: INFO which contains the
739 information available to gdbarch about the (possibly new)
740 architecture; ARCHES which is a list of the previously created
741 \`\`struct gdbarch'' for this architecture.
743 The INIT function parameter INFO shall, as far as possible, be
744 pre-initialized with information obtained from INFO.ABFD or
745 previously selected architecture (if similar). INIT shall ensure
746 that the INFO.BYTE_ORDER is non-zero.
748 The INIT function shall return any of: NULL - indicating that it
749 doesn't reconize the selected architecture; an existing \`\`struct
750 gdbarch'' from the ARCHES list - indicating that the new
751 architecture is just a synonym for an earlier architecture (see
752 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
753 - that describes the selected architecture (see gdbarch_alloc()).
755 The DUMP_TDEP function shall print out all target specific values.
756 Care should be taken to ensure that the function works in both the
757 multi-arch and non- multi-arch cases. */
761 struct gdbarch *gdbarch;
762 struct gdbarch_list *next;
767 /* Use default: bfd_arch_unknown (ZERO). */
768 enum bfd_architecture bfd_architecture;
770 /* Use default: NULL (ZERO). */
771 const struct bfd_arch_info *bfd_arch_info;
773 /* Use default: 0 (ZERO). */
776 /* Use default: NULL (ZERO). */
779 /* Use default: NULL (ZERO). */
780 struct gdbarch_tdep_info *tdep_info;
783 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
784 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
786 /* DEPRECATED - use gdbarch_register() */
787 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
789 extern void gdbarch_register (enum bfd_architecture architecture,
790 gdbarch_init_ftype *,
791 gdbarch_dump_tdep_ftype *);
794 /* Return a freshly allocated, NULL terminated, array of the valid
795 architecture names. Since architectures are registered during the
796 _initialize phase this function only returns useful information
797 once initialization has been completed. */
799 extern const char **gdbarch_printable_names (void);
802 /* Helper function. Search the list of ARCHES for a GDBARCH that
803 matches the information provided by INFO. */
805 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
808 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
809 basic initialization using values obtained from the INFO andTDEP
810 parameters. set_gdbarch_*() functions are called to complete the
811 initialization of the object. */
813 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
816 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
817 It is assumed that the caller freeds the \`\`struct
820 extern void gdbarch_free (struct gdbarch *);
823 /* Helper function. Force an update of the current architecture. Used
824 by legacy targets that have added their own target specific
825 architecture manipulation commands.
827 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
828 sizeof (info), 0)'' set relevant fields) before gdbarch_update_p()
829 is called. gdbarch_update_p() shall initialize any \`\`default''
830 fields using information obtained from the previous architecture or
831 INFO.ABFD (if specified) before calling the corresponding
832 architectures INIT function.
834 Returns non-zero if the update succeeds */
836 extern int gdbarch_update_p (struct gdbarch_info info);
840 /* Register per-architecture data-pointer.
842 Reserve space for a per-architecture data-pointer. An identifier
843 for the reserved data-pointer is returned. That identifer should
844 be saved in a local static.
846 When a new architecture is selected, INIT() is called. When a
847 previous architecture is re-selected, the per-architecture
848 data-pointer for that previous architecture is restored (INIT() is
851 INIT() shall return the initial value for the per-architecture
852 data-pointer for the current architecture.
854 Multiple registrarants for any architecture are allowed (and
855 strongly encouraged). */
857 typedef void *(gdbarch_data_ftype) (void);
858 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
860 /* Return the value of the per-architecture data-pointer for the
861 current architecture. */
863 extern void *gdbarch_data (struct gdbarch_data*);
867 /* Register per-architecture memory region.
869 Provide a memory-region swap mechanism. Per-architecture memory
870 region are created. These memory regions are swapped whenever the
871 architecture is changed. For a new architecture, the memory region
872 is initialized with zero (0) and the INIT function is called.
874 Memory regions are swapped / initialized in the order that they are
875 registered. NULL DATA and/or INIT values can be specified.
877 New code should use register_gdbarch_data(). */
879 typedef void (gdbarch_swap_ftype) (void);
880 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
881 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
885 /* The target-system-dependent byte order is dynamic */
887 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
888 is selectable at runtime. The user can use the \`\`set endian''
889 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
890 target_byte_order should be auto-detected (from the program image
894 /* Multi-arch GDB is always bi-endian. */
895 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
898 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
899 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
900 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
901 #ifdef TARGET_BYTE_ORDER_SELECTABLE
902 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
904 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
908 extern int target_byte_order;
909 #ifdef TARGET_BYTE_ORDER_SELECTABLE
910 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
911 and expect defs.h to re-define TARGET_BYTE_ORDER. */
912 #undef TARGET_BYTE_ORDER
914 #ifndef TARGET_BYTE_ORDER
915 #define TARGET_BYTE_ORDER (target_byte_order + 0)
918 extern int target_byte_order_auto;
919 #ifndef TARGET_BYTE_ORDER_AUTO
920 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
925 /* The target-system-dependent BFD architecture is dynamic */
927 extern int target_architecture_auto;
928 #ifndef TARGET_ARCHITECTURE_AUTO
929 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
932 extern const struct bfd_arch_info *target_architecture;
933 #ifndef TARGET_ARCHITECTURE
934 #define TARGET_ARCHITECTURE (target_architecture + 0)
938 /* The target-system-dependent disassembler is semi-dynamic */
940 #include "dis-asm.h" /* Get defs for disassemble_info */
942 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
943 unsigned int len, disassemble_info *info);
945 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
946 disassemble_info *info);
948 extern void dis_asm_print_address (bfd_vma addr,
949 disassemble_info *info);
951 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
952 extern disassemble_info tm_print_insn_info;
953 #ifndef TARGET_PRINT_INSN
954 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
956 #ifndef TARGET_PRINT_INSN_INFO
957 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
962 /* Explicit test for D10V architecture.
963 USE of these macro's is *STRONGLY* discouraged. */
965 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
968 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
969 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
970 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
971 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
973 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
974 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
979 /* Set the dynamic target-system-dependent parameters (architecture,
980 byte-order, ...) using information found in the BFD */
982 extern void set_gdbarch_from_file (bfd *);
985 /* Initialize the current architecture to the "first" one we find on
988 extern void initialize_current_architecture (void);
991 /* gdbarch trace variable */
992 extern int gdbarch_debug;
994 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
999 #../move-if-change new-gdbarch.h gdbarch.h
1000 compare_new gdbarch.h
1007 exec > new-gdbarch.c
1012 #include "arch-utils.h"
1016 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
1018 /* Just include everything in sight so that the every old definition
1019 of macro is visible. */
1020 #include "gdb_string.h"
1024 #include "inferior.h"
1025 #include "breakpoint.h"
1026 #include "gdb_wait.h"
1027 #include "gdbcore.h"
1030 #include "gdbthread.h"
1031 #include "annotate.h"
1032 #include "symfile.h" /* for overlay functions */
1036 #include "floatformat.h"
1038 /* Static function declarations */
1040 static void verify_gdbarch (struct gdbarch *gdbarch);
1041 static void init_gdbarch_data (struct gdbarch *);
1042 static void init_gdbarch_swap (struct gdbarch *);
1043 static void swapout_gdbarch_swap (struct gdbarch *);
1044 static void swapin_gdbarch_swap (struct gdbarch *);
1046 /* Convenience macro for allocting typesafe memory. */
1049 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
1053 /* Non-zero if we want to trace architecture code. */
1055 #ifndef GDBARCH_DEBUG
1056 #define GDBARCH_DEBUG 0
1058 int gdbarch_debug = GDBARCH_DEBUG;
1062 # gdbarch open the gdbarch object
1064 printf "/* Maintain the struct gdbarch object */\n"
1066 printf "struct gdbarch\n"
1068 printf " /* basic architectural information */\n"
1069 function_list |
while do_read
1073 printf " ${returntype} ${function};\n"
1077 printf " /* target specific vector. */\n"
1078 printf " struct gdbarch_tdep *tdep;\n"
1079 printf " gdbarch_dump_tdep_ftype *dump_tdep;\n"
1081 printf " /* per-architecture data-pointers */\n"
1082 printf " int nr_data;\n"
1083 printf " void **data;\n"
1085 printf " /* per-architecture swap-regions */\n"
1086 printf " struct gdbarch_swap *swap;\n"
1089 /* Multi-arch values.
1091 When extending this structure you must:
1093 Add the field below.
1095 Declare set/get functions and define the corresponding
1098 gdbarch_alloc(): If zero/NULL is not a suitable default,
1099 initialize the new field.
1101 verify_gdbarch(): Confirm that the target updated the field
1104 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
1107 \`\`startup_gdbarch()'': Append an initial value to the static
1108 variable (base values on the host's c-type system).
1110 get_gdbarch(): Implement the set/get functions (probably using
1111 the macro's as shortcuts).
1116 function_list |
while do_read
1118 if class_is_variable_p
1120 printf " ${returntype} ${function};\n"
1121 elif class_is_function_p
1123 printf " gdbarch_${function}_ftype *${function}${attrib};\n"
1128 # A pre-initialized vector
1132 /* The default architecture uses host values (for want of a better
1136 printf "extern const struct bfd_arch_info bfd_default_arch_struct;\n"
1138 printf "struct gdbarch startup_gdbarch =\n"
1140 printf " /* basic architecture information */\n"
1141 function_list |
while do_read
1145 printf " ${staticdefault},\n"
1149 /* target specific vector and its dump routine */
1151 /*per-architecture data-pointers and swap regions */
1153 /* Multi-arch values */
1155 function_list |
while do_read
1157 if class_is_function_p || class_is_variable_p
1159 printf " ${staticdefault},\n"
1163 /* startup_gdbarch() */
1166 struct gdbarch *current_gdbarch = &startup_gdbarch;
1169 # Create a new gdbarch struct
1173 /* Create a new \`\`struct gdbarch'' based on information provided by
1174 \`\`struct gdbarch_info''. */
1179 gdbarch_alloc (const struct gdbarch_info *info,
1180 struct gdbarch_tdep *tdep)
1182 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1183 memset (gdbarch, 0, sizeof (*gdbarch));
1185 gdbarch->tdep = tdep;
1188 function_list |
while do_read
1192 printf " gdbarch->${function} = info->${function};\n"
1196 printf " /* Force the explicit initialization of these. */\n"
1197 function_list |
while do_read
1199 if class_is_function_p || class_is_variable_p
1201 if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1203 printf " gdbarch->${function} = ${predefault};\n"
1208 /* gdbarch_alloc() */
1214 # Free a gdbarch struct.
1218 /* Free a gdbarch struct. This should never happen in normal
1219 operation --- once you've created a gdbarch, you keep it around.
1220 However, if an architecture's init function encounters an error
1221 building the structure, it may need to clean up a partially
1222 constructed gdbarch. */
1225 gdbarch_free (struct gdbarch *arch)
1227 /* At the moment, this is trivial. */
1232 # verify a new architecture
1235 printf "/* Ensure that all values in a GDBARCH are reasonable. */\n"
1239 verify_gdbarch (struct gdbarch *gdbarch)
1241 /* Only perform sanity checks on a multi-arch target. */
1242 if (!GDB_MULTI_ARCH)
1245 if (gdbarch->byte_order == 0)
1246 internal_error ("verify_gdbarch: byte-order unset");
1247 if (gdbarch->bfd_arch_info == NULL)
1248 internal_error ("verify_gdbarch: bfd_arch_info unset");
1249 /* Check those that need to be defined for the given multi-arch level. */
1251 function_list |
while do_read
1253 if class_is_function_p || class_is_variable_p
1255 if [ "${invalid_p}" = "0" ]
1257 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1258 elif class_is_predicate_p
1260 printf " /* Skip verify of ${function}, has predicate */\n"
1261 # FIXME: See do_read for potential simplification
1262 elif [ "${invalid_p}" -a "${postdefault}" ]
1264 printf " if (${invalid_p})\n"
1265 printf " gdbarch->${function} = ${postdefault};\n"
1266 elif [ "${predefault}" -a "${postdefault}" ]
1268 printf " if (gdbarch->${function} == ${predefault})\n"
1269 printf " gdbarch->${function} = ${postdefault};\n"
1270 elif [ "${postdefault}" ]
1272 printf " if (gdbarch->${function} == 0)\n"
1273 printf " gdbarch->${function} = ${postdefault};\n"
1274 elif [ "${invalid_p}" ]
1276 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1277 printf " && (${invalid_p}))\n"
1278 printf " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1279 elif [ "${predefault}" ]
1281 printf " if ((GDB_MULTI_ARCH >= ${level})\n"
1282 printf " && (gdbarch->${function} == ${predefault}))\n"
1283 printf " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");\n"
1291 # dump the structure
1295 /* Print out the details of the current architecture. */
1297 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1298 just happens to match the global variable \`\`current_gdbarch''. That
1299 way macros refering to that variable get the local and not the global
1300 version - ulgh. Once everything is parameterised with gdbarch, this
1304 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1306 fprintf_unfiltered (file,
1307 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1310 function_list |
while do_read
1312 if [ "${returntype}" = "void" ]
1314 printf "#if defined (${macro}) && GDB_MULTI_ARCH\n"
1315 printf " /* Macro might contain \`[{}]' when not multi-arch */\n"
1317 printf "#ifdef ${macro}\n"
1319 if class_is_function_p
1321 printf " fprintf_unfiltered (file,\n"
1322 printf " \"gdbarch_dump: %%s # %%s\\\\n\",\n"
1323 printf " \"${macro}(${actual})\",\n"
1324 printf " XSTRING (${macro} (${actual})));\n"
1326 printf " fprintf_unfiltered (file,\n"
1327 printf " \"gdbarch_dump: ${macro} # %%s\\\\n\",\n"
1328 printf " XSTRING (${macro}));\n"
1332 function_list |
while do_read
1334 printf "#ifdef ${macro}\n"
1335 if [ "${print_p}" = "()" ]
1337 printf " gdbarch_dump_${function} (current_gdbarch);\n"
1338 elif [ "${print_p}" = "0" ]
1340 printf " /* skip print of ${macro}, print_p == 0. */\n"
1341 elif [ "${print_p}" ]
1343 printf " if (${print_p})\n"
1344 printf " fprintf_unfiltered (file,\n"
1345 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1346 printf " ${print});\n"
1347 elif class_is_function_p
1349 printf " if (GDB_MULTI_ARCH)\n"
1350 printf " fprintf_unfiltered (file,\n"
1351 printf " \"gdbarch_dump: ${macro} = 0x%%08lx\\\\n\",\n"
1352 printf " (long) current_gdbarch->${function}\n"
1353 printf " /*${macro} ()*/);\n"
1355 printf " fprintf_unfiltered (file,\n"
1356 printf " \"gdbarch_dump: ${macro} = %s\\\\n\",\n" "${fmt}"
1357 printf " ${print});\n"
1362 if (current_gdbarch->dump_tdep != NULL)
1363 current_gdbarch->dump_tdep (current_gdbarch, file);
1371 struct gdbarch_tdep *
1372 gdbarch_tdep (struct gdbarch *gdbarch)
1374 if (gdbarch_debug >= 2)
1375 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\\n");
1376 return gdbarch->tdep;
1380 function_list |
while do_read
1382 if class_is_predicate_p
1386 printf "gdbarch_${function}_p (struct gdbarch *gdbarch)\n"
1390 printf " return ${valid_p};\n"
1392 printf "#error \"gdbarch_${function}_p: not defined\"\n"
1396 if class_is_function_p
1399 printf "${returntype}\n"
1400 if [ "${formal}" = "void" ]
1402 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1404 printf "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})\n"
1407 printf " if (gdbarch->${function} == 0)\n"
1408 printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1409 printf " if (gdbarch_debug >= 2)\n"
1410 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1411 test "${actual}" = "-" && actual
=""
1412 if [ "${returntype}" = "void" ]
1414 printf " gdbarch->${function} (${actual});\n"
1416 printf " return gdbarch->${function} (${actual});\n"
1421 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1422 printf " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})\n"
1424 printf " gdbarch->${function} = ${function};\n"
1426 elif class_is_variable_p
1429 printf "${returntype}\n"
1430 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1432 if [ "${invalid_p}" = "0" ]
1434 printf " /* Skip verify of ${function}, invalid_p == 0 */\n"
1435 elif [ "${invalid_p}" ]
1437 printf " if (${invalid_p})\n"
1438 printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1439 elif [ "${predefault}" ]
1441 printf " if (gdbarch->${function} == ${predefault})\n"
1442 printf " internal_error (\"gdbarch: gdbarch_${function} invalid\");\n"
1444 printf " if (gdbarch_debug >= 2)\n"
1445 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1446 printf " return gdbarch->${function};\n"
1450 printf "set_gdbarch_${function} (struct gdbarch *gdbarch,\n"
1451 printf " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})\n"
1453 printf " gdbarch->${function} = ${function};\n"
1455 elif class_is_info_p
1458 printf "${returntype}\n"
1459 printf "gdbarch_${function} (struct gdbarch *gdbarch)\n"
1461 printf " if (gdbarch_debug >= 2)\n"
1462 printf " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\\\\n\");\n"
1463 printf " return gdbarch->${function};\n"
1468 # All the trailing guff
1472 /* Keep a registrary of per-architecture data-pointers required by GDB
1480 struct gdbarch_data_registration
1482 gdbarch_data_ftype *init;
1483 struct gdbarch_data *data;
1484 struct gdbarch_data_registration *next;
1487 struct gdbarch_data_registrary
1490 struct gdbarch_data_registration *registrations;
1493 struct gdbarch_data_registrary gdbarch_data_registrary =
1498 struct gdbarch_data *
1499 register_gdbarch_data (gdbarch_data_ftype *init)
1501 struct gdbarch_data_registration **curr;
1502 for (curr = &gdbarch_data_registrary.registrations;
1504 curr = &(*curr)->next);
1505 (*curr) = XMALLOC (struct gdbarch_data_registration);
1506 (*curr)->next = NULL;
1507 (*curr)->init = init;
1508 (*curr)->data = XMALLOC (struct gdbarch_data);
1509 (*curr)->data->index = gdbarch_data_registrary.nr++;
1510 return (*curr)->data;
1514 /* Walk through all the registered users initializing each in turn. */
1517 init_gdbarch_data (struct gdbarch *gdbarch)
1519 struct gdbarch_data_registration *rego;
1520 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1521 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1522 for (rego = gdbarch_data_registrary.registrations;
1526 if (rego->data->index < gdbarch->nr_data)
1527 gdbarch->data[rego->data->index] = rego->init ();
1532 /* Return the current value of the specified per-architecture
1536 gdbarch_data (struct gdbarch_data *data)
1538 if (data->index >= current_gdbarch->nr_data)
1539 internal_error ("gdbarch_data: request for non-existant data.");
1540 return current_gdbarch->data[data->index];
1545 /* Keep a registrary of swapped data required by GDB modules. */
1550 struct gdbarch_swap_registration *source;
1551 struct gdbarch_swap *next;
1554 struct gdbarch_swap_registration
1557 unsigned long sizeof_data;
1558 gdbarch_swap_ftype *init;
1559 struct gdbarch_swap_registration *next;
1562 struct gdbarch_swap_registrary
1565 struct gdbarch_swap_registration *registrations;
1568 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1574 register_gdbarch_swap (void *data,
1575 unsigned long sizeof_data,
1576 gdbarch_swap_ftype *init)
1578 struct gdbarch_swap_registration **rego;
1579 for (rego = &gdbarch_swap_registrary.registrations;
1581 rego = &(*rego)->next);
1582 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1583 (*rego)->next = NULL;
1584 (*rego)->init = init;
1585 (*rego)->data = data;
1586 (*rego)->sizeof_data = sizeof_data;
1591 init_gdbarch_swap (struct gdbarch *gdbarch)
1593 struct gdbarch_swap_registration *rego;
1594 struct gdbarch_swap **curr = &gdbarch->swap;
1595 for (rego = gdbarch_swap_registrary.registrations;
1599 if (rego->data != NULL)
1601 (*curr) = XMALLOC (struct gdbarch_swap);
1602 (*curr)->source = rego;
1603 (*curr)->swap = xmalloc (rego->sizeof_data);
1604 (*curr)->next = NULL;
1605 memset (rego->data, 0, rego->sizeof_data);
1606 curr = &(*curr)->next;
1608 if (rego->init != NULL)
1614 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1616 struct gdbarch_swap *curr;
1617 for (curr = gdbarch->swap;
1620 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1624 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1626 struct gdbarch_swap *curr;
1627 for (curr = gdbarch->swap;
1630 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1634 /* Keep a registrary of the architectures known by GDB. */
1636 struct gdbarch_registration
1638 enum bfd_architecture bfd_architecture;
1639 gdbarch_init_ftype *init;
1640 gdbarch_dump_tdep_ftype *dump_tdep;
1641 struct gdbarch_list *arches;
1642 struct gdbarch_registration *next;
1645 static struct gdbarch_registration *gdbarch_registrary = NULL;
1648 append_name (const char ***buf, int *nr, const char *name)
1650 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1656 gdbarch_printable_names (void)
1660 /* Accumulate a list of names based on the registed list of
1662 enum bfd_architecture a;
1664 const char **arches = NULL;
1665 struct gdbarch_registration *rego;
1666 for (rego = gdbarch_registrary;
1670 const struct bfd_arch_info *ap;
1671 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1673 internal_error ("gdbarch_architecture_names: multi-arch unknown");
1676 append_name (&arches, &nr_arches, ap->printable_name);
1681 append_name (&arches, &nr_arches, NULL);
1685 /* Just return all the architectures that BFD knows. Assume that
1686 the legacy architecture framework supports them. */
1687 return bfd_arch_list ();
1692 gdbarch_register (enum bfd_architecture bfd_architecture,
1693 gdbarch_init_ftype *init,
1694 gdbarch_dump_tdep_ftype *dump_tdep)
1696 struct gdbarch_registration **curr;
1697 const struct bfd_arch_info *bfd_arch_info;
1698 /* Check that BFD reconizes this architecture */
1699 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1700 if (bfd_arch_info == NULL)
1702 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1704 /* Check that we haven't seen this architecture before */
1705 for (curr = &gdbarch_registrary;
1707 curr = &(*curr)->next)
1709 if (bfd_architecture == (*curr)->bfd_architecture)
1710 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1711 bfd_arch_info->printable_name);
1715 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1716 bfd_arch_info->printable_name,
1719 (*curr) = XMALLOC (struct gdbarch_registration);
1720 (*curr)->bfd_architecture = bfd_architecture;
1721 (*curr)->init = init;
1722 (*curr)->dump_tdep = dump_tdep;
1723 (*curr)->arches = NULL;
1724 (*curr)->next = NULL;
1725 /* When non- multi-arch, install what ever target dump routine we've
1726 been provided - hopefully that routine has been writen correct
1727 and works regardless of multi-arch. */
1728 if (!GDB_MULTI_ARCH && dump_tdep != NULL
1729 && startup_gdbarch.dump_tdep == NULL)
1730 startup_gdbarch.dump_tdep = dump_tdep;
1734 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1735 gdbarch_init_ftype *init)
1737 gdbarch_register (bfd_architecture, init, NULL);
1741 /* Look for an architecture using gdbarch_info. Base search on only
1742 BFD_ARCH_INFO and BYTE_ORDER. */
1744 struct gdbarch_list *
1745 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1746 const struct gdbarch_info *info)
1748 for (; arches != NULL; arches = arches->next)
1750 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1752 if (info->byte_order != arches->gdbarch->byte_order)
1760 /* Update the current architecture. Return ZERO if the update request
1764 gdbarch_update_p (struct gdbarch_info info)
1766 struct gdbarch *new_gdbarch;
1767 struct gdbarch_list **list;
1768 struct gdbarch_registration *rego;
1770 /* Fill in any missing bits. Most important is the bfd_architecture
1771 which is used to select the target architecture. */
1772 if (info.bfd_architecture == bfd_arch_unknown)
1774 if (info.bfd_arch_info != NULL)
1775 info.bfd_architecture = info.bfd_arch_info->arch;
1776 else if (info.abfd != NULL)
1777 info.bfd_architecture = bfd_get_arch (info.abfd);
1778 /* FIXME - should query BFD for its default architecture. */
1780 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1782 if (info.bfd_arch_info == NULL)
1784 if (target_architecture_auto && info.abfd != NULL)
1785 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1787 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1789 if (info.byte_order == 0)
1791 if (target_byte_order_auto && info.abfd != NULL)
1792 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1793 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1796 info.byte_order = current_gdbarch->byte_order;
1797 /* FIXME - should query BFD for its default byte-order. */
1799 /* A default for abfd? */
1801 /* Find the target that knows about this architecture. */
1802 for (rego = gdbarch_registrary;
1805 if (rego->bfd_architecture == info.bfd_architecture)
1810 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\\n");
1816 fprintf_unfiltered (gdb_stdlog,
1817 "gdbarch_update: info.bfd_architecture %d (%s)\\n",
1818 info.bfd_architecture,
1819 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1820 fprintf_unfiltered (gdb_stdlog,
1821 "gdbarch_update: info.bfd_arch_info %s\\n",
1822 (info.bfd_arch_info != NULL
1823 ? info.bfd_arch_info->printable_name
1825 fprintf_unfiltered (gdb_stdlog,
1826 "gdbarch_update: info.byte_order %d (%s)\\n",
1828 (info.byte_order == BIG_ENDIAN ? "big"
1829 : info.byte_order == LITTLE_ENDIAN ? "little"
1831 fprintf_unfiltered (gdb_stdlog,
1832 "gdbarch_update: info.abfd 0x%lx\\n",
1834 fprintf_unfiltered (gdb_stdlog,
1835 "gdbarch_update: info.tdep_info 0x%lx\\n",
1836 (long) info.tdep_info);
1839 /* Ask the target for a replacement architecture. */
1840 new_gdbarch = rego->init (info, rego->arches);
1842 /* Did the target like it? No. Reject the change. */
1843 if (new_gdbarch == NULL)
1846 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\\n");
1850 /* Did the architecture change? No. Do nothing. */
1851 if (current_gdbarch == new_gdbarch)
1854 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\\n",
1856 new_gdbarch->bfd_arch_info->printable_name);
1860 /* Swap all data belonging to the old target out */
1861 swapout_gdbarch_swap (current_gdbarch);
1863 /* Is this a pre-existing architecture? Yes. Swap it in. */
1864 for (list = ®o->arches;
1866 list = &(*list)->next)
1868 if ((*list)->gdbarch == new_gdbarch)
1871 fprintf_unfiltered (gdb_stdlog,
1872 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\\n",
1874 new_gdbarch->bfd_arch_info->printable_name);
1875 current_gdbarch = new_gdbarch;
1876 swapin_gdbarch_swap (new_gdbarch);
1881 /* Append this new architecture to this targets list. */
1882 (*list) = XMALLOC (struct gdbarch_list);
1883 (*list)->next = NULL;
1884 (*list)->gdbarch = new_gdbarch;
1886 /* Switch to this new architecture. Dump it out. */
1887 current_gdbarch = new_gdbarch;
1890 fprintf_unfiltered (gdb_stdlog,
1891 "gdbarch_update: New architecture 0x%08lx (%s) selected\\n",
1893 new_gdbarch->bfd_arch_info->printable_name);
1896 /* Check that the newly installed architecture is valid. Plug in
1897 any post init values. */
1898 new_gdbarch->dump_tdep = rego->dump_tdep;
1899 verify_gdbarch (new_gdbarch);
1901 /* Initialize the per-architecture memory (swap) areas.
1902 CURRENT_GDBARCH must be update before these modules are
1904 init_gdbarch_swap (new_gdbarch);
1906 /* Initialize the per-architecture data-pointer of all parties that
1907 registered an interest in this architecture. CURRENT_GDBARCH
1908 must be updated before these modules are called. */
1909 init_gdbarch_data (new_gdbarch);
1912 gdbarch_dump (current_gdbarch, gdb_stdlog);
1920 /* Pointer to the target-dependent disassembly function. */
1921 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1922 disassemble_info tm_print_insn_info;
1925 extern void _initialize_gdbarch (void);
1928 _initialize_gdbarch (void)
1930 struct cmd_list_element *c;
1932 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1933 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1934 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1935 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1936 tm_print_insn_info.print_address_func = dis_asm_print_address;
1938 add_show_from_set (add_set_cmd ("arch",
1941 (char *)&gdbarch_debug,
1942 "Set architecture debugging.\\n\\
1943 When non-zero, architecture debugging is enabled.", &setdebuglist),
1945 c = add_set_cmd ("archdebug",
1948 (char *)&gdbarch_debug,
1949 "Set architecture debugging.\\n\\
1950 When non-zero, architecture debugging is enabled.", &setlist);
1952 deprecate_cmd (c, "set debug arch");
1953 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
1959 #../move-if-change new-gdbarch.c gdbarch.c
1960 compare_new gdbarch.c