1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
4 Copyright 1998, 1999, 2000, 2001, 2002, 2003 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,
21 Boston, MA 02111-1307, USA. */
23 /* This file was created with the aid of ``gdbarch.sh''.
25 The Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
37 #include "arch-utils.h"
41 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
43 /* Just include everything in sight so that the every old definition
44 of macro is visible. */
45 #include "gdb_string.h"
50 #include "breakpoint.h"
55 #include "gdbthread.h"
57 #include "symfile.h" /* for overlay functions */
58 #include "value.h" /* For old tm.h/nm.h macros. */
62 #include "floatformat.h"
64 #include "gdb_assert.h"
65 #include "gdb_string.h"
66 #include "gdb-events.h"
67 #include "reggroups.h"
69 #include "symfile.h" /* For entry_point_address. */
71 /* Static function declarations */
73 static void verify_gdbarch (struct gdbarch
*gdbarch
);
74 static void alloc_gdbarch_data (struct gdbarch
*);
75 static void free_gdbarch_data (struct gdbarch
*);
76 static void init_gdbarch_swap (struct gdbarch
*);
77 static void clear_gdbarch_swap (struct gdbarch
*);
78 static void swapout_gdbarch_swap (struct gdbarch
*);
79 static void swapin_gdbarch_swap (struct gdbarch
*);
81 /* Non-zero if we want to trace architecture code. */
84 #define GDBARCH_DEBUG 0
86 int gdbarch_debug
= GDBARCH_DEBUG
;
89 /* Maintain the struct gdbarch object */
93 /* Has this architecture been fully initialized? */
95 /* basic architectural information */
96 const struct bfd_arch_info
* bfd_arch_info
;
100 /* target specific vector. */
101 struct gdbarch_tdep
*tdep
;
102 gdbarch_dump_tdep_ftype
*dump_tdep
;
104 /* per-architecture data-pointers */
108 /* per-architecture swap-regions */
109 struct gdbarch_swap
*swap
;
111 /* Multi-arch values.
113 When extending this structure you must:
117 Declare set/get functions and define the corresponding
120 gdbarch_alloc(): If zero/NULL is not a suitable default,
121 initialize the new field.
123 verify_gdbarch(): Confirm that the target updated the field
126 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
129 ``startup_gdbarch()'': Append an initial value to the static
130 variable (base values on the host's c-type system).
132 get_gdbarch(): Implement the set/get functions (probably using
133 the macro's as shortcuts).
148 gdbarch_read_pc_ftype
*read_pc
;
149 gdbarch_write_pc_ftype
*write_pc
;
150 gdbarch_deprecated_target_read_fp_ftype
*deprecated_target_read_fp
;
151 gdbarch_read_sp_ftype
*read_sp
;
152 gdbarch_deprecated_dummy_write_sp_ftype
*deprecated_dummy_write_sp
;
153 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
154 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
155 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
159 int deprecated_fp_regnum
;
164 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
165 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
166 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
167 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
168 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
169 gdbarch_register_name_ftype
*register_name
;
170 int deprecated_register_size
;
171 int deprecated_register_bytes
;
172 gdbarch_register_byte_ftype
*register_byte
;
173 gdbarch_register_raw_size_ftype
*register_raw_size
;
174 int deprecated_max_register_raw_size
;
175 gdbarch_register_virtual_size_ftype
*register_virtual_size
;
176 int deprecated_max_register_virtual_size
;
177 gdbarch_register_virtual_type_ftype
*register_virtual_type
;
178 gdbarch_register_type_ftype
*register_type
;
179 gdbarch_deprecated_do_registers_info_ftype
*deprecated_do_registers_info
;
180 gdbarch_print_registers_info_ftype
*print_registers_info
;
181 gdbarch_print_float_info_ftype
*print_float_info
;
182 gdbarch_print_vector_info_ftype
*print_vector_info
;
183 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
184 gdbarch_register_bytes_ok_ftype
*register_bytes_ok
;
185 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
186 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
187 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
188 int deprecated_use_generic_dummy_frames
;
189 int call_dummy_location
;
190 gdbarch_call_dummy_address_ftype
*call_dummy_address
;
191 CORE_ADDR deprecated_call_dummy_start_offset
;
192 CORE_ADDR deprecated_call_dummy_breakpoint_offset
;
193 int deprecated_call_dummy_length
;
194 gdbarch_deprecated_pc_in_call_dummy_ftype
*deprecated_pc_in_call_dummy
;
195 LONGEST
* deprecated_call_dummy_words
;
196 int deprecated_sizeof_call_dummy_words
;
197 int deprecated_call_dummy_stack_adjust
;
198 gdbarch_deprecated_fix_call_dummy_ftype
*deprecated_fix_call_dummy
;
199 gdbarch_push_dummy_code_ftype
*push_dummy_code
;
200 gdbarch_deprecated_init_frame_pc_first_ftype
*deprecated_init_frame_pc_first
;
201 gdbarch_deprecated_init_frame_pc_ftype
*deprecated_init_frame_pc
;
202 int believe_pcc_promotion
;
203 int believe_pcc_promotion_type
;
204 gdbarch_deprecated_get_saved_register_ftype
*deprecated_get_saved_register
;
205 gdbarch_register_convertible_ftype
*register_convertible
;
206 gdbarch_register_convert_to_virtual_ftype
*register_convert_to_virtual
;
207 gdbarch_register_convert_to_raw_ftype
*register_convert_to_raw
;
208 gdbarch_convert_register_p_ftype
*convert_register_p
;
209 gdbarch_register_to_value_ftype
*register_to_value
;
210 gdbarch_value_to_register_ftype
*value_to_register
;
211 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
212 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
213 gdbarch_integer_to_address_ftype
*integer_to_address
;
214 gdbarch_return_value_on_stack_ftype
*return_value_on_stack
;
215 gdbarch_deprecated_push_arguments_ftype
*deprecated_push_arguments
;
216 gdbarch_push_dummy_call_ftype
*push_dummy_call
;
217 gdbarch_deprecated_push_dummy_frame_ftype
*deprecated_push_dummy_frame
;
218 gdbarch_deprecated_push_return_address_ftype
*deprecated_push_return_address
;
219 gdbarch_deprecated_pop_frame_ftype
*deprecated_pop_frame
;
220 gdbarch_deprecated_store_struct_return_ftype
*deprecated_store_struct_return
;
221 gdbarch_extract_return_value_ftype
*extract_return_value
;
222 gdbarch_store_return_value_ftype
*store_return_value
;
223 gdbarch_deprecated_extract_return_value_ftype
*deprecated_extract_return_value
;
224 gdbarch_deprecated_store_return_value_ftype
*deprecated_store_return_value
;
225 gdbarch_extract_struct_value_address_ftype
*extract_struct_value_address
;
226 gdbarch_deprecated_extract_struct_value_address_ftype
*deprecated_extract_struct_value_address
;
227 gdbarch_use_struct_convention_ftype
*use_struct_convention
;
228 gdbarch_deprecated_frame_init_saved_regs_ftype
*deprecated_frame_init_saved_regs
;
229 gdbarch_deprecated_init_extra_frame_info_ftype
*deprecated_init_extra_frame_info
;
230 gdbarch_skip_prologue_ftype
*skip_prologue
;
231 gdbarch_prologue_frameless_p_ftype
*prologue_frameless_p
;
232 gdbarch_inner_than_ftype
*inner_than
;
233 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
234 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
235 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
236 CORE_ADDR decr_pc_after_break
;
237 gdbarch_prepare_to_proceed_ftype
*prepare_to_proceed
;
238 CORE_ADDR function_start_offset
;
239 gdbarch_remote_translate_xfer_address_ftype
*remote_translate_xfer_address
;
240 CORE_ADDR frame_args_skip
;
241 gdbarch_frameless_function_invocation_ftype
*frameless_function_invocation
;
242 gdbarch_deprecated_frame_chain_ftype
*deprecated_frame_chain
;
243 gdbarch_deprecated_frame_chain_valid_ftype
*deprecated_frame_chain_valid
;
244 gdbarch_deprecated_frame_saved_pc_ftype
*deprecated_frame_saved_pc
;
245 gdbarch_unwind_pc_ftype
*unwind_pc
;
246 gdbarch_frame_args_address_ftype
*frame_args_address
;
247 gdbarch_frame_locals_address_ftype
*frame_locals_address
;
248 gdbarch_deprecated_saved_pc_after_call_ftype
*deprecated_saved_pc_after_call
;
249 gdbarch_frame_num_args_ftype
*frame_num_args
;
250 gdbarch_stack_align_ftype
*stack_align
;
251 gdbarch_frame_align_ftype
*frame_align
;
252 int deprecated_extra_stack_alignment_needed
;
253 gdbarch_reg_struct_has_addr_ftype
*reg_struct_has_addr
;
254 gdbarch_save_dummy_frame_tos_ftype
*save_dummy_frame_tos
;
255 gdbarch_unwind_dummy_id_ftype
*unwind_dummy_id
;
257 const struct floatformat
* float_format
;
258 const struct floatformat
* double_format
;
259 const struct floatformat
* long_double_format
;
260 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
261 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
262 gdbarch_smash_text_address_ftype
*smash_text_address
;
263 gdbarch_software_single_step_ftype
*software_single_step
;
264 gdbarch_print_insn_ftype
*print_insn
;
265 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
266 gdbarch_in_solib_call_trampoline_ftype
*in_solib_call_trampoline
;
267 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
268 gdbarch_pc_in_sigtramp_ftype
*pc_in_sigtramp
;
269 gdbarch_sigtramp_start_ftype
*sigtramp_start
;
270 gdbarch_sigtramp_end_ftype
*sigtramp_end
;
271 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
272 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
273 gdbarch_dwarf2_build_frame_info_ftype
*dwarf2_build_frame_info
;
274 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
275 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
276 const char * name_of_malloc
;
277 int cannot_step_breakpoint
;
278 int have_nonsteppable_watchpoint
;
279 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
280 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
281 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
282 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
286 /* The default architecture uses host values (for want of a better
289 extern const struct bfd_arch_info bfd_default_arch_struct
;
291 struct gdbarch startup_gdbarch
=
293 1, /* Always initialized. */
294 /* basic architecture information */
295 &bfd_default_arch_struct
,
298 /* target specific vector and its dump routine */
300 /*per-architecture data-pointers and swap regions */
302 /* Multi-arch values */
306 8 * sizeof (LONGEST
),
309 8 * sizeof (long double),
338 generic_register_byte
,
339 generic_register_size
,
341 generic_register_size
,
346 default_print_registers_info
,
360 generic_pc_in_call_dummy
,
405 generic_remote_translate_xfer_address
,
437 generic_in_function_epilogue_p
,
438 construct_inferior_arguments
,
448 default_register_reggroup_p
,
449 /* startup_gdbarch() */
452 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
454 /* Do any initialization needed for a non-multiarch configuration
455 after the _initialize_MODULE functions have been run. */
457 initialize_non_multiarch (void)
459 alloc_gdbarch_data (&startup_gdbarch
);
460 /* Ensure that all swap areas are zeroed so that they again think
461 they are starting from scratch. */
462 clear_gdbarch_swap (&startup_gdbarch
);
463 init_gdbarch_swap (&startup_gdbarch
);
467 /* Create a new ``struct gdbarch'' based on information provided by
468 ``struct gdbarch_info''. */
471 gdbarch_alloc (const struct gdbarch_info
*info
,
472 struct gdbarch_tdep
*tdep
)
474 /* NOTE: The new architecture variable is named ``current_gdbarch''
475 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
476 the current local architecture and not the previous global
477 architecture. This ensures that the new architectures initial
478 values are not influenced by the previous architecture. Once
479 everything is parameterised with gdbarch, this will go away. */
480 struct gdbarch
*current_gdbarch
= XMALLOC (struct gdbarch
);
481 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
483 alloc_gdbarch_data (current_gdbarch
);
485 current_gdbarch
->tdep
= tdep
;
487 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
488 current_gdbarch
->byte_order
= info
->byte_order
;
489 current_gdbarch
->osabi
= info
->osabi
;
491 /* Force the explicit initialization of these. */
492 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
493 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
494 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
495 current_gdbarch
->long_long_bit
= 2*TARGET_LONG_BIT
;
496 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
497 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
498 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
499 current_gdbarch
->ptr_bit
= TARGET_INT_BIT
;
500 current_gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
501 current_gdbarch
->char_signed
= -1;
502 current_gdbarch
->read_pc
= generic_target_read_pc
;
503 current_gdbarch
->write_pc
= generic_target_write_pc
;
504 current_gdbarch
->read_sp
= generic_target_read_sp
;
505 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
506 current_gdbarch
->num_regs
= -1;
507 current_gdbarch
->sp_regnum
= -1;
508 current_gdbarch
->deprecated_fp_regnum
= -1;
509 current_gdbarch
->pc_regnum
= -1;
510 current_gdbarch
->ps_regnum
= -1;
511 current_gdbarch
->fp0_regnum
= -1;
512 current_gdbarch
->npc_regnum
= -1;
513 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
514 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
515 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
516 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
517 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
518 current_gdbarch
->register_name
= legacy_register_name
;
519 current_gdbarch
->register_byte
= generic_register_byte
;
520 current_gdbarch
->register_raw_size
= generic_register_size
;
521 current_gdbarch
->register_virtual_size
= generic_register_size
;
522 current_gdbarch
->print_registers_info
= default_print_registers_info
;
523 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
524 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
525 current_gdbarch
->cannot_store_register
= cannot_register_not
;
526 current_gdbarch
->deprecated_use_generic_dummy_frames
= 1;
527 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
528 current_gdbarch
->call_dummy_address
= entry_point_address
;
529 current_gdbarch
->deprecated_pc_in_call_dummy
= generic_pc_in_call_dummy
;
530 current_gdbarch
->deprecated_call_dummy_words
= legacy_call_dummy_words
;
531 current_gdbarch
->deprecated_sizeof_call_dummy_words
= legacy_sizeof_call_dummy_words
;
532 current_gdbarch
->register_convertible
= generic_register_convertible_not
;
533 current_gdbarch
->convert_register_p
= legacy_convert_register_p
;
534 current_gdbarch
->register_to_value
= legacy_register_to_value
;
535 current_gdbarch
->value_to_register
= legacy_value_to_register
;
536 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
537 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
538 current_gdbarch
->return_value_on_stack
= generic_return_value_on_stack_not
;
539 current_gdbarch
->extract_return_value
= legacy_extract_return_value
;
540 current_gdbarch
->store_return_value
= legacy_store_return_value
;
541 current_gdbarch
->use_struct_convention
= generic_use_struct_convention
;
542 current_gdbarch
->prologue_frameless_p
= generic_prologue_frameless_p
;
543 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
544 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
545 current_gdbarch
->decr_pc_after_break
= -1;
546 current_gdbarch
->prepare_to_proceed
= default_prepare_to_proceed
;
547 current_gdbarch
->function_start_offset
= -1;
548 current_gdbarch
->remote_translate_xfer_address
= generic_remote_translate_xfer_address
;
549 current_gdbarch
->frame_args_skip
= -1;
550 current_gdbarch
->frameless_function_invocation
= generic_frameless_function_invocation_not
;
551 current_gdbarch
->frame_args_address
= get_frame_base
;
552 current_gdbarch
->frame_locals_address
= get_frame_base
;
553 current_gdbarch
->convert_from_func_ptr_addr
= core_addr_identity
;
554 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
555 current_gdbarch
->smash_text_address
= core_addr_identity
;
556 current_gdbarch
->print_insn
= legacy_print_insn
;
557 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
558 current_gdbarch
->in_solib_call_trampoline
= generic_in_solib_call_trampoline
;
559 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
560 current_gdbarch
->pc_in_sigtramp
= legacy_pc_in_sigtramp
;
561 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
562 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
563 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
564 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
565 current_gdbarch
->name_of_malloc
= "malloc";
566 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
567 /* gdbarch_alloc() */
569 return current_gdbarch
;
573 /* Free a gdbarch struct. This should never happen in normal
574 operation --- once you've created a gdbarch, you keep it around.
575 However, if an architecture's init function encounters an error
576 building the structure, it may need to clean up a partially
577 constructed gdbarch. */
580 gdbarch_free (struct gdbarch
*arch
)
582 gdb_assert (arch
!= NULL
);
583 free_gdbarch_data (arch
);
588 /* Ensure that all values in a GDBARCH are reasonable. */
591 verify_gdbarch (struct gdbarch
*gdbarch
)
594 struct cleanup
*cleanups
;
597 /* Only perform sanity checks on a multi-arch target. */
600 log
= mem_fileopen ();
601 cleanups
= make_cleanup_ui_file_delete (log
);
603 if (gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
604 fprintf_unfiltered (log
, "\n\tbyte-order");
605 if (gdbarch
->bfd_arch_info
== NULL
)
606 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
607 /* Check those that need to be defined for the given multi-arch level. */
608 /* Skip verify of short_bit, invalid_p == 0 */
609 /* Skip verify of int_bit, invalid_p == 0 */
610 /* Skip verify of long_bit, invalid_p == 0 */
611 /* Skip verify of long_long_bit, invalid_p == 0 */
612 /* Skip verify of float_bit, invalid_p == 0 */
613 /* Skip verify of double_bit, invalid_p == 0 */
614 /* Skip verify of long_double_bit, invalid_p == 0 */
615 /* Skip verify of ptr_bit, invalid_p == 0 */
616 if (gdbarch
->addr_bit
== 0)
617 gdbarch
->addr_bit
= TARGET_PTR_BIT
;
618 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
619 if (gdbarch
->char_signed
== -1)
620 gdbarch
->char_signed
= 1;
621 /* Skip verify of read_pc, invalid_p == 0 */
622 /* Skip verify of write_pc, invalid_p == 0 */
623 /* Skip verify of deprecated_target_read_fp, has predicate */
624 /* Skip verify of read_sp, invalid_p == 0 */
625 /* Skip verify of deprecated_dummy_write_sp, has predicate */
626 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
627 /* Skip verify of pseudo_register_read, has predicate */
628 /* Skip verify of pseudo_register_write, has predicate */
629 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
630 && (gdbarch
->num_regs
== -1))
631 fprintf_unfiltered (log
, "\n\tnum_regs");
632 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
633 /* Skip verify of sp_regnum, invalid_p == 0 */
634 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
635 /* Skip verify of pc_regnum, invalid_p == 0 */
636 /* Skip verify of ps_regnum, invalid_p == 0 */
637 /* Skip verify of fp0_regnum, invalid_p == 0 */
638 /* Skip verify of npc_regnum, invalid_p == 0 */
639 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
640 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
641 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
642 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
643 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
644 /* Skip verify of register_name, invalid_p == 0 */
645 /* Skip verify of register_byte, has predicate */
646 /* Skip verify of register_raw_size, invalid_p == 0 */
647 /* Skip verify of deprecated_max_register_raw_size, has predicate */
648 /* Skip verify of register_virtual_size, invalid_p == 0 */
649 /* Skip verify of deprecated_max_register_virtual_size, has predicate */
650 /* Skip verify of register_virtual_type, has predicate */
651 /* Skip verify of register_type, has predicate */
652 /* Skip verify of deprecated_do_registers_info, has predicate */
653 /* Skip verify of print_registers_info, invalid_p == 0 */
654 /* Skip verify of print_float_info, has predicate */
655 /* Skip verify of print_vector_info, has predicate */
656 /* Skip verify of register_sim_regno, invalid_p == 0 */
657 /* Skip verify of register_bytes_ok, has predicate */
658 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
659 /* Skip verify of cannot_store_register, invalid_p == 0 */
660 /* Skip verify of get_longjmp_target, has predicate */
661 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
662 /* Skip verify of call_dummy_location, invalid_p == 0 */
663 /* Skip verify of call_dummy_address, invalid_p == 0 */
664 /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
665 /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
666 /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
667 /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
668 /* Skip verify of deprecated_fix_call_dummy, has predicate */
669 /* Skip verify of push_dummy_code, has predicate */
670 /* Skip verify of deprecated_init_frame_pc_first, has predicate */
671 /* Skip verify of deprecated_init_frame_pc, has predicate */
672 /* Skip verify of deprecated_get_saved_register, has predicate */
673 /* Skip verify of register_convertible, invalid_p == 0 */
674 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
675 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
676 /* Skip verify of convert_register_p, invalid_p == 0 */
677 /* Skip verify of register_to_value, invalid_p == 0 */
678 /* Skip verify of value_to_register, invalid_p == 0 */
679 /* Skip verify of pointer_to_address, invalid_p == 0 */
680 /* Skip verify of address_to_pointer, invalid_p == 0 */
681 /* Skip verify of integer_to_address, has predicate */
682 /* Skip verify of return_value_on_stack, invalid_p == 0 */
683 /* Skip verify of deprecated_push_arguments, has predicate */
684 /* Skip verify of push_dummy_call, has predicate */
685 /* Skip verify of deprecated_push_dummy_frame, has predicate */
686 /* Skip verify of deprecated_push_return_address, has predicate */
687 /* Skip verify of deprecated_pop_frame, has predicate */
688 /* Skip verify of deprecated_store_struct_return, has predicate */
689 /* Skip verify of extract_return_value, invalid_p == 0 */
690 /* Skip verify of store_return_value, invalid_p == 0 */
691 /* Skip verify of extract_struct_value_address, has predicate */
692 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
693 /* Skip verify of use_struct_convention, invalid_p == 0 */
694 /* Skip verify of deprecated_frame_init_saved_regs, has predicate */
695 /* Skip verify of deprecated_init_extra_frame_info, has predicate */
696 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
697 && (gdbarch
->skip_prologue
== 0))
698 fprintf_unfiltered (log
, "\n\tskip_prologue");
699 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
700 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
701 && (gdbarch
->inner_than
== 0))
702 fprintf_unfiltered (log
, "\n\tinner_than");
703 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
704 && (gdbarch
->breakpoint_from_pc
== 0))
705 fprintf_unfiltered (log
, "\n\tbreakpoint_from_pc");
706 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
707 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
708 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
709 && (gdbarch
->decr_pc_after_break
== -1))
710 fprintf_unfiltered (log
, "\n\tdecr_pc_after_break");
711 /* Skip verify of prepare_to_proceed, invalid_p == 0 */
712 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
713 && (gdbarch
->function_start_offset
== -1))
714 fprintf_unfiltered (log
, "\n\tfunction_start_offset");
715 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
716 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
717 && (gdbarch
->frame_args_skip
== -1))
718 fprintf_unfiltered (log
, "\n\tframe_args_skip");
719 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
720 /* Skip verify of deprecated_frame_chain, has predicate */
721 /* Skip verify of deprecated_frame_chain_valid, has predicate */
722 /* Skip verify of deprecated_frame_saved_pc, has predicate */
723 /* Skip verify of unwind_pc, has predicate */
724 /* Skip verify of frame_args_address, invalid_p == 0 */
725 /* Skip verify of frame_locals_address, invalid_p == 0 */
726 /* Skip verify of deprecated_saved_pc_after_call, has predicate */
727 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
728 && (gdbarch
->frame_num_args
== 0))
729 fprintf_unfiltered (log
, "\n\tframe_num_args");
730 /* Skip verify of stack_align, has predicate */
731 /* Skip verify of frame_align, has predicate */
732 /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
733 /* Skip verify of reg_struct_has_addr, has predicate */
734 /* Skip verify of save_dummy_frame_tos, has predicate */
735 /* Skip verify of unwind_dummy_id, has predicate */
736 if (gdbarch
->float_format
== 0)
737 gdbarch
->float_format
= default_float_format (gdbarch
);
738 if (gdbarch
->double_format
== 0)
739 gdbarch
->double_format
= default_double_format (gdbarch
);
740 if (gdbarch
->long_double_format
== 0)
741 gdbarch
->long_double_format
= default_double_format (gdbarch
);
742 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
743 /* Skip verify of addr_bits_remove, invalid_p == 0 */
744 /* Skip verify of smash_text_address, invalid_p == 0 */
745 /* Skip verify of software_single_step, has predicate */
746 /* Skip verify of print_insn, invalid_p == 0 */
747 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
748 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
749 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
750 /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
751 /* Skip verify of sigtramp_start, has predicate */
752 /* Skip verify of sigtramp_end, has predicate */
753 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
754 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
755 /* Skip verify of dwarf2_build_frame_info, has predicate */
756 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
757 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
758 /* Skip verify of name_of_malloc, invalid_p == 0 */
759 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
760 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
761 /* Skip verify of address_class_type_flags, has predicate */
762 /* Skip verify of address_class_type_flags_to_name, has predicate */
763 /* Skip verify of address_class_name_to_type_flags, has predicate */
764 /* Skip verify of register_reggroup_p, invalid_p == 0 */
765 buf
= ui_file_xstrdup (log
, &dummy
);
766 make_cleanup (xfree
, buf
);
767 if (strlen (buf
) > 0)
768 internal_error (__FILE__
, __LINE__
,
769 "verify_gdbarch: the following are invalid ...%s",
771 do_cleanups (cleanups
);
775 /* Print out the details of the current architecture. */
777 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
778 just happens to match the global variable ``current_gdbarch''. That
779 way macros refering to that variable get the local and not the global
780 version - ulgh. Once everything is parameterised with gdbarch, this
784 gdbarch_dump (struct gdbarch
*gdbarch
, struct ui_file
*file
)
786 fprintf_unfiltered (file
,
787 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
790 fprintf_unfiltered (file
,
791 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
792 gdbarch_frame_align_p (current_gdbarch
));
794 fprintf_unfiltered (file
,
795 "gdbarch_dump: frame_align = 0x%08lx\n",
796 (long) current_gdbarch
->frame_align
);
798 fprintf_unfiltered (file
,
799 "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
800 (long) current_gdbarch
->in_function_epilogue_p
);
802 fprintf_unfiltered (file
,
803 "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
804 (long) current_gdbarch
->register_reggroup_p
);
806 fprintf_unfiltered (file
,
807 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
808 gdbarch_pseudo_register_read_p (current_gdbarch
));
810 fprintf_unfiltered (file
,
811 "gdbarch_dump: pseudo_register_read = 0x%08lx\n",
812 (long) current_gdbarch
->pseudo_register_read
);
814 fprintf_unfiltered (file
,
815 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
816 gdbarch_pseudo_register_write_p (current_gdbarch
));
818 fprintf_unfiltered (file
,
819 "gdbarch_dump: pseudo_register_write = 0x%08lx\n",
820 (long) current_gdbarch
->pseudo_register_write
);
822 fprintf_unfiltered (file
,
823 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
824 gdbarch_address_class_name_to_type_flags_p (current_gdbarch
));
826 fprintf_unfiltered (file
,
827 "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
828 (long) current_gdbarch
->address_class_name_to_type_flags
);
829 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
830 fprintf_unfiltered (file
,
831 "gdbarch_dump: %s # %s\n",
832 "ADDRESS_CLASS_TYPE_FLAGS_P()",
833 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
834 fprintf_unfiltered (file
,
835 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n",
836 ADDRESS_CLASS_TYPE_FLAGS_P ());
838 #ifdef ADDRESS_CLASS_TYPE_FLAGS
839 fprintf_unfiltered (file
,
840 "gdbarch_dump: %s # %s\n",
841 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
842 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size
, dwarf2_addr_class
)));
844 fprintf_unfiltered (file
,
845 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
846 (long) current_gdbarch
->address_class_type_flags
847 /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
850 fprintf_unfiltered (file
,
851 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
852 gdbarch_address_class_type_flags_to_name_p (current_gdbarch
));
854 fprintf_unfiltered (file
,
855 "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
856 (long) current_gdbarch
->address_class_type_flags_to_name
);
857 #ifdef ADDRESS_TO_POINTER
859 /* Macro might contain `[{}]' when not multi-arch */
860 fprintf_unfiltered (file
,
861 "gdbarch_dump: %s # %s\n",
862 "ADDRESS_TO_POINTER(type, buf, addr)",
863 XSTRING (ADDRESS_TO_POINTER (type
, buf
, addr
)));
866 fprintf_unfiltered (file
,
867 "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
868 (long) current_gdbarch
->address_to_pointer
869 /*ADDRESS_TO_POINTER ()*/);
871 #ifdef ADDR_BITS_REMOVE
872 fprintf_unfiltered (file
,
873 "gdbarch_dump: %s # %s\n",
874 "ADDR_BITS_REMOVE(addr)",
875 XSTRING (ADDR_BITS_REMOVE (addr
)));
877 fprintf_unfiltered (file
,
878 "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
879 (long) current_gdbarch
->addr_bits_remove
880 /*ADDR_BITS_REMOVE ()*/);
882 #ifdef BELIEVE_PCC_PROMOTION
883 fprintf_unfiltered (file
,
884 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
885 XSTRING (BELIEVE_PCC_PROMOTION
));
886 fprintf_unfiltered (file
,
887 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %d\n",
888 BELIEVE_PCC_PROMOTION
);
890 #ifdef BELIEVE_PCC_PROMOTION_TYPE
891 fprintf_unfiltered (file
,
892 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
893 XSTRING (BELIEVE_PCC_PROMOTION_TYPE
));
894 fprintf_unfiltered (file
,
895 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %d\n",
896 BELIEVE_PCC_PROMOTION_TYPE
);
898 #ifdef BREAKPOINT_FROM_PC
899 fprintf_unfiltered (file
,
900 "gdbarch_dump: %s # %s\n",
901 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
902 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
904 fprintf_unfiltered (file
,
905 "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
906 (long) current_gdbarch
->breakpoint_from_pc
907 /*BREAKPOINT_FROM_PC ()*/);
909 #ifdef CALL_DUMMY_ADDRESS
910 fprintf_unfiltered (file
,
911 "gdbarch_dump: %s # %s\n",
912 "CALL_DUMMY_ADDRESS()",
913 XSTRING (CALL_DUMMY_ADDRESS ()));
915 fprintf_unfiltered (file
,
916 "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n",
917 (long) current_gdbarch
->call_dummy_address
918 /*CALL_DUMMY_ADDRESS ()*/);
920 #ifdef CALL_DUMMY_LOCATION
921 fprintf_unfiltered (file
,
922 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
923 XSTRING (CALL_DUMMY_LOCATION
));
924 fprintf_unfiltered (file
,
925 "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
926 CALL_DUMMY_LOCATION
);
928 #ifdef CANNOT_FETCH_REGISTER
929 fprintf_unfiltered (file
,
930 "gdbarch_dump: %s # %s\n",
931 "CANNOT_FETCH_REGISTER(regnum)",
932 XSTRING (CANNOT_FETCH_REGISTER (regnum
)));
934 fprintf_unfiltered (file
,
935 "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
936 (long) current_gdbarch
->cannot_fetch_register
937 /*CANNOT_FETCH_REGISTER ()*/);
939 #ifdef CANNOT_STEP_BREAKPOINT
940 fprintf_unfiltered (file
,
941 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
942 XSTRING (CANNOT_STEP_BREAKPOINT
));
943 fprintf_unfiltered (file
,
944 "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n",
945 CANNOT_STEP_BREAKPOINT
);
947 #ifdef CANNOT_STORE_REGISTER
948 fprintf_unfiltered (file
,
949 "gdbarch_dump: %s # %s\n",
950 "CANNOT_STORE_REGISTER(regnum)",
951 XSTRING (CANNOT_STORE_REGISTER (regnum
)));
953 fprintf_unfiltered (file
,
954 "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
955 (long) current_gdbarch
->cannot_store_register
956 /*CANNOT_STORE_REGISTER ()*/);
958 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
960 /* Macro might contain `[{}]' when not multi-arch */
961 fprintf_unfiltered (file
,
962 "gdbarch_dump: %s # %s\n",
963 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
964 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val
, msym
)));
967 fprintf_unfiltered (file
,
968 "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
969 (long) current_gdbarch
->coff_make_msymbol_special
970 /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
973 fprintf_unfiltered (file
,
974 "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
975 (long) current_gdbarch
->construct_inferior_arguments
);
976 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
977 fprintf_unfiltered (file
,
978 "gdbarch_dump: %s # %s\n",
979 "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
980 XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr
)));
982 fprintf_unfiltered (file
,
983 "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
984 (long) current_gdbarch
->convert_from_func_ptr_addr
985 /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
987 #ifdef CONVERT_REGISTER_P
988 fprintf_unfiltered (file
,
989 "gdbarch_dump: %s # %s\n",
990 "CONVERT_REGISTER_P(regnum)",
991 XSTRING (CONVERT_REGISTER_P (regnum
)));
993 fprintf_unfiltered (file
,
994 "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
995 (long) current_gdbarch
->convert_register_p
996 /*CONVERT_REGISTER_P ()*/);
998 #ifdef DECR_PC_AFTER_BREAK
999 fprintf_unfiltered (file
,
1000 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1001 XSTRING (DECR_PC_AFTER_BREAK
));
1002 fprintf_unfiltered (file
,
1003 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1004 (long) DECR_PC_AFTER_BREAK
);
1006 #ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
1007 fprintf_unfiltered (file
,
1008 "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
1009 XSTRING (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
));
1010 fprintf_unfiltered (file
,
1011 "gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n",
1012 (long) DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
);
1014 #ifdef DEPRECATED_CALL_DUMMY_LENGTH
1015 fprintf_unfiltered (file
,
1016 "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH # %s\n",
1017 XSTRING (DEPRECATED_CALL_DUMMY_LENGTH
));
1018 fprintf_unfiltered (file
,
1019 "gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH = %d\n",
1020 DEPRECATED_CALL_DUMMY_LENGTH
);
1022 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST_P
1023 fprintf_unfiltered (file
,
1024 "gdbarch_dump: %s # %s\n",
1025 "DEPRECATED_CALL_DUMMY_STACK_ADJUST_P()",
1026 XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()));
1027 fprintf_unfiltered (file
,
1028 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST_P() = %d\n",
1029 DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ());
1031 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST
1032 fprintf_unfiltered (file
,
1033 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST # %s\n",
1034 XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST
));
1035 fprintf_unfiltered (file
,
1036 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST = %d\n",
1037 DEPRECATED_CALL_DUMMY_STACK_ADJUST
);
1039 #ifdef DEPRECATED_CALL_DUMMY_START_OFFSET
1040 fprintf_unfiltered (file
,
1041 "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET # %s\n",
1042 XSTRING (DEPRECATED_CALL_DUMMY_START_OFFSET
));
1043 fprintf_unfiltered (file
,
1044 "gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET = %ld\n",
1045 (long) DEPRECATED_CALL_DUMMY_START_OFFSET
);
1047 #ifdef DEPRECATED_CALL_DUMMY_WORDS
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS # %s\n",
1050 XSTRING (DEPRECATED_CALL_DUMMY_WORDS
));
1051 fprintf_unfiltered (file
,
1052 "gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS = 0x%08lx\n",
1053 (long) DEPRECATED_CALL_DUMMY_WORDS
);
1055 #ifdef DEPRECATED_DO_REGISTERS_INFO_P
1056 fprintf_unfiltered (file
,
1057 "gdbarch_dump: %s # %s\n",
1058 "DEPRECATED_DO_REGISTERS_INFO_P()",
1059 XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ()));
1060 fprintf_unfiltered (file
,
1061 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n",
1062 DEPRECATED_DO_REGISTERS_INFO_P ());
1064 #ifdef DEPRECATED_DO_REGISTERS_INFO
1066 /* Macro might contain `[{}]' when not multi-arch */
1067 fprintf_unfiltered (file
,
1068 "gdbarch_dump: %s # %s\n",
1069 "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
1070 XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr
, fpregs
)));
1073 fprintf_unfiltered (file
,
1074 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
1075 (long) current_gdbarch
->deprecated_do_registers_info
1076 /*DEPRECATED_DO_REGISTERS_INFO ()*/);
1078 #ifdef DEPRECATED_DUMMY_WRITE_SP_P
1079 fprintf_unfiltered (file
,
1080 "gdbarch_dump: %s # %s\n",
1081 "DEPRECATED_DUMMY_WRITE_SP_P()",
1082 XSTRING (DEPRECATED_DUMMY_WRITE_SP_P ()));
1083 fprintf_unfiltered (file
,
1084 "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP_P() = %d\n",
1085 DEPRECATED_DUMMY_WRITE_SP_P ());
1087 #ifdef DEPRECATED_DUMMY_WRITE_SP
1089 /* Macro might contain `[{}]' when not multi-arch */
1090 fprintf_unfiltered (file
,
1091 "gdbarch_dump: %s # %s\n",
1092 "DEPRECATED_DUMMY_WRITE_SP(val)",
1093 XSTRING (DEPRECATED_DUMMY_WRITE_SP (val
)));
1096 fprintf_unfiltered (file
,
1097 "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP = <0x%08lx>\n",
1098 (long) current_gdbarch
->deprecated_dummy_write_sp
1099 /*DEPRECATED_DUMMY_WRITE_SP ()*/);
1101 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
1103 /* Macro might contain `[{}]' when not multi-arch */
1104 fprintf_unfiltered (file
,
1105 "gdbarch_dump: %s # %s\n",
1106 "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1107 XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type
, regbuf
, valbuf
)));
1110 fprintf_unfiltered (file
,
1111 "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1112 (long) current_gdbarch
->deprecated_extract_return_value
1113 /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
1115 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
1116 fprintf_unfiltered (file
,
1117 "gdbarch_dump: %s # %s\n",
1118 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1119 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1120 fprintf_unfiltered (file
,
1121 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1122 DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1124 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
1125 fprintf_unfiltered (file
,
1126 "gdbarch_dump: %s # %s\n",
1127 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1128 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf
)));
1130 fprintf_unfiltered (file
,
1131 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1132 (long) current_gdbarch
->deprecated_extract_struct_value_address
1133 /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1135 #ifdef DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED
1136 fprintf_unfiltered (file
,
1137 "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1138 XSTRING (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED
));
1139 fprintf_unfiltered (file
,
1140 "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
1141 DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED
);
1143 #ifdef DEPRECATED_FIX_CALL_DUMMY_P
1144 fprintf_unfiltered (file
,
1145 "gdbarch_dump: %s # %s\n",
1146 "DEPRECATED_FIX_CALL_DUMMY_P()",
1147 XSTRING (DEPRECATED_FIX_CALL_DUMMY_P ()));
1148 fprintf_unfiltered (file
,
1149 "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY_P() = %d\n",
1150 DEPRECATED_FIX_CALL_DUMMY_P ());
1152 #ifdef DEPRECATED_FIX_CALL_DUMMY
1154 /* Macro might contain `[{}]' when not multi-arch */
1155 fprintf_unfiltered (file
,
1156 "gdbarch_dump: %s # %s\n",
1157 "DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1158 XSTRING (DEPRECATED_FIX_CALL_DUMMY (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)));
1161 fprintf_unfiltered (file
,
1162 "gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY = <0x%08lx>\n",
1163 (long) current_gdbarch
->deprecated_fix_call_dummy
1164 /*DEPRECATED_FIX_CALL_DUMMY ()*/);
1166 #ifdef DEPRECATED_FP_REGNUM
1167 fprintf_unfiltered (file
,
1168 "gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
1169 XSTRING (DEPRECATED_FP_REGNUM
));
1170 fprintf_unfiltered (file
,
1171 "gdbarch_dump: DEPRECATED_FP_REGNUM = %d\n",
1172 DEPRECATED_FP_REGNUM
);
1174 #ifdef DEPRECATED_FRAME_CHAIN_P
1175 fprintf_unfiltered (file
,
1176 "gdbarch_dump: %s # %s\n",
1177 "DEPRECATED_FRAME_CHAIN_P()",
1178 XSTRING (DEPRECATED_FRAME_CHAIN_P ()));
1179 fprintf_unfiltered (file
,
1180 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n",
1181 DEPRECATED_FRAME_CHAIN_P ());
1183 #ifdef DEPRECATED_FRAME_CHAIN
1184 fprintf_unfiltered (file
,
1185 "gdbarch_dump: %s # %s\n",
1186 "DEPRECATED_FRAME_CHAIN(frame)",
1187 XSTRING (DEPRECATED_FRAME_CHAIN (frame
)));
1189 fprintf_unfiltered (file
,
1190 "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n",
1191 (long) current_gdbarch
->deprecated_frame_chain
1192 /*DEPRECATED_FRAME_CHAIN ()*/);
1194 #ifdef DEPRECATED_FRAME_CHAIN_VALID_P
1195 fprintf_unfiltered (file
,
1196 "gdbarch_dump: %s # %s\n",
1197 "DEPRECATED_FRAME_CHAIN_VALID_P()",
1198 XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ()));
1199 fprintf_unfiltered (file
,
1200 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n",
1201 DEPRECATED_FRAME_CHAIN_VALID_P ());
1203 #ifdef DEPRECATED_FRAME_CHAIN_VALID
1204 fprintf_unfiltered (file
,
1205 "gdbarch_dump: %s # %s\n",
1206 "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)",
1207 XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain
, thisframe
)));
1209 fprintf_unfiltered (file
,
1210 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n",
1211 (long) current_gdbarch
->deprecated_frame_chain_valid
1212 /*DEPRECATED_FRAME_CHAIN_VALID ()*/);
1214 #ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P
1215 fprintf_unfiltered (file
,
1216 "gdbarch_dump: %s # %s\n",
1217 "DEPRECATED_FRAME_INIT_SAVED_REGS_P()",
1218 XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()));
1219 fprintf_unfiltered (file
,
1220 "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS_P() = %d\n",
1221 DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
1223 #ifdef DEPRECATED_FRAME_INIT_SAVED_REGS
1225 /* Macro might contain `[{}]' when not multi-arch */
1226 fprintf_unfiltered (file
,
1227 "gdbarch_dump: %s # %s\n",
1228 "DEPRECATED_FRAME_INIT_SAVED_REGS(frame)",
1229 XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS (frame
)));
1232 fprintf_unfiltered (file
,
1233 "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS = <0x%08lx>\n",
1234 (long) current_gdbarch
->deprecated_frame_init_saved_regs
1235 /*DEPRECATED_FRAME_INIT_SAVED_REGS ()*/);
1237 #ifdef DEPRECATED_FRAME_SAVED_PC_P
1238 fprintf_unfiltered (file
,
1239 "gdbarch_dump: %s # %s\n",
1240 "DEPRECATED_FRAME_SAVED_PC_P()",
1241 XSTRING (DEPRECATED_FRAME_SAVED_PC_P ()));
1242 fprintf_unfiltered (file
,
1243 "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC_P() = %d\n",
1244 DEPRECATED_FRAME_SAVED_PC_P ());
1246 #ifdef DEPRECATED_FRAME_SAVED_PC
1247 fprintf_unfiltered (file
,
1248 "gdbarch_dump: %s # %s\n",
1249 "DEPRECATED_FRAME_SAVED_PC(fi)",
1250 XSTRING (DEPRECATED_FRAME_SAVED_PC (fi
)));
1252 fprintf_unfiltered (file
,
1253 "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC = <0x%08lx>\n",
1254 (long) current_gdbarch
->deprecated_frame_saved_pc
1255 /*DEPRECATED_FRAME_SAVED_PC ()*/);
1257 #ifdef DEPRECATED_GET_SAVED_REGISTER_P
1258 fprintf_unfiltered (file
,
1259 "gdbarch_dump: %s # %s\n",
1260 "DEPRECATED_GET_SAVED_REGISTER_P()",
1261 XSTRING (DEPRECATED_GET_SAVED_REGISTER_P ()));
1262 fprintf_unfiltered (file
,
1263 "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER_P() = %d\n",
1264 DEPRECATED_GET_SAVED_REGISTER_P ());
1266 #ifdef DEPRECATED_GET_SAVED_REGISTER
1268 /* Macro might contain `[{}]' when not multi-arch */
1269 fprintf_unfiltered (file
,
1270 "gdbarch_dump: %s # %s\n",
1271 "DEPRECATED_GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1272 XSTRING (DEPRECATED_GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)));
1275 fprintf_unfiltered (file
,
1276 "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER = <0x%08lx>\n",
1277 (long) current_gdbarch
->deprecated_get_saved_register
1278 /*DEPRECATED_GET_SAVED_REGISTER ()*/);
1280 #ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO_P
1281 fprintf_unfiltered (file
,
1282 "gdbarch_dump: %s # %s\n",
1283 "DEPRECATED_INIT_EXTRA_FRAME_INFO_P()",
1284 XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()));
1285 fprintf_unfiltered (file
,
1286 "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO_P() = %d\n",
1287 DEPRECATED_INIT_EXTRA_FRAME_INFO_P ());
1289 #ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO
1291 /* Macro might contain `[{}]' when not multi-arch */
1292 fprintf_unfiltered (file
,
1293 "gdbarch_dump: %s # %s\n",
1294 "DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1295 XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, frame
)));
1298 fprintf_unfiltered (file
,
1299 "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO = <0x%08lx>\n",
1300 (long) current_gdbarch
->deprecated_init_extra_frame_info
1301 /*DEPRECATED_INIT_EXTRA_FRAME_INFO ()*/);
1303 #ifdef DEPRECATED_INIT_FRAME_PC_P
1304 fprintf_unfiltered (file
,
1305 "gdbarch_dump: %s # %s\n",
1306 "DEPRECATED_INIT_FRAME_PC_P()",
1307 XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
1308 fprintf_unfiltered (file
,
1309 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
1310 DEPRECATED_INIT_FRAME_PC_P ());
1312 #ifdef DEPRECATED_INIT_FRAME_PC
1313 fprintf_unfiltered (file
,
1314 "gdbarch_dump: %s # %s\n",
1315 "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
1316 XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf
, prev
)));
1318 fprintf_unfiltered (file
,
1319 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
1320 (long) current_gdbarch
->deprecated_init_frame_pc
1321 /*DEPRECATED_INIT_FRAME_PC ()*/);
1323 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
1324 fprintf_unfiltered (file
,
1325 "gdbarch_dump: %s # %s\n",
1326 "DEPRECATED_INIT_FRAME_PC_FIRST_P()",
1327 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ()));
1328 fprintf_unfiltered (file
,
1329 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n",
1330 DEPRECATED_INIT_FRAME_PC_FIRST_P ());
1332 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST
1333 fprintf_unfiltered (file
,
1334 "gdbarch_dump: %s # %s\n",
1335 "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
1336 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
, prev
)));
1338 fprintf_unfiltered (file
,
1339 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
1340 (long) current_gdbarch
->deprecated_init_frame_pc_first
1341 /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
1343 #ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE_P
1344 fprintf_unfiltered (file
,
1345 "gdbarch_dump: %s # %s\n",
1346 "DEPRECATED_MAX_REGISTER_RAW_SIZE_P()",
1347 XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ()));
1348 fprintf_unfiltered (file
,
1349 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE_P() = %d\n",
1350 DEPRECATED_MAX_REGISTER_RAW_SIZE_P ());
1352 #ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE
1353 fprintf_unfiltered (file
,
1354 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE # %s\n",
1355 XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE
));
1356 fprintf_unfiltered (file
,
1357 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE = %d\n",
1358 DEPRECATED_MAX_REGISTER_RAW_SIZE
);
1360 #ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P
1361 fprintf_unfiltered (file
,
1362 "gdbarch_dump: %s # %s\n",
1363 "DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P()",
1364 XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ()));
1365 fprintf_unfiltered (file
,
1366 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P() = %d\n",
1367 DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ());
1369 #ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE
1370 fprintf_unfiltered (file
,
1371 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1372 XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE
));
1373 fprintf_unfiltered (file
,
1374 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE = %d\n",
1375 DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE
);
1377 #ifdef DEPRECATED_PC_IN_CALL_DUMMY_P
1378 fprintf_unfiltered (file
,
1379 "gdbarch_dump: %s # %s\n",
1380 "DEPRECATED_PC_IN_CALL_DUMMY_P()",
1381 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ()));
1382 fprintf_unfiltered (file
,
1383 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n",
1384 DEPRECATED_PC_IN_CALL_DUMMY_P ());
1386 #ifdef DEPRECATED_PC_IN_CALL_DUMMY
1387 fprintf_unfiltered (file
,
1388 "gdbarch_dump: %s # %s\n",
1389 "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1390 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc
, sp
, frame_address
)));
1392 fprintf_unfiltered (file
,
1393 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
1394 (long) current_gdbarch
->deprecated_pc_in_call_dummy
1395 /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
1397 #ifdef DEPRECATED_POP_FRAME_P
1398 fprintf_unfiltered (file
,
1399 "gdbarch_dump: %s # %s\n",
1400 "DEPRECATED_POP_FRAME_P()",
1401 XSTRING (DEPRECATED_POP_FRAME_P ()));
1402 fprintf_unfiltered (file
,
1403 "gdbarch_dump: DEPRECATED_POP_FRAME_P() = %d\n",
1404 DEPRECATED_POP_FRAME_P ());
1406 #ifdef DEPRECATED_POP_FRAME
1408 /* Macro might contain `[{}]' when not multi-arch */
1409 fprintf_unfiltered (file
,
1410 "gdbarch_dump: %s # %s\n",
1411 "DEPRECATED_POP_FRAME(-)",
1412 XSTRING (DEPRECATED_POP_FRAME (-)));
1415 fprintf_unfiltered (file
,
1416 "gdbarch_dump: DEPRECATED_POP_FRAME = <0x%08lx>\n",
1417 (long) current_gdbarch
->deprecated_pop_frame
1418 /*DEPRECATED_POP_FRAME ()*/);
1420 #ifdef DEPRECATED_PUSH_ARGUMENTS_P
1421 fprintf_unfiltered (file
,
1422 "gdbarch_dump: %s # %s\n",
1423 "DEPRECATED_PUSH_ARGUMENTS_P()",
1424 XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ()));
1425 fprintf_unfiltered (file
,
1426 "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS_P() = %d\n",
1427 DEPRECATED_PUSH_ARGUMENTS_P ());
1429 #ifdef DEPRECATED_PUSH_ARGUMENTS
1430 fprintf_unfiltered (file
,
1431 "gdbarch_dump: %s # %s\n",
1432 "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1433 XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
)));
1435 fprintf_unfiltered (file
,
1436 "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS = <0x%08lx>\n",
1437 (long) current_gdbarch
->deprecated_push_arguments
1438 /*DEPRECATED_PUSH_ARGUMENTS ()*/);
1440 #ifdef DEPRECATED_PUSH_DUMMY_FRAME_P
1441 fprintf_unfiltered (file
,
1442 "gdbarch_dump: %s # %s\n",
1443 "DEPRECATED_PUSH_DUMMY_FRAME_P()",
1444 XSTRING (DEPRECATED_PUSH_DUMMY_FRAME_P ()));
1445 fprintf_unfiltered (file
,
1446 "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME_P() = %d\n",
1447 DEPRECATED_PUSH_DUMMY_FRAME_P ());
1449 #ifdef DEPRECATED_PUSH_DUMMY_FRAME
1451 /* Macro might contain `[{}]' when not multi-arch */
1452 fprintf_unfiltered (file
,
1453 "gdbarch_dump: %s # %s\n",
1454 "DEPRECATED_PUSH_DUMMY_FRAME(-)",
1455 XSTRING (DEPRECATED_PUSH_DUMMY_FRAME (-)));
1458 fprintf_unfiltered (file
,
1459 "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME = <0x%08lx>\n",
1460 (long) current_gdbarch
->deprecated_push_dummy_frame
1461 /*DEPRECATED_PUSH_DUMMY_FRAME ()*/);
1463 #ifdef DEPRECATED_PUSH_RETURN_ADDRESS_P
1464 fprintf_unfiltered (file
,
1465 "gdbarch_dump: %s # %s\n",
1466 "DEPRECATED_PUSH_RETURN_ADDRESS_P()",
1467 XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS_P ()));
1468 fprintf_unfiltered (file
,
1469 "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS_P() = %d\n",
1470 DEPRECATED_PUSH_RETURN_ADDRESS_P ());
1472 #ifdef DEPRECATED_PUSH_RETURN_ADDRESS
1473 fprintf_unfiltered (file
,
1474 "gdbarch_dump: %s # %s\n",
1475 "DEPRECATED_PUSH_RETURN_ADDRESS(pc, sp)",
1476 XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS (pc
, sp
)));
1478 fprintf_unfiltered (file
,
1479 "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS = <0x%08lx>\n",
1480 (long) current_gdbarch
->deprecated_push_return_address
1481 /*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
1483 #ifdef DEPRECATED_REGISTER_BYTES
1484 fprintf_unfiltered (file
,
1485 "gdbarch_dump: DEPRECATED_REGISTER_BYTES # %s\n",
1486 XSTRING (DEPRECATED_REGISTER_BYTES
));
1487 fprintf_unfiltered (file
,
1488 "gdbarch_dump: DEPRECATED_REGISTER_BYTES = %d\n",
1489 DEPRECATED_REGISTER_BYTES
);
1491 #ifdef DEPRECATED_REGISTER_SIZE
1492 fprintf_unfiltered (file
,
1493 "gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
1494 XSTRING (DEPRECATED_REGISTER_SIZE
));
1495 fprintf_unfiltered (file
,
1496 "gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n",
1497 DEPRECATED_REGISTER_SIZE
);
1499 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
1500 fprintf_unfiltered (file
,
1501 "gdbarch_dump: %s # %s\n",
1502 "DEPRECATED_SAVED_PC_AFTER_CALL_P()",
1503 XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL_P ()));
1504 fprintf_unfiltered (file
,
1505 "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL_P() = %d\n",
1506 DEPRECATED_SAVED_PC_AFTER_CALL_P ());
1508 #ifdef DEPRECATED_SAVED_PC_AFTER_CALL
1509 fprintf_unfiltered (file
,
1510 "gdbarch_dump: %s # %s\n",
1511 "DEPRECATED_SAVED_PC_AFTER_CALL(frame)",
1512 XSTRING (DEPRECATED_SAVED_PC_AFTER_CALL (frame
)));
1514 fprintf_unfiltered (file
,
1515 "gdbarch_dump: DEPRECATED_SAVED_PC_AFTER_CALL = <0x%08lx>\n",
1516 (long) current_gdbarch
->deprecated_saved_pc_after_call
1517 /*DEPRECATED_SAVED_PC_AFTER_CALL ()*/);
1519 #ifdef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
1520 fprintf_unfiltered (file
,
1521 "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS # %s\n",
1522 XSTRING (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
));
1523 fprintf_unfiltered (file
,
1524 "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n",
1525 DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
);
1527 #ifdef DEPRECATED_STORE_RETURN_VALUE
1529 /* Macro might contain `[{}]' when not multi-arch */
1530 fprintf_unfiltered (file
,
1531 "gdbarch_dump: %s # %s\n",
1532 "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
1533 XSTRING (DEPRECATED_STORE_RETURN_VALUE (type
, valbuf
)));
1536 fprintf_unfiltered (file
,
1537 "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
1538 (long) current_gdbarch
->deprecated_store_return_value
1539 /*DEPRECATED_STORE_RETURN_VALUE ()*/);
1541 #ifdef DEPRECATED_STORE_STRUCT_RETURN_P
1542 fprintf_unfiltered (file
,
1543 "gdbarch_dump: %s # %s\n",
1544 "DEPRECATED_STORE_STRUCT_RETURN_P()",
1545 XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ()));
1546 fprintf_unfiltered (file
,
1547 "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN_P() = %d\n",
1548 DEPRECATED_STORE_STRUCT_RETURN_P ());
1550 #ifdef DEPRECATED_STORE_STRUCT_RETURN
1552 /* Macro might contain `[{}]' when not multi-arch */
1553 fprintf_unfiltered (file
,
1554 "gdbarch_dump: %s # %s\n",
1555 "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
1556 XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr
, sp
)));
1559 fprintf_unfiltered (file
,
1560 "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN = <0x%08lx>\n",
1561 (long) current_gdbarch
->deprecated_store_struct_return
1562 /*DEPRECATED_STORE_STRUCT_RETURN ()*/);
1564 #ifdef DEPRECATED_TARGET_READ_FP_P
1565 fprintf_unfiltered (file
,
1566 "gdbarch_dump: %s # %s\n",
1567 "DEPRECATED_TARGET_READ_FP_P()",
1568 XSTRING (DEPRECATED_TARGET_READ_FP_P ()));
1569 fprintf_unfiltered (file
,
1570 "gdbarch_dump: DEPRECATED_TARGET_READ_FP_P() = %d\n",
1571 DEPRECATED_TARGET_READ_FP_P ());
1573 #ifdef DEPRECATED_TARGET_READ_FP
1574 fprintf_unfiltered (file
,
1575 "gdbarch_dump: %s # %s\n",
1576 "DEPRECATED_TARGET_READ_FP()",
1577 XSTRING (DEPRECATED_TARGET_READ_FP ()));
1579 fprintf_unfiltered (file
,
1580 "gdbarch_dump: DEPRECATED_TARGET_READ_FP = <0x%08lx>\n",
1581 (long) current_gdbarch
->deprecated_target_read_fp
1582 /*DEPRECATED_TARGET_READ_FP ()*/);
1584 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1585 fprintf_unfiltered (file
,
1586 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
1587 XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
));
1588 fprintf_unfiltered (file
,
1589 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
1590 DEPRECATED_USE_GENERIC_DUMMY_FRAMES
);
1592 #ifdef DWARF2_BUILD_FRAME_INFO_P
1593 fprintf_unfiltered (file
,
1594 "gdbarch_dump: %s # %s\n",
1595 "DWARF2_BUILD_FRAME_INFO_P()",
1596 XSTRING (DWARF2_BUILD_FRAME_INFO_P ()));
1597 fprintf_unfiltered (file
,
1598 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO_P() = %d\n",
1599 DWARF2_BUILD_FRAME_INFO_P ());
1601 #ifdef DWARF2_BUILD_FRAME_INFO
1603 /* Macro might contain `[{}]' when not multi-arch */
1604 fprintf_unfiltered (file
,
1605 "gdbarch_dump: %s # %s\n",
1606 "DWARF2_BUILD_FRAME_INFO(objfile)",
1607 XSTRING (DWARF2_BUILD_FRAME_INFO (objfile
)));
1610 fprintf_unfiltered (file
,
1611 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n",
1612 (long) current_gdbarch
->dwarf2_build_frame_info
1613 /*DWARF2_BUILD_FRAME_INFO ()*/);
1615 #ifdef DWARF2_REG_TO_REGNUM
1616 fprintf_unfiltered (file
,
1617 "gdbarch_dump: %s # %s\n",
1618 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1619 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr
)));
1621 fprintf_unfiltered (file
,
1622 "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
1623 (long) current_gdbarch
->dwarf2_reg_to_regnum
1624 /*DWARF2_REG_TO_REGNUM ()*/);
1626 #ifdef DWARF_REG_TO_REGNUM
1627 fprintf_unfiltered (file
,
1628 "gdbarch_dump: %s # %s\n",
1629 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1630 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr
)));
1632 fprintf_unfiltered (file
,
1633 "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
1634 (long) current_gdbarch
->dwarf_reg_to_regnum
1635 /*DWARF_REG_TO_REGNUM ()*/);
1637 #ifdef ECOFF_REG_TO_REGNUM
1638 fprintf_unfiltered (file
,
1639 "gdbarch_dump: %s # %s\n",
1640 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1641 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr
)));
1643 fprintf_unfiltered (file
,
1644 "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
1645 (long) current_gdbarch
->ecoff_reg_to_regnum
1646 /*ECOFF_REG_TO_REGNUM ()*/);
1648 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1650 /* Macro might contain `[{}]' when not multi-arch */
1651 fprintf_unfiltered (file
,
1652 "gdbarch_dump: %s # %s\n",
1653 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1654 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
)));
1657 fprintf_unfiltered (file
,
1658 "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1659 (long) current_gdbarch
->elf_make_msymbol_special
1660 /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
1662 #ifdef EXTRACT_RETURN_VALUE
1664 /* Macro might contain `[{}]' when not multi-arch */
1665 fprintf_unfiltered (file
,
1666 "gdbarch_dump: %s # %s\n",
1667 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1668 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
1671 fprintf_unfiltered (file
,
1672 "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1673 (long) current_gdbarch
->extract_return_value
1674 /*EXTRACT_RETURN_VALUE ()*/);
1676 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
1677 fprintf_unfiltered (file
,
1678 "gdbarch_dump: %s # %s\n",
1679 "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1680 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1681 fprintf_unfiltered (file
,
1682 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1683 EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1685 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1686 fprintf_unfiltered (file
,
1687 "gdbarch_dump: %s # %s\n",
1688 "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
1689 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
1691 fprintf_unfiltered (file
,
1692 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1693 (long) current_gdbarch
->extract_struct_value_address
1694 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1697 fprintf_unfiltered (file
,
1698 "gdbarch_dump: FP0_REGNUM # %s\n",
1699 XSTRING (FP0_REGNUM
));
1700 fprintf_unfiltered (file
,
1701 "gdbarch_dump: FP0_REGNUM = %d\n",
1704 #ifdef FRAMELESS_FUNCTION_INVOCATION
1705 fprintf_unfiltered (file
,
1706 "gdbarch_dump: %s # %s\n",
1707 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1708 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi
)));
1710 fprintf_unfiltered (file
,
1711 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
1712 (long) current_gdbarch
->frameless_function_invocation
1713 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1715 #ifdef FRAME_ARGS_ADDRESS
1716 fprintf_unfiltered (file
,
1717 "gdbarch_dump: %s # %s\n",
1718 "FRAME_ARGS_ADDRESS(fi)",
1719 XSTRING (FRAME_ARGS_ADDRESS (fi
)));
1721 fprintf_unfiltered (file
,
1722 "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n",
1723 (long) current_gdbarch
->frame_args_address
1724 /*FRAME_ARGS_ADDRESS ()*/);
1726 #ifdef FRAME_ARGS_SKIP
1727 fprintf_unfiltered (file
,
1728 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1729 XSTRING (FRAME_ARGS_SKIP
));
1730 fprintf_unfiltered (file
,
1731 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1732 (long) FRAME_ARGS_SKIP
);
1734 #ifdef FRAME_LOCALS_ADDRESS
1735 fprintf_unfiltered (file
,
1736 "gdbarch_dump: %s # %s\n",
1737 "FRAME_LOCALS_ADDRESS(fi)",
1738 XSTRING (FRAME_LOCALS_ADDRESS (fi
)));
1740 fprintf_unfiltered (file
,
1741 "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
1742 (long) current_gdbarch
->frame_locals_address
1743 /*FRAME_LOCALS_ADDRESS ()*/);
1745 #ifdef FRAME_NUM_ARGS
1746 fprintf_unfiltered (file
,
1747 "gdbarch_dump: %s # %s\n",
1748 "FRAME_NUM_ARGS(frame)",
1749 XSTRING (FRAME_NUM_ARGS (frame
)));
1751 fprintf_unfiltered (file
,
1752 "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
1753 (long) current_gdbarch
->frame_num_args
1754 /*FRAME_NUM_ARGS ()*/);
1756 #ifdef FUNCTION_START_OFFSET
1757 fprintf_unfiltered (file
,
1758 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1759 XSTRING (FUNCTION_START_OFFSET
));
1760 fprintf_unfiltered (file
,
1761 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1762 (long) FUNCTION_START_OFFSET
);
1764 #ifdef GET_LONGJMP_TARGET_P
1765 fprintf_unfiltered (file
,
1766 "gdbarch_dump: %s # %s\n",
1767 "GET_LONGJMP_TARGET_P()",
1768 XSTRING (GET_LONGJMP_TARGET_P ()));
1769 fprintf_unfiltered (file
,
1770 "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n",
1771 GET_LONGJMP_TARGET_P ());
1773 #ifdef GET_LONGJMP_TARGET
1774 fprintf_unfiltered (file
,
1775 "gdbarch_dump: %s # %s\n",
1776 "GET_LONGJMP_TARGET(pc)",
1777 XSTRING (GET_LONGJMP_TARGET (pc
)));
1779 fprintf_unfiltered (file
,
1780 "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
1781 (long) current_gdbarch
->get_longjmp_target
1782 /*GET_LONGJMP_TARGET ()*/);
1784 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1785 fprintf_unfiltered (file
,
1786 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1787 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT
));
1788 fprintf_unfiltered (file
,
1789 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
1790 HAVE_NONSTEPPABLE_WATCHPOINT
);
1793 fprintf_unfiltered (file
,
1794 "gdbarch_dump: %s # %s\n",
1795 "INNER_THAN(lhs, rhs)",
1796 XSTRING (INNER_THAN (lhs
, rhs
)));
1798 fprintf_unfiltered (file
,
1799 "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
1800 (long) current_gdbarch
->inner_than
1803 #ifdef INTEGER_TO_ADDRESS_P
1804 fprintf_unfiltered (file
,
1805 "gdbarch_dump: %s # %s\n",
1806 "INTEGER_TO_ADDRESS_P()",
1807 XSTRING (INTEGER_TO_ADDRESS_P ()));
1808 fprintf_unfiltered (file
,
1809 "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n",
1810 INTEGER_TO_ADDRESS_P ());
1812 #ifdef INTEGER_TO_ADDRESS
1813 fprintf_unfiltered (file
,
1814 "gdbarch_dump: %s # %s\n",
1815 "INTEGER_TO_ADDRESS(type, buf)",
1816 XSTRING (INTEGER_TO_ADDRESS (type
, buf
)));
1818 fprintf_unfiltered (file
,
1819 "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
1820 (long) current_gdbarch
->integer_to_address
1821 /*INTEGER_TO_ADDRESS ()*/);
1823 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1824 fprintf_unfiltered (file
,
1825 "gdbarch_dump: %s # %s\n",
1826 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1827 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc
, name
)));
1829 fprintf_unfiltered (file
,
1830 "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
1831 (long) current_gdbarch
->in_solib_call_trampoline
1832 /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1834 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1835 fprintf_unfiltered (file
,
1836 "gdbarch_dump: %s # %s\n",
1837 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1838 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc
, name
)));
1840 fprintf_unfiltered (file
,
1841 "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
1842 (long) current_gdbarch
->in_solib_return_trampoline
1843 /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
1845 #ifdef MEMORY_INSERT_BREAKPOINT
1846 fprintf_unfiltered (file
,
1847 "gdbarch_dump: %s # %s\n",
1848 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1849 XSTRING (MEMORY_INSERT_BREAKPOINT (addr
, contents_cache
)));
1851 fprintf_unfiltered (file
,
1852 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
1853 (long) current_gdbarch
->memory_insert_breakpoint
1854 /*MEMORY_INSERT_BREAKPOINT ()*/);
1856 #ifdef MEMORY_REMOVE_BREAKPOINT
1857 fprintf_unfiltered (file
,
1858 "gdbarch_dump: %s # %s\n",
1859 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1860 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr
, contents_cache
)));
1862 fprintf_unfiltered (file
,
1863 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
1864 (long) current_gdbarch
->memory_remove_breakpoint
1865 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1867 #ifdef NAME_OF_MALLOC
1868 fprintf_unfiltered (file
,
1869 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1870 XSTRING (NAME_OF_MALLOC
));
1871 fprintf_unfiltered (file
,
1872 "gdbarch_dump: NAME_OF_MALLOC = %s\n",
1876 fprintf_unfiltered (file
,
1877 "gdbarch_dump: NPC_REGNUM # %s\n",
1878 XSTRING (NPC_REGNUM
));
1879 fprintf_unfiltered (file
,
1880 "gdbarch_dump: NPC_REGNUM = %d\n",
1883 #ifdef NUM_PSEUDO_REGS
1884 fprintf_unfiltered (file
,
1885 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1886 XSTRING (NUM_PSEUDO_REGS
));
1887 fprintf_unfiltered (file
,
1888 "gdbarch_dump: NUM_PSEUDO_REGS = %d\n",
1892 fprintf_unfiltered (file
,
1893 "gdbarch_dump: NUM_REGS # %s\n",
1894 XSTRING (NUM_REGS
));
1895 fprintf_unfiltered (file
,
1896 "gdbarch_dump: NUM_REGS = %d\n",
1899 #ifdef PARM_BOUNDARY
1900 fprintf_unfiltered (file
,
1901 "gdbarch_dump: PARM_BOUNDARY # %s\n",
1902 XSTRING (PARM_BOUNDARY
));
1903 fprintf_unfiltered (file
,
1904 "gdbarch_dump: PARM_BOUNDARY = %d\n",
1907 #ifdef PC_IN_SIGTRAMP
1908 fprintf_unfiltered (file
,
1909 "gdbarch_dump: %s # %s\n",
1910 "PC_IN_SIGTRAMP(pc, name)",
1911 XSTRING (PC_IN_SIGTRAMP (pc
, name
)));
1913 fprintf_unfiltered (file
,
1914 "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
1915 (long) current_gdbarch
->pc_in_sigtramp
1916 /*PC_IN_SIGTRAMP ()*/);
1919 fprintf_unfiltered (file
,
1920 "gdbarch_dump: PC_REGNUM # %s\n",
1921 XSTRING (PC_REGNUM
));
1922 fprintf_unfiltered (file
,
1923 "gdbarch_dump: PC_REGNUM = %d\n",
1926 #ifdef POINTER_TO_ADDRESS
1927 fprintf_unfiltered (file
,
1928 "gdbarch_dump: %s # %s\n",
1929 "POINTER_TO_ADDRESS(type, buf)",
1930 XSTRING (POINTER_TO_ADDRESS (type
, buf
)));
1932 fprintf_unfiltered (file
,
1933 "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
1934 (long) current_gdbarch
->pointer_to_address
1935 /*POINTER_TO_ADDRESS ()*/);
1937 #ifdef PREPARE_TO_PROCEED
1938 fprintf_unfiltered (file
,
1939 "gdbarch_dump: %s # %s\n",
1940 "PREPARE_TO_PROCEED(select_it)",
1941 XSTRING (PREPARE_TO_PROCEED (select_it
)));
1943 fprintf_unfiltered (file
,
1944 "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n",
1945 (long) current_gdbarch
->prepare_to_proceed
1946 /*PREPARE_TO_PROCEED ()*/);
1949 fprintf_unfiltered (file
,
1950 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1951 gdbarch_print_float_info_p (current_gdbarch
));
1953 fprintf_unfiltered (file
,
1954 "gdbarch_dump: print_float_info = 0x%08lx\n",
1955 (long) current_gdbarch
->print_float_info
);
1957 fprintf_unfiltered (file
,
1958 "gdbarch_dump: print_registers_info = 0x%08lx\n",
1959 (long) current_gdbarch
->print_registers_info
);
1961 fprintf_unfiltered (file
,
1962 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1963 gdbarch_print_vector_info_p (current_gdbarch
));
1965 fprintf_unfiltered (file
,
1966 "gdbarch_dump: print_vector_info = 0x%08lx\n",
1967 (long) current_gdbarch
->print_vector_info
);
1968 #ifdef PROLOGUE_FRAMELESS_P
1969 fprintf_unfiltered (file
,
1970 "gdbarch_dump: %s # %s\n",
1971 "PROLOGUE_FRAMELESS_P(ip)",
1972 XSTRING (PROLOGUE_FRAMELESS_P (ip
)));
1974 fprintf_unfiltered (file
,
1975 "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
1976 (long) current_gdbarch
->prologue_frameless_p
1977 /*PROLOGUE_FRAMELESS_P ()*/);
1980 fprintf_unfiltered (file
,
1981 "gdbarch_dump: PS_REGNUM # %s\n",
1982 XSTRING (PS_REGNUM
));
1983 fprintf_unfiltered (file
,
1984 "gdbarch_dump: PS_REGNUM = %d\n",
1988 fprintf_unfiltered (file
,
1989 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1990 gdbarch_push_dummy_call_p (current_gdbarch
));
1992 fprintf_unfiltered (file
,
1993 "gdbarch_dump: push_dummy_call = 0x%08lx\n",
1994 (long) current_gdbarch
->push_dummy_call
);
1996 fprintf_unfiltered (file
,
1997 "gdbarch_dump: gdbarch_push_dummy_code_p() = %d\n",
1998 gdbarch_push_dummy_code_p (current_gdbarch
));
2000 fprintf_unfiltered (file
,
2001 "gdbarch_dump: push_dummy_code = 0x%08lx\n",
2002 (long) current_gdbarch
->push_dummy_code
);
2003 #ifdef REGISTER_BYTE_P
2004 fprintf_unfiltered (file
,
2005 "gdbarch_dump: %s # %s\n",
2006 "REGISTER_BYTE_P()",
2007 XSTRING (REGISTER_BYTE_P ()));
2008 fprintf_unfiltered (file
,
2009 "gdbarch_dump: REGISTER_BYTE_P() = %d\n",
2010 REGISTER_BYTE_P ());
2012 #ifdef REGISTER_BYTE
2013 fprintf_unfiltered (file
,
2014 "gdbarch_dump: %s # %s\n",
2015 "REGISTER_BYTE(reg_nr)",
2016 XSTRING (REGISTER_BYTE (reg_nr
)));
2018 fprintf_unfiltered (file
,
2019 "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
2020 (long) current_gdbarch
->register_byte
2021 /*REGISTER_BYTE ()*/);
2023 #ifdef REGISTER_BYTES_OK_P
2024 fprintf_unfiltered (file
,
2025 "gdbarch_dump: %s # %s\n",
2026 "REGISTER_BYTES_OK_P()",
2027 XSTRING (REGISTER_BYTES_OK_P ()));
2028 fprintf_unfiltered (file
,
2029 "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n",
2030 REGISTER_BYTES_OK_P ());
2032 #ifdef REGISTER_BYTES_OK
2033 fprintf_unfiltered (file
,
2034 "gdbarch_dump: %s # %s\n",
2035 "REGISTER_BYTES_OK(nr_bytes)",
2036 XSTRING (REGISTER_BYTES_OK (nr_bytes
)));
2038 fprintf_unfiltered (file
,
2039 "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
2040 (long) current_gdbarch
->register_bytes_ok
2041 /*REGISTER_BYTES_OK ()*/);
2043 #ifdef REGISTER_CONVERTIBLE
2044 fprintf_unfiltered (file
,
2045 "gdbarch_dump: %s # %s\n",
2046 "REGISTER_CONVERTIBLE(nr)",
2047 XSTRING (REGISTER_CONVERTIBLE (nr
)));
2049 fprintf_unfiltered (file
,
2050 "gdbarch_dump: REGISTER_CONVERTIBLE = <0x%08lx>\n",
2051 (long) current_gdbarch
->register_convertible
2052 /*REGISTER_CONVERTIBLE ()*/);
2054 #ifdef REGISTER_CONVERT_TO_RAW
2056 /* Macro might contain `[{}]' when not multi-arch */
2057 fprintf_unfiltered (file
,
2058 "gdbarch_dump: %s # %s\n",
2059 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
2060 XSTRING (REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
)));
2063 fprintf_unfiltered (file
,
2064 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
2065 (long) current_gdbarch
->register_convert_to_raw
2066 /*REGISTER_CONVERT_TO_RAW ()*/);
2068 #ifdef REGISTER_CONVERT_TO_VIRTUAL
2070 /* Macro might contain `[{}]' when not multi-arch */
2071 fprintf_unfiltered (file
,
2072 "gdbarch_dump: %s # %s\n",
2073 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
2074 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
)));
2077 fprintf_unfiltered (file
,
2078 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
2079 (long) current_gdbarch
->register_convert_to_virtual
2080 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
2082 #ifdef REGISTER_NAME
2083 fprintf_unfiltered (file
,
2084 "gdbarch_dump: %s # %s\n",
2085 "REGISTER_NAME(regnr)",
2086 XSTRING (REGISTER_NAME (regnr
)));
2088 fprintf_unfiltered (file
,
2089 "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
2090 (long) current_gdbarch
->register_name
2091 /*REGISTER_NAME ()*/);
2093 #ifdef REGISTER_RAW_SIZE
2094 fprintf_unfiltered (file
,
2095 "gdbarch_dump: %s # %s\n",
2096 "REGISTER_RAW_SIZE(reg_nr)",
2097 XSTRING (REGISTER_RAW_SIZE (reg_nr
)));
2099 fprintf_unfiltered (file
,
2100 "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
2101 (long) current_gdbarch
->register_raw_size
2102 /*REGISTER_RAW_SIZE ()*/);
2104 #ifdef REGISTER_SIM_REGNO
2105 fprintf_unfiltered (file
,
2106 "gdbarch_dump: %s # %s\n",
2107 "REGISTER_SIM_REGNO(reg_nr)",
2108 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
2110 fprintf_unfiltered (file
,
2111 "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
2112 (long) current_gdbarch
->register_sim_regno
2113 /*REGISTER_SIM_REGNO ()*/);
2115 #ifdef REGISTER_TO_VALUE
2117 /* Macro might contain `[{}]' when not multi-arch */
2118 fprintf_unfiltered (file
,
2119 "gdbarch_dump: %s # %s\n",
2120 "REGISTER_TO_VALUE(regnum, type, from, to)",
2121 XSTRING (REGISTER_TO_VALUE (regnum
, type
, from
, to
)));
2124 fprintf_unfiltered (file
,
2125 "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
2126 (long) current_gdbarch
->register_to_value
2127 /*REGISTER_TO_VALUE ()*/);
2130 fprintf_unfiltered (file
,
2131 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
2132 gdbarch_register_type_p (current_gdbarch
));
2134 fprintf_unfiltered (file
,
2135 "gdbarch_dump: register_type = 0x%08lx\n",
2136 (long) current_gdbarch
->register_type
);
2137 #ifdef REGISTER_VIRTUAL_SIZE
2138 fprintf_unfiltered (file
,
2139 "gdbarch_dump: %s # %s\n",
2140 "REGISTER_VIRTUAL_SIZE(reg_nr)",
2141 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr
)));
2143 fprintf_unfiltered (file
,
2144 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
2145 (long) current_gdbarch
->register_virtual_size
2146 /*REGISTER_VIRTUAL_SIZE ()*/);
2148 #ifdef REGISTER_VIRTUAL_TYPE_P
2149 fprintf_unfiltered (file
,
2150 "gdbarch_dump: %s # %s\n",
2151 "REGISTER_VIRTUAL_TYPE_P()",
2152 XSTRING (REGISTER_VIRTUAL_TYPE_P ()));
2153 fprintf_unfiltered (file
,
2154 "gdbarch_dump: REGISTER_VIRTUAL_TYPE_P() = %d\n",
2155 REGISTER_VIRTUAL_TYPE_P ());
2157 #ifdef REGISTER_VIRTUAL_TYPE
2158 fprintf_unfiltered (file
,
2159 "gdbarch_dump: %s # %s\n",
2160 "REGISTER_VIRTUAL_TYPE(reg_nr)",
2161 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr
)));
2163 fprintf_unfiltered (file
,
2164 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
2165 (long) current_gdbarch
->register_virtual_type
2166 /*REGISTER_VIRTUAL_TYPE ()*/);
2168 #ifdef REG_STRUCT_HAS_ADDR_P
2169 fprintf_unfiltered (file
,
2170 "gdbarch_dump: %s # %s\n",
2171 "REG_STRUCT_HAS_ADDR_P()",
2172 XSTRING (REG_STRUCT_HAS_ADDR_P ()));
2173 fprintf_unfiltered (file
,
2174 "gdbarch_dump: REG_STRUCT_HAS_ADDR_P() = %d\n",
2175 REG_STRUCT_HAS_ADDR_P ());
2177 #ifdef REG_STRUCT_HAS_ADDR
2178 fprintf_unfiltered (file
,
2179 "gdbarch_dump: %s # %s\n",
2180 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
2181 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
2183 fprintf_unfiltered (file
,
2184 "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
2185 (long) current_gdbarch
->reg_struct_has_addr
2186 /*REG_STRUCT_HAS_ADDR ()*/);
2189 fprintf_unfiltered (file
,
2190 "gdbarch_dump: remote_translate_xfer_address = 0x%08lx\n",
2191 (long) current_gdbarch
->remote_translate_xfer_address
);
2192 #ifdef RETURN_VALUE_ON_STACK
2193 fprintf_unfiltered (file
,
2194 "gdbarch_dump: %s # %s\n",
2195 "RETURN_VALUE_ON_STACK(type)",
2196 XSTRING (RETURN_VALUE_ON_STACK (type
)));
2198 fprintf_unfiltered (file
,
2199 "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
2200 (long) current_gdbarch
->return_value_on_stack
2201 /*RETURN_VALUE_ON_STACK ()*/);
2203 #ifdef SAVE_DUMMY_FRAME_TOS_P
2204 fprintf_unfiltered (file
,
2205 "gdbarch_dump: %s # %s\n",
2206 "SAVE_DUMMY_FRAME_TOS_P()",
2207 XSTRING (SAVE_DUMMY_FRAME_TOS_P ()));
2208 fprintf_unfiltered (file
,
2209 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS_P() = %d\n",
2210 SAVE_DUMMY_FRAME_TOS_P ());
2212 #ifdef SAVE_DUMMY_FRAME_TOS
2214 /* Macro might contain `[{}]' when not multi-arch */
2215 fprintf_unfiltered (file
,
2216 "gdbarch_dump: %s # %s\n",
2217 "SAVE_DUMMY_FRAME_TOS(sp)",
2218 XSTRING (SAVE_DUMMY_FRAME_TOS (sp
)));
2221 fprintf_unfiltered (file
,
2222 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
2223 (long) current_gdbarch
->save_dummy_frame_tos
2224 /*SAVE_DUMMY_FRAME_TOS ()*/);
2226 #ifdef SDB_REG_TO_REGNUM
2227 fprintf_unfiltered (file
,
2228 "gdbarch_dump: %s # %s\n",
2229 "SDB_REG_TO_REGNUM(sdb_regnr)",
2230 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
2232 fprintf_unfiltered (file
,
2233 "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
2234 (long) current_gdbarch
->sdb_reg_to_regnum
2235 /*SDB_REG_TO_REGNUM ()*/);
2237 #ifdef SIGTRAMP_END_P
2238 fprintf_unfiltered (file
,
2239 "gdbarch_dump: %s # %s\n",
2241 XSTRING (SIGTRAMP_END_P ()));
2242 fprintf_unfiltered (file
,
2243 "gdbarch_dump: SIGTRAMP_END_P() = %d\n",
2247 fprintf_unfiltered (file
,
2248 "gdbarch_dump: %s # %s\n",
2250 XSTRING (SIGTRAMP_END (pc
)));
2252 fprintf_unfiltered (file
,
2253 "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
2254 (long) current_gdbarch
->sigtramp_end
2255 /*SIGTRAMP_END ()*/);
2257 #ifdef SIGTRAMP_START_P
2258 fprintf_unfiltered (file
,
2259 "gdbarch_dump: %s # %s\n",
2260 "SIGTRAMP_START_P()",
2261 XSTRING (SIGTRAMP_START_P ()));
2262 fprintf_unfiltered (file
,
2263 "gdbarch_dump: SIGTRAMP_START_P() = %d\n",
2264 SIGTRAMP_START_P ());
2266 #ifdef SIGTRAMP_START
2267 fprintf_unfiltered (file
,
2268 "gdbarch_dump: %s # %s\n",
2269 "SIGTRAMP_START(pc)",
2270 XSTRING (SIGTRAMP_START (pc
)));
2272 fprintf_unfiltered (file
,
2273 "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
2274 (long) current_gdbarch
->sigtramp_start
2275 /*SIGTRAMP_START ()*/);
2277 #ifdef SKIP_PROLOGUE
2278 fprintf_unfiltered (file
,
2279 "gdbarch_dump: %s # %s\n",
2280 "SKIP_PROLOGUE(ip)",
2281 XSTRING (SKIP_PROLOGUE (ip
)));
2283 fprintf_unfiltered (file
,
2284 "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
2285 (long) current_gdbarch
->skip_prologue
2286 /*SKIP_PROLOGUE ()*/);
2288 #ifdef SKIP_TRAMPOLINE_CODE
2289 fprintf_unfiltered (file
,
2290 "gdbarch_dump: %s # %s\n",
2291 "SKIP_TRAMPOLINE_CODE(pc)",
2292 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
2294 fprintf_unfiltered (file
,
2295 "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
2296 (long) current_gdbarch
->skip_trampoline_code
2297 /*SKIP_TRAMPOLINE_CODE ()*/);
2299 #ifdef SMASH_TEXT_ADDRESS
2300 fprintf_unfiltered (file
,
2301 "gdbarch_dump: %s # %s\n",
2302 "SMASH_TEXT_ADDRESS(addr)",
2303 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
2305 fprintf_unfiltered (file
,
2306 "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
2307 (long) current_gdbarch
->smash_text_address
2308 /*SMASH_TEXT_ADDRESS ()*/);
2310 #ifdef SOFTWARE_SINGLE_STEP_P
2311 fprintf_unfiltered (file
,
2312 "gdbarch_dump: %s # %s\n",
2313 "SOFTWARE_SINGLE_STEP_P()",
2314 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
2315 fprintf_unfiltered (file
,
2316 "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n",
2317 SOFTWARE_SINGLE_STEP_P ());
2319 #ifdef SOFTWARE_SINGLE_STEP
2321 /* Macro might contain `[{}]' when not multi-arch */
2322 fprintf_unfiltered (file
,
2323 "gdbarch_dump: %s # %s\n",
2324 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
2325 XSTRING (SOFTWARE_SINGLE_STEP (sig
, insert_breakpoints_p
)));
2328 fprintf_unfiltered (file
,
2329 "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
2330 (long) current_gdbarch
->software_single_step
2331 /*SOFTWARE_SINGLE_STEP ()*/);
2334 fprintf_unfiltered (file
,
2335 "gdbarch_dump: SP_REGNUM # %s\n",
2336 XSTRING (SP_REGNUM
));
2337 fprintf_unfiltered (file
,
2338 "gdbarch_dump: SP_REGNUM = %d\n",
2341 #ifdef STAB_REG_TO_REGNUM
2342 fprintf_unfiltered (file
,
2343 "gdbarch_dump: %s # %s\n",
2344 "STAB_REG_TO_REGNUM(stab_regnr)",
2345 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
2347 fprintf_unfiltered (file
,
2348 "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
2349 (long) current_gdbarch
->stab_reg_to_regnum
2350 /*STAB_REG_TO_REGNUM ()*/);
2352 #ifdef STACK_ALIGN_P
2353 fprintf_unfiltered (file
,
2354 "gdbarch_dump: %s # %s\n",
2356 XSTRING (STACK_ALIGN_P ()));
2357 fprintf_unfiltered (file
,
2358 "gdbarch_dump: STACK_ALIGN_P() = %d\n",
2362 fprintf_unfiltered (file
,
2363 "gdbarch_dump: %s # %s\n",
2365 XSTRING (STACK_ALIGN (sp
)));
2367 fprintf_unfiltered (file
,
2368 "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
2369 (long) current_gdbarch
->stack_align
2370 /*STACK_ALIGN ()*/);
2372 #ifdef STORE_RETURN_VALUE
2374 /* Macro might contain `[{}]' when not multi-arch */
2375 fprintf_unfiltered (file
,
2376 "gdbarch_dump: %s # %s\n",
2377 "STORE_RETURN_VALUE(type, regcache, valbuf)",
2378 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
2381 fprintf_unfiltered (file
,
2382 "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
2383 (long) current_gdbarch
->store_return_value
2384 /*STORE_RETURN_VALUE ()*/);
2386 #ifdef TARGET_ADDR_BIT
2387 fprintf_unfiltered (file
,
2388 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
2389 XSTRING (TARGET_ADDR_BIT
));
2390 fprintf_unfiltered (file
,
2391 "gdbarch_dump: TARGET_ADDR_BIT = %d\n",
2394 #ifdef TARGET_ARCHITECTURE
2395 fprintf_unfiltered (file
,
2396 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
2397 XSTRING (TARGET_ARCHITECTURE
));
2398 if (TARGET_ARCHITECTURE
!= NULL
)
2399 fprintf_unfiltered (file
,
2400 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
2401 TARGET_ARCHITECTURE
->printable_name
);
2403 #ifdef TARGET_BFD_VMA_BIT
2404 fprintf_unfiltered (file
,
2405 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
2406 XSTRING (TARGET_BFD_VMA_BIT
));
2407 fprintf_unfiltered (file
,
2408 "gdbarch_dump: TARGET_BFD_VMA_BIT = %d\n",
2409 TARGET_BFD_VMA_BIT
);
2411 #ifdef TARGET_BYTE_ORDER
2412 fprintf_unfiltered (file
,
2413 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
2414 XSTRING (TARGET_BYTE_ORDER
));
2415 fprintf_unfiltered (file
,
2416 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
2417 (long) TARGET_BYTE_ORDER
);
2419 #ifdef TARGET_CHAR_SIGNED
2420 fprintf_unfiltered (file
,
2421 "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
2422 XSTRING (TARGET_CHAR_SIGNED
));
2423 fprintf_unfiltered (file
,
2424 "gdbarch_dump: TARGET_CHAR_SIGNED = %d\n",
2425 TARGET_CHAR_SIGNED
);
2427 #ifdef TARGET_DOUBLE_BIT
2428 fprintf_unfiltered (file
,
2429 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
2430 XSTRING (TARGET_DOUBLE_BIT
));
2431 fprintf_unfiltered (file
,
2432 "gdbarch_dump: TARGET_DOUBLE_BIT = %d\n",
2435 #ifdef TARGET_DOUBLE_FORMAT
2436 fprintf_unfiltered (file
,
2437 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
2438 XSTRING (TARGET_DOUBLE_FORMAT
));
2439 fprintf_unfiltered (file
,
2440 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
2441 (TARGET_DOUBLE_FORMAT
)->name
);
2443 #ifdef TARGET_FLOAT_BIT
2444 fprintf_unfiltered (file
,
2445 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
2446 XSTRING (TARGET_FLOAT_BIT
));
2447 fprintf_unfiltered (file
,
2448 "gdbarch_dump: TARGET_FLOAT_BIT = %d\n",
2451 #ifdef TARGET_FLOAT_FORMAT
2452 fprintf_unfiltered (file
,
2453 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
2454 XSTRING (TARGET_FLOAT_FORMAT
));
2455 fprintf_unfiltered (file
,
2456 "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
2457 (TARGET_FLOAT_FORMAT
)->name
);
2459 #ifdef TARGET_INT_BIT
2460 fprintf_unfiltered (file
,
2461 "gdbarch_dump: TARGET_INT_BIT # %s\n",
2462 XSTRING (TARGET_INT_BIT
));
2463 fprintf_unfiltered (file
,
2464 "gdbarch_dump: TARGET_INT_BIT = %d\n",
2467 #ifdef TARGET_LONG_BIT
2468 fprintf_unfiltered (file
,
2469 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
2470 XSTRING (TARGET_LONG_BIT
));
2471 fprintf_unfiltered (file
,
2472 "gdbarch_dump: TARGET_LONG_BIT = %d\n",
2475 #ifdef TARGET_LONG_DOUBLE_BIT
2476 fprintf_unfiltered (file
,
2477 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
2478 XSTRING (TARGET_LONG_DOUBLE_BIT
));
2479 fprintf_unfiltered (file
,
2480 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %d\n",
2481 TARGET_LONG_DOUBLE_BIT
);
2483 #ifdef TARGET_LONG_DOUBLE_FORMAT
2484 fprintf_unfiltered (file
,
2485 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
2486 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
2487 fprintf_unfiltered (file
,
2488 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
2489 (TARGET_LONG_DOUBLE_FORMAT
)->name
);
2491 #ifdef TARGET_LONG_LONG_BIT
2492 fprintf_unfiltered (file
,
2493 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
2494 XSTRING (TARGET_LONG_LONG_BIT
));
2495 fprintf_unfiltered (file
,
2496 "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
2497 TARGET_LONG_LONG_BIT
);
2500 fprintf_unfiltered (file
,
2501 "gdbarch_dump: TARGET_OSABI # %s\n",
2502 XSTRING (TARGET_OSABI
));
2503 fprintf_unfiltered (file
,
2504 "gdbarch_dump: TARGET_OSABI = %ld\n",
2505 (long) TARGET_OSABI
);
2507 #ifdef TARGET_PRINT_INSN
2508 fprintf_unfiltered (file
,
2509 "gdbarch_dump: %s # %s\n",
2510 "TARGET_PRINT_INSN(vma, info)",
2511 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
2513 fprintf_unfiltered (file
,
2514 "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
2515 (long) current_gdbarch
->print_insn
2516 /*TARGET_PRINT_INSN ()*/);
2518 #ifdef TARGET_PTR_BIT
2519 fprintf_unfiltered (file
,
2520 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
2521 XSTRING (TARGET_PTR_BIT
));
2522 fprintf_unfiltered (file
,
2523 "gdbarch_dump: TARGET_PTR_BIT = %d\n",
2526 #ifdef TARGET_READ_PC
2527 fprintf_unfiltered (file
,
2528 "gdbarch_dump: %s # %s\n",
2529 "TARGET_READ_PC(ptid)",
2530 XSTRING (TARGET_READ_PC (ptid
)));
2532 fprintf_unfiltered (file
,
2533 "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
2534 (long) current_gdbarch
->read_pc
2535 /*TARGET_READ_PC ()*/);
2537 #ifdef TARGET_READ_SP
2538 fprintf_unfiltered (file
,
2539 "gdbarch_dump: %s # %s\n",
2541 XSTRING (TARGET_READ_SP ()));
2543 fprintf_unfiltered (file
,
2544 "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
2545 (long) current_gdbarch
->read_sp
2546 /*TARGET_READ_SP ()*/);
2548 #ifdef TARGET_SHORT_BIT
2549 fprintf_unfiltered (file
,
2550 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
2551 XSTRING (TARGET_SHORT_BIT
));
2552 fprintf_unfiltered (file
,
2553 "gdbarch_dump: TARGET_SHORT_BIT = %d\n",
2556 #ifdef TARGET_VIRTUAL_FRAME_POINTER
2558 /* Macro might contain `[{}]' when not multi-arch */
2559 fprintf_unfiltered (file
,
2560 "gdbarch_dump: %s # %s\n",
2561 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
2562 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
2565 fprintf_unfiltered (file
,
2566 "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
2567 (long) current_gdbarch
->virtual_frame_pointer
2568 /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
2570 #ifdef TARGET_WRITE_PC
2572 /* Macro might contain `[{}]' when not multi-arch */
2573 fprintf_unfiltered (file
,
2574 "gdbarch_dump: %s # %s\n",
2575 "TARGET_WRITE_PC(val, ptid)",
2576 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
2579 fprintf_unfiltered (file
,
2580 "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
2581 (long) current_gdbarch
->write_pc
2582 /*TARGET_WRITE_PC ()*/);
2585 fprintf_unfiltered (file
,
2586 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
2587 gdbarch_unwind_dummy_id_p (current_gdbarch
));
2589 fprintf_unfiltered (file
,
2590 "gdbarch_dump: unwind_dummy_id = 0x%08lx\n",
2591 (long) current_gdbarch
->unwind_dummy_id
);
2593 fprintf_unfiltered (file
,
2594 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
2595 gdbarch_unwind_pc_p (current_gdbarch
));
2597 fprintf_unfiltered (file
,
2598 "gdbarch_dump: unwind_pc = 0x%08lx\n",
2599 (long) current_gdbarch
->unwind_pc
);
2600 #ifdef USE_STRUCT_CONVENTION
2601 fprintf_unfiltered (file
,
2602 "gdbarch_dump: %s # %s\n",
2603 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2604 XSTRING (USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
2606 fprintf_unfiltered (file
,
2607 "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
2608 (long) current_gdbarch
->use_struct_convention
2609 /*USE_STRUCT_CONVENTION ()*/);
2611 #ifdef VALUE_TO_REGISTER
2613 /* Macro might contain `[{}]' when not multi-arch */
2614 fprintf_unfiltered (file
,
2615 "gdbarch_dump: %s # %s\n",
2616 "VALUE_TO_REGISTER(type, regnum, from, to)",
2617 XSTRING (VALUE_TO_REGISTER (type
, regnum
, from
, to
)));
2620 fprintf_unfiltered (file
,
2621 "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
2622 (long) current_gdbarch
->value_to_register
2623 /*VALUE_TO_REGISTER ()*/);
2625 if (current_gdbarch
->dump_tdep
!= NULL
)
2626 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
2629 struct gdbarch_tdep
*
2630 gdbarch_tdep (struct gdbarch
*gdbarch
)
2632 if (gdbarch_debug
>= 2)
2633 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
2634 return gdbarch
->tdep
;
2638 const struct bfd_arch_info
*
2639 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
2641 gdb_assert (gdbarch
!= NULL
);
2642 if (gdbarch_debug
>= 2)
2643 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
2644 return gdbarch
->bfd_arch_info
;
2648 gdbarch_byte_order (struct gdbarch
*gdbarch
)
2650 gdb_assert (gdbarch
!= NULL
);
2651 if (gdbarch_debug
>= 2)
2652 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
2653 return gdbarch
->byte_order
;
2657 gdbarch_osabi (struct gdbarch
*gdbarch
)
2659 gdb_assert (gdbarch
!= NULL
);
2660 if (gdbarch_debug
>= 2)
2661 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
2662 return gdbarch
->osabi
;
2666 gdbarch_short_bit (struct gdbarch
*gdbarch
)
2668 gdb_assert (gdbarch
!= NULL
);
2669 /* Skip verify of short_bit, invalid_p == 0 */
2670 if (gdbarch_debug
>= 2)
2671 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
2672 return gdbarch
->short_bit
;
2676 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
2679 gdbarch
->short_bit
= short_bit
;
2683 gdbarch_int_bit (struct gdbarch
*gdbarch
)
2685 gdb_assert (gdbarch
!= NULL
);
2686 /* Skip verify of int_bit, invalid_p == 0 */
2687 if (gdbarch_debug
>= 2)
2688 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
2689 return gdbarch
->int_bit
;
2693 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
2696 gdbarch
->int_bit
= int_bit
;
2700 gdbarch_long_bit (struct gdbarch
*gdbarch
)
2702 gdb_assert (gdbarch
!= NULL
);
2703 /* Skip verify of long_bit, invalid_p == 0 */
2704 if (gdbarch_debug
>= 2)
2705 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
2706 return gdbarch
->long_bit
;
2710 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
2713 gdbarch
->long_bit
= long_bit
;
2717 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
2719 gdb_assert (gdbarch
!= NULL
);
2720 /* Skip verify of long_long_bit, invalid_p == 0 */
2721 if (gdbarch_debug
>= 2)
2722 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
2723 return gdbarch
->long_long_bit
;
2727 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
2730 gdbarch
->long_long_bit
= long_long_bit
;
2734 gdbarch_float_bit (struct gdbarch
*gdbarch
)
2736 gdb_assert (gdbarch
!= NULL
);
2737 /* Skip verify of float_bit, invalid_p == 0 */
2738 if (gdbarch_debug
>= 2)
2739 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
2740 return gdbarch
->float_bit
;
2744 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
2747 gdbarch
->float_bit
= float_bit
;
2751 gdbarch_double_bit (struct gdbarch
*gdbarch
)
2753 gdb_assert (gdbarch
!= NULL
);
2754 /* Skip verify of double_bit, invalid_p == 0 */
2755 if (gdbarch_debug
>= 2)
2756 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
2757 return gdbarch
->double_bit
;
2761 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
2764 gdbarch
->double_bit
= double_bit
;
2768 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
2770 gdb_assert (gdbarch
!= NULL
);
2771 /* Skip verify of long_double_bit, invalid_p == 0 */
2772 if (gdbarch_debug
>= 2)
2773 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
2774 return gdbarch
->long_double_bit
;
2778 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
2779 int long_double_bit
)
2781 gdbarch
->long_double_bit
= long_double_bit
;
2785 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
2787 gdb_assert (gdbarch
!= NULL
);
2788 /* Skip verify of ptr_bit, invalid_p == 0 */
2789 if (gdbarch_debug
>= 2)
2790 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
2791 return gdbarch
->ptr_bit
;
2795 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
2798 gdbarch
->ptr_bit
= ptr_bit
;
2802 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
2804 gdb_assert (gdbarch
!= NULL
);
2805 if (gdbarch
->addr_bit
== 0)
2806 internal_error (__FILE__
, __LINE__
,
2807 "gdbarch: gdbarch_addr_bit invalid");
2808 if (gdbarch_debug
>= 2)
2809 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
2810 return gdbarch
->addr_bit
;
2814 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
2817 gdbarch
->addr_bit
= addr_bit
;
2821 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
2823 gdb_assert (gdbarch
!= NULL
);
2824 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2825 if (gdbarch_debug
>= 2)
2826 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
2827 return gdbarch
->bfd_vma_bit
;
2831 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
2834 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
2838 gdbarch_char_signed (struct gdbarch
*gdbarch
)
2840 gdb_assert (gdbarch
!= NULL
);
2841 if (gdbarch
->char_signed
== -1)
2842 internal_error (__FILE__
, __LINE__
,
2843 "gdbarch: gdbarch_char_signed invalid");
2844 if (gdbarch_debug
>= 2)
2845 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
2846 return gdbarch
->char_signed
;
2850 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
2853 gdbarch
->char_signed
= char_signed
;
2857 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
2859 gdb_assert (gdbarch
!= NULL
);
2860 if (gdbarch
->read_pc
== 0)
2861 internal_error (__FILE__
, __LINE__
,
2862 "gdbarch: gdbarch_read_pc invalid");
2863 if (gdbarch_debug
>= 2)
2864 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
2865 return gdbarch
->read_pc (ptid
);
2869 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
2870 gdbarch_read_pc_ftype read_pc
)
2872 gdbarch
->read_pc
= read_pc
;
2876 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
2878 gdb_assert (gdbarch
!= NULL
);
2879 if (gdbarch
->write_pc
== 0)
2880 internal_error (__FILE__
, __LINE__
,
2881 "gdbarch: gdbarch_write_pc invalid");
2882 if (gdbarch_debug
>= 2)
2883 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
2884 gdbarch
->write_pc (val
, ptid
);
2888 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
2889 gdbarch_write_pc_ftype write_pc
)
2891 gdbarch
->write_pc
= write_pc
;
2895 gdbarch_deprecated_target_read_fp_p (struct gdbarch
*gdbarch
)
2897 gdb_assert (gdbarch
!= NULL
);
2898 return gdbarch
->deprecated_target_read_fp
!= 0;
2902 gdbarch_deprecated_target_read_fp (struct gdbarch
*gdbarch
)
2904 gdb_assert (gdbarch
!= NULL
);
2905 if (gdbarch
->deprecated_target_read_fp
== 0)
2906 internal_error (__FILE__
, __LINE__
,
2907 "gdbarch: gdbarch_deprecated_target_read_fp invalid");
2908 if (gdbarch_debug
>= 2)
2909 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_target_read_fp called\n");
2910 return gdbarch
->deprecated_target_read_fp ();
2914 set_gdbarch_deprecated_target_read_fp (struct gdbarch
*gdbarch
,
2915 gdbarch_deprecated_target_read_fp_ftype deprecated_target_read_fp
)
2917 gdbarch
->deprecated_target_read_fp
= deprecated_target_read_fp
;
2921 gdbarch_read_sp (struct gdbarch
*gdbarch
)
2923 gdb_assert (gdbarch
!= NULL
);
2924 if (gdbarch
->read_sp
== 0)
2925 internal_error (__FILE__
, __LINE__
,
2926 "gdbarch: gdbarch_read_sp invalid");
2927 if (gdbarch_debug
>= 2)
2928 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_sp called\n");
2929 return gdbarch
->read_sp ();
2933 set_gdbarch_read_sp (struct gdbarch
*gdbarch
,
2934 gdbarch_read_sp_ftype read_sp
)
2936 gdbarch
->read_sp
= read_sp
;
2940 gdbarch_deprecated_dummy_write_sp_p (struct gdbarch
*gdbarch
)
2942 gdb_assert (gdbarch
!= NULL
);
2943 return gdbarch
->deprecated_dummy_write_sp
!= 0;
2947 gdbarch_deprecated_dummy_write_sp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2949 gdb_assert (gdbarch
!= NULL
);
2950 if (gdbarch
->deprecated_dummy_write_sp
== 0)
2951 internal_error (__FILE__
, __LINE__
,
2952 "gdbarch: gdbarch_deprecated_dummy_write_sp invalid");
2953 if (gdbarch_debug
>= 2)
2954 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_dummy_write_sp called\n");
2955 gdbarch
->deprecated_dummy_write_sp (val
);
2959 set_gdbarch_deprecated_dummy_write_sp (struct gdbarch
*gdbarch
,
2960 gdbarch_deprecated_dummy_write_sp_ftype deprecated_dummy_write_sp
)
2962 gdbarch
->deprecated_dummy_write_sp
= deprecated_dummy_write_sp
;
2966 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
2968 gdb_assert (gdbarch
!= NULL
);
2969 if (gdbarch
->virtual_frame_pointer
== 0)
2970 internal_error (__FILE__
, __LINE__
,
2971 "gdbarch: gdbarch_virtual_frame_pointer invalid");
2972 if (gdbarch_debug
>= 2)
2973 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
2974 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
2978 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
2979 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
2981 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
2985 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
2987 gdb_assert (gdbarch
!= NULL
);
2988 return gdbarch
->pseudo_register_read
!= 0;
2992 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, void *buf
)
2994 gdb_assert (gdbarch
!= NULL
);
2995 if (gdbarch
->pseudo_register_read
== 0)
2996 internal_error (__FILE__
, __LINE__
,
2997 "gdbarch: gdbarch_pseudo_register_read invalid");
2998 if (gdbarch_debug
>= 2)
2999 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
3000 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
3004 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
3005 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
3007 gdbarch
->pseudo_register_read
= pseudo_register_read
;
3011 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
3013 gdb_assert (gdbarch
!= NULL
);
3014 return gdbarch
->pseudo_register_write
!= 0;
3018 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const void *buf
)
3020 gdb_assert (gdbarch
!= NULL
);
3021 if (gdbarch
->pseudo_register_write
== 0)
3022 internal_error (__FILE__
, __LINE__
,
3023 "gdbarch: gdbarch_pseudo_register_write invalid");
3024 if (gdbarch_debug
>= 2)
3025 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
3026 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
3030 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
3031 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
3033 gdbarch
->pseudo_register_write
= pseudo_register_write
;
3037 gdbarch_num_regs (struct gdbarch
*gdbarch
)
3039 gdb_assert (gdbarch
!= NULL
);
3040 if (gdbarch
->num_regs
== -1)
3041 internal_error (__FILE__
, __LINE__
,
3042 "gdbarch: gdbarch_num_regs invalid");
3043 if (gdbarch_debug
>= 2)
3044 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
3045 return gdbarch
->num_regs
;
3049 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
3052 gdbarch
->num_regs
= num_regs
;
3056 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
3058 gdb_assert (gdbarch
!= NULL
);
3059 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
3060 if (gdbarch_debug
>= 2)
3061 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
3062 return gdbarch
->num_pseudo_regs
;
3066 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
3067 int num_pseudo_regs
)
3069 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
3073 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
3075 gdb_assert (gdbarch
!= NULL
);
3076 /* Skip verify of sp_regnum, invalid_p == 0 */
3077 if (gdbarch_debug
>= 2)
3078 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
3079 return gdbarch
->sp_regnum
;
3083 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
3086 gdbarch
->sp_regnum
= sp_regnum
;
3090 gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
)
3092 gdb_assert (gdbarch
!= NULL
);
3093 /* Skip verify of deprecated_fp_regnum, invalid_p == 0 */
3094 if (gdbarch_debug
>= 2)
3095 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fp_regnum called\n");
3096 return gdbarch
->deprecated_fp_regnum
;
3100 set_gdbarch_deprecated_fp_regnum (struct gdbarch
*gdbarch
,
3101 int deprecated_fp_regnum
)
3103 gdbarch
->deprecated_fp_regnum
= deprecated_fp_regnum
;
3107 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
3109 gdb_assert (gdbarch
!= NULL
);
3110 /* Skip verify of pc_regnum, invalid_p == 0 */
3111 if (gdbarch_debug
>= 2)
3112 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
3113 return gdbarch
->pc_regnum
;
3117 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
3120 gdbarch
->pc_regnum
= pc_regnum
;
3124 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
3126 gdb_assert (gdbarch
!= NULL
);
3127 /* Skip verify of ps_regnum, invalid_p == 0 */
3128 if (gdbarch_debug
>= 2)
3129 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
3130 return gdbarch
->ps_regnum
;
3134 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
3137 gdbarch
->ps_regnum
= ps_regnum
;
3141 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
3143 gdb_assert (gdbarch
!= NULL
);
3144 /* Skip verify of fp0_regnum, invalid_p == 0 */
3145 if (gdbarch_debug
>= 2)
3146 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
3147 return gdbarch
->fp0_regnum
;
3151 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
3154 gdbarch
->fp0_regnum
= fp0_regnum
;
3158 gdbarch_npc_regnum (struct gdbarch
*gdbarch
)
3160 gdb_assert (gdbarch
!= NULL
);
3161 /* Skip verify of npc_regnum, invalid_p == 0 */
3162 if (gdbarch_debug
>= 2)
3163 fprintf_unfiltered (gdb_stdlog
, "gdbarch_npc_regnum called\n");
3164 return gdbarch
->npc_regnum
;
3168 set_gdbarch_npc_regnum (struct gdbarch
*gdbarch
,
3171 gdbarch
->npc_regnum
= npc_regnum
;
3175 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
3177 gdb_assert (gdbarch
!= NULL
);
3178 if (gdbarch
->stab_reg_to_regnum
== 0)
3179 internal_error (__FILE__
, __LINE__
,
3180 "gdbarch: gdbarch_stab_reg_to_regnum invalid");
3181 if (gdbarch_debug
>= 2)
3182 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
3183 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
3187 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
3188 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
3190 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
3194 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
3196 gdb_assert (gdbarch
!= NULL
);
3197 if (gdbarch
->ecoff_reg_to_regnum
== 0)
3198 internal_error (__FILE__
, __LINE__
,
3199 "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
3200 if (gdbarch_debug
>= 2)
3201 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
3202 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
3206 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
3207 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
3209 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
3213 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
3215 gdb_assert (gdbarch
!= NULL
);
3216 if (gdbarch
->dwarf_reg_to_regnum
== 0)
3217 internal_error (__FILE__
, __LINE__
,
3218 "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
3219 if (gdbarch_debug
>= 2)
3220 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
3221 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
3225 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
3226 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
3228 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
3232 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
3234 gdb_assert (gdbarch
!= NULL
);
3235 if (gdbarch
->sdb_reg_to_regnum
== 0)
3236 internal_error (__FILE__
, __LINE__
,
3237 "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
3238 if (gdbarch_debug
>= 2)
3239 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
3240 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
3244 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
3245 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
3247 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
3251 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
3253 gdb_assert (gdbarch
!= NULL
);
3254 if (gdbarch
->dwarf2_reg_to_regnum
== 0)
3255 internal_error (__FILE__
, __LINE__
,
3256 "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
3257 if (gdbarch_debug
>= 2)
3258 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
3259 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
3263 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
3264 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
3266 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
3270 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
3272 gdb_assert (gdbarch
!= NULL
);
3273 if (gdbarch
->register_name
== 0)
3274 internal_error (__FILE__
, __LINE__
,
3275 "gdbarch: gdbarch_register_name invalid");
3276 if (gdbarch_debug
>= 2)
3277 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
3278 return gdbarch
->register_name (regnr
);
3282 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
3283 gdbarch_register_name_ftype register_name
)
3285 gdbarch
->register_name
= register_name
;
3289 gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
)
3291 gdb_assert (gdbarch
!= NULL
);
3292 if (gdbarch_debug
>= 2)
3293 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_size called\n");
3294 return gdbarch
->deprecated_register_size
;
3298 set_gdbarch_deprecated_register_size (struct gdbarch
*gdbarch
,
3299 int deprecated_register_size
)
3301 gdbarch
->deprecated_register_size
= deprecated_register_size
;
3305 gdbarch_deprecated_register_bytes (struct gdbarch
*gdbarch
)
3307 gdb_assert (gdbarch
!= NULL
);
3308 if (gdbarch_debug
>= 2)
3309 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_register_bytes called\n");
3310 return gdbarch
->deprecated_register_bytes
;
3314 set_gdbarch_deprecated_register_bytes (struct gdbarch
*gdbarch
,
3315 int deprecated_register_bytes
)
3317 gdbarch
->deprecated_register_bytes
= deprecated_register_bytes
;
3321 gdbarch_register_byte_p (struct gdbarch
*gdbarch
)
3323 gdb_assert (gdbarch
!= NULL
);
3324 return gdbarch
->register_byte
!= generic_register_byte
;
3328 gdbarch_register_byte (struct gdbarch
*gdbarch
, int reg_nr
)
3330 gdb_assert (gdbarch
!= NULL
);
3331 if (gdbarch
->register_byte
== 0)
3332 internal_error (__FILE__
, __LINE__
,
3333 "gdbarch: gdbarch_register_byte invalid");
3334 /* Ignore predicate (gdbarch->register_byte != generic_register_byte). */
3335 if (gdbarch_debug
>= 2)
3336 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_byte called\n");
3337 return gdbarch
->register_byte (reg_nr
);
3341 set_gdbarch_register_byte (struct gdbarch
*gdbarch
,
3342 gdbarch_register_byte_ftype register_byte
)
3344 gdbarch
->register_byte
= register_byte
;
3348 gdbarch_register_raw_size (struct gdbarch
*gdbarch
, int reg_nr
)
3350 gdb_assert (gdbarch
!= NULL
);
3351 if (gdbarch
->register_raw_size
== 0)
3352 internal_error (__FILE__
, __LINE__
,
3353 "gdbarch: gdbarch_register_raw_size invalid");
3354 if (gdbarch_debug
>= 2)
3355 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_raw_size called\n");
3356 return gdbarch
->register_raw_size (reg_nr
);
3360 set_gdbarch_register_raw_size (struct gdbarch
*gdbarch
,
3361 gdbarch_register_raw_size_ftype register_raw_size
)
3363 gdbarch
->register_raw_size
= register_raw_size
;
3367 gdbarch_deprecated_max_register_raw_size_p (struct gdbarch
*gdbarch
)
3369 gdb_assert (gdbarch
!= NULL
);
3370 return gdbarch
->deprecated_max_register_raw_size
!= 0;
3374 gdbarch_deprecated_max_register_raw_size (struct gdbarch
*gdbarch
)
3376 gdb_assert (gdbarch
!= NULL
);
3377 if (gdbarch_debug
>= 2)
3378 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_max_register_raw_size called\n");
3379 return gdbarch
->deprecated_max_register_raw_size
;
3383 set_gdbarch_deprecated_max_register_raw_size (struct gdbarch
*gdbarch
,
3384 int deprecated_max_register_raw_size
)
3386 gdbarch
->deprecated_max_register_raw_size
= deprecated_max_register_raw_size
;
3390 gdbarch_register_virtual_size (struct gdbarch
*gdbarch
, int reg_nr
)
3392 gdb_assert (gdbarch
!= NULL
);
3393 if (gdbarch
->register_virtual_size
== 0)
3394 internal_error (__FILE__
, __LINE__
,
3395 "gdbarch: gdbarch_register_virtual_size invalid");
3396 if (gdbarch_debug
>= 2)
3397 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_size called\n");
3398 return gdbarch
->register_virtual_size (reg_nr
);
3402 set_gdbarch_register_virtual_size (struct gdbarch
*gdbarch
,
3403 gdbarch_register_virtual_size_ftype register_virtual_size
)
3405 gdbarch
->register_virtual_size
= register_virtual_size
;
3409 gdbarch_deprecated_max_register_virtual_size_p (struct gdbarch
*gdbarch
)
3411 gdb_assert (gdbarch
!= NULL
);
3412 return gdbarch
->deprecated_max_register_virtual_size
!= 0;
3416 gdbarch_deprecated_max_register_virtual_size (struct gdbarch
*gdbarch
)
3418 gdb_assert (gdbarch
!= NULL
);
3419 if (gdbarch_debug
>= 2)
3420 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_max_register_virtual_size called\n");
3421 return gdbarch
->deprecated_max_register_virtual_size
;
3425 set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch
*gdbarch
,
3426 int deprecated_max_register_virtual_size
)
3428 gdbarch
->deprecated_max_register_virtual_size
= deprecated_max_register_virtual_size
;
3432 gdbarch_register_virtual_type_p (struct gdbarch
*gdbarch
)
3434 gdb_assert (gdbarch
!= NULL
);
3435 return gdbarch
->register_virtual_type
!= 0;
3439 gdbarch_register_virtual_type (struct gdbarch
*gdbarch
, int reg_nr
)
3441 gdb_assert (gdbarch
!= NULL
);
3442 if (gdbarch
->register_virtual_type
== 0)
3443 internal_error (__FILE__
, __LINE__
,
3444 "gdbarch: gdbarch_register_virtual_type invalid");
3445 if (gdbarch_debug
>= 2)
3446 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_type called\n");
3447 return gdbarch
->register_virtual_type (reg_nr
);
3451 set_gdbarch_register_virtual_type (struct gdbarch
*gdbarch
,
3452 gdbarch_register_virtual_type_ftype register_virtual_type
)
3454 gdbarch
->register_virtual_type
= register_virtual_type
;
3458 gdbarch_register_type_p (struct gdbarch
*gdbarch
)
3460 gdb_assert (gdbarch
!= NULL
);
3461 return gdbarch
->register_type
!= 0;
3465 gdbarch_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
3467 gdb_assert (gdbarch
!= NULL
);
3468 if (gdbarch
->register_type
== 0)
3469 internal_error (__FILE__
, __LINE__
,
3470 "gdbarch: gdbarch_register_type invalid");
3471 if (gdbarch_debug
>= 2)
3472 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_type called\n");
3473 return gdbarch
->register_type (gdbarch
, reg_nr
);
3477 set_gdbarch_register_type (struct gdbarch
*gdbarch
,
3478 gdbarch_register_type_ftype register_type
)
3480 gdbarch
->register_type
= register_type
;
3484 gdbarch_deprecated_do_registers_info_p (struct gdbarch
*gdbarch
)
3486 gdb_assert (gdbarch
!= NULL
);
3487 return gdbarch
->deprecated_do_registers_info
!= 0;
3491 gdbarch_deprecated_do_registers_info (struct gdbarch
*gdbarch
, int reg_nr
, int fpregs
)
3493 gdb_assert (gdbarch
!= NULL
);
3494 if (gdbarch
->deprecated_do_registers_info
== 0)
3495 internal_error (__FILE__
, __LINE__
,
3496 "gdbarch: gdbarch_deprecated_do_registers_info invalid");
3497 if (gdbarch_debug
>= 2)
3498 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_do_registers_info called\n");
3499 gdbarch
->deprecated_do_registers_info (reg_nr
, fpregs
);
3503 set_gdbarch_deprecated_do_registers_info (struct gdbarch
*gdbarch
,
3504 gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info
)
3506 gdbarch
->deprecated_do_registers_info
= deprecated_do_registers_info
;
3510 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
3512 gdb_assert (gdbarch
!= NULL
);
3513 if (gdbarch
->print_registers_info
== 0)
3514 internal_error (__FILE__
, __LINE__
,
3515 "gdbarch: gdbarch_print_registers_info invalid");
3516 if (gdbarch_debug
>= 2)
3517 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
3518 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
3522 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
3523 gdbarch_print_registers_info_ftype print_registers_info
)
3525 gdbarch
->print_registers_info
= print_registers_info
;
3529 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
3531 gdb_assert (gdbarch
!= NULL
);
3532 return gdbarch
->print_float_info
!= 0;
3536 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
3538 gdb_assert (gdbarch
!= NULL
);
3539 if (gdbarch
->print_float_info
== 0)
3540 internal_error (__FILE__
, __LINE__
,
3541 "gdbarch: gdbarch_print_float_info invalid");
3542 if (gdbarch_debug
>= 2)
3543 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
3544 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
3548 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
3549 gdbarch_print_float_info_ftype print_float_info
)
3551 gdbarch
->print_float_info
= print_float_info
;
3555 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
3557 gdb_assert (gdbarch
!= NULL
);
3558 return gdbarch
->print_vector_info
!= 0;
3562 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
3564 gdb_assert (gdbarch
!= NULL
);
3565 if (gdbarch
->print_vector_info
== 0)
3566 internal_error (__FILE__
, __LINE__
,
3567 "gdbarch: gdbarch_print_vector_info invalid");
3568 if (gdbarch_debug
>= 2)
3569 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
3570 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
3574 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
3575 gdbarch_print_vector_info_ftype print_vector_info
)
3577 gdbarch
->print_vector_info
= print_vector_info
;
3581 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
3583 gdb_assert (gdbarch
!= NULL
);
3584 if (gdbarch
->register_sim_regno
== 0)
3585 internal_error (__FILE__
, __LINE__
,
3586 "gdbarch: gdbarch_register_sim_regno invalid");
3587 if (gdbarch_debug
>= 2)
3588 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
3589 return gdbarch
->register_sim_regno (reg_nr
);
3593 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
3594 gdbarch_register_sim_regno_ftype register_sim_regno
)
3596 gdbarch
->register_sim_regno
= register_sim_regno
;
3600 gdbarch_register_bytes_ok_p (struct gdbarch
*gdbarch
)
3602 gdb_assert (gdbarch
!= NULL
);
3603 return gdbarch
->register_bytes_ok
!= 0;
3607 gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
, long nr_bytes
)
3609 gdb_assert (gdbarch
!= NULL
);
3610 if (gdbarch
->register_bytes_ok
== 0)
3611 internal_error (__FILE__
, __LINE__
,
3612 "gdbarch: gdbarch_register_bytes_ok invalid");
3613 if (gdbarch_debug
>= 2)
3614 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes_ok called\n");
3615 return gdbarch
->register_bytes_ok (nr_bytes
);
3619 set_gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
,
3620 gdbarch_register_bytes_ok_ftype register_bytes_ok
)
3622 gdbarch
->register_bytes_ok
= register_bytes_ok
;
3626 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
3628 gdb_assert (gdbarch
!= NULL
);
3629 if (gdbarch
->cannot_fetch_register
== 0)
3630 internal_error (__FILE__
, __LINE__
,
3631 "gdbarch: gdbarch_cannot_fetch_register invalid");
3632 if (gdbarch_debug
>= 2)
3633 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
3634 return gdbarch
->cannot_fetch_register (regnum
);
3638 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
3639 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
3641 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
3645 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
3647 gdb_assert (gdbarch
!= NULL
);
3648 if (gdbarch
->cannot_store_register
== 0)
3649 internal_error (__FILE__
, __LINE__
,
3650 "gdbarch: gdbarch_cannot_store_register invalid");
3651 if (gdbarch_debug
>= 2)
3652 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
3653 return gdbarch
->cannot_store_register (regnum
);
3657 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
3658 gdbarch_cannot_store_register_ftype cannot_store_register
)
3660 gdbarch
->cannot_store_register
= cannot_store_register
;
3664 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
3666 gdb_assert (gdbarch
!= NULL
);
3667 return gdbarch
->get_longjmp_target
!= 0;
3671 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
3673 gdb_assert (gdbarch
!= NULL
);
3674 if (gdbarch
->get_longjmp_target
== 0)
3675 internal_error (__FILE__
, __LINE__
,
3676 "gdbarch: gdbarch_get_longjmp_target invalid");
3677 if (gdbarch_debug
>= 2)
3678 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
3679 return gdbarch
->get_longjmp_target (pc
);
3683 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
3684 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
3686 gdbarch
->get_longjmp_target
= get_longjmp_target
;
3690 gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch
*gdbarch
)
3692 gdb_assert (gdbarch
!= NULL
);
3693 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
3694 if (gdbarch_debug
>= 2)
3695 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_generic_dummy_frames called\n");
3696 return gdbarch
->deprecated_use_generic_dummy_frames
;
3700 set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch
*gdbarch
,
3701 int deprecated_use_generic_dummy_frames
)
3703 gdbarch
->deprecated_use_generic_dummy_frames
= deprecated_use_generic_dummy_frames
;
3707 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
3709 gdb_assert (gdbarch
!= NULL
);
3710 /* Skip verify of call_dummy_location, invalid_p == 0 */
3711 if (gdbarch_debug
>= 2)
3712 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
3713 return gdbarch
->call_dummy_location
;
3717 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
3718 int call_dummy_location
)
3720 gdbarch
->call_dummy_location
= call_dummy_location
;
3724 gdbarch_call_dummy_address (struct gdbarch
*gdbarch
)
3726 gdb_assert (gdbarch
!= NULL
);
3727 if (gdbarch
->call_dummy_address
== 0)
3728 internal_error (__FILE__
, __LINE__
,
3729 "gdbarch: gdbarch_call_dummy_address invalid");
3730 if (gdbarch_debug
>= 2)
3731 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_address called\n");
3732 return gdbarch
->call_dummy_address ();
3736 set_gdbarch_call_dummy_address (struct gdbarch
*gdbarch
,
3737 gdbarch_call_dummy_address_ftype call_dummy_address
)
3739 gdbarch
->call_dummy_address
= call_dummy_address
;
3743 gdbarch_deprecated_call_dummy_start_offset (struct gdbarch
*gdbarch
)
3745 gdb_assert (gdbarch
!= NULL
);
3746 if (gdbarch_debug
>= 2)
3747 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_call_dummy_start_offset called\n");
3748 return gdbarch
->deprecated_call_dummy_start_offset
;
3752 set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch
*gdbarch
,
3753 CORE_ADDR deprecated_call_dummy_start_offset
)
3755 gdbarch
->deprecated_call_dummy_start_offset
= deprecated_call_dummy_start_offset
;
3759 gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
)
3761 gdb_assert (gdbarch
!= NULL
);
3762 if (gdbarch_debug
>= 2)
3763 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_call_dummy_breakpoint_offset called\n");
3764 return gdbarch
->deprecated_call_dummy_breakpoint_offset
;
3768 set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
,
3769 CORE_ADDR deprecated_call_dummy_breakpoint_offset
)
3771 gdbarch
->deprecated_call_dummy_breakpoint_offset
= deprecated_call_dummy_breakpoint_offset
;
3775 gdbarch_deprecated_call_dummy_length (struct gdbarch
*gdbarch
)
3777 gdb_assert (gdbarch
!= NULL
);
3778 if (gdbarch_debug
>= 2)
3779 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_call_dummy_length called\n");
3780 return gdbarch
->deprecated_call_dummy_length
;
3784 set_gdbarch_deprecated_call_dummy_length (struct gdbarch
*gdbarch
,
3785 int deprecated_call_dummy_length
)
3787 gdbarch
->deprecated_call_dummy_length
= deprecated_call_dummy_length
;
3791 gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch
*gdbarch
)
3793 gdb_assert (gdbarch
!= NULL
);
3794 return gdbarch
->deprecated_pc_in_call_dummy
!= generic_pc_in_call_dummy
;
3798 gdbarch_deprecated_pc_in_call_dummy (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
3800 gdb_assert (gdbarch
!= NULL
);
3801 if (gdbarch
->deprecated_pc_in_call_dummy
== 0)
3802 internal_error (__FILE__
, __LINE__
,
3803 "gdbarch: gdbarch_deprecated_pc_in_call_dummy invalid");
3804 /* Ignore predicate (gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy). */
3805 if (gdbarch_debug
>= 2)
3806 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_pc_in_call_dummy called\n");
3807 return gdbarch
->deprecated_pc_in_call_dummy (pc
, sp
, frame_address
);
3811 set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch
*gdbarch
,
3812 gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy
)
3814 gdbarch
->deprecated_pc_in_call_dummy
= deprecated_pc_in_call_dummy
;
3818 gdbarch_deprecated_call_dummy_words (struct gdbarch
*gdbarch
)
3820 gdb_assert (gdbarch
!= NULL
);
3821 /* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
3822 if (gdbarch_debug
>= 2)
3823 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_call_dummy_words called\n");
3824 return gdbarch
->deprecated_call_dummy_words
;
3828 set_gdbarch_deprecated_call_dummy_words (struct gdbarch
*gdbarch
,
3829 LONGEST
* deprecated_call_dummy_words
)
3831 gdbarch
->deprecated_call_dummy_words
= deprecated_call_dummy_words
;
3835 gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch
*gdbarch
)
3837 gdb_assert (gdbarch
!= NULL
);
3838 /* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
3839 if (gdbarch_debug
>= 2)
3840 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_sizeof_call_dummy_words called\n");
3841 return gdbarch
->deprecated_sizeof_call_dummy_words
;
3845 set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch
*gdbarch
,
3846 int deprecated_sizeof_call_dummy_words
)
3848 gdbarch
->deprecated_sizeof_call_dummy_words
= deprecated_sizeof_call_dummy_words
;
3852 gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
)
3854 gdb_assert (gdbarch
!= NULL
);
3855 return gdbarch
->deprecated_call_dummy_stack_adjust
!= 0;
3859 gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch
*gdbarch
)
3861 gdb_assert (gdbarch
!= NULL
);
3862 if (gdbarch_debug
>= 2)
3863 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_call_dummy_stack_adjust called\n");
3864 return gdbarch
->deprecated_call_dummy_stack_adjust
;
3868 set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch
*gdbarch
,
3869 int deprecated_call_dummy_stack_adjust
)
3871 gdbarch
->deprecated_call_dummy_stack_adjust
= deprecated_call_dummy_stack_adjust
;
3875 gdbarch_deprecated_fix_call_dummy_p (struct gdbarch
*gdbarch
)
3877 gdb_assert (gdbarch
!= NULL
);
3878 return gdbarch
->deprecated_fix_call_dummy
!= 0;
3882 gdbarch_deprecated_fix_call_dummy (struct gdbarch
*gdbarch
, char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
, struct value
**args
, struct type
*type
, int gcc_p
)
3884 gdb_assert (gdbarch
!= NULL
);
3885 if (gdbarch
->deprecated_fix_call_dummy
== 0)
3886 internal_error (__FILE__
, __LINE__
,
3887 "gdbarch: gdbarch_deprecated_fix_call_dummy invalid");
3888 if (gdbarch_debug
>= 2)
3889 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_fix_call_dummy called\n");
3890 gdbarch
->deprecated_fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
);
3894 set_gdbarch_deprecated_fix_call_dummy (struct gdbarch
*gdbarch
,
3895 gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy
)
3897 gdbarch
->deprecated_fix_call_dummy
= deprecated_fix_call_dummy
;
3901 gdbarch_push_dummy_code_p (struct gdbarch
*gdbarch
)
3903 gdb_assert (gdbarch
!= NULL
);
3904 return gdbarch
->push_dummy_code
!= 0;
3908 gdbarch_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
, CORE_ADDR funaddr
, int using_gcc
, struct value
**args
, int nargs
, struct type
*value_type
, CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
)
3910 gdb_assert (gdbarch
!= NULL
);
3911 if (gdbarch
->push_dummy_code
== 0)
3912 internal_error (__FILE__
, __LINE__
,
3913 "gdbarch: gdbarch_push_dummy_code invalid");
3914 if (gdbarch_debug
>= 2)
3915 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_code called\n");
3916 return gdbarch
->push_dummy_code (gdbarch
, sp
, funaddr
, using_gcc
, args
, nargs
, value_type
, real_pc
, bp_addr
);
3920 set_gdbarch_push_dummy_code (struct gdbarch
*gdbarch
,
3921 gdbarch_push_dummy_code_ftype push_dummy_code
)
3923 gdbarch
->push_dummy_code
= push_dummy_code
;
3927 gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch
*gdbarch
)
3929 gdb_assert (gdbarch
!= NULL
);
3930 return gdbarch
->deprecated_init_frame_pc_first
!= 0;
3934 gdbarch_deprecated_init_frame_pc_first (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*prev
)
3936 gdb_assert (gdbarch
!= NULL
);
3937 if (gdbarch
->deprecated_init_frame_pc_first
== 0)
3938 internal_error (__FILE__
, __LINE__
,
3939 "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid");
3940 if (gdbarch_debug
>= 2)
3941 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_init_frame_pc_first called\n");
3942 return gdbarch
->deprecated_init_frame_pc_first (fromleaf
, prev
);
3946 set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch
*gdbarch
,
3947 gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first
)
3949 gdbarch
->deprecated_init_frame_pc_first
= deprecated_init_frame_pc_first
;
3953 gdbarch_deprecated_init_frame_pc_p (struct gdbarch
*gdbarch
)
3955 gdb_assert (gdbarch
!= NULL
);
3956 return gdbarch
->deprecated_init_frame_pc
!= 0;
3960 gdbarch_deprecated_init_frame_pc (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*prev
)
3962 gdb_assert (gdbarch
!= NULL
);
3963 if (gdbarch
->deprecated_init_frame_pc
== 0)
3964 internal_error (__FILE__
, __LINE__
,
3965 "gdbarch: gdbarch_deprecated_init_frame_pc invalid");
3966 if (gdbarch_debug
>= 2)
3967 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_init_frame_pc called\n");
3968 return gdbarch
->deprecated_init_frame_pc (fromleaf
, prev
);
3972 set_gdbarch_deprecated_init_frame_pc (struct gdbarch
*gdbarch
,
3973 gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc
)
3975 gdbarch
->deprecated_init_frame_pc
= deprecated_init_frame_pc
;
3979 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
3981 gdb_assert (gdbarch
!= NULL
);
3982 if (gdbarch_debug
>= 2)
3983 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
3984 return gdbarch
->believe_pcc_promotion
;
3988 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
3989 int believe_pcc_promotion
)
3991 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
3995 gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
)
3997 gdb_assert (gdbarch
!= NULL
);
3998 if (gdbarch_debug
>= 2)
3999 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion_type called\n");
4000 return gdbarch
->believe_pcc_promotion_type
;
4004 set_gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
,
4005 int believe_pcc_promotion_type
)
4007 gdbarch
->believe_pcc_promotion_type
= believe_pcc_promotion_type
;
4011 gdbarch_deprecated_get_saved_register_p (struct gdbarch
*gdbarch
)
4013 gdb_assert (gdbarch
!= NULL
);
4014 return gdbarch
->deprecated_get_saved_register
!= 0;
4018 gdbarch_deprecated_get_saved_register (struct gdbarch
*gdbarch
, char *raw_buffer
, int *optimized
, CORE_ADDR
*addrp
, struct frame_info
*frame
, int regnum
, enum lval_type
*lval
)
4020 gdb_assert (gdbarch
!= NULL
);
4021 if (gdbarch
->deprecated_get_saved_register
== 0)
4022 internal_error (__FILE__
, __LINE__
,
4023 "gdbarch: gdbarch_deprecated_get_saved_register invalid");
4024 if (gdbarch_debug
>= 2)
4025 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_get_saved_register called\n");
4026 gdbarch
->deprecated_get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
4030 set_gdbarch_deprecated_get_saved_register (struct gdbarch
*gdbarch
,
4031 gdbarch_deprecated_get_saved_register_ftype deprecated_get_saved_register
)
4033 gdbarch
->deprecated_get_saved_register
= deprecated_get_saved_register
;
4037 gdbarch_register_convertible (struct gdbarch
*gdbarch
, int nr
)
4039 gdb_assert (gdbarch
!= NULL
);
4040 if (gdbarch
->register_convertible
== 0)
4041 internal_error (__FILE__
, __LINE__
,
4042 "gdbarch: gdbarch_register_convertible invalid");
4043 if (gdbarch_debug
>= 2)
4044 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convertible called\n");
4045 return gdbarch
->register_convertible (nr
);
4049 set_gdbarch_register_convertible (struct gdbarch
*gdbarch
,
4050 gdbarch_register_convertible_ftype register_convertible
)
4052 gdbarch
->register_convertible
= register_convertible
;
4056 gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
4058 gdb_assert (gdbarch
!= NULL
);
4059 if (gdbarch
->register_convert_to_virtual
== 0)
4060 internal_error (__FILE__
, __LINE__
,
4061 "gdbarch: gdbarch_register_convert_to_virtual invalid");
4062 if (gdbarch_debug
>= 2)
4063 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_virtual called\n");
4064 gdbarch
->register_convert_to_virtual (regnum
, type
, from
, to
);
4068 set_gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
,
4069 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual
)
4071 gdbarch
->register_convert_to_virtual
= register_convert_to_virtual
;
4075 gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
4077 gdb_assert (gdbarch
!= NULL
);
4078 if (gdbarch
->register_convert_to_raw
== 0)
4079 internal_error (__FILE__
, __LINE__
,
4080 "gdbarch: gdbarch_register_convert_to_raw invalid");
4081 if (gdbarch_debug
>= 2)
4082 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_raw called\n");
4083 gdbarch
->register_convert_to_raw (type
, regnum
, from
, to
);
4087 set_gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
,
4088 gdbarch_register_convert_to_raw_ftype register_convert_to_raw
)
4090 gdbarch
->register_convert_to_raw
= register_convert_to_raw
;
4094 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
)
4096 gdb_assert (gdbarch
!= NULL
);
4097 if (gdbarch
->convert_register_p
== 0)
4098 internal_error (__FILE__
, __LINE__
,
4099 "gdbarch: gdbarch_convert_register_p invalid");
4100 if (gdbarch_debug
>= 2)
4101 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
4102 return gdbarch
->convert_register_p (regnum
);
4106 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
4107 gdbarch_convert_register_p_ftype convert_register_p
)
4109 gdbarch
->convert_register_p
= convert_register_p
;
4113 gdbarch_register_to_value (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
4115 gdb_assert (gdbarch
!= NULL
);
4116 if (gdbarch
->register_to_value
== 0)
4117 internal_error (__FILE__
, __LINE__
,
4118 "gdbarch: gdbarch_register_to_value invalid");
4119 if (gdbarch_debug
>= 2)
4120 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
4121 gdbarch
->register_to_value (regnum
, type
, from
, to
);
4125 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
4126 gdbarch_register_to_value_ftype register_to_value
)
4128 gdbarch
->register_to_value
= register_to_value
;
4132 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
4134 gdb_assert (gdbarch
!= NULL
);
4135 if (gdbarch
->value_to_register
== 0)
4136 internal_error (__FILE__
, __LINE__
,
4137 "gdbarch: gdbarch_value_to_register invalid");
4138 if (gdbarch_debug
>= 2)
4139 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
4140 gdbarch
->value_to_register (type
, regnum
, from
, to
);
4144 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
4145 gdbarch_value_to_register_ftype value_to_register
)
4147 gdbarch
->value_to_register
= value_to_register
;
4151 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, const void *buf
)
4153 gdb_assert (gdbarch
!= NULL
);
4154 if (gdbarch
->pointer_to_address
== 0)
4155 internal_error (__FILE__
, __LINE__
,
4156 "gdbarch: gdbarch_pointer_to_address invalid");
4157 if (gdbarch_debug
>= 2)
4158 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
4159 return gdbarch
->pointer_to_address (type
, buf
);
4163 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
4164 gdbarch_pointer_to_address_ftype pointer_to_address
)
4166 gdbarch
->pointer_to_address
= pointer_to_address
;
4170 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
, CORE_ADDR addr
)
4172 gdb_assert (gdbarch
!= NULL
);
4173 if (gdbarch
->address_to_pointer
== 0)
4174 internal_error (__FILE__
, __LINE__
,
4175 "gdbarch: gdbarch_address_to_pointer invalid");
4176 if (gdbarch_debug
>= 2)
4177 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
4178 gdbarch
->address_to_pointer (type
, buf
, addr
);
4182 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
4183 gdbarch_address_to_pointer_ftype address_to_pointer
)
4185 gdbarch
->address_to_pointer
= address_to_pointer
;
4189 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
4191 gdb_assert (gdbarch
!= NULL
);
4192 return gdbarch
->integer_to_address
!= 0;
4196 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
4198 gdb_assert (gdbarch
!= NULL
);
4199 if (gdbarch
->integer_to_address
== 0)
4200 internal_error (__FILE__
, __LINE__
,
4201 "gdbarch: gdbarch_integer_to_address invalid");
4202 if (gdbarch_debug
>= 2)
4203 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
4204 return gdbarch
->integer_to_address (type
, buf
);
4208 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
4209 gdbarch_integer_to_address_ftype integer_to_address
)
4211 gdbarch
->integer_to_address
= integer_to_address
;
4215 gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
, struct type
*type
)
4217 gdb_assert (gdbarch
!= NULL
);
4218 if (gdbarch
->return_value_on_stack
== 0)
4219 internal_error (__FILE__
, __LINE__
,
4220 "gdbarch: gdbarch_return_value_on_stack invalid");
4221 if (gdbarch_debug
>= 2)
4222 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value_on_stack called\n");
4223 return gdbarch
->return_value_on_stack (type
);
4227 set_gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
,
4228 gdbarch_return_value_on_stack_ftype return_value_on_stack
)
4230 gdbarch
->return_value_on_stack
= return_value_on_stack
;
4234 gdbarch_deprecated_push_arguments_p (struct gdbarch
*gdbarch
)
4236 gdb_assert (gdbarch
!= NULL
);
4237 return gdbarch
->deprecated_push_arguments
!= 0;
4241 gdbarch_deprecated_push_arguments (struct gdbarch
*gdbarch
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
4243 gdb_assert (gdbarch
!= NULL
);
4244 if (gdbarch
->deprecated_push_arguments
== 0)
4245 internal_error (__FILE__
, __LINE__
,
4246 "gdbarch: gdbarch_deprecated_push_arguments invalid");
4247 if (gdbarch_debug
>= 2)
4248 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_push_arguments called\n");
4249 return gdbarch
->deprecated_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
4253 set_gdbarch_deprecated_push_arguments (struct gdbarch
*gdbarch
,
4254 gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments
)
4256 gdbarch
->deprecated_push_arguments
= deprecated_push_arguments
;
4260 gdbarch_push_dummy_call_p (struct gdbarch
*gdbarch
)
4262 gdb_assert (gdbarch
!= NULL
);
4263 return gdbarch
->push_dummy_call
!= 0;
4267 gdbarch_push_dummy_call (struct gdbarch
*gdbarch
, struct regcache
*regcache
, CORE_ADDR dummy_addr
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
4269 gdb_assert (gdbarch
!= NULL
);
4270 if (gdbarch
->push_dummy_call
== 0)
4271 internal_error (__FILE__
, __LINE__
,
4272 "gdbarch: gdbarch_push_dummy_call invalid");
4273 if (gdbarch_debug
>= 2)
4274 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_call called\n");
4275 return gdbarch
->push_dummy_call (gdbarch
, regcache
, dummy_addr
, nargs
, args
, sp
, struct_return
, struct_addr
);
4279 set_gdbarch_push_dummy_call (struct gdbarch
*gdbarch
,
4280 gdbarch_push_dummy_call_ftype push_dummy_call
)
4282 gdbarch
->push_dummy_call
= push_dummy_call
;
4286 gdbarch_deprecated_push_dummy_frame_p (struct gdbarch
*gdbarch
)
4288 gdb_assert (gdbarch
!= NULL
);
4289 return gdbarch
->deprecated_push_dummy_frame
!= 0;
4293 gdbarch_deprecated_push_dummy_frame (struct gdbarch
*gdbarch
)
4295 gdb_assert (gdbarch
!= NULL
);
4296 if (gdbarch
->deprecated_push_dummy_frame
== 0)
4297 internal_error (__FILE__
, __LINE__
,
4298 "gdbarch: gdbarch_deprecated_push_dummy_frame invalid");
4299 if (gdbarch_debug
>= 2)
4300 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_push_dummy_frame called\n");
4301 gdbarch
->deprecated_push_dummy_frame ();
4305 set_gdbarch_deprecated_push_dummy_frame (struct gdbarch
*gdbarch
,
4306 gdbarch_deprecated_push_dummy_frame_ftype deprecated_push_dummy_frame
)
4308 gdbarch
->deprecated_push_dummy_frame
= deprecated_push_dummy_frame
;
4312 gdbarch_deprecated_push_return_address_p (struct gdbarch
*gdbarch
)
4314 gdb_assert (gdbarch
!= NULL
);
4315 return gdbarch
->deprecated_push_return_address
!= 0;
4319 gdbarch_deprecated_push_return_address (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
)
4321 gdb_assert (gdbarch
!= NULL
);
4322 if (gdbarch
->deprecated_push_return_address
== 0)
4323 internal_error (__FILE__
, __LINE__
,
4324 "gdbarch: gdbarch_deprecated_push_return_address invalid");
4325 if (gdbarch_debug
>= 2)
4326 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_push_return_address called\n");
4327 return gdbarch
->deprecated_push_return_address (pc
, sp
);
4331 set_gdbarch_deprecated_push_return_address (struct gdbarch
*gdbarch
,
4332 gdbarch_deprecated_push_return_address_ftype deprecated_push_return_address
)
4334 gdbarch
->deprecated_push_return_address
= deprecated_push_return_address
;
4338 gdbarch_deprecated_pop_frame_p (struct gdbarch
*gdbarch
)
4340 gdb_assert (gdbarch
!= NULL
);
4341 return gdbarch
->deprecated_pop_frame
!= 0;
4345 gdbarch_deprecated_pop_frame (struct gdbarch
*gdbarch
)
4347 gdb_assert (gdbarch
!= NULL
);
4348 if (gdbarch
->deprecated_pop_frame
== 0)
4349 internal_error (__FILE__
, __LINE__
,
4350 "gdbarch: gdbarch_deprecated_pop_frame invalid");
4351 if (gdbarch_debug
>= 2)
4352 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_pop_frame called\n");
4353 gdbarch
->deprecated_pop_frame ();
4357 set_gdbarch_deprecated_pop_frame (struct gdbarch
*gdbarch
,
4358 gdbarch_deprecated_pop_frame_ftype deprecated_pop_frame
)
4360 gdbarch
->deprecated_pop_frame
= deprecated_pop_frame
;
4364 gdbarch_deprecated_store_struct_return_p (struct gdbarch
*gdbarch
)
4366 gdb_assert (gdbarch
!= NULL
);
4367 return gdbarch
->deprecated_store_struct_return
!= 0;
4371 gdbarch_deprecated_store_struct_return (struct gdbarch
*gdbarch
, CORE_ADDR addr
, CORE_ADDR sp
)
4373 gdb_assert (gdbarch
!= NULL
);
4374 if (gdbarch
->deprecated_store_struct_return
== 0)
4375 internal_error (__FILE__
, __LINE__
,
4376 "gdbarch: gdbarch_deprecated_store_struct_return invalid");
4377 if (gdbarch_debug
>= 2)
4378 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_store_struct_return called\n");
4379 gdbarch
->deprecated_store_struct_return (addr
, sp
);
4383 set_gdbarch_deprecated_store_struct_return (struct gdbarch
*gdbarch
,
4384 gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return
)
4386 gdbarch
->deprecated_store_struct_return
= deprecated_store_struct_return
;
4390 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, void *valbuf
)
4392 gdb_assert (gdbarch
!= NULL
);
4393 if (gdbarch
->extract_return_value
== 0)
4394 internal_error (__FILE__
, __LINE__
,
4395 "gdbarch: gdbarch_extract_return_value invalid");
4396 if (gdbarch_debug
>= 2)
4397 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
4398 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
4402 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
4403 gdbarch_extract_return_value_ftype extract_return_value
)
4405 gdbarch
->extract_return_value
= extract_return_value
;
4409 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const void *valbuf
)
4411 gdb_assert (gdbarch
!= NULL
);
4412 if (gdbarch
->store_return_value
== 0)
4413 internal_error (__FILE__
, __LINE__
,
4414 "gdbarch: gdbarch_store_return_value invalid");
4415 if (gdbarch_debug
>= 2)
4416 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
4417 gdbarch
->store_return_value (type
, regcache
, valbuf
);
4421 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
4422 gdbarch_store_return_value_ftype store_return_value
)
4424 gdbarch
->store_return_value
= store_return_value
;
4428 gdbarch_deprecated_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *regbuf
, char *valbuf
)
4430 gdb_assert (gdbarch
!= NULL
);
4431 if (gdbarch
->deprecated_extract_return_value
== 0)
4432 internal_error (__FILE__
, __LINE__
,
4433 "gdbarch: gdbarch_deprecated_extract_return_value invalid");
4434 if (gdbarch_debug
>= 2)
4435 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_return_value called\n");
4436 gdbarch
->deprecated_extract_return_value (type
, regbuf
, valbuf
);
4440 set_gdbarch_deprecated_extract_return_value (struct gdbarch
*gdbarch
,
4441 gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value
)
4443 gdbarch
->deprecated_extract_return_value
= deprecated_extract_return_value
;
4447 gdbarch_deprecated_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *valbuf
)
4449 gdb_assert (gdbarch
!= NULL
);
4450 if (gdbarch
->deprecated_store_return_value
== 0)
4451 internal_error (__FILE__
, __LINE__
,
4452 "gdbarch: gdbarch_deprecated_store_return_value invalid");
4453 if (gdbarch_debug
>= 2)
4454 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_store_return_value called\n");
4455 gdbarch
->deprecated_store_return_value (type
, valbuf
);
4459 set_gdbarch_deprecated_store_return_value (struct gdbarch
*gdbarch
,
4460 gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value
)
4462 gdbarch
->deprecated_store_return_value
= deprecated_store_return_value
;
4466 gdbarch_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
4468 gdb_assert (gdbarch
!= NULL
);
4469 return gdbarch
->extract_struct_value_address
!= 0;
4473 gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
4475 gdb_assert (gdbarch
!= NULL
);
4476 if (gdbarch
->extract_struct_value_address
== 0)
4477 internal_error (__FILE__
, __LINE__
,
4478 "gdbarch: gdbarch_extract_struct_value_address invalid");
4479 if (gdbarch_debug
>= 2)
4480 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_struct_value_address called\n");
4481 return gdbarch
->extract_struct_value_address (regcache
);
4485 set_gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
,
4486 gdbarch_extract_struct_value_address_ftype extract_struct_value_address
)
4488 gdbarch
->extract_struct_value_address
= extract_struct_value_address
;
4492 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
4494 gdb_assert (gdbarch
!= NULL
);
4495 return gdbarch
->deprecated_extract_struct_value_address
!= 0;
4499 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, char *regbuf
)
4501 gdb_assert (gdbarch
!= NULL
);
4502 if (gdbarch
->deprecated_extract_struct_value_address
== 0)
4503 internal_error (__FILE__
, __LINE__
,
4504 "gdbarch: gdbarch_deprecated_extract_struct_value_address invalid");
4505 if (gdbarch_debug
>= 2)
4506 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
4507 return gdbarch
->deprecated_extract_struct_value_address (regbuf
);
4511 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
4512 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
4514 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
4518 gdbarch_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
4520 gdb_assert (gdbarch
!= NULL
);
4521 if (gdbarch
->use_struct_convention
== 0)
4522 internal_error (__FILE__
, __LINE__
,
4523 "gdbarch: gdbarch_use_struct_convention invalid");
4524 if (gdbarch_debug
>= 2)
4525 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_struct_convention called\n");
4526 return gdbarch
->use_struct_convention (gcc_p
, value_type
);
4530 set_gdbarch_use_struct_convention (struct gdbarch
*gdbarch
,
4531 gdbarch_use_struct_convention_ftype use_struct_convention
)
4533 gdbarch
->use_struct_convention
= use_struct_convention
;
4537 gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch
*gdbarch
)
4539 gdb_assert (gdbarch
!= NULL
);
4540 return gdbarch
->deprecated_frame_init_saved_regs
!= 0;
4544 gdbarch_deprecated_frame_init_saved_regs (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4546 gdb_assert (gdbarch
!= NULL
);
4547 if (gdbarch
->deprecated_frame_init_saved_regs
== 0)
4548 internal_error (__FILE__
, __LINE__
,
4549 "gdbarch: gdbarch_deprecated_frame_init_saved_regs invalid");
4550 if (gdbarch_debug
>= 2)
4551 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_frame_init_saved_regs called\n");
4552 gdbarch
->deprecated_frame_init_saved_regs (frame
);
4556 set_gdbarch_deprecated_frame_init_saved_regs (struct gdbarch
*gdbarch
,
4557 gdbarch_deprecated_frame_init_saved_regs_ftype deprecated_frame_init_saved_regs
)
4559 gdbarch
->deprecated_frame_init_saved_regs
= deprecated_frame_init_saved_regs
;
4563 gdbarch_deprecated_init_extra_frame_info_p (struct gdbarch
*gdbarch
)
4565 gdb_assert (gdbarch
!= NULL
);
4566 return gdbarch
->deprecated_init_extra_frame_info
!= 0;
4570 gdbarch_deprecated_init_extra_frame_info (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*frame
)
4572 gdb_assert (gdbarch
!= NULL
);
4573 if (gdbarch
->deprecated_init_extra_frame_info
== 0)
4574 internal_error (__FILE__
, __LINE__
,
4575 "gdbarch: gdbarch_deprecated_init_extra_frame_info invalid");
4576 if (gdbarch_debug
>= 2)
4577 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_init_extra_frame_info called\n");
4578 gdbarch
->deprecated_init_extra_frame_info (fromleaf
, frame
);
4582 set_gdbarch_deprecated_init_extra_frame_info (struct gdbarch
*gdbarch
,
4583 gdbarch_deprecated_init_extra_frame_info_ftype deprecated_init_extra_frame_info
)
4585 gdbarch
->deprecated_init_extra_frame_info
= deprecated_init_extra_frame_info
;
4589 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
4591 gdb_assert (gdbarch
!= NULL
);
4592 if (gdbarch
->skip_prologue
== 0)
4593 internal_error (__FILE__
, __LINE__
,
4594 "gdbarch: gdbarch_skip_prologue invalid");
4595 if (gdbarch_debug
>= 2)
4596 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
4597 return gdbarch
->skip_prologue (ip
);
4601 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
4602 gdbarch_skip_prologue_ftype skip_prologue
)
4604 gdbarch
->skip_prologue
= skip_prologue
;
4608 gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
4610 gdb_assert (gdbarch
!= NULL
);
4611 if (gdbarch
->prologue_frameless_p
== 0)
4612 internal_error (__FILE__
, __LINE__
,
4613 "gdbarch: gdbarch_prologue_frameless_p invalid");
4614 if (gdbarch_debug
>= 2)
4615 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prologue_frameless_p called\n");
4616 return gdbarch
->prologue_frameless_p (ip
);
4620 set_gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
,
4621 gdbarch_prologue_frameless_p_ftype prologue_frameless_p
)
4623 gdbarch
->prologue_frameless_p
= prologue_frameless_p
;
4627 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
4629 gdb_assert (gdbarch
!= NULL
);
4630 if (gdbarch
->inner_than
== 0)
4631 internal_error (__FILE__
, __LINE__
,
4632 "gdbarch: gdbarch_inner_than invalid");
4633 if (gdbarch_debug
>= 2)
4634 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
4635 return gdbarch
->inner_than (lhs
, rhs
);
4639 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
4640 gdbarch_inner_than_ftype inner_than
)
4642 gdbarch
->inner_than
= inner_than
;
4645 const unsigned char *
4646 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
4648 gdb_assert (gdbarch
!= NULL
);
4649 if (gdbarch
->breakpoint_from_pc
== 0)
4650 internal_error (__FILE__
, __LINE__
,
4651 "gdbarch: gdbarch_breakpoint_from_pc invalid");
4652 if (gdbarch_debug
>= 2)
4653 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
4654 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
4658 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
4659 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
4661 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
4665 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
4667 gdb_assert (gdbarch
!= NULL
);
4668 if (gdbarch
->memory_insert_breakpoint
== 0)
4669 internal_error (__FILE__
, __LINE__
,
4670 "gdbarch: gdbarch_memory_insert_breakpoint invalid");
4671 if (gdbarch_debug
>= 2)
4672 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
4673 return gdbarch
->memory_insert_breakpoint (addr
, contents_cache
);
4677 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
4678 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
4680 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
4684 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
4686 gdb_assert (gdbarch
!= NULL
);
4687 if (gdbarch
->memory_remove_breakpoint
== 0)
4688 internal_error (__FILE__
, __LINE__
,
4689 "gdbarch: gdbarch_memory_remove_breakpoint invalid");
4690 if (gdbarch_debug
>= 2)
4691 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
4692 return gdbarch
->memory_remove_breakpoint (addr
, contents_cache
);
4696 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
4697 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
4699 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
4703 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
4705 gdb_assert (gdbarch
!= NULL
);
4706 if (gdbarch
->decr_pc_after_break
== -1)
4707 internal_error (__FILE__
, __LINE__
,
4708 "gdbarch: gdbarch_decr_pc_after_break invalid");
4709 if (gdbarch_debug
>= 2)
4710 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
4711 return gdbarch
->decr_pc_after_break
;
4715 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
4716 CORE_ADDR decr_pc_after_break
)
4718 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
4722 gdbarch_prepare_to_proceed (struct gdbarch
*gdbarch
, int select_it
)
4724 gdb_assert (gdbarch
!= NULL
);
4725 if (gdbarch
->prepare_to_proceed
== 0)
4726 internal_error (__FILE__
, __LINE__
,
4727 "gdbarch: gdbarch_prepare_to_proceed invalid");
4728 if (gdbarch_debug
>= 2)
4729 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prepare_to_proceed called\n");
4730 return gdbarch
->prepare_to_proceed (select_it
);
4734 set_gdbarch_prepare_to_proceed (struct gdbarch
*gdbarch
,
4735 gdbarch_prepare_to_proceed_ftype prepare_to_proceed
)
4737 gdbarch
->prepare_to_proceed
= prepare_to_proceed
;
4741 gdbarch_function_start_offset (struct gdbarch
*gdbarch
)
4743 gdb_assert (gdbarch
!= NULL
);
4744 if (gdbarch
->function_start_offset
== -1)
4745 internal_error (__FILE__
, __LINE__
,
4746 "gdbarch: gdbarch_function_start_offset invalid");
4747 if (gdbarch_debug
>= 2)
4748 fprintf_unfiltered (gdb_stdlog
, "gdbarch_function_start_offset called\n");
4749 return gdbarch
->function_start_offset
;
4753 set_gdbarch_function_start_offset (struct gdbarch
*gdbarch
,
4754 CORE_ADDR function_start_offset
)
4756 gdbarch
->function_start_offset
= function_start_offset
;
4760 gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
, CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
)
4762 gdb_assert (gdbarch
!= NULL
);
4763 if (gdbarch
->remote_translate_xfer_address
== 0)
4764 internal_error (__FILE__
, __LINE__
,
4765 "gdbarch: gdbarch_remote_translate_xfer_address invalid");
4766 if (gdbarch_debug
>= 2)
4767 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_translate_xfer_address called\n");
4768 gdbarch
->remote_translate_xfer_address (gdbarch
, regcache
, gdb_addr
, gdb_len
, rem_addr
, rem_len
);
4772 set_gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
4773 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address
)
4775 gdbarch
->remote_translate_xfer_address
= remote_translate_xfer_address
;
4779 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
4781 gdb_assert (gdbarch
!= NULL
);
4782 if (gdbarch
->frame_args_skip
== -1)
4783 internal_error (__FILE__
, __LINE__
,
4784 "gdbarch: gdbarch_frame_args_skip invalid");
4785 if (gdbarch_debug
>= 2)
4786 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
4787 return gdbarch
->frame_args_skip
;
4791 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
4792 CORE_ADDR frame_args_skip
)
4794 gdbarch
->frame_args_skip
= frame_args_skip
;
4798 gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4800 gdb_assert (gdbarch
!= NULL
);
4801 if (gdbarch
->frameless_function_invocation
== 0)
4802 internal_error (__FILE__
, __LINE__
,
4803 "gdbarch: gdbarch_frameless_function_invocation invalid");
4804 if (gdbarch_debug
>= 2)
4805 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frameless_function_invocation called\n");
4806 return gdbarch
->frameless_function_invocation (fi
);
4810 set_gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
,
4811 gdbarch_frameless_function_invocation_ftype frameless_function_invocation
)
4813 gdbarch
->frameless_function_invocation
= frameless_function_invocation
;
4817 gdbarch_deprecated_frame_chain_p (struct gdbarch
*gdbarch
)
4819 gdb_assert (gdbarch
!= NULL
);
4820 return gdbarch
->deprecated_frame_chain
!= 0;
4824 gdbarch_deprecated_frame_chain (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4826 gdb_assert (gdbarch
!= NULL
);
4827 if (gdbarch
->deprecated_frame_chain
== 0)
4828 internal_error (__FILE__
, __LINE__
,
4829 "gdbarch: gdbarch_deprecated_frame_chain invalid");
4830 if (gdbarch_debug
>= 2)
4831 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_frame_chain called\n");
4832 return gdbarch
->deprecated_frame_chain (frame
);
4836 set_gdbarch_deprecated_frame_chain (struct gdbarch
*gdbarch
,
4837 gdbarch_deprecated_frame_chain_ftype deprecated_frame_chain
)
4839 gdbarch
->deprecated_frame_chain
= deprecated_frame_chain
;
4843 gdbarch_deprecated_frame_chain_valid_p (struct gdbarch
*gdbarch
)
4845 gdb_assert (gdbarch
!= NULL
);
4846 return gdbarch
->deprecated_frame_chain_valid
!= 0;
4850 gdbarch_deprecated_frame_chain_valid (struct gdbarch
*gdbarch
, CORE_ADDR chain
, struct frame_info
*thisframe
)
4852 gdb_assert (gdbarch
!= NULL
);
4853 if (gdbarch
->deprecated_frame_chain_valid
== 0)
4854 internal_error (__FILE__
, __LINE__
,
4855 "gdbarch: gdbarch_deprecated_frame_chain_valid invalid");
4856 if (gdbarch_debug
>= 2)
4857 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_frame_chain_valid called\n");
4858 return gdbarch
->deprecated_frame_chain_valid (chain
, thisframe
);
4862 set_gdbarch_deprecated_frame_chain_valid (struct gdbarch
*gdbarch
,
4863 gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid
)
4865 gdbarch
->deprecated_frame_chain_valid
= deprecated_frame_chain_valid
;
4869 gdbarch_deprecated_frame_saved_pc_p (struct gdbarch
*gdbarch
)
4871 gdb_assert (gdbarch
!= NULL
);
4872 return gdbarch
->deprecated_frame_saved_pc
!= 0;
4876 gdbarch_deprecated_frame_saved_pc (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4878 gdb_assert (gdbarch
!= NULL
);
4879 if (gdbarch
->deprecated_frame_saved_pc
== 0)
4880 internal_error (__FILE__
, __LINE__
,
4881 "gdbarch: gdbarch_deprecated_frame_saved_pc invalid");
4882 if (gdbarch_debug
>= 2)
4883 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_frame_saved_pc called\n");
4884 return gdbarch
->deprecated_frame_saved_pc (fi
);
4888 set_gdbarch_deprecated_frame_saved_pc (struct gdbarch
*gdbarch
,
4889 gdbarch_deprecated_frame_saved_pc_ftype deprecated_frame_saved_pc
)
4891 gdbarch
->deprecated_frame_saved_pc
= deprecated_frame_saved_pc
;
4895 gdbarch_unwind_pc_p (struct gdbarch
*gdbarch
)
4897 gdb_assert (gdbarch
!= NULL
);
4898 return gdbarch
->unwind_pc
!= 0;
4902 gdbarch_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
4904 gdb_assert (gdbarch
!= NULL
);
4905 if (gdbarch
->unwind_pc
== 0)
4906 internal_error (__FILE__
, __LINE__
,
4907 "gdbarch: gdbarch_unwind_pc invalid");
4908 if (gdbarch_debug
>= 2)
4909 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_pc called\n");
4910 return gdbarch
->unwind_pc (gdbarch
, next_frame
);
4914 set_gdbarch_unwind_pc (struct gdbarch
*gdbarch
,
4915 gdbarch_unwind_pc_ftype unwind_pc
)
4917 gdbarch
->unwind_pc
= unwind_pc
;
4921 gdbarch_frame_args_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4923 gdb_assert (gdbarch
!= NULL
);
4924 if (gdbarch
->frame_args_address
== 0)
4925 internal_error (__FILE__
, __LINE__
,
4926 "gdbarch: gdbarch_frame_args_address invalid");
4927 if (gdbarch_debug
>= 2)
4928 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_address called\n");
4929 return gdbarch
->frame_args_address (fi
);
4933 set_gdbarch_frame_args_address (struct gdbarch
*gdbarch
,
4934 gdbarch_frame_args_address_ftype frame_args_address
)
4936 gdbarch
->frame_args_address
= frame_args_address
;
4940 gdbarch_frame_locals_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4942 gdb_assert (gdbarch
!= NULL
);
4943 if (gdbarch
->frame_locals_address
== 0)
4944 internal_error (__FILE__
, __LINE__
,
4945 "gdbarch: gdbarch_frame_locals_address invalid");
4946 if (gdbarch_debug
>= 2)
4947 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_locals_address called\n");
4948 return gdbarch
->frame_locals_address (fi
);
4952 set_gdbarch_frame_locals_address (struct gdbarch
*gdbarch
,
4953 gdbarch_frame_locals_address_ftype frame_locals_address
)
4955 gdbarch
->frame_locals_address
= frame_locals_address
;
4959 gdbarch_deprecated_saved_pc_after_call_p (struct gdbarch
*gdbarch
)
4961 gdb_assert (gdbarch
!= NULL
);
4962 return gdbarch
->deprecated_saved_pc_after_call
!= 0;
4966 gdbarch_deprecated_saved_pc_after_call (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4968 gdb_assert (gdbarch
!= NULL
);
4969 if (gdbarch
->deprecated_saved_pc_after_call
== 0)
4970 internal_error (__FILE__
, __LINE__
,
4971 "gdbarch: gdbarch_deprecated_saved_pc_after_call invalid");
4972 if (gdbarch_debug
>= 2)
4973 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_saved_pc_after_call called\n");
4974 return gdbarch
->deprecated_saved_pc_after_call (frame
);
4978 set_gdbarch_deprecated_saved_pc_after_call (struct gdbarch
*gdbarch
,
4979 gdbarch_deprecated_saved_pc_after_call_ftype deprecated_saved_pc_after_call
)
4981 gdbarch
->deprecated_saved_pc_after_call
= deprecated_saved_pc_after_call
;
4985 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4987 gdb_assert (gdbarch
!= NULL
);
4988 if (gdbarch
->frame_num_args
== 0)
4989 internal_error (__FILE__
, __LINE__
,
4990 "gdbarch: gdbarch_frame_num_args invalid");
4991 if (gdbarch_debug
>= 2)
4992 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
4993 return gdbarch
->frame_num_args (frame
);
4997 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
4998 gdbarch_frame_num_args_ftype frame_num_args
)
5000 gdbarch
->frame_num_args
= frame_num_args
;
5004 gdbarch_stack_align_p (struct gdbarch
*gdbarch
)
5006 gdb_assert (gdbarch
!= NULL
);
5007 return gdbarch
->stack_align
!= 0;
5011 gdbarch_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
5013 gdb_assert (gdbarch
!= NULL
);
5014 if (gdbarch
->stack_align
== 0)
5015 internal_error (__FILE__
, __LINE__
,
5016 "gdbarch: gdbarch_stack_align invalid");
5017 if (gdbarch_debug
>= 2)
5018 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stack_align called\n");
5019 return gdbarch
->stack_align (sp
);
5023 set_gdbarch_stack_align (struct gdbarch
*gdbarch
,
5024 gdbarch_stack_align_ftype stack_align
)
5026 gdbarch
->stack_align
= stack_align
;
5030 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
5032 gdb_assert (gdbarch
!= NULL
);
5033 return gdbarch
->frame_align
!= 0;
5037 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5039 gdb_assert (gdbarch
!= NULL
);
5040 if (gdbarch
->frame_align
== 0)
5041 internal_error (__FILE__
, __LINE__
,
5042 "gdbarch: gdbarch_frame_align invalid");
5043 if (gdbarch_debug
>= 2)
5044 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
5045 return gdbarch
->frame_align (gdbarch
, address
);
5049 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
5050 gdbarch_frame_align_ftype frame_align
)
5052 gdbarch
->frame_align
= frame_align
;
5056 gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch
*gdbarch
)
5058 gdb_assert (gdbarch
!= NULL
);
5059 /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
5060 if (gdbarch_debug
>= 2)
5061 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extra_stack_alignment_needed called\n");
5062 return gdbarch
->deprecated_extra_stack_alignment_needed
;
5066 set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch
*gdbarch
,
5067 int deprecated_extra_stack_alignment_needed
)
5069 gdbarch
->deprecated_extra_stack_alignment_needed
= deprecated_extra_stack_alignment_needed
;
5073 gdbarch_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
5075 gdb_assert (gdbarch
!= NULL
);
5076 return gdbarch
->reg_struct_has_addr
!= 0;
5080 gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
5082 gdb_assert (gdbarch
!= NULL
);
5083 if (gdbarch
->reg_struct_has_addr
== 0)
5084 internal_error (__FILE__
, __LINE__
,
5085 "gdbarch: gdbarch_reg_struct_has_addr invalid");
5086 if (gdbarch_debug
>= 2)
5087 fprintf_unfiltered (gdb_stdlog
, "gdbarch_reg_struct_has_addr called\n");
5088 return gdbarch
->reg_struct_has_addr (gcc_p
, type
);
5092 set_gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
,
5093 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr
)
5095 gdbarch
->reg_struct_has_addr
= reg_struct_has_addr
;
5099 gdbarch_save_dummy_frame_tos_p (struct gdbarch
*gdbarch
)
5101 gdb_assert (gdbarch
!= NULL
);
5102 return gdbarch
->save_dummy_frame_tos
!= 0;
5106 gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
5108 gdb_assert (gdbarch
!= NULL
);
5109 if (gdbarch
->save_dummy_frame_tos
== 0)
5110 internal_error (__FILE__
, __LINE__
,
5111 "gdbarch: gdbarch_save_dummy_frame_tos invalid");
5112 if (gdbarch_debug
>= 2)
5113 fprintf_unfiltered (gdb_stdlog
, "gdbarch_save_dummy_frame_tos called\n");
5114 gdbarch
->save_dummy_frame_tos (sp
);
5118 set_gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
,
5119 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos
)
5121 gdbarch
->save_dummy_frame_tos
= save_dummy_frame_tos
;
5125 gdbarch_unwind_dummy_id_p (struct gdbarch
*gdbarch
)
5127 gdb_assert (gdbarch
!= NULL
);
5128 return gdbarch
->unwind_dummy_id
!= 0;
5132 gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*info
)
5134 gdb_assert (gdbarch
!= NULL
);
5135 if (gdbarch
->unwind_dummy_id
== 0)
5136 internal_error (__FILE__
, __LINE__
,
5137 "gdbarch: gdbarch_unwind_dummy_id invalid");
5138 if (gdbarch_debug
>= 2)
5139 fprintf_unfiltered (gdb_stdlog
, "gdbarch_unwind_dummy_id called\n");
5140 return gdbarch
->unwind_dummy_id (gdbarch
, info
);
5144 set_gdbarch_unwind_dummy_id (struct gdbarch
*gdbarch
,
5145 gdbarch_unwind_dummy_id_ftype unwind_dummy_id
)
5147 gdbarch
->unwind_dummy_id
= unwind_dummy_id
;
5151 gdbarch_parm_boundary (struct gdbarch
*gdbarch
)
5153 gdb_assert (gdbarch
!= NULL
);
5154 if (gdbarch_debug
>= 2)
5155 fprintf_unfiltered (gdb_stdlog
, "gdbarch_parm_boundary called\n");
5156 return gdbarch
->parm_boundary
;
5160 set_gdbarch_parm_boundary (struct gdbarch
*gdbarch
,
5163 gdbarch
->parm_boundary
= parm_boundary
;
5166 const struct floatformat
*
5167 gdbarch_float_format (struct gdbarch
*gdbarch
)
5169 gdb_assert (gdbarch
!= NULL
);
5170 if (gdbarch_debug
>= 2)
5171 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
5172 return gdbarch
->float_format
;
5176 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
5177 const struct floatformat
* float_format
)
5179 gdbarch
->float_format
= float_format
;
5182 const struct floatformat
*
5183 gdbarch_double_format (struct gdbarch
*gdbarch
)
5185 gdb_assert (gdbarch
!= NULL
);
5186 if (gdbarch_debug
>= 2)
5187 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
5188 return gdbarch
->double_format
;
5192 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
5193 const struct floatformat
* double_format
)
5195 gdbarch
->double_format
= double_format
;
5198 const struct floatformat
*
5199 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
5201 gdb_assert (gdbarch
!= NULL
);
5202 if (gdbarch_debug
>= 2)
5203 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
5204 return gdbarch
->long_double_format
;
5208 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
5209 const struct floatformat
* long_double_format
)
5211 gdbarch
->long_double_format
= long_double_format
;
5215 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
5217 gdb_assert (gdbarch
!= NULL
);
5218 if (gdbarch
->convert_from_func_ptr_addr
== 0)
5219 internal_error (__FILE__
, __LINE__
,
5220 "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
5221 if (gdbarch_debug
>= 2)
5222 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
5223 return gdbarch
->convert_from_func_ptr_addr (addr
);
5227 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
5228 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
5230 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
5234 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
5236 gdb_assert (gdbarch
!= NULL
);
5237 if (gdbarch
->addr_bits_remove
== 0)
5238 internal_error (__FILE__
, __LINE__
,
5239 "gdbarch: gdbarch_addr_bits_remove invalid");
5240 if (gdbarch_debug
>= 2)
5241 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
5242 return gdbarch
->addr_bits_remove (addr
);
5246 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
5247 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
5249 gdbarch
->addr_bits_remove
= addr_bits_remove
;
5253 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
5255 gdb_assert (gdbarch
!= NULL
);
5256 if (gdbarch
->smash_text_address
== 0)
5257 internal_error (__FILE__
, __LINE__
,
5258 "gdbarch: gdbarch_smash_text_address invalid");
5259 if (gdbarch_debug
>= 2)
5260 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
5261 return gdbarch
->smash_text_address (addr
);
5265 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
5266 gdbarch_smash_text_address_ftype smash_text_address
)
5268 gdbarch
->smash_text_address
= smash_text_address
;
5272 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
5274 gdb_assert (gdbarch
!= NULL
);
5275 return gdbarch
->software_single_step
!= 0;
5279 gdbarch_software_single_step (struct gdbarch
*gdbarch
, enum target_signal sig
, int insert_breakpoints_p
)
5281 gdb_assert (gdbarch
!= NULL
);
5282 if (gdbarch
->software_single_step
== 0)
5283 internal_error (__FILE__
, __LINE__
,
5284 "gdbarch: gdbarch_software_single_step invalid");
5285 if (gdbarch_debug
>= 2)
5286 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
5287 gdbarch
->software_single_step (sig
, insert_breakpoints_p
);
5291 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
5292 gdbarch_software_single_step_ftype software_single_step
)
5294 gdbarch
->software_single_step
= software_single_step
;
5298 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, disassemble_info
*info
)
5300 gdb_assert (gdbarch
!= NULL
);
5301 if (gdbarch
->print_insn
== 0)
5302 internal_error (__FILE__
, __LINE__
,
5303 "gdbarch: gdbarch_print_insn invalid");
5304 if (gdbarch_debug
>= 2)
5305 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
5306 return gdbarch
->print_insn (vma
, info
);
5310 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
5311 gdbarch_print_insn_ftype print_insn
)
5313 gdbarch
->print_insn
= print_insn
;
5317 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5319 gdb_assert (gdbarch
!= NULL
);
5320 if (gdbarch
->skip_trampoline_code
== 0)
5321 internal_error (__FILE__
, __LINE__
,
5322 "gdbarch: gdbarch_skip_trampoline_code invalid");
5323 if (gdbarch_debug
>= 2)
5324 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
5325 return gdbarch
->skip_trampoline_code (pc
);
5329 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
5330 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
5332 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
5336 gdbarch_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
5338 gdb_assert (gdbarch
!= NULL
);
5339 if (gdbarch
->in_solib_call_trampoline
== 0)
5340 internal_error (__FILE__
, __LINE__
,
5341 "gdbarch: gdbarch_in_solib_call_trampoline invalid");
5342 if (gdbarch_debug
>= 2)
5343 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_call_trampoline called\n");
5344 return gdbarch
->in_solib_call_trampoline (pc
, name
);
5348 set_gdbarch_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
5349 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline
)
5351 gdbarch
->in_solib_call_trampoline
= in_solib_call_trampoline
;
5355 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
5357 gdb_assert (gdbarch
!= NULL
);
5358 if (gdbarch
->in_solib_return_trampoline
== 0)
5359 internal_error (__FILE__
, __LINE__
,
5360 "gdbarch: gdbarch_in_solib_return_trampoline invalid");
5361 if (gdbarch_debug
>= 2)
5362 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
5363 return gdbarch
->in_solib_return_trampoline (pc
, name
);
5367 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
5368 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
5370 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
5374 gdbarch_pc_in_sigtramp (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
5376 gdb_assert (gdbarch
!= NULL
);
5377 if (gdbarch
->pc_in_sigtramp
== 0)
5378 internal_error (__FILE__
, __LINE__
,
5379 "gdbarch: gdbarch_pc_in_sigtramp invalid");
5380 if (gdbarch_debug
>= 2)
5381 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_sigtramp called\n");
5382 return gdbarch
->pc_in_sigtramp (pc
, name
);
5386 set_gdbarch_pc_in_sigtramp (struct gdbarch
*gdbarch
,
5387 gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp
)
5389 gdbarch
->pc_in_sigtramp
= pc_in_sigtramp
;
5393 gdbarch_sigtramp_start_p (struct gdbarch
*gdbarch
)
5395 gdb_assert (gdbarch
!= NULL
);
5396 return gdbarch
->sigtramp_start
!= 0;
5400 gdbarch_sigtramp_start (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5402 gdb_assert (gdbarch
!= NULL
);
5403 if (gdbarch
->sigtramp_start
== 0)
5404 internal_error (__FILE__
, __LINE__
,
5405 "gdbarch: gdbarch_sigtramp_start invalid");
5406 if (gdbarch_debug
>= 2)
5407 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sigtramp_start called\n");
5408 return gdbarch
->sigtramp_start (pc
);
5412 set_gdbarch_sigtramp_start (struct gdbarch
*gdbarch
,
5413 gdbarch_sigtramp_start_ftype sigtramp_start
)
5415 gdbarch
->sigtramp_start
= sigtramp_start
;
5419 gdbarch_sigtramp_end_p (struct gdbarch
*gdbarch
)
5421 gdb_assert (gdbarch
!= NULL
);
5422 return gdbarch
->sigtramp_end
!= 0;
5426 gdbarch_sigtramp_end (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5428 gdb_assert (gdbarch
!= NULL
);
5429 if (gdbarch
->sigtramp_end
== 0)
5430 internal_error (__FILE__
, __LINE__
,
5431 "gdbarch: gdbarch_sigtramp_end invalid");
5432 if (gdbarch_debug
>= 2)
5433 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sigtramp_end called\n");
5434 return gdbarch
->sigtramp_end (pc
);
5438 set_gdbarch_sigtramp_end (struct gdbarch
*gdbarch
,
5439 gdbarch_sigtramp_end_ftype sigtramp_end
)
5441 gdbarch
->sigtramp_end
= sigtramp_end
;
5445 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
5447 gdb_assert (gdbarch
!= NULL
);
5448 if (gdbarch
->in_function_epilogue_p
== 0)
5449 internal_error (__FILE__
, __LINE__
,
5450 "gdbarch: gdbarch_in_function_epilogue_p invalid");
5451 if (gdbarch_debug
>= 2)
5452 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
5453 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
5457 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
5458 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
5460 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
5464 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
5466 gdb_assert (gdbarch
!= NULL
);
5467 if (gdbarch
->construct_inferior_arguments
== 0)
5468 internal_error (__FILE__
, __LINE__
,
5469 "gdbarch: gdbarch_construct_inferior_arguments invalid");
5470 if (gdbarch_debug
>= 2)
5471 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
5472 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
5476 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
5477 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
5479 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
5483 gdbarch_dwarf2_build_frame_info_p (struct gdbarch
*gdbarch
)
5485 gdb_assert (gdbarch
!= NULL
);
5486 return gdbarch
->dwarf2_build_frame_info
!= 0;
5490 gdbarch_dwarf2_build_frame_info (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
5492 gdb_assert (gdbarch
!= NULL
);
5493 if (gdbarch
->dwarf2_build_frame_info
== 0)
5494 internal_error (__FILE__
, __LINE__
,
5495 "gdbarch: gdbarch_dwarf2_build_frame_info invalid");
5496 if (gdbarch_debug
>= 2)
5497 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_build_frame_info called\n");
5498 gdbarch
->dwarf2_build_frame_info (objfile
);
5502 set_gdbarch_dwarf2_build_frame_info (struct gdbarch
*gdbarch
,
5503 gdbarch_dwarf2_build_frame_info_ftype dwarf2_build_frame_info
)
5505 gdbarch
->dwarf2_build_frame_info
= dwarf2_build_frame_info
;
5509 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
5511 gdb_assert (gdbarch
!= NULL
);
5512 if (gdbarch
->elf_make_msymbol_special
== 0)
5513 internal_error (__FILE__
, __LINE__
,
5514 "gdbarch: gdbarch_elf_make_msymbol_special invalid");
5515 if (gdbarch_debug
>= 2)
5516 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
5517 gdbarch
->elf_make_msymbol_special (sym
, msym
);
5521 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
5522 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
5524 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
5528 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
5530 gdb_assert (gdbarch
!= NULL
);
5531 if (gdbarch
->coff_make_msymbol_special
== 0)
5532 internal_error (__FILE__
, __LINE__
,
5533 "gdbarch: gdbarch_coff_make_msymbol_special invalid");
5534 if (gdbarch_debug
>= 2)
5535 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
5536 gdbarch
->coff_make_msymbol_special (val
, msym
);
5540 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
5541 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
5543 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
5547 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
5549 gdb_assert (gdbarch
!= NULL
);
5550 /* Skip verify of name_of_malloc, invalid_p == 0 */
5551 if (gdbarch_debug
>= 2)
5552 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
5553 return gdbarch
->name_of_malloc
;
5557 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
5558 const char * name_of_malloc
)
5560 gdbarch
->name_of_malloc
= name_of_malloc
;
5564 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
5566 gdb_assert (gdbarch
!= NULL
);
5567 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
5568 if (gdbarch_debug
>= 2)
5569 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
5570 return gdbarch
->cannot_step_breakpoint
;
5574 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
5575 int cannot_step_breakpoint
)
5577 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
5581 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
5583 gdb_assert (gdbarch
!= NULL
);
5584 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
5585 if (gdbarch_debug
>= 2)
5586 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
5587 return gdbarch
->have_nonsteppable_watchpoint
;
5591 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
5592 int have_nonsteppable_watchpoint
)
5594 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
5598 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
5600 gdb_assert (gdbarch
!= NULL
);
5601 return gdbarch
->address_class_type_flags
!= 0;
5605 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
5607 gdb_assert (gdbarch
!= NULL
);
5608 if (gdbarch
->address_class_type_flags
== 0)
5609 internal_error (__FILE__
, __LINE__
,
5610 "gdbarch: gdbarch_address_class_type_flags invalid");
5611 if (gdbarch_debug
>= 2)
5612 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
5613 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
5617 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
5618 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
5620 gdbarch
->address_class_type_flags
= address_class_type_flags
;
5624 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
5626 gdb_assert (gdbarch
!= NULL
);
5627 return gdbarch
->address_class_type_flags_to_name
!= 0;
5631 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
5633 gdb_assert (gdbarch
!= NULL
);
5634 if (gdbarch
->address_class_type_flags_to_name
== 0)
5635 internal_error (__FILE__
, __LINE__
,
5636 "gdbarch: gdbarch_address_class_type_flags_to_name invalid");
5637 if (gdbarch_debug
>= 2)
5638 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
5639 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
5643 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
5644 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
5646 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
5650 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
5652 gdb_assert (gdbarch
!= NULL
);
5653 return gdbarch
->address_class_name_to_type_flags
!= 0;
5657 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
5659 gdb_assert (gdbarch
!= NULL
);
5660 if (gdbarch
->address_class_name_to_type_flags
== 0)
5661 internal_error (__FILE__
, __LINE__
,
5662 "gdbarch: gdbarch_address_class_name_to_type_flags invalid");
5663 if (gdbarch_debug
>= 2)
5664 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
5665 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
5669 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
5670 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
5672 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
5676 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
5678 gdb_assert (gdbarch
!= NULL
);
5679 if (gdbarch
->register_reggroup_p
== 0)
5680 internal_error (__FILE__
, __LINE__
,
5681 "gdbarch: gdbarch_register_reggroup_p invalid");
5682 if (gdbarch_debug
>= 2)
5683 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
5684 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
5688 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
5689 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
5691 gdbarch
->register_reggroup_p
= register_reggroup_p
;
5695 /* Keep a registry of per-architecture data-pointers required by GDB
5702 gdbarch_data_init_ftype
*init
;
5703 gdbarch_data_free_ftype
*free
;
5706 struct gdbarch_data_registration
5708 struct gdbarch_data
*data
;
5709 struct gdbarch_data_registration
*next
;
5712 struct gdbarch_data_registry
5715 struct gdbarch_data_registration
*registrations
;
5718 struct gdbarch_data_registry gdbarch_data_registry
=
5723 struct gdbarch_data
*
5724 register_gdbarch_data (gdbarch_data_init_ftype
*init
,
5725 gdbarch_data_free_ftype
*free
)
5727 struct gdbarch_data_registration
**curr
;
5728 /* Append the new registraration. */
5729 for (curr
= &gdbarch_data_registry
.registrations
;
5731 curr
= &(*curr
)->next
);
5732 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
5733 (*curr
)->next
= NULL
;
5734 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
5735 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
5736 (*curr
)->data
->init
= init
;
5737 (*curr
)->data
->init_p
= 1;
5738 (*curr
)->data
->free
= free
;
5739 return (*curr
)->data
;
5743 /* Create/delete the gdbarch data vector. */
5746 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
5748 gdb_assert (gdbarch
->data
== NULL
);
5749 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
5750 gdbarch
->data
= xcalloc (gdbarch
->nr_data
, sizeof (void*));
5754 free_gdbarch_data (struct gdbarch
*gdbarch
)
5756 struct gdbarch_data_registration
*rego
;
5757 gdb_assert (gdbarch
->data
!= NULL
);
5758 for (rego
= gdbarch_data_registry
.registrations
;
5762 struct gdbarch_data
*data
= rego
->data
;
5763 gdb_assert (data
->index
< gdbarch
->nr_data
);
5764 if (data
->free
!= NULL
&& gdbarch
->data
[data
->index
] != NULL
)
5766 data
->free (gdbarch
, gdbarch
->data
[data
->index
]);
5767 gdbarch
->data
[data
->index
] = NULL
;
5770 xfree (gdbarch
->data
);
5771 gdbarch
->data
= NULL
;
5775 /* Initialize the current value of the specified per-architecture
5779 set_gdbarch_data (struct gdbarch
*gdbarch
,
5780 struct gdbarch_data
*data
,
5783 gdb_assert (data
->index
< gdbarch
->nr_data
);
5784 if (gdbarch
->data
[data
->index
] != NULL
)
5786 gdb_assert (data
->free
!= NULL
);
5787 data
->free (gdbarch
, gdbarch
->data
[data
->index
]);
5789 gdbarch
->data
[data
->index
] = pointer
;
5792 /* Return the current value of the specified per-architecture
5796 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
5798 gdb_assert (data
->index
< gdbarch
->nr_data
);
5799 /* The data-pointer isn't initialized, call init() to get a value but
5800 only if the architecture initializaiton has completed. Otherwise
5801 punt - hope that the caller knows what they are doing. */
5802 if (gdbarch
->data
[data
->index
] == NULL
5803 && gdbarch
->initialized_p
)
5805 /* Be careful to detect an initialization cycle. */
5806 gdb_assert (data
->init_p
);
5808 gdb_assert (data
->init
!= NULL
);
5809 gdbarch
->data
[data
->index
] = data
->init (gdbarch
);
5811 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
5813 return gdbarch
->data
[data
->index
];
5818 /* Keep a registry of swapped data required by GDB modules. */
5823 struct gdbarch_swap_registration
*source
;
5824 struct gdbarch_swap
*next
;
5827 struct gdbarch_swap_registration
5830 unsigned long sizeof_data
;
5831 gdbarch_swap_ftype
*init
;
5832 struct gdbarch_swap_registration
*next
;
5835 struct gdbarch_swap_registry
5838 struct gdbarch_swap_registration
*registrations
;
5841 struct gdbarch_swap_registry gdbarch_swap_registry
=
5847 register_gdbarch_swap (void *data
,
5848 unsigned long sizeof_data
,
5849 gdbarch_swap_ftype
*init
)
5851 struct gdbarch_swap_registration
**rego
;
5852 for (rego
= &gdbarch_swap_registry
.registrations
;
5854 rego
= &(*rego
)->next
);
5855 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
5856 (*rego
)->next
= NULL
;
5857 (*rego
)->init
= init
;
5858 (*rego
)->data
= data
;
5859 (*rego
)->sizeof_data
= sizeof_data
;
5863 clear_gdbarch_swap (struct gdbarch
*gdbarch
)
5865 struct gdbarch_swap
*curr
;
5866 for (curr
= gdbarch
->swap
;
5870 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
5875 init_gdbarch_swap (struct gdbarch
*gdbarch
)
5877 struct gdbarch_swap_registration
*rego
;
5878 struct gdbarch_swap
**curr
= &gdbarch
->swap
;
5879 for (rego
= gdbarch_swap_registry
.registrations
;
5883 if (rego
->data
!= NULL
)
5885 (*curr
) = XMALLOC (struct gdbarch_swap
);
5886 (*curr
)->source
= rego
;
5887 (*curr
)->swap
= xmalloc (rego
->sizeof_data
);
5888 (*curr
)->next
= NULL
;
5889 curr
= &(*curr
)->next
;
5891 if (rego
->init
!= NULL
)
5897 swapout_gdbarch_swap (struct gdbarch
*gdbarch
)
5899 struct gdbarch_swap
*curr
;
5900 for (curr
= gdbarch
->swap
;
5903 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
5907 swapin_gdbarch_swap (struct gdbarch
*gdbarch
)
5909 struct gdbarch_swap
*curr
;
5910 for (curr
= gdbarch
->swap
;
5913 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
5917 /* Keep a registry of the architectures known by GDB. */
5919 struct gdbarch_registration
5921 enum bfd_architecture bfd_architecture
;
5922 gdbarch_init_ftype
*init
;
5923 gdbarch_dump_tdep_ftype
*dump_tdep
;
5924 struct gdbarch_list
*arches
;
5925 struct gdbarch_registration
*next
;
5928 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
5931 append_name (const char ***buf
, int *nr
, const char *name
)
5933 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
5939 gdbarch_printable_names (void)
5943 /* Accumulate a list of names based on the registed list of
5945 enum bfd_architecture a
;
5947 const char **arches
= NULL
;
5948 struct gdbarch_registration
*rego
;
5949 for (rego
= gdbarch_registry
;
5953 const struct bfd_arch_info
*ap
;
5954 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
5956 internal_error (__FILE__
, __LINE__
,
5957 "gdbarch_architecture_names: multi-arch unknown");
5960 append_name (&arches
, &nr_arches
, ap
->printable_name
);
5965 append_name (&arches
, &nr_arches
, NULL
);
5969 /* Just return all the architectures that BFD knows. Assume that
5970 the legacy architecture framework supports them. */
5971 return bfd_arch_list ();
5976 gdbarch_register (enum bfd_architecture bfd_architecture
,
5977 gdbarch_init_ftype
*init
,
5978 gdbarch_dump_tdep_ftype
*dump_tdep
)
5980 struct gdbarch_registration
**curr
;
5981 const struct bfd_arch_info
*bfd_arch_info
;
5982 /* Check that BFD recognizes this architecture */
5983 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
5984 if (bfd_arch_info
== NULL
)
5986 internal_error (__FILE__
, __LINE__
,
5987 "gdbarch: Attempt to register unknown architecture (%d)",
5990 /* Check that we haven't seen this architecture before */
5991 for (curr
= &gdbarch_registry
;
5993 curr
= &(*curr
)->next
)
5995 if (bfd_architecture
== (*curr
)->bfd_architecture
)
5996 internal_error (__FILE__
, __LINE__
,
5997 "gdbarch: Duplicate registraration of architecture (%s)",
5998 bfd_arch_info
->printable_name
);
6002 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
6003 bfd_arch_info
->printable_name
,
6006 (*curr
) = XMALLOC (struct gdbarch_registration
);
6007 (*curr
)->bfd_architecture
= bfd_architecture
;
6008 (*curr
)->init
= init
;
6009 (*curr
)->dump_tdep
= dump_tdep
;
6010 (*curr
)->arches
= NULL
;
6011 (*curr
)->next
= NULL
;
6012 /* When non- multi-arch, install whatever target dump routine we've
6013 been provided - hopefully that routine has been written correctly
6014 and works regardless of multi-arch. */
6015 if (!GDB_MULTI_ARCH
&& dump_tdep
!= NULL
6016 && startup_gdbarch
.dump_tdep
== NULL
)
6017 startup_gdbarch
.dump_tdep
= dump_tdep
;
6021 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
6022 gdbarch_init_ftype
*init
)
6024 gdbarch_register (bfd_architecture
, init
, NULL
);
6028 /* Look for an architecture using gdbarch_info. Base search on only
6029 BFD_ARCH_INFO and BYTE_ORDER. */
6031 struct gdbarch_list
*
6032 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
6033 const struct gdbarch_info
*info
)
6035 for (; arches
!= NULL
; arches
= arches
->next
)
6037 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
6039 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
6041 if (info
->osabi
!= arches
->gdbarch
->osabi
)
6049 /* Update the current architecture. Return ZERO if the update request
6053 gdbarch_update_p (struct gdbarch_info info
)
6055 struct gdbarch
*new_gdbarch
;
6056 struct gdbarch
*old_gdbarch
;
6057 struct gdbarch_registration
*rego
;
6059 /* Fill in missing parts of the INFO struct using a number of
6060 sources: ``set ...''; INFOabfd supplied; existing target. */
6062 /* ``(gdb) set architecture ...'' */
6063 if (info
.bfd_arch_info
== NULL
6064 && !TARGET_ARCHITECTURE_AUTO
)
6065 info
.bfd_arch_info
= TARGET_ARCHITECTURE
;
6066 if (info
.bfd_arch_info
== NULL
6067 && info
.abfd
!= NULL
6068 && bfd_get_arch (info
.abfd
) != bfd_arch_unknown
6069 && bfd_get_arch (info
.abfd
) != bfd_arch_obscure
)
6070 info
.bfd_arch_info
= bfd_get_arch_info (info
.abfd
);
6071 if (info
.bfd_arch_info
== NULL
)
6072 info
.bfd_arch_info
= TARGET_ARCHITECTURE
;
6074 /* ``(gdb) set byte-order ...'' */
6075 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
6076 && !TARGET_BYTE_ORDER_AUTO
)
6077 info
.byte_order
= TARGET_BYTE_ORDER
;
6078 /* From the INFO struct. */
6079 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
6080 && info
.abfd
!= NULL
)
6081 info
.byte_order
= (bfd_big_endian (info
.abfd
) ? BFD_ENDIAN_BIG
6082 : bfd_little_endian (info
.abfd
) ? BFD_ENDIAN_LITTLE
6083 : BFD_ENDIAN_UNKNOWN
);
6084 /* From the current target. */
6085 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
6086 info
.byte_order
= TARGET_BYTE_ORDER
;
6088 /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi. */
6089 if (info
.osabi
== GDB_OSABI_UNINITIALIZED
)
6090 info
.osabi
= gdbarch_lookup_osabi (info
.abfd
);
6091 if (info
.osabi
== GDB_OSABI_UNINITIALIZED
)
6092 info
.osabi
= current_gdbarch
->osabi
;
6094 /* Must have found some sort of architecture. */
6095 gdb_assert (info
.bfd_arch_info
!= NULL
);
6099 fprintf_unfiltered (gdb_stdlog
,
6100 "gdbarch_update: info.bfd_arch_info %s\n",
6101 (info
.bfd_arch_info
!= NULL
6102 ? info
.bfd_arch_info
->printable_name
6104 fprintf_unfiltered (gdb_stdlog
,
6105 "gdbarch_update: info.byte_order %d (%s)\n",
6107 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
6108 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
6110 fprintf_unfiltered (gdb_stdlog
,
6111 "gdbarch_update: info.osabi %d (%s)\n",
6112 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
6113 fprintf_unfiltered (gdb_stdlog
,
6114 "gdbarch_update: info.abfd 0x%lx\n",
6116 fprintf_unfiltered (gdb_stdlog
,
6117 "gdbarch_update: info.tdep_info 0x%lx\n",
6118 (long) info
.tdep_info
);
6121 /* Find the target that knows about this architecture. */
6122 for (rego
= gdbarch_registry
;
6125 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
6130 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: No matching architecture\n");
6134 /* Swap the data belonging to the old target out setting the
6135 installed data to zero. This stops the ->init() function trying
6136 to refer to the previous architecture's global data structures. */
6137 swapout_gdbarch_swap (current_gdbarch
);
6138 clear_gdbarch_swap (current_gdbarch
);
6140 /* Save the previously selected architecture, setting the global to
6141 NULL. This stops ->init() trying to use the previous
6142 architecture's configuration. The previous architecture may not
6143 even be of the same architecture family. The most recent
6144 architecture of the same family is found at the head of the
6145 rego->arches list. */
6146 old_gdbarch
= current_gdbarch
;
6147 current_gdbarch
= NULL
;
6149 /* Ask the target for a replacement architecture. */
6150 new_gdbarch
= rego
->init (info
, rego
->arches
);
6152 /* Did the target like it? No. Reject the change and revert to the
6153 old architecture. */
6154 if (new_gdbarch
== NULL
)
6157 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Target rejected architecture\n");
6158 swapin_gdbarch_swap (old_gdbarch
);
6159 current_gdbarch
= old_gdbarch
;
6163 /* Did the architecture change? No. Oops, put the old architecture
6165 if (old_gdbarch
== new_gdbarch
)
6168 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
6170 new_gdbarch
->bfd_arch_info
->printable_name
);
6171 swapin_gdbarch_swap (old_gdbarch
);
6172 current_gdbarch
= old_gdbarch
;
6176 /* Is this a pre-existing architecture? Yes. Move it to the front
6177 of the list of architectures (keeping the list sorted Most
6178 Recently Used) and then copy it in. */
6180 struct gdbarch_list
**list
;
6181 for (list
= ®o
->arches
;
6183 list
= &(*list
)->next
)
6185 if ((*list
)->gdbarch
== new_gdbarch
)
6187 struct gdbarch_list
*this;
6189 fprintf_unfiltered (gdb_stdlog
,
6190 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
6192 new_gdbarch
->bfd_arch_info
->printable_name
);
6195 (*list
) = this->next
;
6196 /* Insert in the front. */
6197 this->next
= rego
->arches
;
6198 rego
->arches
= this;
6199 /* Copy the new architecture in. */
6200 current_gdbarch
= new_gdbarch
;
6201 swapin_gdbarch_swap (new_gdbarch
);
6202 architecture_changed_event ();
6208 /* Prepend this new architecture to the architecture list (keep the
6209 list sorted Most Recently Used). */
6211 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
6212 this->next
= rego
->arches
;
6213 this->gdbarch
= new_gdbarch
;
6214 rego
->arches
= this;
6217 /* Switch to this new architecture marking it initialized. */
6218 current_gdbarch
= new_gdbarch
;
6219 current_gdbarch
->initialized_p
= 1;
6222 fprintf_unfiltered (gdb_stdlog
,
6223 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
6225 new_gdbarch
->bfd_arch_info
->printable_name
);
6228 /* Check that the newly installed architecture is valid. Plug in
6229 any post init values. */
6230 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
6231 verify_gdbarch (new_gdbarch
);
6233 /* Initialize the per-architecture memory (swap) areas.
6234 CURRENT_GDBARCH must be update before these modules are
6236 init_gdbarch_swap (new_gdbarch
);
6238 /* Initialize the per-architecture data. CURRENT_GDBARCH
6239 must be updated before these modules are called. */
6240 architecture_changed_event ();
6243 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
6251 /* Pointer to the target-dependent disassembly function. */
6252 int (*deprecated_tm_print_insn
) (bfd_vma
, disassemble_info
*);
6254 extern void _initialize_gdbarch (void);
6257 _initialize_gdbarch (void)
6259 struct cmd_list_element
*c
;
6261 add_show_from_set (add_set_cmd ("arch",
6264 (char *)&gdbarch_debug
,
6265 "Set architecture debugging.\n\
6266 When non-zero, architecture debugging is enabled.", &setdebuglist
),
6268 c
= add_set_cmd ("archdebug",
6271 (char *)&gdbarch_debug
,
6272 "Set architecture debugging.\n\
6273 When non-zero, architecture debugging is enabled.", &setlist
);
6275 deprecate_cmd (c
, "set debug arch");
6276 deprecate_cmd (add_show_from_set (c
, &showlist
), "show debug arch");