1 #!/usr/local/bin/bash -u
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"
44 test "${staticdefault}" || staticdefault
=0
45 # NOT YET: Breaks BELIEVE_PCC_PROMOTION and confuses non-
46 # multi-arch defaults.
47 # test "${predefault}" || predefault=0
48 test "${fmt}" ||
fmt="%ld"
49 test "${print}" || print
="(long) ${macro}"
50 case "${invalid_p}" in
53 if [ "${predefault}" ]
55 #invalid_p="gdbarch->${function} == ${predefault}"
56 valid_p
="gdbarch->${function} != ${predefault}"
58 #invalid_p="gdbarch->${function} == 0"
59 valid_p
="gdbarch->${function} != 0"
62 * ) valid_p
="!(${invalid_p})"
65 # PREDEFAULT is a valid fallback definition of MEMBER when
66 # multi-arch is not enabled. This ensures that the default
67 # value, when multi-arch is the same as the default value when
68 # not multi-arch. POSTDEFAULT is always a valid definition of
69 # MEMBER as this again ensures consistency.
70 if [ "${postdefault}" != "" ]
72 fallbackdefault
="${postdefault}"
73 elif [ "${predefault}" != "" ]
75 fallbackdefault
="${predefault}"
80 # See gdbarch.log for basic verification of database
90 [ "${postdefault}" != "" -a "${invalid_p}" != "0" ] \
91 ||
[ "${predefault}" != "" -a "${invalid_p}" = "0" ]
94 class_is_variable_p
()
96 [ "${class}" = "v" -o "${class}" = "V" ]
99 class_is_function_p
()
101 [ "${class}" = "f" -o "${class}" = "F" ]
104 class_is_predicate_p
()
106 [ "${class}" = "F" -o "${class}" = "V" ]
115 # dump out/verify the doco
125 # F -> function + predicate
126 # hiding a function + predicate to test function validity
129 # V -> variable + predicate
130 # hiding a variable + predicate to test variables validity
132 # hiding something from the ``struct info'' object
136 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
137 # LEVEL is a predicate on checking that a given method is
138 # initialized (using INVALID_P).
142 # The name of the MACRO that this method is to be accessed by.
146 # For functions, the return type; for variables, the data type
150 # For functions, the member function name; for variables, the
151 # variable name. Member function names are always prefixed with
152 # ``gdbarch_'' for name-space purity.
156 # The formal argument list. It is assumed that the formal
157 # argument list includes the actual name of each list element.
158 # A function with no arguments shall have ``void'' as the
159 # formal argument list.
163 # The list of actual arguments. The arguments specified shall
164 # match the FORMAL list given above. Functions with out
165 # arguments leave this blank.
169 # Any GCC attributes that should be attached to the function
170 # declaration. At present this field is unused.
174 # To help with the GDB startup a static gdbarch object is
175 # created. STATICDEFAULT is the value to insert into that
176 # static gdbarch object. Since this a static object only
177 # simple expressions can be used.
179 # If STATICDEFAULT is empty, zero is used.
183 # A initial value to assign to MEMBER of the freshly
184 # malloc()ed gdbarch object. After the gdbarch object has
185 # been initialized using PREDEFAULT, it is passed to the
186 # target code for further updates.
188 # If PREDEFAULT is empty, zero is used.
190 # When POSTDEFAULT is empty, a non-empty PREDEFAULT and a zero
191 # INVALID_P will be used as default values when when
192 # multi-arch is disabled. Specify a zero PREDEFAULT function
193 # to make that fallback call internal_error().
195 # Variable declarations can refer to ``gdbarch'' which will
196 # contain the current architecture. Care should be taken.
200 # A value to assign to MEMBER of the new gdbarch object should
201 # the target code fail to change the PREDEFAULT value. Also
202 # use POSTDEFAULT as the fallback value for the non-
205 # If POSTDEFAULT is empty, no post update is performed.
207 # If both INVALID_P and POSTDEFAULT are non-empty then
208 # INVALID_P will be used to determine if MEMBER should be
209 # changed to POSTDEFAULT.
211 # You cannot specify both a zero INVALID_P and a POSTDEFAULT.
213 # Variable declarations can refer to ``gdbarch'' which will
214 # contain the current architecture. Care should be taken.
218 # A predicate equation that validates MEMBER. Non-zero is
219 # returned if the code creating the new architecture failed to
220 # initialize MEMBER or the initialized the member is invalid.
221 # If POSTDEFAULT is non-empty then MEMBER will be updated to
222 # that value. If POSTDEFAULT is empty then internal_error()
225 # If INVALID_P is empty, a check that MEMBER is no longer
226 # equal to PREDEFAULT is used.
228 # The expression ``0'' disables the INVALID_P check making
229 # PREDEFAULT a legitimate value.
231 # See also PREDEFAULT and POSTDEFAULT.
235 # printf style format string that can be used to print out the
236 # MEMBER. Sometimes "%s" is useful. For functions, this is
237 # ignored and the function address is printed.
239 # If FMT is empty, ``%ld'' is used.
243 # An optional equation that casts MEMBER to a value suitable
244 # for formatting by FMT.
246 # If PRINT is empty, ``(long)'' is used.
250 # An optional indicator for any predicte to wrap around the
253 # () -> Call a custom function to do the dump.
254 # exp -> Wrap print up in ``if (${print_p}) ...
255 # ``'' -> No predicate
257 # If PRINT_P is empty, ``1'' is always used.
271 # See below (DOCO) for description of each field
273 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct::::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
275 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
277 v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address::0
278 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
279 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
280 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
281 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
282 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
283 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
284 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
285 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
286 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
287 v:1:IEEE_FLOAT:int:ieee_float::::0:0::0:::
289 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
290 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
291 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
292 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
293 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
294 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
296 v:2:NUM_REGS:int:num_regs::::0:-1
297 # This macro gives the number of pseudo-registers that live in the
298 # register namespace but do not get fetched or stored on the target.
299 # These pseudo-registers may be aliases for other registers,
300 # combinations of other registers, or they may be computed by GDB.
301 v:2:NUM_PSEUDO_REGS:int:num_pseudo_regs::::0:0::0:::
302 v:2:SP_REGNUM:int:sp_regnum::::0:-1
303 v:2:FP_REGNUM:int:fp_regnum::::0:-1
304 v:2:PC_REGNUM:int:pc_regnum::::0:-1
305 v:2:FP0_REGNUM:int:fp0_regnum::::0:-1::0
306 v:2:NPC_REGNUM:int:npc_regnum::::0:-1::0
307 v:2:NNPC_REGNUM:int:nnpc_regnum::::0:-1::0
308 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name::0
309 v:2:REGISTER_SIZE:int:register_size::::0:-1
310 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
311 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
312 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
313 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
314 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
315 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
316 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
318 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
319 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
320 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
321 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
322 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1:::0x%08lx
323 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
324 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1:::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
325 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
326 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
327 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
328 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0:0x%08lx
329 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1:::0x%08lx
330 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
331 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
333 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion:::::::
334 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type:::::::
335 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
336 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
338 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not::0
339 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
340 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
341 #This function is called when the value of a pseudo-register needs
342 #to be updated. Typically it will be defined on a per-architecture
344 f:2:FETCH_PSEUDO_REGISTER:void:fetch_pseudo_register:int regnum:regnum:::0::0
345 #This function is called when the value of a pseudo-register needs
346 #to be set or stored. Typically it will be defined on a per-architecture
348 f:2:STORE_PSEUDO_REGISTER:void:store_pseudo_register:int regnum:regnum:::0::0
350 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, void *buf:type, buf:::unsigned_pointer_to_address::0
351 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
353 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not::0
354 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
355 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
356 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
357 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
358 f:2:POP_FRAME:void:pop_frame:void:-:::0
360 # I wish that these would just go away....
361 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0::0
362 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0::0
363 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0::0
364 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0::0
365 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0::0
366 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0::0
368 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
369 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
370 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
371 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
373 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
374 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
376 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
377 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p::0
378 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
379 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc::0
380 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint::0
381 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint::0
382 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
383 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
385 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
387 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
388 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
389 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
390 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
391 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
392 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
393 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
394 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
395 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
397 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
398 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
399 F:2:SAVE_DUMMY_FRAME_TOS:void:save_dummy_frame_tos:CORE_ADDR sp:sp::0:0
401 v:2:TARGET_FLOAT_FORMAT:const struct floatformat *:float_format::::::default_float_format (gdbarch)
402 v:2:TARGET_DOUBLE_FORMAT:const struct floatformat *:double_format::::::default_double_format (gdbarch)
403 v:2:TARGET_LONG_DOUBLE_FORMAT:const struct floatformat *:long_double_format::::::&floatformat_unknown
411 exec > new-gdbarch.log
412 function_list |
while do_read
# eval read $read
415 ${class} ${macro}(${actual})
416 ${returntype} ${function} ($formal)${attrib}
418 staticdefault=${staticdefault}
419 predefault=${predefault}
420 postdefault=${postdefault}
421 fallbackdefault=${fallbackdefault}
422 invalid_p=${invalid_p}
427 description=${description}
429 if class_is_predicate_p
&& fallback_default_p
431 echo "Error: predicate function can not have a non- multi-arch default" 1>&2
435 if [ "${invalid_p}" = "0" -a "${postdefault}" != "" ]
437 echo "Error: postdefault is useless when invalid_p=0" 1>&2
444 compare_new gdbarch.log
450 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
452 /* Dynamic architecture support for GDB, the GNU debugger.
453 Copyright 1998-1999, Free Software Foundation, Inc.
455 This file is part of GDB.
457 This program is free software; you can redistribute it and/or modify
458 it under the terms of the GNU General Public License as published by
459 the Free Software Foundation; either version 2 of the License, or
460 (at your option) any later version.
462 This program is distributed in the hope that it will be useful,
463 but WITHOUT ANY WARRANTY; without even the implied warranty of
464 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
465 GNU General Public License for more details.
467 You should have received a copy of the GNU General Public License
468 along with this program; if not, write to the Free Software
469 Foundation, Inc., 59 Temple Place - Suite 330,
470 Boston, MA 02111-1307, USA. */
472 /* This file was created with the aid of \`\`gdbarch.sh''.
474 The bourn shell script \`\`gdbarch.sh'' creates the files
475 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
476 against the existing \`\`gdbarch.[hc]''. Any differences found
479 If editing this file, please also run gdbarch.sh and merge any
480 changes into that script. Conversely, when makeing sweeping changes
481 to this file, modifying gdbarch.sh and using its output may prove
501 extern struct gdbarch *current_gdbarch;
504 /* If any of the following are defined, the target wasn't correctly
508 #if defined (EXTRA_FRAME_INFO)
509 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
514 #if defined (FRAME_FIND_SAVED_REGS)
515 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
523 echo "/* The following are pre-initialized by GDBARCH. */"
524 function_list |
while do_read
# eval read $read
529 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
530 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
531 echo "#if GDB_MULTI_ARCH"
532 echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})"
533 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
542 echo "/* The following are initialized by the target dependant code. */"
543 function_list |
while do_read
# eval read $read
545 if class_is_predicate_p
548 echo "#if defined (${macro})"
549 echo "/* Legacy for systems yet to multi-arch ${macro} */"
550 # echo "#if (GDB_MULTI_ARCH <= GDB_MULTI_ARCH_PARTIAL) && defined (${macro})"
551 echo "#define ${macro}_P() (1)"
554 echo "/* Default predicate for non- multi-arch targets. */"
555 echo "#if (!GDB_MULTI_ARCH) && !defined (${macro}_P)"
556 echo "#define ${macro}_P() (0)"
559 echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
560 echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro}_P)"
561 echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
564 if class_is_variable_p
566 if fallback_default_p || class_is_predicate_p
569 echo "/* Default (value) for non- multi-arch platforms. */"
570 echo "#if (!GDB_MULTI_ARCH) && !defined (${macro})"
571 echo "#define ${macro} (${fallbackdefault})" \
572 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
576 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
577 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
578 echo "#if GDB_MULTI_ARCH"
579 echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})"
580 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
584 if class_is_function_p
586 if fallback_default_p || class_is_predicate_p
589 echo "/* Default (function) for non- multi-arch platforms. */"
590 echo "#if (!GDB_MULTI_ARCH) && !defined (${macro})"
591 if [ "${fallbackdefault}" = "0" ]
593 echo "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)"
595 # FIXME: Should be passing current_gdbarch through!
596 echo "#define ${macro}(${actual}) (${fallbackdefault} (${actual}))" \
597 |
sed -e 's/\([^a-z_]\)\(gdbarch[^a-z_]\)/\1current_\2/g'
602 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
603 if [ "${formal}" = "void" ]
605 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
607 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
609 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
610 echo "#if GDB_MULTI_ARCH"
611 echo "#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (${macro})"
612 if [ "${actual}" = "" ]
614 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
615 elif [ "${actual}" = "-" ]
617 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
619 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
629 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
632 /* Mechanism for co-ordinating the selection of a specific
635 GDB targets (*-tdep.c) can register an interest in a specific
636 architecture. Other GDB components can register a need to maintain
637 per-architecture data.
639 The mechanisms below ensures that there is only a loose connection
640 between the set-architecture command and the various GDB
641 components. Each component can independantly register their need
642 to maintain architecture specific data with gdbarch.
646 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
649 The more traditional mega-struct containing architecture specific
650 data for all the various GDB components was also considered. Since
651 GDB is built from a variable number of (fairly independant)
652 components it was determined that the global aproach was not
656 /* Register a new architectural family with GDB.
658 Register support for the specified ARCHITECTURE with GDB. When
659 gdbarch determines that the specified architecture has been
660 selected, the corresponding INIT function is called.
664 The INIT function takes two parameters: INFO which contains the
665 information available to gdbarch about the (possibly new)
666 architecture; ARCHES which is a list of the previously created
667 \`\`struct gdbarch'' for this architecture.
669 The INIT function parameter INFO shall, as far as possible, be
670 pre-initialized with information obtained from INFO.ABFD or
671 previously selected architecture (if similar). INIT shall ensure
672 that the INFO.BYTE_ORDER is non-zero.
674 The INIT function shall return any of: NULL - indicating that it
675 doesn't reconize the selected architecture; an existing \`\`struct
676 gdbarch'' from the ARCHES list - indicating that the new
677 architecture is just a synonym for an earlier architecture (see
678 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
679 - that describes the selected architecture (see gdbarch_alloc()).
681 The DUMP_TDEP function shall print out all target specific values.
682 Care should be taken to ensure that the function works in both the
683 multi-arch and non- multi-arch cases. */
687 struct gdbarch *gdbarch;
688 struct gdbarch_list *next;
693 /* Use default: bfd_arch_unknown (ZERO). */
694 enum bfd_architecture bfd_architecture;
696 /* Use default: NULL (ZERO). */
697 const struct bfd_arch_info *bfd_arch_info;
699 /* Use default: 0 (ZERO). */
702 /* Use default: NULL (ZERO). */
705 /* Use default: NULL (ZERO). */
706 struct gdbarch_tdep_info *tdep_info;
709 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
710 typedef void (gdbarch_dump_tdep_ftype) (struct gdbarch *gdbarch, struct ui_file *file);
712 /* DEPRECATED - use gdbarch_register() */
713 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
715 extern void gdbarch_register (enum bfd_architecture architecture,
716 gdbarch_init_ftype *,
717 gdbarch_dump_tdep_ftype *);
720 /* Return a freshly allocated, NULL terminated, array of the valid
721 architecture names. Since architectures are registered during the
722 _initialize phase this function only returns useful information
723 once initialization has been completed. */
725 extern const char **gdbarch_printable_names (void);
728 /* Helper function. Search the list of ARCHES for a GDBARCH that
729 matches the information provided by INFO. */
731 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
734 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
735 basic initialization using values obtained from the INFO andTDEP
736 parameters. set_gdbarch_*() functions are called to complete the
737 initialization of the object. */
739 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
742 /* Helper function. Free a partially-constructed \`\`struct gdbarch''.
743 It is assumed that the caller freeds the \`\`struct
746 extern void gdbarch_free (struct gdbarch *);
749 /* Helper function. Force an update of the current architecture. Used
750 by legacy targets that have added their own target specific
751 architecture manipulation commands.
753 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
754 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
755 called. gdbarch_update() shall initialize any \`\`default'' fields
756 using information obtained from the previous architecture or
757 INFO.ABFD (if specified) before calling the corresponding
758 architectures INIT function. */
760 extern int gdbarch_update (struct gdbarch_info info);
764 /* Register per-architecture data-pointer.
766 Reserve space for a per-architecture data-pointer. An identifier
767 for the reserved data-pointer is returned. That identifer should
768 be saved in a local static.
770 When a new architecture is selected, INIT() is called. When a
771 previous architecture is re-selected, the per-architecture
772 data-pointer for that previous architecture is restored (INIT() is
775 INIT() shall return the initial value for the per-architecture
776 data-pointer for the current architecture.
778 Multiple registrarants for any architecture are allowed (and
779 strongly encouraged). */
781 typedef void *(gdbarch_data_ftype) (void);
782 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
784 /* Return the value of the per-architecture data-pointer for the
785 current architecture. */
787 extern void *gdbarch_data (struct gdbarch_data*);
791 /* Register per-architecture memory region.
793 Provide a memory-region swap mechanism. Per-architecture memory
794 region are created. These memory regions are swapped whenever the
795 architecture is changed. For a new architecture, the memory region
796 is initialized with zero (0) and the INIT function is called.
798 Memory regions are swapped / initialized in the order that they are
799 registered. NULL DATA and/or INIT values can be specified.
801 New code should use register_gdbarch_data(). */
803 typedef void (gdbarch_swap_ftype) (void);
804 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
805 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
809 /* The target-system-dependant byte order is dynamic */
811 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
812 is selectable at runtime. The user can use the \`\`set endian''
813 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
814 target_byte_order should be auto-detected (from the program image
818 /* Multi-arch GDB is always bi-endian. */
819 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
822 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
823 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
824 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
825 #ifdef TARGET_BYTE_ORDER_SELECTABLE
826 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
828 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
832 extern int target_byte_order;
833 #ifdef TARGET_BYTE_ORDER_SELECTABLE
834 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
835 and expect defs.h to re-define TARGET_BYTE_ORDER. */
836 #undef TARGET_BYTE_ORDER
838 #ifndef TARGET_BYTE_ORDER
839 #define TARGET_BYTE_ORDER (target_byte_order + 0)
842 extern int target_byte_order_auto;
843 #ifndef TARGET_BYTE_ORDER_AUTO
844 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
849 /* The target-system-dependant BFD architecture is dynamic */
851 extern int target_architecture_auto;
852 #ifndef TARGET_ARCHITECTURE_AUTO
853 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
856 extern const struct bfd_arch_info *target_architecture;
857 #ifndef TARGET_ARCHITECTURE
858 #define TARGET_ARCHITECTURE (target_architecture + 0)
862 /* The target-system-dependant disassembler is semi-dynamic */
864 #include "dis-asm.h" /* Get defs for disassemble_info */
866 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
867 unsigned int len, disassemble_info *info);
869 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
870 disassemble_info *info);
872 extern void dis_asm_print_address (bfd_vma addr,
873 disassemble_info *info);
875 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
876 extern disassemble_info tm_print_insn_info;
877 #ifndef TARGET_PRINT_INSN
878 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
880 #ifndef TARGET_PRINT_INSN_INFO
881 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
886 /* Explicit test for D10V architecture.
887 USE of these macro's is *STRONGLY* discouraged. */
889 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
892 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
893 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
894 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
895 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
897 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
898 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
903 /* Set the dynamic target-system-dependant parameters (architecture,
904 byte-order, ...) using information found in the BFD */
906 extern void set_gdbarch_from_file (bfd *);
909 /* Initialize the current architecture to the "first" one we find on
912 extern void initialize_current_architecture (void);
915 /* gdbarch trace variable */
916 extern int gdbarch_debug;
918 extern void gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file);
923 #../move-if-change new-gdbarch.h gdbarch.h
924 compare_new gdbarch.h
936 #include "arch-utils.h"
940 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
942 /* Just include everything in sight so that the every old definition
943 of macro is visible. */
944 #include "gdb_string.h"
948 #include "inferior.h"
949 #include "breakpoint.h"
950 #include "gdb_wait.h"
954 #include "gdbthread.h"
955 #include "annotate.h"
956 #include "symfile.h" /* for overlay functions */
960 #include "floatformat.h"
962 /* Static function declarations */
964 static void verify_gdbarch (struct gdbarch *gdbarch);
965 static void init_gdbarch_data (struct gdbarch *);
966 static void init_gdbarch_swap (struct gdbarch *);
967 static void swapout_gdbarch_swap (struct gdbarch *);
968 static void swapin_gdbarch_swap (struct gdbarch *);
970 /* Convenience macro for allocting typesafe memory. */
973 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
977 /* Non-zero if we want to trace architecture code. */
979 #ifndef GDBARCH_DEBUG
980 #define GDBARCH_DEBUG 0
982 int gdbarch_debug = GDBARCH_DEBUG;
986 # gdbarch open the gdbarch object
988 echo "/* Maintain the struct gdbarch object */"
990 echo "struct gdbarch"
992 echo " /* basic architectural information */"
993 function_list |
while do_read
# eval read $read
997 echo " ${returntype} ${function};"
1001 echo " /* target specific vector. */"
1002 echo " struct gdbarch_tdep *tdep;"
1003 echo " gdbarch_dump_tdep_ftype *dump_tdep;"
1005 echo " /* per-architecture data-pointers */"
1006 echo " int nr_data;"
1007 echo " void **data;"
1009 echo " /* per-architecture swap-regions */"
1010 echo " struct gdbarch_swap *swap;"
1013 /* Multi-arch values.
1015 When extending this structure you must:
1017 Add the field below.
1019 Declare set/get functions and define the corresponding
1022 gdbarch_alloc(): If zero/NULL is not a suitable default,
1023 initialize the new field.
1025 verify_gdbarch(): Confirm that the target updated the field
1028 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
1031 \`\`startup_gdbarch()'': Append an initial value to the static
1032 variable (base values on the host's c-type system).
1034 get_gdbarch(): Implement the set/get functions (probably using
1035 the macro's as shortcuts).
1040 function_list |
while do_read
# eval read $read
1042 if class_is_variable_p
1044 echo " ${returntype} ${function};"
1045 elif class_is_function_p
1047 echo " gdbarch_${function}_ftype *${function}${attrib};"
1052 # A pre-initialized vector
1056 /* The default architecture uses host values (for want of a better
1060 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
1062 echo "struct gdbarch startup_gdbarch ="
1064 echo " /* basic architecture information */"
1065 function_list |
while do_read
1069 echo " ${staticdefault},"
1073 /* target specific vector and its dump routine */
1075 /*per-architecture data-pointers and swap regions */
1077 /* Multi-arch values */
1079 function_list |
while do_read
# eval read $read
1081 if class_is_function_p || class_is_variable_p
1083 echo " ${staticdefault},"
1087 /* startup_gdbarch() */
1090 struct gdbarch *current_gdbarch = &startup_gdbarch;
1093 # Create a new gdbarch struct
1097 /* Create a new \`\`struct gdbarch'' based in information provided by
1098 \`\`struct gdbarch_info''. */
1103 gdbarch_alloc (const struct gdbarch_info *info,
1104 struct gdbarch_tdep *tdep)
1106 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1107 memset (gdbarch, 0, sizeof (*gdbarch));
1109 gdbarch->tdep = tdep;
1112 function_list |
while do_read
# eval read $read
1116 echo " gdbarch->${function} = info->${function};"
1120 echo " /* Force the explicit initialization of these. */"
1121 function_list |
while do_read
# eval read $read
1123 if class_is_function_p || class_is_variable_p
1125 if [ "${predefault}" != "" -a "${predefault}" != "0" ]
1127 echo " gdbarch->${function} = ${predefault};"
1132 /* gdbarch_alloc() */
1138 # Free a gdbarch struct.
1142 /* Free a gdbarch struct. This should never happen in normal
1143 operation --- once you've created a gdbarch, you keep it around.
1144 However, if an architecture's init function encounters an error
1145 building the structure, it may need to clean up a partially
1146 constructed gdbarch. */
1149 gdbarch_free (struct gdbarch *arch)
1151 /* At the moment, this is trivial. */
1156 # verify a new architecture
1159 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1163 verify_gdbarch (struct gdbarch *gdbarch)
1165 /* Only perform sanity checks on a multi-arch target. */
1166 if (!GDB_MULTI_ARCH)
1169 if (gdbarch->byte_order == 0)
1170 internal_error ("verify_gdbarch: byte-order unset");
1171 if (gdbarch->bfd_arch_info == NULL)
1172 internal_error ("verify_gdbarch: bfd_arch_info unset");
1173 /* Check those that need to be defined for the given multi-arch level. */
1175 function_list |
while do_read
# eval read $read
1177 if class_is_function_p || class_is_variable_p
1179 if [ "${invalid_p}" = "0" ]
1181 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1182 elif class_is_predicate_p
1184 echo " /* Skip verify of ${function}, has predicate */"
1185 # FIXME: See do_read for potential simplification
1186 elif [ "${invalid_p}" -a "${postdefault}" ]
1188 echo " if (${invalid_p})"
1189 echo " gdbarch->${function} = ${postdefault};"
1190 elif [ "${predefault}" -a "${postdefault}" ]
1192 echo " if (gdbarch->${function} == ${predefault})"
1193 echo " gdbarch->${function} = ${postdefault};"
1194 elif [ "${postdefault}" ]
1196 echo " if (gdbarch->${function} == 0)"
1197 echo " gdbarch->${function} = ${postdefault};"
1198 elif [ "${invalid_p}" ]
1200 echo " if ((GDB_MULTI_ARCH >= ${level})"
1201 echo " && (${invalid_p}))"
1202 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1203 elif [ "${predefault}" ]
1205 echo " if ((GDB_MULTI_ARCH >= ${level})"
1206 echo " && (gdbarch->${function} == ${predefault}))"
1207 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1215 # dump the structure
1219 /* Print out the details of the current architecture. */
1221 /* NOTE/WARNING: The parameter is called \`\`current_gdbarch'' so that it
1222 just happens to match the global variable \`\`current_gdbarch''. That
1223 way macros refering to that variable get the local and not the global
1224 version - ulgh. Once everything is parameterised with gdbarch, this
1228 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
1230 fprintf_unfiltered (file,
1231 "gdbarch_dump: GDB_MULTI_ARCH = %d\\n",
1234 function_list |
while do_read
1236 if [ ${returntype} == "void" ]
1238 echo "#if defined (${macro}) && GDB_MULTI_ARCH"
1239 echo " /* Macro might contain \`[{}]' when not multi-arch */"
1241 echo "#ifdef ${macro}"
1243 if class_is_function_p
1245 echo " fprintf_unfiltered (file,"
1246 echo " \"gdbarch_dump: %s # %s\\n\","
1247 echo " \"${macro}(${actual})\","
1248 echo " XSTRING (${macro} (${actual})));"
1250 echo " fprintf_unfiltered (file,"
1251 echo " \"gdbarch_dump: ${macro} # %s\\n\","
1252 echo " XSTRING (${macro}));"
1256 function_list |
while do_read
1258 echo "#ifdef ${macro}"
1259 if [ "${print_p}" = "()" ]
1261 echo " gdbarch_dump_${function} (current_gdbarch);"
1262 elif [ "${print_p}" = "0" ]
1264 echo " /* skip print of ${macro}, print_p == 0. */"
1265 elif [ "${print_p}" ]
1267 echo " if (${print_p})"
1268 echo " fprintf_unfiltered (file,"
1269 echo " \"gdbarch_dump: ${macro} = ${fmt}\\n\","
1271 elif class_is_function_p
1273 echo " if (GDB_MULTI_ARCH)"
1274 echo " fprintf_unfiltered (file,"
1275 echo " \"gdbarch_dump: ${macro} = 0x%08lx\\n\","
1276 echo " (long) current_gdbarch->${function}"
1277 echo " /*${macro} ()*/);"
1279 echo " fprintf_unfiltered (file,"
1280 echo " \"gdbarch_dump: ${macro} = ${fmt}\\n\","
1286 if (current_gdbarch->dump_tdep != NULL)
1287 current_gdbarch->dump_tdep (current_gdbarch, file);
1295 struct gdbarch_tdep *
1296 gdbarch_tdep (struct gdbarch *gdbarch)
1298 if (gdbarch_debug >= 2)
1299 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1300 return gdbarch->tdep;
1304 function_list |
while do_read
# eval read $read
1306 if class_is_predicate_p
1310 echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1314 echo " return ${valid_p};"
1316 echo "#error \"gdbarch_${function}_p: not defined\""
1320 if class_is_function_p
1323 echo "${returntype}"
1324 if [ "${formal}" = "void" ]
1326 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1328 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1331 echo " if (gdbarch->${function} == 0)"
1332 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1333 echo " if (gdbarch_debug >= 2)"
1334 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1335 test "${actual}" = "-" && actual
=""
1336 if [ "${returntype}" = "void" ]
1338 echo " gdbarch->${function} (${actual});"
1340 echo " return gdbarch->${function} (${actual});"
1345 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1346 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1348 echo " gdbarch->${function} = ${function};"
1350 elif class_is_variable_p
1353 echo "${returntype}"
1354 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1356 if [ "${invalid_p}" = "0" ]
1358 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1359 elif [ "${invalid_p}" ]
1361 echo " if (${invalid_p})"
1362 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1363 elif [ "${predefault}" ]
1365 echo " if (gdbarch->${function} == ${predefault})"
1366 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1368 echo " if (gdbarch_debug >= 2)"
1369 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1370 echo " return gdbarch->${function};"
1374 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1375 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1377 echo " gdbarch->${function} = ${function};"
1379 elif class_is_info_p
1382 echo "${returntype}"
1383 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1385 echo " if (gdbarch_debug >= 2)"
1386 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1387 echo " return gdbarch->${function};"
1392 # All the trailing guff
1396 /* Keep a registrary of per-architecture data-pointers required by GDB
1404 struct gdbarch_data_registration
1406 gdbarch_data_ftype *init;
1407 struct gdbarch_data *data;
1408 struct gdbarch_data_registration *next;
1411 struct gdbarch_data_registrary
1414 struct gdbarch_data_registration *registrations;
1417 struct gdbarch_data_registrary gdbarch_data_registrary =
1422 struct gdbarch_data *
1423 register_gdbarch_data (gdbarch_data_ftype *init)
1425 struct gdbarch_data_registration **curr;
1426 for (curr = &gdbarch_data_registrary.registrations;
1428 curr = &(*curr)->next);
1429 (*curr) = XMALLOC (struct gdbarch_data_registration);
1430 (*curr)->next = NULL;
1431 (*curr)->init = init;
1432 (*curr)->data = XMALLOC (struct gdbarch_data);
1433 (*curr)->data->index = gdbarch_data_registrary.nr++;
1434 return (*curr)->data;
1438 /* Walk through all the registered users initializing each in turn. */
1441 init_gdbarch_data (struct gdbarch *gdbarch)
1443 struct gdbarch_data_registration *rego;
1444 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1445 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1446 for (rego = gdbarch_data_registrary.registrations;
1450 if (rego->data->index < gdbarch->nr_data)
1451 gdbarch->data[rego->data->index] = rego->init ();
1456 /* Return the current value of the specified per-architecture
1461 struct gdbarch_data *data;
1463 if (data->index >= current_gdbarch->nr_data)
1464 internal_error ("gdbarch_data: request for non-existant data.");
1465 return current_gdbarch->data[data->index];
1470 /* Keep a registrary of swaped data required by GDB modules. */
1475 struct gdbarch_swap_registration *source;
1476 struct gdbarch_swap *next;
1479 struct gdbarch_swap_registration
1482 unsigned long sizeof_data;
1483 gdbarch_swap_ftype *init;
1484 struct gdbarch_swap_registration *next;
1487 struct gdbarch_swap_registrary
1490 struct gdbarch_swap_registration *registrations;
1493 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1499 register_gdbarch_swap (void *data,
1500 unsigned long sizeof_data,
1501 gdbarch_swap_ftype *init)
1503 struct gdbarch_swap_registration **rego;
1504 for (rego = &gdbarch_swap_registrary.registrations;
1506 rego = &(*rego)->next);
1507 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1508 (*rego)->next = NULL;
1509 (*rego)->init = init;
1510 (*rego)->data = data;
1511 (*rego)->sizeof_data = sizeof_data;
1516 init_gdbarch_swap (struct gdbarch *gdbarch)
1518 struct gdbarch_swap_registration *rego;
1519 struct gdbarch_swap **curr = &gdbarch->swap;
1520 for (rego = gdbarch_swap_registrary.registrations;
1524 if (rego->data != NULL)
1526 (*curr) = XMALLOC (struct gdbarch_swap);
1527 (*curr)->source = rego;
1528 (*curr)->swap = xmalloc (rego->sizeof_data);
1529 (*curr)->next = NULL;
1530 memset (rego->data, 0, rego->sizeof_data);
1531 curr = &(*curr)->next;
1533 if (rego->init != NULL)
1539 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1541 struct gdbarch_swap *curr;
1542 for (curr = gdbarch->swap;
1545 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1549 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1551 struct gdbarch_swap *curr;
1552 for (curr = gdbarch->swap;
1555 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1559 /* Keep a registrary of the architectures known by GDB. */
1561 struct gdbarch_registration
1563 enum bfd_architecture bfd_architecture;
1564 gdbarch_init_ftype *init;
1565 gdbarch_dump_tdep_ftype *dump_tdep;
1566 struct gdbarch_list *arches;
1567 struct gdbarch_registration *next;
1570 static struct gdbarch_registration *gdbarch_registrary = NULL;
1573 append_name (const char ***buf, int *nr, const char *name)
1575 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
1581 gdbarch_printable_names (void)
1585 /* Accumulate a list of names based on the registed list of
1587 enum bfd_architecture a;
1589 const char **arches = NULL;
1590 struct gdbarch_registration *rego;
1591 for (rego = gdbarch_registrary;
1595 const struct bfd_arch_info *ap;
1596 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1598 internal_error ("gdbarch_architecture_names: multi-arch unknown");
1601 append_name (&arches, &nr_arches, ap->printable_name);
1606 append_name (&arches, &nr_arches, NULL);
1610 /* Just return all the architectures that BFD knows. Assume that
1611 the legacy architecture framework supports them. */
1612 return bfd_arch_list ();
1617 gdbarch_register (enum bfd_architecture bfd_architecture,
1618 gdbarch_init_ftype *init,
1619 gdbarch_dump_tdep_ftype *dump_tdep)
1621 struct gdbarch_registration **curr;
1622 const struct bfd_arch_info *bfd_arch_info;
1623 /* Check that BFD reconizes this architecture */
1624 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1625 if (bfd_arch_info == NULL)
1627 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1629 /* Check that we haven't seen this architecture before */
1630 for (curr = &gdbarch_registrary;
1632 curr = &(*curr)->next)
1634 if (bfd_architecture == (*curr)->bfd_architecture)
1635 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1636 bfd_arch_info->printable_name);
1640 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1641 bfd_arch_info->printable_name,
1644 (*curr) = XMALLOC (struct gdbarch_registration);
1645 (*curr)->bfd_architecture = bfd_architecture;
1646 (*curr)->init = init;
1647 (*curr)->dump_tdep = dump_tdep;
1648 (*curr)->arches = NULL;
1649 (*curr)->next = NULL;
1650 /* When non- multi-arch, install what ever target dump routine we've
1651 been provided - hopefully that routine has been writen correct
1652 and works regardless of multi-arch. */
1653 if (!GDB_MULTI_ARCH && dump_tdep != NULL
1654 && startup_gdbarch.dump_tdep == NULL)
1655 startup_gdbarch.dump_tdep = dump_tdep;
1659 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1660 gdbarch_init_ftype *init)
1662 gdbarch_register (bfd_architecture, init, NULL);
1666 /* Look for an architecture using gdbarch_info. Base search on only
1667 BFD_ARCH_INFO and BYTE_ORDER. */
1669 struct gdbarch_list *
1670 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1671 const struct gdbarch_info *info)
1673 for (; arches != NULL; arches = arches->next)
1675 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1677 if (info->byte_order != arches->gdbarch->byte_order)
1685 /* Update the current architecture. Return ZERO if the update request
1689 gdbarch_update (struct gdbarch_info info)
1691 struct gdbarch *new_gdbarch;
1692 struct gdbarch_list **list;
1693 struct gdbarch_registration *rego;
1695 /* Fill in any missing bits. Most important is the bfd_architecture
1696 which is used to select the target architecture. */
1697 if (info.bfd_architecture == bfd_arch_unknown)
1699 if (info.bfd_arch_info != NULL)
1700 info.bfd_architecture = info.bfd_arch_info->arch;
1701 else if (info.abfd != NULL)
1702 info.bfd_architecture = bfd_get_arch (info.abfd);
1703 /* FIXME - should query BFD for its default architecture. */
1705 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1707 if (info.bfd_arch_info == NULL)
1709 if (target_architecture_auto && info.abfd != NULL)
1710 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1712 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1714 if (info.byte_order == 0)
1716 if (target_byte_order_auto && info.abfd != NULL)
1717 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1718 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1721 info.byte_order = current_gdbarch->byte_order;
1722 /* FIXME - should query BFD for its default byte-order. */
1724 /* A default for abfd? */
1726 /* Find the target that knows about this architecture. */
1727 for (rego = gdbarch_registrary;
1730 if (rego->bfd_architecture == info.bfd_architecture)
1735 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1741 fprintf_unfiltered (gdb_stdlog,
1742 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1743 info.bfd_architecture,
1744 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1745 fprintf_unfiltered (gdb_stdlog,
1746 "gdbarch_update: info.bfd_arch_info %s\n",
1747 (info.bfd_arch_info != NULL
1748 ? info.bfd_arch_info->printable_name
1750 fprintf_unfiltered (gdb_stdlog,
1751 "gdbarch_update: info.byte_order %d (%s)\n",
1753 (info.byte_order == BIG_ENDIAN ? "big"
1754 : info.byte_order == LITTLE_ENDIAN ? "little"
1756 fprintf_unfiltered (gdb_stdlog,
1757 "gdbarch_update: info.abfd 0x%lx\n",
1759 fprintf_unfiltered (gdb_stdlog,
1760 "gdbarch_update: info.tdep_info 0x%lx\n",
1761 (long) info.tdep_info);
1764 /* Ask the target for a replacement architecture. */
1765 new_gdbarch = rego->init (info, rego->arches);
1767 /* Did the target like it? No. Reject the change. */
1768 if (new_gdbarch == NULL)
1771 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1775 /* Did the architecture change? No. Do nothing. */
1776 if (current_gdbarch == new_gdbarch)
1779 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1781 new_gdbarch->bfd_arch_info->printable_name);
1785 /* Swap all data belonging to the old target out */
1786 swapout_gdbarch_swap (current_gdbarch);
1788 /* Is this a pre-existing architecture? Yes. Swap it in. */
1789 for (list = ®o->arches;
1791 list = &(*list)->next)
1793 if ((*list)->gdbarch == new_gdbarch)
1796 fprintf_unfiltered (gdb_stdlog,
1797 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1799 new_gdbarch->bfd_arch_info->printable_name);
1800 current_gdbarch = new_gdbarch;
1801 swapin_gdbarch_swap (new_gdbarch);
1806 /* Append this new architecture to this targets list. */
1807 (*list) = XMALLOC (struct gdbarch_list);
1808 (*list)->next = NULL;
1809 (*list)->gdbarch = new_gdbarch;
1811 /* Switch to this new architecture. Dump it out. */
1812 current_gdbarch = new_gdbarch;
1815 fprintf_unfiltered (gdb_stdlog,
1816 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1818 new_gdbarch->bfd_arch_info->printable_name);
1821 /* Check that the newly installed architecture is valid. Plug in
1822 any post init values. */
1823 new_gdbarch->dump_tdep = rego->dump_tdep;
1824 verify_gdbarch (new_gdbarch);
1826 /* Initialize the per-architecture memory (swap) areas.
1827 CURRENT_GDBARCH must be update before these modules are
1829 init_gdbarch_swap (new_gdbarch);
1831 /* Initialize the per-architecture data-pointer of all parties that
1832 registered an interest in this architecture. CURRENT_GDBARCH
1833 must be updated before these modules are called. */
1834 init_gdbarch_data (new_gdbarch);
1837 gdbarch_dump (current_gdbarch, gdb_stdlog);
1845 /* Pointer to the target-dependent disassembly function. */
1846 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1847 disassemble_info tm_print_insn_info;
1850 extern void _initialize_gdbarch (void);
1853 _initialize_gdbarch ()
1855 struct cmd_list_element *c;
1857 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1858 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1859 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1860 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1861 tm_print_insn_info.print_address_func = dis_asm_print_address;
1863 add_show_from_set (add_set_cmd ("arch",
1866 (char *)&gdbarch_debug,
1867 "Set architecture debugging.\n\\
1868 When non-zero, architecture debugging is enabled.", &setdebuglist),
1870 c = add_set_cmd ("archdebug",
1873 (char *)&gdbarch_debug,
1874 "Set architecture debugging.\n\\
1875 When non-zero, architecture debugging is enabled.", &setlist);
1877 deprecate_cmd (c, "set debug arch");
1878 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
1884 #../move-if-change new-gdbarch.c gdbarch.c
1885 compare_new gdbarch.c