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
292 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0
293 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0
294 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::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:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
306 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc:0
307 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
308 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
309 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
310 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
312 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
314 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
315 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not:0
316 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
317 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
318 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
319 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
320 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
321 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
322 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
324 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
325 F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
335 function_list | while do_read # eval read $read
338 ${class} ${macro}(${actual})
339 ${returntype} ${function} ($formal)${attrib}
343 invalid_p=${invalid_p}
348 description=${description}
350 if class_is_predicate_p && default_is_fallback_p
352 echo "Error: predicate function can not have a non- multi-arch default" 1>&2
362 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
364 /* Dynamic architecture support for GDB, the GNU debugger.
365 Copyright 1998-1999, Free Software Foundation, Inc.
367 This file is part of GDB.
369 This program is free software; you can redistribute it and/or modify
370 it under the terms of the GNU General Public License as published by
371 the Free Software Foundation; either version 2 of the License, or
372 (at your option) any later version.
374 This program is distributed in the hope that it will be useful,
375 but WITHOUT ANY WARRANTY; without even the implied warranty of
376 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
377 GNU General Public License for more details.
379 You should have received a copy of the GNU General Public License
380 along with this program; if not, write to the Free Software
381 Foundation, Inc., 59 Temple Place - Suite 330,
382 Boston, MA 02111-1307, USA. */
384 /* This file was created with the aid of \`\`gdbarch.sh''.
386 The bourn shell script \`\`gdbarch.sh'' creates the files
387 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
388 against the existing \`\`gdbarch.[hc]''. Any differences found
391 If editing this file, please also run gdbarch.sh and merge any
392 changes into that script. Conversely, when makeing sweeping changes
393 to this file, modifying gdbarch.sh and using its output may prove
413 #ifndef GDB_MULTI_ARCH
414 #define GDB_MULTI_ARCH 0
417 extern struct gdbarch *current_gdbarch;
420 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
424 /* If any of the following are defined, the target wasn't correctly
428 #if defined (EXTRA_FRAME_INFO)
429 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
434 #if defined (FRAME_FIND_SAVED_REGS)
435 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
443 echo "/* The following are pre-initialized by GDBARCH. */"
444 function_list | while do_read # eval read $read
449 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
450 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
451 echo "#if GDB_MULTI_ARCH"
452 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
453 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
462 echo "/* The following are initialized by the target dependant code. */"
463 function_list | while do_read # eval read $read
465 if class_is_predicate_p
468 echo "#if defined (${macro})"
469 echo "/* Legacy for systems yet to multi-arch ${macro} */"
470 echo "#define ${macro}_P() (1)"
473 echo "extern int gdbarch_${function}_p (struct gdbarch *gdbarch);"
474 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro}_P)"
475 echo "#define ${macro}_P() (gdbarch_${function}_p (current_gdbarch))"
478 if class_is_variable_p
481 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
482 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
483 if ! default_is_fallback_p && ! class_is_predicate_p
485 echo "#if GDB_MULTI_ARCH"
487 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
488 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
490 if ! default_is_fallback_p && ! class_is_predicate_p
495 if class_is_function_p
498 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
499 if [ "${formal}" = "void" ]
501 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
503 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
505 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
506 if ! default_is_fallback_p && ! class_is_predicate_p
508 echo "#if GDB_MULTI_ARCH"
510 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
511 if [ "${actual}" = "" ]
513 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
514 elif [ "${actual}" = "-" ]
516 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
518 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
521 if ! default_is_fallback_p && ! class_is_predicate_p
531 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
534 /* Mechanism for co-ordinating the selection of a specific
537 GDB targets (*-tdep.c) can register an interest in a specific
538 architecture. Other GDB components can register a need to maintain
539 per-architecture data.
541 The mechanisms below ensures that there is only a loose connection
542 between the set-architecture command and the various GDB
543 components. Each component can independantly register their need
544 to maintain architecture specific data with gdbarch.
548 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
551 The more traditional mega-struct containing architecture specific
552 data for all the various GDB components was also considered. Since
553 GDB is built from a variable number of (fairly independant)
554 components it was determined that the global aproach was not
558 /* Register a new architectural family with GDB.
560 Register support for the specified ARCHITECTURE with GDB. When
561 gdbarch determines that the specified architecture has been
562 selected, the corresponding INIT function is called.
566 The INIT function takes two parameters: INFO which contains the
567 information available to gdbarch about the (possibly new)
568 architecture; ARCHES which is a list of the previously created
569 \`\`struct gdbarch'' for this architecture.
571 The INIT function parameter INFO shall, as far as possible, be
572 pre-initialized with information obtained from INFO.ABFD or
573 previously selected architecture (if similar). INIT shall ensure
574 that the INFO.BYTE_ORDER is non-zero.
576 The INIT function shall return any of: NULL - indicating that it
577 doesn't reconize the selected architecture; an existing \`\`struct
578 gdbarch'' from the ARCHES list - indicating that the new
579 architecture is just a synonym for an earlier architecture (see
580 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
581 - that describes the selected architecture (see
586 struct gdbarch *gdbarch;
587 struct gdbarch_list *next;
592 /* Use default: bfd_arch_unknown (ZERO). */
593 enum bfd_architecture bfd_architecture;
595 /* Use default: NULL (ZERO). */
596 const struct bfd_arch_info *bfd_arch_info;
598 /* Use default: 0 (ZERO). */
601 /* Use default: NULL (ZERO). */
604 /* Use default: NULL (ZERO). */
605 struct gdbarch_tdep_info *tdep_info;
608 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
610 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
613 /* Helper function. Search the list of ARCHES for a GDBARCH that
614 matches the information provided by INFO. */
616 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
619 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
620 basic initialization using values obtained from the INFO andTDEP
621 parameters. set_gdbarch_*() functions are called to complete the
622 initialization of the object. */
624 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
627 /* Helper function. Free a partially-constructed \`\`struct gdbarch''. */
628 extern void gdbarch_free (struct gdbarch *);
631 /* Helper function. Force an update of the current architecture. Used
632 by legacy targets that have added their own target specific
633 architecture manipulation commands.
635 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
636 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
637 called. gdbarch_update() shall initialize any \`\`default'' fields
638 using information obtained from the previous architecture or
639 INFO.ABFD (if specified) before calling the corresponding
640 architectures INIT function. */
642 extern int gdbarch_update (struct gdbarch_info info);
646 /* Register per-architecture data-pointer.
648 Reserve space for a per-architecture data-pointer. An identifier
649 for the reserved data-pointer is returned. That identifer should
650 be saved in a local static.
652 When a new architecture is selected, INIT() is called. When a
653 previous architecture is re-selected, the per-architecture
654 data-pointer for that previous architecture is restored (INIT() is
657 INIT() shall return the initial value for the per-architecture
658 data-pointer for the current architecture.
660 Multiple registrarants for any architecture are allowed (and
661 strongly encouraged). */
663 typedef void *(gdbarch_data_ftype) (void);
664 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
666 /* Return the value of the per-architecture data-pointer for the
667 current architecture. */
669 extern void *gdbarch_data (struct gdbarch_data*);
673 /* Register per-architecture memory region.
675 Provide a memory-region swap mechanism. Per-architecture memory
676 region are created. These memory regions are swapped whenever the
677 architecture is changed. For a new architecture, the memory region
678 is initialized with zero (0) and the INIT function is called.
680 Memory regions are swapped / initialized in the order that they are
681 registered. NULL DATA and/or INIT values can be specified.
683 New code should use register_gdbarch_data(). */
685 typedef void (gdbarch_swap_ftype) (void);
686 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
687 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
691 /* The target-system-dependant byte order is dynamic */
693 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
694 is selectable at runtime. The user can use the \`\`set endian''
695 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
696 target_byte_order should be auto-detected (from the program image
700 /* Multi-arch GDB is always bi-endian. */
701 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
704 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
705 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
706 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
707 #ifdef TARGET_BYTE_ORDER_SELECTABLE
708 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
710 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
714 extern int target_byte_order;
715 #ifdef TARGET_BYTE_ORDER_SELECTABLE
716 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
717 and expect defs.h to re-define TARGET_BYTE_ORDER. */
718 #undef TARGET_BYTE_ORDER
720 #ifndef TARGET_BYTE_ORDER
721 #define TARGET_BYTE_ORDER (target_byte_order + 0)
724 extern int target_byte_order_auto;
725 #ifndef TARGET_BYTE_ORDER_AUTO
726 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
731 /* The target-system-dependant BFD architecture is dynamic */
733 extern int target_architecture_auto;
734 #ifndef TARGET_ARCHITECTURE_AUTO
735 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
738 extern const struct bfd_arch_info *target_architecture;
739 #ifndef TARGET_ARCHITECTURE
740 #define TARGET_ARCHITECTURE (target_architecture + 0)
743 /* Notify the target dependant backend of a change to the selected
744 architecture. A zero return status indicates that the target did
745 not like the change. */
747 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
751 /* The target-system-dependant disassembler is semi-dynamic */
753 #include "dis-asm.h" /* Get defs for disassemble_info */
755 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
756 unsigned int len, disassemble_info *info);
758 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
759 disassemble_info *info);
761 extern void dis_asm_print_address (bfd_vma addr,
762 disassemble_info *info);
764 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
765 extern disassemble_info tm_print_insn_info;
766 #ifndef TARGET_PRINT_INSN
767 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
769 #ifndef TARGET_PRINT_INSN_INFO
770 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
775 /* Explicit test for D10V architecture.
776 USE of these macro's is *STRONGLY* discouraged. */
778 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
781 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
782 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
783 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
784 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
786 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
787 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
792 /* Set the dynamic target-system-dependant parameters (architecture,
793 byte-order, ...) using information found in the BFD */
795 extern void set_gdbarch_from_file (bfd *);
798 /* Explicitly set the dynamic target-system-dependant parameters based
799 on bfd_architecture and machine. */
801 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
804 /* Initialize the current architecture to the "first" one we find on
807 extern void initialize_current_architecture (void);
809 /* Helper function for targets that don't know how my arguments are
812 extern int frame_num_args_unknown (struct frame_info *fi);
815 /* gdbarch trace variable */
816 extern int gdbarch_debug;
818 extern void gdbarch_dump (void);
823 #../move-if-change new-gdbarch.h gdbarch.h
824 compare_new gdbarch.h
836 #include "arch-utils.h"
840 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
842 /* Just include everything in sight so that the every old definition
843 of macro is visible. */
844 #include "gdb_string.h"
848 #include "inferior.h"
849 #include "breakpoint.h"
850 #include "gdb_wait.h"
854 #include "gdbthread.h"
855 #include "annotate.h"
856 #include "symfile.h" /* for overlay functions */
861 /* Static function declarations */
863 static void verify_gdbarch (struct gdbarch *gdbarch);
864 static void init_gdbarch_data (struct gdbarch *);
865 static void init_gdbarch_swap (struct gdbarch *);
866 static void swapout_gdbarch_swap (struct gdbarch *);
867 static void swapin_gdbarch_swap (struct gdbarch *);
869 /* Convenience macro for allocting typesafe memory. */
872 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
876 /* Non-zero if we want to trace architecture code. */
878 #ifndef GDBARCH_DEBUG
879 #define GDBARCH_DEBUG 0
881 int gdbarch_debug = GDBARCH_DEBUG;
885 # gdbarch open the gdbarch object
887 echo "/* Maintain the struct gdbarch object */"
889 echo "struct gdbarch"
891 echo " /* basic architectural information */"
892 function_list | while do_read # eval read $read
896 echo " ${returntype} ${function};"
900 echo " /* target specific vector. */"
901 echo " struct gdbarch_tdep *tdep;"
903 echo " /* per-architecture data-pointers */"
907 echo " /* per-architecture swap-regions */"
908 echo " struct gdbarch_swap *swap;"
911 /* Multi-arch values.
913 When extending this structure you must:
917 Declare set/get functions and define the corresponding
920 gdbarch_alloc(): If zero/NULL is not a suitable default,
921 initialize the new field.
923 verify_gdbarch(): Confirm that the target updated the field
926 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
929 \`\`startup_gdbarch()'': Append an initial value to the static
930 variable (base values on the host's c-type system).
932 get_gdbarch(): Implement the set/get functions (probably using
933 the macro's as shortcuts).
938 function_list | while do_read # eval read $read
940 if class_is_variable_p
942 echo " ${returntype} ${function};"
943 elif class_is_function_p
945 echo " gdbarch_${function}_ftype *${function}${attrib};"
950 # A pre-initialized vector
954 /* The default architecture uses host values (for want of a better
958 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
960 echo "struct gdbarch startup_gdbarch = {"
961 echo " /* basic architecture information */"
962 function_list | while do_read # eval read $read
970 /* target specific vector */
972 /*per-architecture data-pointers and swap regions */
974 /* Multi-arch values */
976 function_list | while do_read # eval read $read
978 if class_is_function_p || class_is_variable_p
984 /* startup_gdbarch() */
986 struct gdbarch *current_gdbarch = &startup_gdbarch;
989 # Create a new gdbarch struct
993 /* Create a new \`\`struct gdbarch'' based in information provided by
994 \`\`struct gdbarch_info''. */
999 gdbarch_alloc (const struct gdbarch_info *info,
1000 struct gdbarch_tdep *tdep)
1002 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
1003 memset (gdbarch, 0, sizeof (*gdbarch));
1005 gdbarch->tdep = tdep;
1008 function_list | while do_read # eval read $read
1012 echo " gdbarch->${function} = info->${function};"
1016 echo " /* Force the explicit initialization of these. */"
1017 function_list | while do_read # eval read $read
1019 if class_is_function_p || class_is_variable_p
1021 if [ "${default}" != "" -a "${default}" != "0" ]
1023 echo " gdbarch->${function} = ${default};"
1028 /* gdbarch_alloc() */
1034 # Free a gdbarch struct.
1038 /* Free a gdbarch struct. This should never happen in normal
1039 operation --- once you've created a gdbarch, you keep it around.
1040 However, if an architecture's init function encounters an error
1041 building the structure, it may need to clean up a partially
1042 constructed gdbarch. */
1044 gdbarch_free (struct gdbarch *arch)
1046 /* At the moment, this is trivial. */
1051 # verify a new architecture
1054 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1058 verify_gdbarch (struct gdbarch *gdbarch)
1060 /* Only perform sanity checks on a multi-arch target. */
1061 if (GDB_MULTI_ARCH <= 0)
1064 if (gdbarch->byte_order == 0)
1065 internal_error ("verify_gdbarch: byte-order unset");
1066 if (gdbarch->bfd_arch_info == NULL)
1067 internal_error ("verify_gdbarch: bfd_arch_info unset");
1068 /* Check those that need to be defined for the given multi-arch level. */
1070 function_list | while do_read # eval read $read
1072 if class_is_function_p || class_is_variable_p
1074 if [ "${invalid_p}" = "0" ]
1076 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1077 elif class_is_predicate_p
1079 echo " /* Skip verify of ${function}, has predicate */"
1080 elif [ "${invalid_p}" ]
1082 echo " if ((GDB_MULTI_ARCH >= ${level})"
1083 echo " && (${invalid_p}))"
1084 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1085 elif [ "${default}" ]
1087 echo " if ((GDB_MULTI_ARCH >= ${level})"
1088 echo " && (gdbarch->${function} == ${default}))"
1089 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1097 # dump the structure
1100 echo "/* Print out the details of the current architecture. */"
1107 function_list | while do_read # eval read $read
1109 if class_is_function_p
1111 echo " fprintf_unfiltered (gdb_stdlog,"
1112 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1113 echo " (long) current_gdbarch->${function}"
1114 echo " /*${macro} ()*/);"
1116 if [ "${print_p}" = "#" ]
1118 echo "#ifdef ${macro}"
1119 echo " fprintf_unfiltered (gdb_stdlog,"
1120 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1123 elif [ "${print_p}" ]
1125 echo " if (${print_p})"
1126 echo " fprintf_unfiltered (gdb_stdlog,"
1127 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1130 echo " fprintf_unfiltered (gdb_stdlog,"
1131 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1142 struct gdbarch_tdep *
1143 gdbarch_tdep (struct gdbarch *gdbarch)
1145 if (gdbarch_debug >= 2)
1146 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1147 return gdbarch->tdep;
1151 function_list | while do_read # eval read $read
1153 if class_is_predicate_p
1157 echo "gdbarch_${function}_p (struct gdbarch *gdbarch)"
1161 echo " return ${valid_p};"
1163 echo "#error \"gdbarch_${function}_p: not defined\""
1167 if class_is_function_p
1170 echo "${returntype}"
1171 if [ "${formal}" = "void" ]
1173 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1175 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1178 if default_is_fallback_p && [ "${default}" != "0" ]
1180 echo " if (GDB_MULTI_ARCH == 0)"
1181 if [ "${returntype}" = "void" ]
1184 echo " ${default} (${actual});"
1188 echo " return ${default} (${actual});"
1191 echo " if (gdbarch->${function} == 0)"
1192 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1193 echo " if (gdbarch_debug >= 2)"
1194 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1195 test "${actual}" = "-" && actual=""
1196 if [ "${returntype}" = "void" ]
1198 echo " gdbarch->${function} (${actual});"
1200 echo " return gdbarch->${function} (${actual});"
1205 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1206 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1208 echo " gdbarch->${function} = ${function};"
1210 elif class_is_variable_p
1213 echo "${returntype}"
1214 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1216 if default_is_fallback_p && [ "${default}" != "0" ]
1218 echo " if (GDB_MULTI_ARCH == 0)"
1219 echo " return ${default};"
1221 if [ "${invalid_p}" = "0" ]
1223 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1224 elif [ "${invalid_p}" ]
1226 echo " if (${invalid_p})"
1227 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1228 elif [ "${default}" ]
1230 echo " if (gdbarch->${function} == ${default})"
1231 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1233 echo " if (gdbarch_debug >= 2)"
1234 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1235 echo " return gdbarch->${function};"
1239 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1240 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1242 echo " gdbarch->${function} = ${function};"
1244 elif class_is_info_p
1247 echo "${returntype}"
1248 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1250 echo " if (gdbarch_debug >= 2)"
1251 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1252 echo " return gdbarch->${function};"
1257 # All the trailing guff
1261 /* Keep a registrary of per-architecture data-pointers required by GDB
1269 struct gdbarch_data_registration
1271 gdbarch_data_ftype *init;
1272 struct gdbarch_data *data;
1273 struct gdbarch_data_registration *next;
1276 struct gdbarch_data_registrary
1279 struct gdbarch_data_registration *registrations;
1282 struct gdbarch_data_registrary gdbarch_data_registrary =
1287 struct gdbarch_data *
1288 register_gdbarch_data (gdbarch_data_ftype *init)
1290 struct gdbarch_data_registration **curr;
1291 for (curr = &gdbarch_data_registrary.registrations;
1293 curr = &(*curr)->next);
1294 (*curr) = XMALLOC (struct gdbarch_data_registration);
1295 (*curr)->next = NULL;
1296 (*curr)->init = init;
1297 (*curr)->data = XMALLOC (struct gdbarch_data);
1298 (*curr)->data->index = gdbarch_data_registrary.nr++;
1299 return (*curr)->data;
1303 /* Walk through all the registered users initializing each in turn. */
1306 init_gdbarch_data (struct gdbarch *gdbarch)
1308 struct gdbarch_data_registration *rego;
1309 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1310 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1311 for (rego = gdbarch_data_registrary.registrations;
1315 if (rego->data->index < gdbarch->nr_data)
1316 gdbarch->data[rego->data->index] = rego->init ();
1321 /* Return the current value of the specified per-architecture
1326 struct gdbarch_data *data;
1328 if (data->index >= current_gdbarch->nr_data)
1329 internal_error ("gdbarch_data: request for non-existant data.");
1330 return current_gdbarch->data[data->index];
1335 /* Keep a registrary of swaped data required by GDB modules. */
1340 struct gdbarch_swap_registration *source;
1341 struct gdbarch_swap *next;
1344 struct gdbarch_swap_registration
1347 unsigned long sizeof_data;
1348 gdbarch_swap_ftype *init;
1349 struct gdbarch_swap_registration *next;
1352 struct gdbarch_swap_registrary
1355 struct gdbarch_swap_registration *registrations;
1358 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1364 register_gdbarch_swap (void *data,
1365 unsigned long sizeof_data,
1366 gdbarch_swap_ftype *init)
1368 struct gdbarch_swap_registration **rego;
1369 for (rego = &gdbarch_swap_registrary.registrations;
1371 rego = &(*rego)->next);
1372 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1373 (*rego)->next = NULL;
1374 (*rego)->init = init;
1375 (*rego)->data = data;
1376 (*rego)->sizeof_data = sizeof_data;
1381 init_gdbarch_swap (struct gdbarch *gdbarch)
1383 struct gdbarch_swap_registration *rego;
1384 struct gdbarch_swap **curr = &gdbarch->swap;
1385 for (rego = gdbarch_swap_registrary.registrations;
1389 if (rego->data != NULL)
1391 (*curr) = XMALLOC (struct gdbarch_swap);
1392 (*curr)->source = rego;
1393 (*curr)->swap = xmalloc (rego->sizeof_data);
1394 (*curr)->next = NULL;
1395 memset (rego->data, 0, rego->sizeof_data);
1396 curr = &(*curr)->next;
1398 if (rego->init != NULL)
1404 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1406 struct gdbarch_swap *curr;
1407 for (curr = gdbarch->swap;
1410 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1414 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1416 struct gdbarch_swap *curr;
1417 for (curr = gdbarch->swap;
1420 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1424 /* Keep a registrary of the architectures known by GDB. */
1426 struct gdbarch_init_registration
1428 enum bfd_architecture bfd_architecture;
1429 gdbarch_init_ftype *init;
1430 struct gdbarch_list *arches;
1431 struct gdbarch_init_registration *next;
1434 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1437 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1438 gdbarch_init_ftype *init)
1440 struct gdbarch_init_registration **curr;
1441 const struct bfd_arch_info *bfd_arch_info;
1442 /* Check that BFD reconizes this architecture */
1443 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1444 if (bfd_arch_info == NULL)
1446 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1448 /* Check that we haven't seen this architecture before */
1449 for (curr = &gdbarch_init_registrary;
1451 curr = &(*curr)->next)
1453 if (bfd_architecture == (*curr)->bfd_architecture)
1454 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1455 bfd_arch_info->printable_name);
1459 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1460 bfd_arch_info->printable_name,
1463 (*curr) = XMALLOC (struct gdbarch_init_registration);
1464 (*curr)->bfd_architecture = bfd_architecture;
1465 (*curr)->init = init;
1466 (*curr)->arches = NULL;
1467 (*curr)->next = NULL;
1472 /* Look for an architecture using gdbarch_info. Base search on only
1473 BFD_ARCH_INFO and BYTE_ORDER. */
1475 struct gdbarch_list *
1476 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1477 const struct gdbarch_info *info)
1479 for (; arches != NULL; arches = arches->next)
1481 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1483 if (info->byte_order != arches->gdbarch->byte_order)
1491 /* Update the current architecture. Return ZERO if the update request
1495 gdbarch_update (struct gdbarch_info info)
1497 struct gdbarch *new_gdbarch;
1498 struct gdbarch_list **list;
1499 struct gdbarch_init_registration *rego;
1501 /* Fill in any missing bits. Most important is the bfd_architecture
1502 which is used to select the target architecture. */
1503 if (info.bfd_architecture == bfd_arch_unknown)
1505 if (info.bfd_arch_info != NULL)
1506 info.bfd_architecture = info.bfd_arch_info->arch;
1507 else if (info.abfd != NULL)
1508 info.bfd_architecture = bfd_get_arch (info.abfd);
1509 /* FIXME - should query BFD for its default architecture. */
1511 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1513 if (info.bfd_arch_info == NULL)
1515 if (target_architecture_auto && info.abfd != NULL)
1516 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1518 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1520 if (info.byte_order == 0)
1522 if (target_byte_order_auto && info.abfd != NULL)
1523 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1524 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1527 info.byte_order = current_gdbarch->byte_order;
1528 /* FIXME - should query BFD for its default byte-order. */
1530 /* A default for abfd? */
1532 /* Find the target that knows about this architecture. */
1533 for (rego = gdbarch_init_registrary;
1534 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1539 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1545 fprintf_unfiltered (gdb_stdlog,
1546 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1547 info.bfd_architecture,
1548 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1549 fprintf_unfiltered (gdb_stdlog,
1550 "gdbarch_update: info.bfd_arch_info %s\n",
1551 (info.bfd_arch_info != NULL
1552 ? info.bfd_arch_info->printable_name
1554 fprintf_unfiltered (gdb_stdlog,
1555 "gdbarch_update: info.byte_order %d (%s)\n",
1557 (info.byte_order == BIG_ENDIAN ? "big"
1558 : info.byte_order == LITTLE_ENDIAN ? "little"
1560 fprintf_unfiltered (gdb_stdlog,
1561 "gdbarch_update: info.abfd 0x%lx\n",
1563 fprintf_unfiltered (gdb_stdlog,
1564 "gdbarch_update: info.tdep_info 0x%lx\n",
1565 (long) info.tdep_info);
1568 /* Ask the target for a replacement architecture. */
1569 new_gdbarch = rego->init (info, rego->arches);
1571 /* Did the target like it? No. Reject the change. */
1572 if (new_gdbarch == NULL)
1575 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1579 /* Did the architecture change? No. Do nothing. */
1580 if (current_gdbarch == new_gdbarch)
1583 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1585 new_gdbarch->bfd_arch_info->printable_name);
1589 /* Swap all data belonging to the old target out */
1590 swapout_gdbarch_swap (current_gdbarch);
1592 /* Is this a pre-existing architecture? Yes. Swap it in. */
1593 for (list = ®o->arches;
1595 list = &(*list)->next)
1597 if ((*list)->gdbarch == new_gdbarch)
1600 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1602 new_gdbarch->bfd_arch_info->printable_name);
1603 current_gdbarch = new_gdbarch;
1604 swapin_gdbarch_swap (new_gdbarch);
1609 /* Append this new architecture to this targets list. */
1610 (*list) = XMALLOC (struct gdbarch_list);
1611 (*list)->next = NULL;
1612 (*list)->gdbarch = new_gdbarch;
1614 /* Switch to this new architecture. Dump it out. */
1615 current_gdbarch = new_gdbarch;
1618 fprintf_unfiltered (gdb_stdlog,
1619 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1621 new_gdbarch->bfd_arch_info->printable_name);
1625 /* Check that the newly installed architecture is valid. */
1626 verify_gdbarch (new_gdbarch);
1628 /* Initialize the per-architecture memory (swap) areas.
1629 CURRENT_GDBARCH must be update before these modules are
1631 init_gdbarch_swap (new_gdbarch);
1633 /* Initialize the per-architecture data-pointer of all parties that
1634 registered an interest in this architecture. CURRENT_GDBARCH
1635 must be updated before these modules are called. */
1636 init_gdbarch_data (new_gdbarch);
1643 /* Functions to manipulate the endianness of the target. */
1645 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1646 /* compat - Catch old targets that expect a selectable byte-order to
1647 default to BIG_ENDIAN */
1648 #ifndef TARGET_BYTE_ORDER_DEFAULT
1649 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1652 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1653 #ifndef TARGET_BYTE_ORDER_DEFAULT
1654 /* compat - Catch old non byte-order selectable targets that do not
1655 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1656 TARGET_BYTE_ORDER to be used as the default. For targets that
1657 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1658 below will get a strange compiler warning. */
1659 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1662 #ifndef TARGET_BYTE_ORDER_DEFAULT
1663 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1665 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1666 int target_byte_order_auto = 1;
1668 /* Chain containing the \"set endian\" commands. */
1669 static struct cmd_list_element *endianlist = NULL;
1671 /* Called by \`\`show endian''. */
1673 show_endian (char *args, int from_tty)
1676 (TARGET_BYTE_ORDER_AUTO
1677 ? "The target endianness is set automatically (currently %s endian)\n"
1678 : "The target is assumed to be %s endian\n");
1679 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1682 /* Called if the user enters \`\`set endian'' without an argument. */
1684 set_endian (char *args, int from_tty)
1686 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1687 show_endian (args, from_tty);
1690 /* Called by \`\`set endian big''. */
1692 set_endian_big (char *args, int from_tty)
1694 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1696 target_byte_order = BIG_ENDIAN;
1697 target_byte_order_auto = 0;
1700 struct gdbarch_info info;
1701 memset (&info, 0, sizeof info);
1702 info.byte_order = BIG_ENDIAN;
1703 gdbarch_update (info);
1708 printf_unfiltered ("Byte order is not selectable.");
1709 show_endian (args, from_tty);
1713 /* Called by \`\`set endian little''. */
1715 set_endian_little (char *args, int from_tty)
1717 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1719 target_byte_order = LITTLE_ENDIAN;
1720 target_byte_order_auto = 0;
1723 struct gdbarch_info info;
1724 memset (&info, 0, sizeof info);
1725 info.byte_order = LITTLE_ENDIAN;
1726 gdbarch_update (info);
1731 printf_unfiltered ("Byte order is not selectable.");
1732 show_endian (args, from_tty);
1736 /* Called by \`\`set endian auto''. */
1738 set_endian_auto (char *args, int from_tty)
1740 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1742 target_byte_order_auto = 1;
1746 printf_unfiltered ("Byte order is not selectable.");
1747 show_endian (args, from_tty);
1751 /* Set the endianness from a BFD. */
1753 set_endian_from_file (bfd *abfd)
1755 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1759 if (bfd_big_endian (abfd))
1762 want = LITTLE_ENDIAN;
1763 if (TARGET_BYTE_ORDER_AUTO)
1764 target_byte_order = want;
1765 else if (TARGET_BYTE_ORDER != want)
1766 warning ("%s endian file does not match %s endian target.",
1767 want == BIG_ENDIAN ? "big" : "little",
1768 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1772 if (bfd_big_endian (abfd)
1773 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1774 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1775 warning ("%s endian file does not match %s endian target.",
1776 bfd_big_endian (abfd) ? "big" : "little",
1777 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1783 /* Functions to manipulate the architecture of the target */
1785 enum set_arch { set_arch_auto, set_arch_manual };
1787 int target_architecture_auto = 1;
1788 extern const struct bfd_arch_info bfd_default_arch_struct;
1789 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1790 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1792 static void show_endian (char *, int);
1793 static void set_endian (char *, int);
1794 static void set_endian_big (char *, int);
1795 static void set_endian_little (char *, int);
1796 static void set_endian_auto (char *, int);
1797 static void set_endian_from_file (bfd *);
1798 static int arch_ok (const struct bfd_arch_info *arch);
1799 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1800 static void show_architecture (char *, int);
1801 static void set_architecture (char *, int);
1802 static void info_architecture (char *, int);
1803 static void set_architecture_from_file (bfd *);
1805 /* Do the real work of changing the current architecture */
1808 arch_ok (const struct bfd_arch_info *arch)
1810 /* Should be performing the more basic check that the binary is
1811 compatible with GDB. */
1812 /* Check with the target that the architecture is valid. */
1813 return (target_architecture_hook == NULL
1814 || target_architecture_hook (arch));
1818 set_arch (const struct bfd_arch_info *arch,
1824 if (!arch_ok (arch))
1825 warning ("Target may not support %s architecture",
1826 arch->printable_name);
1827 target_architecture = arch;
1829 case set_arch_manual:
1830 if (!arch_ok (arch))
1832 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1833 arch->printable_name);
1837 target_architecture_auto = 0;
1838 target_architecture = arch;
1846 /* Called if the user enters \`\`show architecture'' without an argument. */
1848 show_architecture (char *args, int from_tty)
1851 arch = TARGET_ARCHITECTURE->printable_name;
1852 if (target_architecture_auto)
1853 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1855 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1858 /* Called if the user enters \`\`set architecture'' with or without an
1861 set_architecture (char *args, int from_tty)
1865 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1867 else if (strcmp (args, "auto") == 0)
1869 target_architecture_auto = 1;
1871 else if (GDB_MULTI_ARCH)
1873 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1875 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1878 struct gdbarch_info info;
1879 memset (&info, 0, sizeof info);
1880 info.bfd_arch_info = arch;
1881 if (gdbarch_update (info))
1882 target_architecture_auto = 0;
1884 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1889 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1891 set_arch (arch, set_arch_manual);
1893 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1897 /* Called if the user enters \`\`info architecture'' without an argument. */
1899 info_architecture (char *args, int from_tty)
1901 enum bfd_architecture a;
1904 if (gdbarch_init_registrary != NULL)
1906 struct gdbarch_init_registration *rego;
1907 printf_filtered ("Available architectures are:\n");
1908 for (rego = gdbarch_init_registrary;
1912 const struct bfd_arch_info *ap;
1913 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1918 printf_filtered (" %s", ap->printable_name);
1922 printf_filtered ("\n");
1928 printf_filtered ("There are no available architectures.\n");
1932 printf_filtered ("Available architectures are:\n");
1933 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1935 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1940 printf_filtered (" %s", ap->printable_name);
1944 printf_filtered ("\n");
1949 /* Set the architecture from arch/machine */
1951 set_architecture_from_arch_mach (arch, mach)
1952 enum bfd_architecture arch;
1955 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1957 set_arch (wanted, set_arch_manual);
1959 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1962 /* Set the architecture from a BFD */
1964 set_architecture_from_file (bfd *abfd)
1966 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1967 if (target_architecture_auto)
1969 set_arch (wanted, set_arch_auto);
1971 else if (wanted != target_architecture)
1973 warning ("%s architecture file may be incompatible with %s target.",
1974 wanted->printable_name,
1975 target_architecture->printable_name);
1980 /* Misc helper functions for targets. */
1983 frame_num_args_unknown (fi)
1984 struct frame_info *fi;
1991 generic_register_convertible_not (num)
2000 /* Pointer to the target-dependent disassembly function. */
2001 int (*tm_print_insn) (bfd_vma, disassemble_info *);
2002 disassemble_info tm_print_insn_info;
2006 /* Set the dynamic target-system-dependant parameters (architecture,
2007 byte-order) using information found in the BFD */
2010 set_gdbarch_from_file (abfd)
2015 struct gdbarch_info info;
2016 memset (&info, 0, sizeof info);
2018 gdbarch_update (info);
2021 set_architecture_from_file (abfd);
2022 set_endian_from_file (abfd);
2026 /* Initialize the current architecture. */
2028 initialize_current_architecture ()
2032 struct gdbarch_init_registration *rego;
2033 const struct bfd_arch_info *chosen = NULL;
2034 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
2036 const struct bfd_arch_info *ap
2037 = bfd_lookup_arch (rego->bfd_architecture, 0);
2039 /* Choose the first architecture alphabetically. */
2041 || strcmp (ap->printable_name, chosen->printable_name) < 0)
2047 struct gdbarch_info info;
2048 memset (&info, 0, sizeof info);
2049 info.bfd_arch_info = chosen;
2050 gdbarch_update (info);
2055 extern void _initialize_gdbarch (void);
2057 _initialize_gdbarch ()
2059 struct cmd_list_element *c;
2061 add_prefix_cmd ("endian", class_support, set_endian,
2062 "Set endianness of target.",
2063 &endianlist, "set endian ", 0, &setlist);
2064 add_cmd ("big", class_support, set_endian_big,
2065 "Set target as being big endian.", &endianlist);
2066 add_cmd ("little", class_support, set_endian_little,
2067 "Set target as being little endian.", &endianlist);
2068 add_cmd ("auto", class_support, set_endian_auto,
2069 "Select target endianness automatically.", &endianlist);
2070 add_cmd ("endian", class_support, show_endian,
2071 "Show endianness of target.", &showlist);
2073 add_cmd ("architecture", class_support, set_architecture,
2074 "Set architecture of target.", &setlist);
2075 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
2076 add_cmd ("architecture", class_support, show_architecture,
2077 "Show architecture of target.", &showlist);
2078 add_cmd ("architecture", class_support, info_architecture,
2079 "List supported target architectures", &infolist);
2081 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2082 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2083 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2084 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2085 tm_print_insn_info.print_address_func = dis_asm_print_address;
2087 add_show_from_set (add_set_cmd ("arch",
2090 (char *)&gdbarch_debug,
2091 "Set architecture debugging.\n\\
2092 When non-zero, architecture debugging is enabled.", &setdebuglist),
2094 c = add_set_cmd ("archdebug",
2097 (char *)&gdbarch_debug,
2098 "Set architecture debugging.\n\\
2099 When non-zero, architecture debugging is enabled.", &setlist);
2101 deprecate_cmd (c, "set debug arch");
2102 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2108 #../move-if-change new-gdbarch.c gdbarch.c
2109 compare_new gdbarch.c