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 # DEFAULT is a valid fallback definition of a MACRO when
38 # multi-arch is not enabled.
39 default_is_fallback_p
()
41 [ "${default}" != "" -a "${invalid_p}" = "0" ]
44 # Format of the input table
45 read="class level macro returntype function formal actual attrib startup default invalid_p fmt print print_p description"
47 class_is_variable_p
()
49 [ "${class}" = "v" -o "${class}" = "V" ]
52 class_is_function_p
()
54 [ "${class}" = "f" -o "${class}" = "F" ]
57 class_is_predicate_p
()
59 [ "${class}" = "F" -o "${class}" = "V" ]
72 test "${startup}" || startup
=0
73 test "${fmt}" ||
fmt="%ld"
74 test "${print}" || print
="(long) ${macro}"
76 #Should set DEFAULT to zero and force the user to provide
78 #test "${default}" || default=0 - NO
79 case "${invalid_p}" in
81 "" ) test "${default}" && valid_p="gdbarch->${function} != ${default}"
83 #test "${default}" && invalid_p="gdbarch->${function} == ${default}"
85 * ) valid_p
="!(${invalid_p})"
95 # dump out/verify the doco
105 # F -> function + predicate
106 # hiding a function + predicate to test function validity
109 # V -> variable + predicate
110 # hiding a variable + predicate to test variables validity
112 # hiding something from the ``struct info'' object
116 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
117 # LEVEL is a predicate on checking that a given method is
118 # initialized (using INVALID_P).
122 # The name of the MACRO that this method is to be accessed by.
126 # For functions, the return type; for variables, the data type
130 # For functions, the member function name; for variables, the
131 # variable name. Member function names are always prefixed with
132 # ``gdbarch_'' for name-space purity.
136 # The formal argument list. It is assumed that the formal
137 # argument list includes the actual name of each list element.
138 # A function with no arguments shall have ``void'' as the
139 # formal argument list.
143 # The list of actual arguments. The arguments specified shall
144 # match the FORMAL list given above. Functions with out
145 # arguments leave this blank.
149 # Any GCC attributes that should be attached to the function
150 # declaration. At present this field is unused.
154 # To help with the GDB startup a static gdbarch object is
155 # created. STARTUP is the value to insert into that static
158 # By default ``0'' is used.
162 # Any initial value to assign to a new gdbarch object after it
163 # as been malloc()ed. Zero is used by default.
165 # Specify a non-empty DEFAULT and a zero INVALID_P to create a
166 # fallback value or function for when multi-arch is disabled.
167 # Specify a zero DEFAULT function to make that fallback
172 # A predicate equation that validates MEMBER. Non-zero is
173 # returned if the code creating the new architecture failed to
174 # initialize the MEMBER or initialized the member to something
175 # invalid. By default, a check that the value is no longer
176 # equal to DEFAULT is performed. The equation ``0'' disables
177 # the invalid_p check.
181 # printf style format string that can be used to print out the
182 # MEMBER. Sometimes "%s" is useful. For functions, this is
183 # ignored and the function address is printed.
185 # By default ```%ld'' is used.
189 # An optional equation that casts MEMBER to a value suitable
190 # for formatting by FMT.
192 # By default ``(long)'' is used.
196 # An optional indicator for any predicte to wrap around the
199 # # -> Wrap print up in ``#ifdef MACRO''
200 # exp -> Wrap print up in ``if (${print_p}) ...
201 # ``'' -> No predicate
215 # See below (DOCO) for description of each field
217 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct:::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
219 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
221 v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address:0
222 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
223 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
224 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
225 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
226 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
227 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
228 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
229 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
230 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
231 v:1:IEEE_FLOAT:int:ieee_float::::0:0:0:::
233 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
234 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
235 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
236 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
237 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
238 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
240 v:2:NUM_REGS:int:num_regs::::0:-1
241 v:2:SP_REGNUM:int:sp_regnum::::0:-1
242 v:2:FP_REGNUM:int:fp_regnum::::0:-1
243 v:2:PC_REGNUM:int:pc_regnum::::0:-1
244 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name:0
245 v:2:REGISTER_SIZE:int:register_size::::0:-1
246 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
247 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
248 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
249 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
250 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
251 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
252 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
254 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
255 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
256 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:
257 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1::0x%08lx
258 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::0x%08lx
259 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
260 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
261 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
262 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
263 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words:0:0x%08lx
264 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words:0:0x%08lx
265 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1::0x%08lx
266 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
267 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:0
269 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::#
270 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::#
271 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
272 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
274 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not:0
275 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
276 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
278 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, char *buf:type, buf:::generic_pointer_to_address:0
279 f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, char *buf, CORE_ADDR addr:type, buf, addr:::generic_address_to_pointer:0
281 f:2:RETURN_VALUE_ON_STACK:int:return_value_on_stack:struct type *type:type:::generic_return_value_on_stack_not:0
282 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
283 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
284 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
285 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
286 f:2:POP_FRAME:void:pop_frame:void:-:::0
288 # I wish that these would just go away....
289 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0:0
290 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0:0
291 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0:0
292 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0:0
293 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0:0
294 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0:0
296 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
297 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
298 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
299 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
301 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
302 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
304 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
305 f:2:PROLOGUE_FRAMELESS_P:int:prologue_frameless_p:CORE_ADDR ip:ip::0:generic_prologue_frameless_p:0
306 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
307 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc:0
308 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
309 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
310 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
311 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
313 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
315 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
316 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not:0
317 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
318 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
319 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
320 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
321 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
322 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
323 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
325 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
326 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
336 function_list |
while do_read
# eval read $read
339 ${class} ${macro}(${actual})
340 ${returntype} ${function} ($formal)${attrib}
344 invalid_p=${invalid_p}
349 description=${description}
351 if class_is_predicate_p
&& default_is_fallback_p
353 echo "Error: predicate function can not have a non- multi-arch default" 1>&2
364 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
366 /* Dynamic architecture support for GDB, the GNU debugger.
367 Copyright 1998-1999, Free Software Foundation, Inc.
369 This file is part of GDB.
371 This program is free software; you can redistribute it and/or modify
372 it under the terms of the GNU General Public License as published by
373 the Free Software Foundation; either version 2 of the License, or
374 (at your option) any later version.
376 This program is distributed in the hope that it will be useful,
377 but WITHOUT ANY WARRANTY; without even the implied warranty of
378 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
379 GNU General Public License for more details.
381 You should have received a copy of the GNU General Public License
382 along with this program; if not, write to the Free Software
383 Foundation, Inc., 59 Temple Place - Suite 330,
384 Boston, MA 02111-1307, USA. */
386 /* This file was created with the aid of \`\`gdbarch.sh''.
388 The bourn shell script \`\`gdbarch.sh'' creates the files
389 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
390 against the existing \`\`gdbarch.[hc]''. Any differences found
393 If editing this file, please also run gdbarch.sh and merge any
394 changes into that script. Conversely, when makeing sweeping changes
395 to this file, modifying gdbarch.sh and using its output may prove
415 #ifndef GDB_MULTI_ARCH
416 #define GDB_MULTI_ARCH 0
419 extern struct gdbarch *current_gdbarch;
422 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
426 /* If any of the following are defined, the target wasn't correctly
430 #if defined (EXTRA_FRAME_INFO)
431 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
436 #if defined (FRAME_FIND_SAVED_REGS)
437 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
445 echo "/* The following are pre-initialized by GDBARCH. */"
446 function_list |
while do_read
# eval read $read
451 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
452 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
453 echo "#if GDB_MULTI_ARCH"
454 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
455 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
464 echo "/* The following are initialized by the target dependant code. */"
465 function_list |
while do_read
# eval read $read
467 if class_is_predicate_p
470 echo "#if defined (${macro})"
471 echo "/* Legacy for systems yet to multi-arch ${macro} */"
472 # echo "#if (GDB_MULTI_ARCH <= 2) && defined (${macro})"
473 echo "#define ${macro}_P() (1)"
476 echo "/* Default predicate for non- multi-arch targets. */"
477 echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro}_P)"
478 echo "#define ${macro}_P() (0)"
481 echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
482 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro}_P)"
483 echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
486 if class_is_variable_p
488 if default_is_fallback_p || class_is_predicate_p
491 echo "/* Default (value) for non- multi-arch platforms. */"
492 echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
493 echo "#define ${macro} (${default})"
497 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
498 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
499 echo "#if GDB_MULTI_ARCH"
500 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
501 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
505 if class_is_function_p
507 if default_is_fallback_p || class_is_predicate_p
510 echo "/* Default (function) for non- multi-arch platforms. */"
511 echo "#if (GDB_MULTI_ARCH == 0) && !defined (${macro})"
512 if [ "${default}" = "0" ]
514 echo "#define ${macro}(${actual}) (internal_error (\"${macro}\"), 0)"
516 echo "#define ${macro}(${actual}) (${default} (${actual}))"
521 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
522 if [ "${formal}" = "void" ]
524 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
526 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
528 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
529 echo "#if GDB_MULTI_ARCH"
530 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
531 if [ "${actual}" = "" ]
533 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
534 elif [ "${actual}" = "-" ]
536 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
538 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
548 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
551 /* Mechanism for co-ordinating the selection of a specific
554 GDB targets (*-tdep.c) can register an interest in a specific
555 architecture. Other GDB components can register a need to maintain
556 per-architecture data.
558 The mechanisms below ensures that there is only a loose connection
559 between the set-architecture command and the various GDB
560 components. Each component can independantly register their need
561 to maintain architecture specific data with gdbarch.
565 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
568 The more traditional mega-struct containing architecture specific
569 data for all the various GDB components was also considered. Since
570 GDB is built from a variable number of (fairly independant)
571 components it was determined that the global aproach was not
575 /* Register a new architectural family with GDB.
577 Register support for the specified ARCHITECTURE with GDB. When
578 gdbarch determines that the specified architecture has been
579 selected, the corresponding INIT function is called.
583 The INIT function takes two parameters: INFO which contains the
584 information available to gdbarch about the (possibly new)
585 architecture; ARCHES which is a list of the previously created
586 \`\`struct gdbarch'' for this architecture.
588 The INIT function parameter INFO shall, as far as possible, be
589 pre-initialized with information obtained from INFO.ABFD or
590 previously selected architecture (if similar). INIT shall ensure
591 that the INFO.BYTE_ORDER is non-zero.
593 The INIT function shall return any of: NULL - indicating that it
594 doesn't reconize the selected architecture; an existing \`\`struct
595 gdbarch'' from the ARCHES list - indicating that the new
596 architecture is just a synonym for an earlier architecture (see
597 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
598 - that describes the selected architecture (see
603 struct gdbarch *gdbarch;
604 struct gdbarch_list *next;
609 /* Use default: bfd_arch_unknown (ZERO). */
610 enum bfd_architecture bfd_architecture;
612 /* Use default: NULL (ZERO). */
613 const struct bfd_arch_info *bfd_arch_info;
615 /* Use default: 0 (ZERO). */
618 /* Use default: NULL (ZERO). */
621 /* Use default: NULL (ZERO). */
622 struct gdbarch_tdep_info *tdep_info;
625 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
627 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
630 /* Helper function. Search the list of ARCHES for a GDBARCH that
631 matches the information provided by INFO. */
633 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
636 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
637 basic initialization using values obtained from the INFO andTDEP
638 parameters. set_gdbarch_*() functions are called to complete the
639 initialization of the object. */
641 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
644 /* Helper function. Free a partially-constructed \`\`struct gdbarch''. */
645 extern void gdbarch_free (struct gdbarch *);
648 /* Helper function. Force an update of the current architecture. Used
649 by legacy targets that have added their own target specific
650 architecture manipulation commands.
652 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
653 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
654 called. gdbarch_update() shall initialize any \`\`default'' fields
655 using information obtained from the previous architecture or
656 INFO.ABFD (if specified) before calling the corresponding
657 architectures INIT function. */
659 extern int gdbarch_update (struct gdbarch_info info);
663 /* Register per-architecture data-pointer.
665 Reserve space for a per-architecture data-pointer. An identifier
666 for the reserved data-pointer is returned. That identifer should
667 be saved in a local static.
669 When a new architecture is selected, INIT() is called. When a
670 previous architecture is re-selected, the per-architecture
671 data-pointer for that previous architecture is restored (INIT() is
674 INIT() shall return the initial value for the per-architecture
675 data-pointer for the current architecture.
677 Multiple registrarants for any architecture are allowed (and
678 strongly encouraged). */
680 typedef void *(gdbarch_data_ftype) (void);
681 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
683 /* Return the value of the per-architecture data-pointer for the
684 current architecture. */
686 extern void *gdbarch_data (struct gdbarch_data*);
690 /* Register per-architecture memory region.
692 Provide a memory-region swap mechanism. Per-architecture memory
693 region are created. These memory regions are swapped whenever the
694 architecture is changed. For a new architecture, the memory region
695 is initialized with zero (0) and the INIT function is called.
697 Memory regions are swapped / initialized in the order that they are
698 registered. NULL DATA and/or INIT values can be specified.
700 New code should use register_gdbarch_data(). */
702 typedef void (gdbarch_swap_ftype) (void);
703 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
704 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
708 /* The target-system-dependant byte order is dynamic */
710 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
711 is selectable at runtime. The user can use the \`\`set endian''
712 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
713 target_byte_order should be auto-detected (from the program image
717 /* Multi-arch GDB is always bi-endian. */
718 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
721 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
722 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
723 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
724 #ifdef TARGET_BYTE_ORDER_SELECTABLE
725 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
727 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
731 extern int target_byte_order;
732 #ifdef TARGET_BYTE_ORDER_SELECTABLE
733 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
734 and expect defs.h to re-define TARGET_BYTE_ORDER. */
735 #undef TARGET_BYTE_ORDER
737 #ifndef TARGET_BYTE_ORDER
738 #define TARGET_BYTE_ORDER (target_byte_order + 0)
741 extern int target_byte_order_auto;
742 #ifndef TARGET_BYTE_ORDER_AUTO
743 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
748 /* The target-system-dependant BFD architecture is dynamic */
750 extern int target_architecture_auto;
751 #ifndef TARGET_ARCHITECTURE_AUTO
752 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
755 extern const struct bfd_arch_info *target_architecture;
756 #ifndef TARGET_ARCHITECTURE
757 #define TARGET_ARCHITECTURE (target_architecture + 0)
760 /* Notify the target dependant backend of a change to the selected
761 architecture. A zero return status indicates that the target did
762 not like the change. */
764 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
768 /* The target-system-dependant disassembler is semi-dynamic */
770 #include "dis-asm.h" /* Get defs for disassemble_info */
772 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
773 unsigned int len, disassemble_info *info);
775 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
776 disassemble_info *info);
778 extern void dis_asm_print_address (bfd_vma addr,
779 disassemble_info *info);
781 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
782 extern disassemble_info tm_print_insn_info;
783 #ifndef TARGET_PRINT_INSN
784 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
786 #ifndef TARGET_PRINT_INSN_INFO
787 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
792 /* Explicit test for D10V architecture.
793 USE of these macro's is *STRONGLY* discouraged. */
795 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
798 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
799 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
800 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
801 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
803 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
804 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
809 /* Set the dynamic target-system-dependant parameters (architecture,
810 byte-order, ...) using information found in the BFD */
812 extern void set_gdbarch_from_file (bfd *);
815 /* Explicitly set the dynamic target-system-dependant parameters based
816 on bfd_architecture and machine. */
818 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
821 /* Initialize the current architecture to the "first" one we find on
824 extern void initialize_current_architecture (void);
826 /* Helper function for targets that don't know how my arguments are
829 extern int frame_num_args_unknown (struct frame_info *fi);
832 /* gdbarch trace variable */
833 extern int gdbarch_debug;
835 extern void gdbarch_dump (void);
840 #../move-if-change new-gdbarch.h gdbarch.h
841 compare_new gdbarch.h
853 #include "arch-utils.h"
857 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
859 /* Just include everything in sight so that the every old definition
860 of macro is visible. */
861 #include "gdb_string.h"
865 #include "inferior.h"
866 #include "breakpoint.h"
867 #include "gdb_wait.h"
871 #include "gdbthread.h"
872 #include "annotate.h"
873 #include "symfile.h" /* for overlay functions */
878 /* Static function declarations */
880 static void verify_gdbarch (struct gdbarch *gdbarch);
881 static void init_gdbarch_data (struct gdbarch *);
882 static void init_gdbarch_swap (struct gdbarch *);
883 static void swapout_gdbarch_swap (struct gdbarch *);
884 static void swapin_gdbarch_swap (struct gdbarch *);
886 /* Convenience macro for allocting typesafe memory. */
889 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
893 /* Non-zero if we want to trace architecture code. */
895 #ifndef GDBARCH_DEBUG
896 #define GDBARCH_DEBUG 0
898 int gdbarch_debug = GDBARCH_DEBUG;
902 # gdbarch open the gdbarch object
904 echo "/* Maintain the struct gdbarch object */"
906 echo "struct gdbarch"
908 echo " /* basic architectural information */"
909 function_list |
while do_read
# eval read $read
913 echo " ${returntype} ${function};"
917 echo " /* target specific vector. */"
918 echo " struct gdbarch_tdep *tdep;"
920 echo " /* per-architecture data-pointers */"
924 echo " /* per-architecture swap-regions */"
925 echo " struct gdbarch_swap *swap;"
928 /* Multi-arch values.
930 When extending this structure you must:
934 Declare set/get functions and define the corresponding
937 gdbarch_alloc(): If zero/NULL is not a suitable default,
938 initialize the new field.
940 verify_gdbarch(): Confirm that the target updated the field
943 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
946 \`\`startup_gdbarch()'': Append an initial value to the static
947 variable (base values on the host's c-type system).
949 get_gdbarch(): Implement the set/get functions (probably using
950 the macro's as shortcuts).
955 function_list |
while do_read
# eval read $read
957 if class_is_variable_p
959 echo " ${returntype} ${function};"
960 elif class_is_function_p
962 echo " gdbarch_${function}_ftype *${function}${attrib};"
967 # A pre-initialized vector
971 /* The default architecture uses host values (for want of a better
975 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
977 echo "struct gdbarch startup_gdbarch = {"
978 echo " /* basic architecture information */"
979 function_list |
while do_read
# eval read $read
987 /* target specific vector */
989 /*per-architecture data-pointers and swap regions */
991 /* Multi-arch values */
993 function_list |
while do_read
# eval read $read
995 if class_is_function_p || class_is_variable_p
1001 /* startup_gdbarch() */
1003 struct gdbarch *current_gdbarch = &startup_gdbarch;
1006 # Create a new gdbarch struct
1010 /* Create a new \`\`struct gdbarch'' based in information provided by
1011 \`\`struct gdbarch_info''. */
1016 gdbarch_alloc (const struct gdbarch_info *info,
1017 struct gdbarch_tdep *tdep)
1019 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1020 memset (gdbarch, 0, sizeof (*gdbarch));
1022 gdbarch->tdep = tdep;
1025 function_list |
while do_read
# eval read $read
1029 echo " gdbarch->${function} = info->${function};"
1033 echo " /* Force the explicit initialization of these. */"
1034 function_list |
while do_read
# eval read $read
1036 if class_is_function_p || class_is_variable_p
1038 if [ "${default}" != "" -a "${default}" != "0" ]
1040 echo " gdbarch->${function} = ${default};"
1045 /* gdbarch_alloc() */
1051 # Free a gdbarch struct.
1055 /* Free a gdbarch struct. This should never happen in normal
1056 operation --- once you've created a gdbarch, you keep it around.
1057 However, if an architecture's init function encounters an error
1058 building the structure, it may need to clean up a partially
1059 constructed gdbarch. */
1061 gdbarch_free (struct gdbarch *arch)
1063 /* At the moment, this is trivial. */
1068 # verify a new architecture
1071 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1075 verify_gdbarch (struct gdbarch *gdbarch)
1077 /* Only perform sanity checks on a multi-arch target. */
1078 if (GDB_MULTI_ARCH <= 0)
1081 if (gdbarch->byte_order == 0)
1082 internal_error ("verify_gdbarch: byte-order unset");
1083 if (gdbarch->bfd_arch_info == NULL)
1084 internal_error ("verify_gdbarch: bfd_arch_info unset");
1085 /* Check those that need to be defined for the given multi-arch level. */
1087 function_list |
while do_read
# eval read $read
1089 if class_is_function_p || class_is_variable_p
1091 if [ "${invalid_p}" = "0" ]
1093 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1094 elif class_is_predicate_p
1096 echo " /* Skip verify of ${function}, has predicate */"
1097 elif [ "${invalid_p}" ]
1099 echo " if ((GDB_MULTI_ARCH >= ${level})"
1100 echo " && (${invalid_p}))"
1101 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1102 elif [ "${default}" ]
1104 echo " if ((GDB_MULTI_ARCH >= ${level})"
1105 echo " && (gdbarch->${function} == ${default}))"
1106 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1114 # dump the structure
1117 echo "/* Print out the details of the current architecture. */"
1124 function_list |
while do_read
# eval read $read
1126 if class_is_function_p
1128 echo " fprintf_unfiltered (gdb_stdlog,"
1129 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1130 echo " (long) current_gdbarch->${function}"
1131 echo " /*${macro} ()*/);"
1133 if [ "${print_p}" = "#" ]
1135 echo "#ifdef ${macro}"
1136 echo " fprintf_unfiltered (gdb_stdlog,"
1137 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1140 elif [ "${print_p}" ]
1142 echo " if (${print_p})"
1143 echo " fprintf_unfiltered (gdb_stdlog,"
1144 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1147 echo " fprintf_unfiltered (gdb_stdlog,"
1148 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1159 struct gdbarch_tdep *
1160 gdbarch_tdep (struct gdbarch *gdbarch)
1162 if (gdbarch_debug >= 2)
1163 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1164 return gdbarch->tdep;
1168 function_list |
while do_read
# eval read $read
1170 if class_is_predicate_p
1174 echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1178 echo " return ${valid_p};"
1180 echo "#error \"gdbarch_${function}_p: not defined\""
1184 if class_is_function_p
1187 echo "${returntype}"
1188 if [ "${formal}" = "void" ]
1190 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1192 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1195 echo " if (gdbarch->${function} == 0)"
1196 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1197 echo " if (gdbarch_debug >= 2)"
1198 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1199 test "${actual}" = "-" && actual
=""
1200 if [ "${returntype}" = "void" ]
1202 echo " gdbarch->${function} (${actual});"
1204 echo " return gdbarch->${function} (${actual});"
1209 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1210 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1212 echo " gdbarch->${function} = ${function};"
1214 elif class_is_variable_p
1217 echo "${returntype}"
1218 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1220 if [ "${invalid_p}" = "0" ]
1222 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1223 elif [ "${invalid_p}" ]
1225 echo " if (${invalid_p})"
1226 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1227 elif [ "${default}" ]
1229 echo " if (gdbarch->${function} == ${default})"
1230 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1232 echo " if (gdbarch_debug >= 2)"
1233 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1234 echo " return gdbarch->${function};"
1238 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1239 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1241 echo " gdbarch->${function} = ${function};"
1243 elif class_is_info_p
1246 echo "${returntype}"
1247 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1249 echo " if (gdbarch_debug >= 2)"
1250 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1251 echo " return gdbarch->${function};"
1256 # All the trailing guff
1260 /* Keep a registrary of per-architecture data-pointers required by GDB
1268 struct gdbarch_data_registration
1270 gdbarch_data_ftype *init;
1271 struct gdbarch_data *data;
1272 struct gdbarch_data_registration *next;
1275 struct gdbarch_data_registrary
1278 struct gdbarch_data_registration *registrations;
1281 struct gdbarch_data_registrary gdbarch_data_registrary =
1286 struct gdbarch_data *
1287 register_gdbarch_data (gdbarch_data_ftype *init)
1289 struct gdbarch_data_registration **curr;
1290 for (curr = &gdbarch_data_registrary.registrations;
1292 curr = &(*curr)->next);
1293 (*curr) = XMALLOC (struct gdbarch_data_registration);
1294 (*curr)->next = NULL;
1295 (*curr)->init = init;
1296 (*curr)->data = XMALLOC (struct gdbarch_data);
1297 (*curr)->data->index = gdbarch_data_registrary.nr++;
1298 return (*curr)->data;
1302 /* Walk through all the registered users initializing each in turn. */
1305 init_gdbarch_data (struct gdbarch *gdbarch)
1307 struct gdbarch_data_registration *rego;
1308 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1309 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1310 for (rego = gdbarch_data_registrary.registrations;
1314 if (rego->data->index < gdbarch->nr_data)
1315 gdbarch->data[rego->data->index] = rego->init ();
1320 /* Return the current value of the specified per-architecture
1325 struct gdbarch_data *data;
1327 if (data->index >= current_gdbarch->nr_data)
1328 internal_error ("gdbarch_data: request for non-existant data.");
1329 return current_gdbarch->data[data->index];
1334 /* Keep a registrary of swaped data required by GDB modules. */
1339 struct gdbarch_swap_registration *source;
1340 struct gdbarch_swap *next;
1343 struct gdbarch_swap_registration
1346 unsigned long sizeof_data;
1347 gdbarch_swap_ftype *init;
1348 struct gdbarch_swap_registration *next;
1351 struct gdbarch_swap_registrary
1354 struct gdbarch_swap_registration *registrations;
1357 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1363 register_gdbarch_swap (void *data,
1364 unsigned long sizeof_data,
1365 gdbarch_swap_ftype *init)
1367 struct gdbarch_swap_registration **rego;
1368 for (rego = &gdbarch_swap_registrary.registrations;
1370 rego = &(*rego)->next);
1371 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1372 (*rego)->next = NULL;
1373 (*rego)->init = init;
1374 (*rego)->data = data;
1375 (*rego)->sizeof_data = sizeof_data;
1380 init_gdbarch_swap (struct gdbarch *gdbarch)
1382 struct gdbarch_swap_registration *rego;
1383 struct gdbarch_swap **curr = &gdbarch->swap;
1384 for (rego = gdbarch_swap_registrary.registrations;
1388 if (rego->data != NULL)
1390 (*curr) = XMALLOC (struct gdbarch_swap);
1391 (*curr)->source = rego;
1392 (*curr)->swap = xmalloc (rego->sizeof_data);
1393 (*curr)->next = NULL;
1394 memset (rego->data, 0, rego->sizeof_data);
1395 curr = &(*curr)->next;
1397 if (rego->init != NULL)
1403 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1405 struct gdbarch_swap *curr;
1406 for (curr = gdbarch->swap;
1409 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1413 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1415 struct gdbarch_swap *curr;
1416 for (curr = gdbarch->swap;
1419 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1423 /* Keep a registrary of the architectures known by GDB. */
1425 struct gdbarch_init_registration
1427 enum bfd_architecture bfd_architecture;
1428 gdbarch_init_ftype *init;
1429 struct gdbarch_list *arches;
1430 struct gdbarch_init_registration *next;
1433 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1436 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1437 gdbarch_init_ftype *init)
1439 struct gdbarch_init_registration **curr;
1440 const struct bfd_arch_info *bfd_arch_info;
1441 /* Check that BFD reconizes this architecture */
1442 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1443 if (bfd_arch_info == NULL)
1445 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1447 /* Check that we haven't seen this architecture before */
1448 for (curr = &gdbarch_init_registrary;
1450 curr = &(*curr)->next)
1452 if (bfd_architecture == (*curr)->bfd_architecture)
1453 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1454 bfd_arch_info->printable_name);
1458 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1459 bfd_arch_info->printable_name,
1462 (*curr) = XMALLOC (struct gdbarch_init_registration);
1463 (*curr)->bfd_architecture = bfd_architecture;
1464 (*curr)->init = init;
1465 (*curr)->arches = NULL;
1466 (*curr)->next = NULL;
1471 /* Look for an architecture using gdbarch_info. Base search on only
1472 BFD_ARCH_INFO and BYTE_ORDER. */
1474 struct gdbarch_list *
1475 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1476 const struct gdbarch_info *info)
1478 for (; arches != NULL; arches = arches->next)
1480 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1482 if (info->byte_order != arches->gdbarch->byte_order)
1490 /* Update the current architecture. Return ZERO if the update request
1494 gdbarch_update (struct gdbarch_info info)
1496 struct gdbarch *new_gdbarch;
1497 struct gdbarch_list **list;
1498 struct gdbarch_init_registration *rego;
1500 /* Fill in any missing bits. Most important is the bfd_architecture
1501 which is used to select the target architecture. */
1502 if (info.bfd_architecture == bfd_arch_unknown)
1504 if (info.bfd_arch_info != NULL)
1505 info.bfd_architecture = info.bfd_arch_info->arch;
1506 else if (info.abfd != NULL)
1507 info.bfd_architecture = bfd_get_arch (info.abfd);
1508 /* FIXME - should query BFD for its default architecture. */
1510 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1512 if (info.bfd_arch_info == NULL)
1514 if (target_architecture_auto && info.abfd != NULL)
1515 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1517 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1519 if (info.byte_order == 0)
1521 if (target_byte_order_auto && info.abfd != NULL)
1522 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1523 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1526 info.byte_order = current_gdbarch->byte_order;
1527 /* FIXME - should query BFD for its default byte-order. */
1529 /* A default for abfd? */
1531 /* Find the target that knows about this architecture. */
1532 for (rego = gdbarch_init_registrary;
1533 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1538 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1544 fprintf_unfiltered (gdb_stdlog,
1545 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1546 info.bfd_architecture,
1547 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1548 fprintf_unfiltered (gdb_stdlog,
1549 "gdbarch_update: info.bfd_arch_info %s\n",
1550 (info.bfd_arch_info != NULL
1551 ? info.bfd_arch_info->printable_name
1553 fprintf_unfiltered (gdb_stdlog,
1554 "gdbarch_update: info.byte_order %d (%s)\n",
1556 (info.byte_order == BIG_ENDIAN ? "big"
1557 : info.byte_order == LITTLE_ENDIAN ? "little"
1559 fprintf_unfiltered (gdb_stdlog,
1560 "gdbarch_update: info.abfd 0x%lx\n",
1562 fprintf_unfiltered (gdb_stdlog,
1563 "gdbarch_update: info.tdep_info 0x%lx\n",
1564 (long) info.tdep_info);
1567 /* Ask the target for a replacement architecture. */
1568 new_gdbarch = rego->init (info, rego->arches);
1570 /* Did the target like it? No. Reject the change. */
1571 if (new_gdbarch == NULL)
1574 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1578 /* Did the architecture change? No. Do nothing. */
1579 if (current_gdbarch == new_gdbarch)
1582 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1584 new_gdbarch->bfd_arch_info->printable_name);
1588 /* Swap all data belonging to the old target out */
1589 swapout_gdbarch_swap (current_gdbarch);
1591 /* Is this a pre-existing architecture? Yes. Swap it in. */
1592 for (list = ®o->arches;
1594 list = &(*list)->next)
1596 if ((*list)->gdbarch == new_gdbarch)
1599 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1601 new_gdbarch->bfd_arch_info->printable_name);
1602 current_gdbarch = new_gdbarch;
1603 swapin_gdbarch_swap (new_gdbarch);
1608 /* Append this new architecture to this targets list. */
1609 (*list) = XMALLOC (struct gdbarch_list);
1610 (*list)->next = NULL;
1611 (*list)->gdbarch = new_gdbarch;
1613 /* Switch to this new architecture. Dump it out. */
1614 current_gdbarch = new_gdbarch;
1617 fprintf_unfiltered (gdb_stdlog,
1618 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1620 new_gdbarch->bfd_arch_info->printable_name);
1624 /* Check that the newly installed architecture is valid. */
1625 verify_gdbarch (new_gdbarch);
1627 /* Initialize the per-architecture memory (swap) areas.
1628 CURRENT_GDBARCH must be update before these modules are
1630 init_gdbarch_swap (new_gdbarch);
1632 /* Initialize the per-architecture data-pointer of all parties that
1633 registered an interest in this architecture. CURRENT_GDBARCH
1634 must be updated before these modules are called. */
1635 init_gdbarch_data (new_gdbarch);
1642 /* Functions to manipulate the endianness of the target. */
1644 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1645 /* compat - Catch old targets that expect a selectable byte-order to
1646 default to BIG_ENDIAN */
1647 #ifndef TARGET_BYTE_ORDER_DEFAULT
1648 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1651 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1652 #ifndef TARGET_BYTE_ORDER_DEFAULT
1653 /* compat - Catch old non byte-order selectable targets that do not
1654 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1655 TARGET_BYTE_ORDER to be used as the default. For targets that
1656 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1657 below will get a strange compiler warning. */
1658 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1661 #ifndef TARGET_BYTE_ORDER_DEFAULT
1662 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1664 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1665 int target_byte_order_auto = 1;
1667 /* Chain containing the \"set endian\" commands. */
1668 static struct cmd_list_element *endianlist = NULL;
1670 /* Called by \`\`show endian''. */
1672 show_endian (char *args, int from_tty)
1675 (TARGET_BYTE_ORDER_AUTO
1676 ? "The target endianness is set automatically (currently %s endian)\n"
1677 : "The target is assumed to be %s endian\n");
1678 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1681 /* Called if the user enters \`\`set endian'' without an argument. */
1683 set_endian (char *args, int from_tty)
1685 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1686 show_endian (args, from_tty);
1689 /* Called by \`\`set endian big''. */
1691 set_endian_big (char *args, int from_tty)
1693 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1695 target_byte_order = BIG_ENDIAN;
1696 target_byte_order_auto = 0;
1699 struct gdbarch_info info;
1700 memset (&info, 0, sizeof info);
1701 info.byte_order = BIG_ENDIAN;
1702 gdbarch_update (info);
1707 printf_unfiltered ("Byte order is not selectable.");
1708 show_endian (args, from_tty);
1712 /* Called by \`\`set endian little''. */
1714 set_endian_little (char *args, int from_tty)
1716 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1718 target_byte_order = LITTLE_ENDIAN;
1719 target_byte_order_auto = 0;
1722 struct gdbarch_info info;
1723 memset (&info, 0, sizeof info);
1724 info.byte_order = LITTLE_ENDIAN;
1725 gdbarch_update (info);
1730 printf_unfiltered ("Byte order is not selectable.");
1731 show_endian (args, from_tty);
1735 /* Called by \`\`set endian auto''. */
1737 set_endian_auto (char *args, int from_tty)
1739 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1741 target_byte_order_auto = 1;
1745 printf_unfiltered ("Byte order is not selectable.");
1746 show_endian (args, from_tty);
1750 /* Set the endianness from a BFD. */
1752 set_endian_from_file (bfd *abfd)
1754 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1758 if (bfd_big_endian (abfd))
1761 want = LITTLE_ENDIAN;
1762 if (TARGET_BYTE_ORDER_AUTO)
1763 target_byte_order = want;
1764 else if (TARGET_BYTE_ORDER != want)
1765 warning ("%s endian file does not match %s endian target.",
1766 want == BIG_ENDIAN ? "big" : "little",
1767 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1771 if (bfd_big_endian (abfd)
1772 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1773 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1774 warning ("%s endian file does not match %s endian target.",
1775 bfd_big_endian (abfd) ? "big" : "little",
1776 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1782 /* Functions to manipulate the architecture of the target */
1784 enum set_arch { set_arch_auto, set_arch_manual };
1786 int target_architecture_auto = 1;
1787 extern const struct bfd_arch_info bfd_default_arch_struct;
1788 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1789 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1791 static void show_endian (char *, int);
1792 static void set_endian (char *, int);
1793 static void set_endian_big (char *, int);
1794 static void set_endian_little (char *, int);
1795 static void set_endian_auto (char *, int);
1796 static void set_endian_from_file (bfd *);
1797 static int arch_ok (const struct bfd_arch_info *arch);
1798 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1799 static void show_architecture (char *, int);
1800 static void set_architecture (char *, int);
1801 static void info_architecture (char *, int);
1802 static void set_architecture_from_file (bfd *);
1804 /* Do the real work of changing the current architecture */
1807 arch_ok (const struct bfd_arch_info *arch)
1809 /* Should be performing the more basic check that the binary is
1810 compatible with GDB. */
1811 /* Check with the target that the architecture is valid. */
1812 return (target_architecture_hook == NULL
1813 || target_architecture_hook (arch));
1817 set_arch (const struct bfd_arch_info *arch,
1823 if (!arch_ok (arch))
1824 warning ("Target may not support %s architecture",
1825 arch->printable_name);
1826 target_architecture = arch;
1828 case set_arch_manual:
1829 if (!arch_ok (arch))
1831 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1832 arch->printable_name);
1836 target_architecture_auto = 0;
1837 target_architecture = arch;
1845 /* Called if the user enters \`\`show architecture'' without an argument. */
1847 show_architecture (char *args, int from_tty)
1850 arch = TARGET_ARCHITECTURE->printable_name;
1851 if (target_architecture_auto)
1852 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1854 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1857 /* Called if the user enters \`\`set architecture'' with or without an
1860 set_architecture (char *args, int from_tty)
1864 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1866 else if (strcmp (args, "auto") == 0)
1868 target_architecture_auto = 1;
1870 else if (GDB_MULTI_ARCH)
1872 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1874 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1877 struct gdbarch_info info;
1878 memset (&info, 0, sizeof info);
1879 info.bfd_arch_info = arch;
1880 if (gdbarch_update (info))
1881 target_architecture_auto = 0;
1883 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1888 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1890 set_arch (arch, set_arch_manual);
1892 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1896 /* Called if the user enters \`\`info architecture'' without an argument. */
1898 info_architecture (char *args, int from_tty)
1900 enum bfd_architecture a;
1903 if (gdbarch_init_registrary != NULL)
1905 struct gdbarch_init_registration *rego;
1906 printf_filtered ("Available architectures are:\n");
1907 for (rego = gdbarch_init_registrary;
1911 const struct bfd_arch_info *ap;
1912 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1917 printf_filtered (" %s", ap->printable_name);
1921 printf_filtered ("\n");
1927 printf_filtered ("There are no available architectures.\n");
1931 printf_filtered ("Available architectures are:\n");
1932 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1934 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1939 printf_filtered (" %s", ap->printable_name);
1943 printf_filtered ("\n");
1948 /* Set the architecture from arch/machine */
1950 set_architecture_from_arch_mach (arch, mach)
1951 enum bfd_architecture arch;
1954 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1956 set_arch (wanted, set_arch_manual);
1958 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1961 /* Set the architecture from a BFD */
1963 set_architecture_from_file (bfd *abfd)
1965 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1966 if (target_architecture_auto)
1968 set_arch (wanted, set_arch_auto);
1970 else if (wanted != target_architecture)
1972 warning ("%s architecture file may be incompatible with %s target.",
1973 wanted->printable_name,
1974 target_architecture->printable_name);
1979 /* Misc helper functions for targets. */
1982 frame_num_args_unknown (fi)
1983 struct frame_info *fi;
1990 generic_register_convertible_not (num)
1999 /* Pointer to the target-dependent disassembly function. */
2000 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2001 disassemble_info tm_print_insn_info;
2005 /* Set the dynamic target-system-dependant parameters (architecture,
2006 byte-order) using information found in the BFD */
2009 set_gdbarch_from_file (abfd)
2014 struct gdbarch_info info;
2015 memset (&info, 0, sizeof info);
2017 gdbarch_update (info);
2020 set_architecture_from_file (abfd);
2021 set_endian_from_file (abfd);
2025 /* Initialize the current architecture. */
2027 initialize_current_architecture ()
2031 struct gdbarch_init_registration *rego;
2032 const struct bfd_arch_info *chosen = NULL;
2033 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
2035 const struct bfd_arch_info *ap
2036 = bfd_lookup_arch (rego->bfd_architecture, 0);
2038 /* Choose the first architecture alphabetically. */
2040 || strcmp (ap->printable_name, chosen->printable_name) < 0)
2046 struct gdbarch_info info;
2047 memset (&info, 0, sizeof info);
2048 info.bfd_arch_info = chosen;
2049 gdbarch_update (info);
2054 extern void _initialize_gdbarch (void);
2056 _initialize_gdbarch ()
2058 struct cmd_list_element *c;
2060 add_prefix_cmd ("endian", class_support, set_endian,
2061 "Set endianness of target.",
2062 &endianlist, "set endian ", 0, &setlist);
2063 add_cmd ("big", class_support, set_endian_big,
2064 "Set target as being big endian.", &endianlist);
2065 add_cmd ("little", class_support, set_endian_little,
2066 "Set target as being little endian.", &endianlist);
2067 add_cmd ("auto", class_support, set_endian_auto,
2068 "Select target endianness automatically.", &endianlist);
2069 add_cmd ("endian", class_support, show_endian,
2070 "Show endianness of target.", &showlist);
2072 add_cmd ("architecture", class_support, set_architecture,
2073 "Set architecture of target.", &setlist);
2074 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
2075 add_cmd ("architecture", class_support, show_architecture,
2076 "Show architecture of target.", &showlist);
2077 add_cmd ("architecture", class_support, info_architecture,
2078 "List supported target architectures", &infolist);
2080 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2081 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2082 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2083 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2084 tm_print_insn_info.print_address_func = dis_asm_print_address;
2086 add_show_from_set (add_set_cmd ("arch",
2089 (char *)&gdbarch_debug,
2090 "Set architecture debugging.\n\\
2091 When non-zero, architecture debugging is enabled.", &setdebuglist),
2093 c = add_set_cmd ("archdebug",
2096 (char *)&gdbarch_debug,
2097 "Set architecture debugging.\n\\
2098 When non-zero, architecture debugging is enabled.", &setlist);
2100 deprecate_cmd (c, "set debug arch");
2101 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2107 #../move-if-change new-gdbarch.c gdbarch.c
2108 compare_new gdbarch.c