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"
70 /* Static function declarations */
72 static void verify_gdbarch (struct gdbarch
*gdbarch
);
73 static void alloc_gdbarch_data (struct gdbarch
*);
74 static void free_gdbarch_data (struct gdbarch
*);
75 static void init_gdbarch_swap (struct gdbarch
*);
76 static void clear_gdbarch_swap (struct gdbarch
*);
77 static void swapout_gdbarch_swap (struct gdbarch
*);
78 static void swapin_gdbarch_swap (struct gdbarch
*);
80 /* Non-zero if we want to trace architecture code. */
83 #define GDBARCH_DEBUG 0
85 int gdbarch_debug
= GDBARCH_DEBUG
;
88 /* Maintain the struct gdbarch object */
92 /* Has this architecture been fully initialized? */
94 /* basic architectural information */
95 const struct bfd_arch_info
* bfd_arch_info
;
99 /* target specific vector. */
100 struct gdbarch_tdep
*tdep
;
101 gdbarch_dump_tdep_ftype
*dump_tdep
;
103 /* per-architecture data-pointers */
107 /* per-architecture swap-regions */
108 struct gdbarch_swap
*swap
;
110 /* Multi-arch values.
112 When extending this structure you must:
116 Declare set/get functions and define the corresponding
119 gdbarch_alloc(): If zero/NULL is not a suitable default,
120 initialize the new field.
122 verify_gdbarch(): Confirm that the target updated the field
125 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
128 ``startup_gdbarch()'': Append an initial value to the static
129 variable (base values on the host's c-type system).
131 get_gdbarch(): Implement the set/get functions (probably using
132 the macro's as shortcuts).
147 gdbarch_read_pc_ftype
*read_pc
;
148 gdbarch_write_pc_ftype
*write_pc
;
149 gdbarch_read_fp_ftype
*read_fp
;
150 gdbarch_read_sp_ftype
*read_sp
;
151 gdbarch_write_sp_ftype
*write_sp
;
152 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
153 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
154 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
163 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
164 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
165 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
166 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
167 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
168 gdbarch_register_name_ftype
*register_name
;
171 gdbarch_register_byte_ftype
*register_byte
;
172 gdbarch_register_raw_size_ftype
*register_raw_size
;
173 int max_register_raw_size
;
174 gdbarch_register_virtual_size_ftype
*register_virtual_size
;
175 int max_register_virtual_size
;
176 gdbarch_register_virtual_type_ftype
*register_virtual_type
;
177 gdbarch_deprecated_do_registers_info_ftype
*deprecated_do_registers_info
;
178 gdbarch_print_registers_info_ftype
*print_registers_info
;
179 gdbarch_print_float_info_ftype
*print_float_info
;
180 gdbarch_print_vector_info_ftype
*print_vector_info
;
181 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
182 gdbarch_register_bytes_ok_ftype
*register_bytes_ok
;
183 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
184 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
185 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
186 int deprecated_use_generic_dummy_frames
;
187 int call_dummy_location
;
188 gdbarch_call_dummy_address_ftype
*call_dummy_address
;
189 CORE_ADDR call_dummy_start_offset
;
190 CORE_ADDR call_dummy_breakpoint_offset
;
191 int call_dummy_breakpoint_offset_p
;
192 int call_dummy_length
;
193 gdbarch_deprecated_pc_in_call_dummy_ftype
*deprecated_pc_in_call_dummy
;
195 LONGEST
* call_dummy_words
;
196 int sizeof_call_dummy_words
;
197 int call_dummy_stack_adjust_p
;
198 int call_dummy_stack_adjust
;
199 gdbarch_fix_call_dummy_ftype
*fix_call_dummy
;
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_get_saved_register_ftype
*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_push_arguments_ftype
*push_arguments
;
216 gdbarch_push_dummy_frame_ftype
*push_dummy_frame
;
217 gdbarch_push_return_address_ftype
*push_return_address
;
218 gdbarch_pop_frame_ftype
*pop_frame
;
219 gdbarch_store_struct_return_ftype
*store_struct_return
;
220 gdbarch_extract_return_value_ftype
*extract_return_value
;
221 gdbarch_store_return_value_ftype
*store_return_value
;
222 gdbarch_deprecated_extract_return_value_ftype
*deprecated_extract_return_value
;
223 gdbarch_deprecated_store_return_value_ftype
*deprecated_store_return_value
;
224 gdbarch_extract_struct_value_address_ftype
*extract_struct_value_address
;
225 gdbarch_deprecated_extract_struct_value_address_ftype
*deprecated_extract_struct_value_address
;
226 gdbarch_use_struct_convention_ftype
*use_struct_convention
;
227 gdbarch_frame_init_saved_regs_ftype
*frame_init_saved_regs
;
228 gdbarch_init_extra_frame_info_ftype
*init_extra_frame_info
;
229 gdbarch_skip_prologue_ftype
*skip_prologue
;
230 gdbarch_prologue_frameless_p_ftype
*prologue_frameless_p
;
231 gdbarch_inner_than_ftype
*inner_than
;
232 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
233 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
234 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
235 CORE_ADDR decr_pc_after_break
;
236 gdbarch_prepare_to_proceed_ftype
*prepare_to_proceed
;
237 CORE_ADDR function_start_offset
;
238 gdbarch_remote_translate_xfer_address_ftype
*remote_translate_xfer_address
;
239 CORE_ADDR frame_args_skip
;
240 gdbarch_frameless_function_invocation_ftype
*frameless_function_invocation
;
241 gdbarch_frame_chain_ftype
*frame_chain
;
242 gdbarch_frame_chain_valid_ftype
*frame_chain_valid
;
243 gdbarch_frame_saved_pc_ftype
*frame_saved_pc
;
244 gdbarch_frame_args_address_ftype
*frame_args_address
;
245 gdbarch_frame_locals_address_ftype
*frame_locals_address
;
246 gdbarch_saved_pc_after_call_ftype
*saved_pc_after_call
;
247 gdbarch_frame_num_args_ftype
*frame_num_args
;
248 gdbarch_stack_align_ftype
*stack_align
;
249 gdbarch_frame_align_ftype
*frame_align
;
250 int extra_stack_alignment_needed
;
251 gdbarch_reg_struct_has_addr_ftype
*reg_struct_has_addr
;
252 gdbarch_save_dummy_frame_tos_ftype
*save_dummy_frame_tos
;
254 const struct floatformat
* float_format
;
255 const struct floatformat
* double_format
;
256 const struct floatformat
* long_double_format
;
257 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
258 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
259 gdbarch_smash_text_address_ftype
*smash_text_address
;
260 gdbarch_software_single_step_ftype
*software_single_step
;
261 gdbarch_print_insn_ftype
*print_insn
;
262 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
263 gdbarch_in_solib_call_trampoline_ftype
*in_solib_call_trampoline
;
264 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
265 gdbarch_pc_in_sigtramp_ftype
*pc_in_sigtramp
;
266 gdbarch_sigtramp_start_ftype
*sigtramp_start
;
267 gdbarch_sigtramp_end_ftype
*sigtramp_end
;
268 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
269 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
270 gdbarch_dwarf2_build_frame_info_ftype
*dwarf2_build_frame_info
;
271 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
272 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
273 const char * name_of_malloc
;
274 int cannot_step_breakpoint
;
275 int have_nonsteppable_watchpoint
;
276 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
277 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
278 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
279 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
283 /* The default architecture uses host values (for want of a better
286 extern const struct bfd_arch_info bfd_default_arch_struct
;
288 struct gdbarch startup_gdbarch
=
290 1, /* Always initialized. */
291 /* basic architecture information */
292 &bfd_default_arch_struct
,
295 /* target specific vector and its dump routine */
297 /*per-architecture data-pointers and swap regions */
299 /* Multi-arch values */
303 8 * sizeof (LONGEST
),
306 8 * sizeof (long double),
335 generic_register_byte
,
336 generic_register_size
,
338 generic_register_size
,
342 default_print_registers_info
,
357 generic_pc_in_call_dummy
,
432 generic_in_function_epilogue_p
,
433 construct_inferior_arguments
,
443 default_register_reggroup_p
,
444 /* startup_gdbarch() */
447 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
449 /* Do any initialization needed for a non-multiarch configuration
450 after the _initialize_MODULE functions have been run. */
452 initialize_non_multiarch (void)
454 alloc_gdbarch_data (&startup_gdbarch
);
455 /* Ensure that all swap areas are zeroed so that they again think
456 they are starting from scratch. */
457 clear_gdbarch_swap (&startup_gdbarch
);
458 init_gdbarch_swap (&startup_gdbarch
);
462 /* Create a new ``struct gdbarch'' based on information provided by
463 ``struct gdbarch_info''. */
466 gdbarch_alloc (const struct gdbarch_info
*info
,
467 struct gdbarch_tdep
*tdep
)
469 /* NOTE: The new architecture variable is named ``current_gdbarch''
470 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
471 the current local architecture and not the previous global
472 architecture. This ensures that the new architectures initial
473 values are not influenced by the previous architecture. Once
474 everything is parameterised with gdbarch, this will go away. */
475 struct gdbarch
*current_gdbarch
= XMALLOC (struct gdbarch
);
476 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
478 alloc_gdbarch_data (current_gdbarch
);
480 current_gdbarch
->tdep
= tdep
;
482 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
483 current_gdbarch
->byte_order
= info
->byte_order
;
484 current_gdbarch
->osabi
= info
->osabi
;
486 /* Force the explicit initialization of these. */
487 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
488 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
489 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
490 current_gdbarch
->long_long_bit
= 2*TARGET_LONG_BIT
;
491 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
492 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
493 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
494 current_gdbarch
->ptr_bit
= TARGET_INT_BIT
;
495 current_gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
496 current_gdbarch
->char_signed
= -1;
497 current_gdbarch
->read_pc
= generic_target_read_pc
;
498 current_gdbarch
->write_pc
= generic_target_write_pc
;
499 current_gdbarch
->read_fp
= generic_target_read_fp
;
500 current_gdbarch
->read_sp
= generic_target_read_sp
;
501 current_gdbarch
->write_sp
= generic_target_write_sp
;
502 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
503 current_gdbarch
->num_regs
= -1;
504 current_gdbarch
->sp_regnum
= -1;
505 current_gdbarch
->fp_regnum
= -1;
506 current_gdbarch
->pc_regnum
= -1;
507 current_gdbarch
->ps_regnum
= -1;
508 current_gdbarch
->fp0_regnum
= -1;
509 current_gdbarch
->npc_regnum
= -1;
510 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
511 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
512 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
513 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
514 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
515 current_gdbarch
->register_name
= legacy_register_name
;
516 current_gdbarch
->register_size
= -1;
517 current_gdbarch
->register_bytes
= -1;
518 current_gdbarch
->register_byte
= generic_register_byte
;
519 current_gdbarch
->register_raw_size
= generic_register_size
;
520 current_gdbarch
->max_register_raw_size
= -1;
521 current_gdbarch
->register_virtual_size
= generic_register_size
;
522 current_gdbarch
->max_register_virtual_size
= -1;
523 current_gdbarch
->print_registers_info
= default_print_registers_info
;
524 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
525 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
526 current_gdbarch
->cannot_store_register
= cannot_register_not
;
527 current_gdbarch
->deprecated_use_generic_dummy_frames
= 1;
528 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
529 current_gdbarch
->call_dummy_start_offset
= -1;
530 current_gdbarch
->call_dummy_breakpoint_offset
= -1;
531 current_gdbarch
->call_dummy_breakpoint_offset_p
= -1;
532 current_gdbarch
->call_dummy_length
= -1;
533 current_gdbarch
->deprecated_pc_in_call_dummy
= generic_pc_in_call_dummy
;
534 current_gdbarch
->call_dummy_p
= -1;
535 current_gdbarch
->call_dummy_words
= legacy_call_dummy_words
;
536 current_gdbarch
->sizeof_call_dummy_words
= legacy_sizeof_call_dummy_words
;
537 current_gdbarch
->call_dummy_stack_adjust_p
= -1;
538 current_gdbarch
->register_convertible
= generic_register_convertible_not
;
539 current_gdbarch
->convert_register_p
= legacy_convert_register_p
;
540 current_gdbarch
->register_to_value
= legacy_register_to_value
;
541 current_gdbarch
->value_to_register
= legacy_value_to_register
;
542 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
543 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
544 current_gdbarch
->return_value_on_stack
= generic_return_value_on_stack_not
;
545 current_gdbarch
->push_arguments
= default_push_arguments
;
546 current_gdbarch
->extract_return_value
= legacy_extract_return_value
;
547 current_gdbarch
->store_return_value
= legacy_store_return_value
;
548 current_gdbarch
->use_struct_convention
= generic_use_struct_convention
;
549 current_gdbarch
->prologue_frameless_p
= generic_prologue_frameless_p
;
550 current_gdbarch
->breakpoint_from_pc
= legacy_breakpoint_from_pc
;
551 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
552 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
553 current_gdbarch
->decr_pc_after_break
= -1;
554 current_gdbarch
->prepare_to_proceed
= default_prepare_to_proceed
;
555 current_gdbarch
->function_start_offset
= -1;
556 current_gdbarch
->remote_translate_xfer_address
= generic_remote_translate_xfer_address
;
557 current_gdbarch
->frame_args_skip
= -1;
558 current_gdbarch
->frameless_function_invocation
= generic_frameless_function_invocation_not
;
559 current_gdbarch
->frame_chain_valid
= generic_func_frame_chain_valid
;
560 current_gdbarch
->frame_args_address
= get_frame_base
;
561 current_gdbarch
->frame_locals_address
= get_frame_base
;
562 current_gdbarch
->extra_stack_alignment_needed
= 1;
563 current_gdbarch
->convert_from_func_ptr_addr
= core_addr_identity
;
564 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
565 current_gdbarch
->smash_text_address
= core_addr_identity
;
566 current_gdbarch
->print_insn
= legacy_print_insn
;
567 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
568 current_gdbarch
->in_solib_call_trampoline
= generic_in_solib_call_trampoline
;
569 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
570 current_gdbarch
->pc_in_sigtramp
= legacy_pc_in_sigtramp
;
571 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
572 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
573 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
574 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
575 current_gdbarch
->name_of_malloc
= "malloc";
576 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
577 /* gdbarch_alloc() */
579 return current_gdbarch
;
583 /* Free a gdbarch struct. This should never happen in normal
584 operation --- once you've created a gdbarch, you keep it around.
585 However, if an architecture's init function encounters an error
586 building the structure, it may need to clean up a partially
587 constructed gdbarch. */
590 gdbarch_free (struct gdbarch
*arch
)
592 gdb_assert (arch
!= NULL
);
593 free_gdbarch_data (arch
);
598 /* Ensure that all values in a GDBARCH are reasonable. */
601 verify_gdbarch (struct gdbarch
*gdbarch
)
604 struct cleanup
*cleanups
;
607 /* Only perform sanity checks on a multi-arch target. */
610 log
= mem_fileopen ();
611 cleanups
= make_cleanup_ui_file_delete (log
);
613 if (gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
614 fprintf_unfiltered (log
, "\n\tbyte-order");
615 if (gdbarch
->bfd_arch_info
== NULL
)
616 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
617 /* Check those that need to be defined for the given multi-arch level. */
618 /* Skip verify of short_bit, invalid_p == 0 */
619 /* Skip verify of int_bit, invalid_p == 0 */
620 /* Skip verify of long_bit, invalid_p == 0 */
621 /* Skip verify of long_long_bit, invalid_p == 0 */
622 /* Skip verify of float_bit, invalid_p == 0 */
623 /* Skip verify of double_bit, invalid_p == 0 */
624 /* Skip verify of long_double_bit, invalid_p == 0 */
625 /* Skip verify of ptr_bit, invalid_p == 0 */
626 if (gdbarch
->addr_bit
== 0)
627 gdbarch
->addr_bit
= TARGET_PTR_BIT
;
628 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
629 if (gdbarch
->char_signed
== -1)
630 gdbarch
->char_signed
= 1;
631 /* Skip verify of read_pc, invalid_p == 0 */
632 /* Skip verify of write_pc, invalid_p == 0 */
633 /* Skip verify of read_fp, invalid_p == 0 */
634 /* Skip verify of read_sp, invalid_p == 0 */
635 /* Skip verify of write_sp, invalid_p == 0 */
636 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
637 /* Skip verify of pseudo_register_read, has predicate */
638 /* Skip verify of pseudo_register_write, has predicate */
639 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
640 && (gdbarch
->num_regs
== -1))
641 fprintf_unfiltered (log
, "\n\tnum_regs");
642 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
643 /* Skip verify of sp_regnum, invalid_p == 0 */
644 /* Skip verify of fp_regnum, invalid_p == 0 */
645 /* Skip verify of pc_regnum, invalid_p == 0 */
646 /* Skip verify of ps_regnum, invalid_p == 0 */
647 /* Skip verify of fp0_regnum, invalid_p == 0 */
648 /* Skip verify of npc_regnum, invalid_p == 0 */
649 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
650 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
651 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
652 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
653 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
654 /* Skip verify of register_name, invalid_p == 0 */
655 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
656 && (gdbarch
->register_size
== -1))
657 fprintf_unfiltered (log
, "\n\tregister_size");
658 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
659 && (gdbarch
->register_bytes
== -1))
660 fprintf_unfiltered (log
, "\n\tregister_bytes");
661 /* Skip verify of register_byte, invalid_p == 0 */
662 /* Skip verify of register_raw_size, invalid_p == 0 */
663 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
664 && (gdbarch
->max_register_raw_size
== -1))
665 fprintf_unfiltered (log
, "\n\tmax_register_raw_size");
666 /* Skip verify of register_virtual_size, invalid_p == 0 */
667 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
668 && (gdbarch
->max_register_virtual_size
== -1))
669 fprintf_unfiltered (log
, "\n\tmax_register_virtual_size");
670 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
671 && (gdbarch
->register_virtual_type
== 0))
672 fprintf_unfiltered (log
, "\n\tregister_virtual_type");
673 /* Skip verify of deprecated_do_registers_info, has predicate */
674 /* Skip verify of print_registers_info, invalid_p == 0 */
675 /* Skip verify of print_float_info, has predicate */
676 /* Skip verify of print_vector_info, has predicate */
677 /* Skip verify of register_sim_regno, invalid_p == 0 */
678 /* Skip verify of register_bytes_ok, has predicate */
679 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
680 /* Skip verify of cannot_store_register, invalid_p == 0 */
681 /* Skip verify of get_longjmp_target, has predicate */
682 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
683 /* Skip verify of call_dummy_location, invalid_p == 0 */
684 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
685 && (gdbarch
->call_dummy_location
== AT_ENTRY_POINT
&& gdbarch
->call_dummy_address
== 0))
686 fprintf_unfiltered (log
, "\n\tcall_dummy_address");
687 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
688 && (gdbarch
->call_dummy_start_offset
== -1))
689 fprintf_unfiltered (log
, "\n\tcall_dummy_start_offset");
690 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
691 && (gdbarch
->call_dummy_breakpoint_offset_p
&& gdbarch
->call_dummy_breakpoint_offset
== -1))
692 fprintf_unfiltered (log
, "\n\tcall_dummy_breakpoint_offset");
693 if ((GDB_MULTI_ARCH
>= GDB_MULTI_ARCH_PARTIAL
)
694 && (gdbarch
->call_dummy_breakpoint_offset_p
== -1))
695 fprintf_unfiltered (log
, "\n\tcall_dummy_breakpoint_offset_p");
696 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
697 && (gdbarch
->call_dummy_length
== -1))
698 fprintf_unfiltered (log
, "\n\tcall_dummy_length");
699 /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
700 if ((GDB_MULTI_ARCH
>= GDB_MULTI_ARCH_PARTIAL
)
701 && (gdbarch
->call_dummy_p
== -1))
702 fprintf_unfiltered (log
, "\n\tcall_dummy_p");
703 /* Skip verify of call_dummy_words, invalid_p == 0 */
704 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
705 if ((GDB_MULTI_ARCH
>= GDB_MULTI_ARCH_PARTIAL
)
706 && (gdbarch
->call_dummy_stack_adjust_p
== -1))
707 fprintf_unfiltered (log
, "\n\tcall_dummy_stack_adjust_p");
708 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
709 && (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0))
710 fprintf_unfiltered (log
, "\n\tcall_dummy_stack_adjust");
711 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
712 && (gdbarch
->fix_call_dummy
== 0))
713 fprintf_unfiltered (log
, "\n\tfix_call_dummy");
714 /* Skip verify of deprecated_init_frame_pc_first, has predicate */
715 /* Skip verify of deprecated_init_frame_pc, has predicate */
716 /* Skip verify of get_saved_register, has predicate */
717 /* Skip verify of register_convertible, invalid_p == 0 */
718 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
719 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
720 /* Skip verify of convert_register_p, invalid_p == 0 */
721 /* Skip verify of register_to_value, invalid_p == 0 */
722 /* Skip verify of value_to_register, invalid_p == 0 */
723 /* Skip verify of pointer_to_address, invalid_p == 0 */
724 /* Skip verify of address_to_pointer, invalid_p == 0 */
725 /* Skip verify of integer_to_address, has predicate */
726 /* Skip verify of return_value_on_stack, invalid_p == 0 */
727 /* Skip verify of push_arguments, invalid_p == 0 */
728 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
729 && (gdbarch
->push_dummy_frame
== 0))
730 fprintf_unfiltered (log
, "\n\tpush_dummy_frame");
731 /* Skip verify of push_return_address, has predicate */
732 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
733 && (gdbarch
->pop_frame
== 0))
734 fprintf_unfiltered (log
, "\n\tpop_frame");
735 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
736 && (gdbarch
->store_struct_return
== 0))
737 fprintf_unfiltered (log
, "\n\tstore_struct_return");
738 /* Skip verify of extract_return_value, invalid_p == 0 */
739 /* Skip verify of store_return_value, invalid_p == 0 */
740 /* Skip verify of extract_struct_value_address, has predicate */
741 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
742 /* Skip verify of use_struct_convention, invalid_p == 0 */
743 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
744 && (gdbarch
->frame_init_saved_regs
== 0))
745 fprintf_unfiltered (log
, "\n\tframe_init_saved_regs");
746 /* Skip verify of init_extra_frame_info, has predicate */
747 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
748 && (gdbarch
->skip_prologue
== 0))
749 fprintf_unfiltered (log
, "\n\tskip_prologue");
750 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
751 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
752 && (gdbarch
->inner_than
== 0))
753 fprintf_unfiltered (log
, "\n\tinner_than");
754 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
755 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
756 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
757 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
758 && (gdbarch
->decr_pc_after_break
== -1))
759 fprintf_unfiltered (log
, "\n\tdecr_pc_after_break");
760 /* Skip verify of prepare_to_proceed, invalid_p == 0 */
761 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
762 && (gdbarch
->function_start_offset
== -1))
763 fprintf_unfiltered (log
, "\n\tfunction_start_offset");
764 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
765 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
766 && (gdbarch
->frame_args_skip
== -1))
767 fprintf_unfiltered (log
, "\n\tframe_args_skip");
768 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
769 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
770 && (gdbarch
->frame_chain
== 0))
771 fprintf_unfiltered (log
, "\n\tframe_chain");
772 /* Skip verify of frame_chain_valid, invalid_p == 0 */
773 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
774 && (gdbarch
->frame_saved_pc
== 0))
775 fprintf_unfiltered (log
, "\n\tframe_saved_pc");
776 /* Skip verify of frame_args_address, invalid_p == 0 */
777 /* Skip verify of frame_locals_address, invalid_p == 0 */
778 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
779 && (gdbarch
->saved_pc_after_call
== 0))
780 fprintf_unfiltered (log
, "\n\tsaved_pc_after_call");
781 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
782 && (gdbarch
->frame_num_args
== 0))
783 fprintf_unfiltered (log
, "\n\tframe_num_args");
784 /* Skip verify of stack_align, has predicate */
785 /* Skip verify of frame_align, has predicate */
786 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
787 /* Skip verify of reg_struct_has_addr, has predicate */
788 /* Skip verify of save_dummy_frame_tos, has predicate */
789 if (gdbarch
->float_format
== 0)
790 gdbarch
->float_format
= default_float_format (gdbarch
);
791 if (gdbarch
->double_format
== 0)
792 gdbarch
->double_format
= default_double_format (gdbarch
);
793 if (gdbarch
->long_double_format
== 0)
794 gdbarch
->long_double_format
= default_double_format (gdbarch
);
795 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
796 /* Skip verify of addr_bits_remove, invalid_p == 0 */
797 /* Skip verify of smash_text_address, invalid_p == 0 */
798 /* Skip verify of software_single_step, has predicate */
799 /* Skip verify of print_insn, invalid_p == 0 */
800 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
801 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
802 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
803 /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
804 /* Skip verify of sigtramp_start, has predicate */
805 /* Skip verify of sigtramp_end, has predicate */
806 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
807 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
808 /* Skip verify of dwarf2_build_frame_info, has predicate */
809 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
810 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
811 /* Skip verify of name_of_malloc, invalid_p == 0 */
812 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
813 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
814 /* Skip verify of address_class_type_flags, has predicate */
815 /* Skip verify of address_class_type_flags_to_name, has predicate */
816 /* Skip verify of address_class_name_to_type_flags, has predicate */
817 /* Skip verify of register_reggroup_p, invalid_p == 0 */
818 buf
= ui_file_xstrdup (log
, &dummy
);
819 make_cleanup (xfree
, buf
);
820 if (strlen (buf
) > 0)
821 internal_error (__FILE__
, __LINE__
,
822 "verify_gdbarch: the following are invalid ...%s",
824 do_cleanups (cleanups
);
828 /* Print out the details of the current architecture. */
830 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
831 just happens to match the global variable ``current_gdbarch''. That
832 way macros refering to that variable get the local and not the global
833 version - ulgh. Once everything is parameterised with gdbarch, this
837 gdbarch_dump (struct gdbarch
*gdbarch
, struct ui_file
*file
)
839 fprintf_unfiltered (file
,
840 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
843 fprintf_unfiltered (file
,
844 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
845 gdbarch_frame_align_p (current_gdbarch
));
847 fprintf_unfiltered (file
,
848 "gdbarch_dump: frame_align = 0x%08lx\n",
849 (long) current_gdbarch
->frame_align
);
851 fprintf_unfiltered (file
,
852 "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
853 (long) current_gdbarch
->in_function_epilogue_p
);
855 fprintf_unfiltered (file
,
856 "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
857 (long) current_gdbarch
->register_reggroup_p
);
859 fprintf_unfiltered (file
,
860 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
861 gdbarch_pseudo_register_read_p (current_gdbarch
));
863 fprintf_unfiltered (file
,
864 "gdbarch_dump: pseudo_register_read = 0x%08lx\n",
865 (long) current_gdbarch
->pseudo_register_read
);
867 fprintf_unfiltered (file
,
868 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
869 gdbarch_pseudo_register_write_p (current_gdbarch
));
871 fprintf_unfiltered (file
,
872 "gdbarch_dump: pseudo_register_write = 0x%08lx\n",
873 (long) current_gdbarch
->pseudo_register_write
);
875 fprintf_unfiltered (file
,
876 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
877 gdbarch_address_class_name_to_type_flags_p (current_gdbarch
));
879 fprintf_unfiltered (file
,
880 "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
881 (long) current_gdbarch
->address_class_name_to_type_flags
);
882 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
883 fprintf_unfiltered (file
,
884 "gdbarch_dump: %s # %s\n",
885 "ADDRESS_CLASS_TYPE_FLAGS_P()",
886 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
887 fprintf_unfiltered (file
,
888 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n",
889 ADDRESS_CLASS_TYPE_FLAGS_P ());
891 #ifdef ADDRESS_CLASS_TYPE_FLAGS
892 fprintf_unfiltered (file
,
893 "gdbarch_dump: %s # %s\n",
894 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
895 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size
, dwarf2_addr_class
)));
897 fprintf_unfiltered (file
,
898 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
899 (long) current_gdbarch
->address_class_type_flags
900 /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
903 fprintf_unfiltered (file
,
904 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
905 gdbarch_address_class_type_flags_to_name_p (current_gdbarch
));
907 fprintf_unfiltered (file
,
908 "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
909 (long) current_gdbarch
->address_class_type_flags_to_name
);
910 #ifdef ADDRESS_TO_POINTER
912 /* Macro might contain `[{}]' when not multi-arch */
913 fprintf_unfiltered (file
,
914 "gdbarch_dump: %s # %s\n",
915 "ADDRESS_TO_POINTER(type, buf, addr)",
916 XSTRING (ADDRESS_TO_POINTER (type
, buf
, addr
)));
919 fprintf_unfiltered (file
,
920 "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
921 (long) current_gdbarch
->address_to_pointer
922 /*ADDRESS_TO_POINTER ()*/);
924 #ifdef ADDR_BITS_REMOVE
925 fprintf_unfiltered (file
,
926 "gdbarch_dump: %s # %s\n",
927 "ADDR_BITS_REMOVE(addr)",
928 XSTRING (ADDR_BITS_REMOVE (addr
)));
930 fprintf_unfiltered (file
,
931 "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
932 (long) current_gdbarch
->addr_bits_remove
933 /*ADDR_BITS_REMOVE ()*/);
935 #ifdef BELIEVE_PCC_PROMOTION
936 fprintf_unfiltered (file
,
937 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
938 XSTRING (BELIEVE_PCC_PROMOTION
));
939 fprintf_unfiltered (file
,
940 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %d\n",
941 BELIEVE_PCC_PROMOTION
);
943 #ifdef BELIEVE_PCC_PROMOTION_TYPE
944 fprintf_unfiltered (file
,
945 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
946 XSTRING (BELIEVE_PCC_PROMOTION_TYPE
));
947 fprintf_unfiltered (file
,
948 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %d\n",
949 BELIEVE_PCC_PROMOTION_TYPE
);
951 #ifdef BREAKPOINT_FROM_PC
952 fprintf_unfiltered (file
,
953 "gdbarch_dump: %s # %s\n",
954 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
955 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
957 fprintf_unfiltered (file
,
958 "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
959 (long) current_gdbarch
->breakpoint_from_pc
960 /*BREAKPOINT_FROM_PC ()*/);
962 #ifdef CALL_DUMMY_ADDRESS
963 fprintf_unfiltered (file
,
964 "gdbarch_dump: %s # %s\n",
965 "CALL_DUMMY_ADDRESS()",
966 XSTRING (CALL_DUMMY_ADDRESS ()));
968 fprintf_unfiltered (file
,
969 "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n",
970 (long) current_gdbarch
->call_dummy_address
971 /*CALL_DUMMY_ADDRESS ()*/);
973 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
974 fprintf_unfiltered (file
,
975 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
976 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET
));
977 if (CALL_DUMMY_BREAKPOINT_OFFSET_P
)
978 fprintf_unfiltered (file
,
979 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
980 (long) CALL_DUMMY_BREAKPOINT_OFFSET
);
982 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
983 fprintf_unfiltered (file
,
984 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
985 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P
));
986 fprintf_unfiltered (file
,
987 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %d\n",
988 CALL_DUMMY_BREAKPOINT_OFFSET_P
);
990 #ifdef CALL_DUMMY_LENGTH
991 fprintf_unfiltered (file
,
992 "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
993 XSTRING (CALL_DUMMY_LENGTH
));
994 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
|| CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
995 fprintf_unfiltered (file
,
996 "gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
999 #ifdef CALL_DUMMY_LOCATION
1000 fprintf_unfiltered (file
,
1001 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
1002 XSTRING (CALL_DUMMY_LOCATION
));
1003 fprintf_unfiltered (file
,
1004 "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
1005 CALL_DUMMY_LOCATION
);
1008 fprintf_unfiltered (file
,
1009 "gdbarch_dump: CALL_DUMMY_P # %s\n",
1010 XSTRING (CALL_DUMMY_P
));
1011 fprintf_unfiltered (file
,
1012 "gdbarch_dump: CALL_DUMMY_P = %d\n",
1015 #ifdef CALL_DUMMY_STACK_ADJUST
1016 fprintf_unfiltered (file
,
1017 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
1018 XSTRING (CALL_DUMMY_STACK_ADJUST
));
1019 if (CALL_DUMMY_STACK_ADJUST_P
)
1020 fprintf_unfiltered (file
,
1021 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
1022 (long) CALL_DUMMY_STACK_ADJUST
);
1024 #ifdef CALL_DUMMY_STACK_ADJUST_P
1025 fprintf_unfiltered (file
,
1026 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
1027 XSTRING (CALL_DUMMY_STACK_ADJUST_P
));
1028 fprintf_unfiltered (file
,
1029 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
1030 (long) CALL_DUMMY_STACK_ADJUST_P
);
1032 #ifdef CALL_DUMMY_START_OFFSET
1033 fprintf_unfiltered (file
,
1034 "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
1035 XSTRING (CALL_DUMMY_START_OFFSET
));
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
1038 (long) CALL_DUMMY_START_OFFSET
);
1040 #ifdef CALL_DUMMY_WORDS
1041 fprintf_unfiltered (file
,
1042 "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
1043 XSTRING (CALL_DUMMY_WORDS
));
1044 fprintf_unfiltered (file
,
1045 "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
1046 (long) CALL_DUMMY_WORDS
);
1048 #ifdef CANNOT_FETCH_REGISTER
1049 fprintf_unfiltered (file
,
1050 "gdbarch_dump: %s # %s\n",
1051 "CANNOT_FETCH_REGISTER(regnum)",
1052 XSTRING (CANNOT_FETCH_REGISTER (regnum
)));
1054 fprintf_unfiltered (file
,
1055 "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
1056 (long) current_gdbarch
->cannot_fetch_register
1057 /*CANNOT_FETCH_REGISTER ()*/);
1059 #ifdef CANNOT_STEP_BREAKPOINT
1060 fprintf_unfiltered (file
,
1061 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
1062 XSTRING (CANNOT_STEP_BREAKPOINT
));
1063 fprintf_unfiltered (file
,
1064 "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n",
1065 CANNOT_STEP_BREAKPOINT
);
1067 #ifdef CANNOT_STORE_REGISTER
1068 fprintf_unfiltered (file
,
1069 "gdbarch_dump: %s # %s\n",
1070 "CANNOT_STORE_REGISTER(regnum)",
1071 XSTRING (CANNOT_STORE_REGISTER (regnum
)));
1073 fprintf_unfiltered (file
,
1074 "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
1075 (long) current_gdbarch
->cannot_store_register
1076 /*CANNOT_STORE_REGISTER ()*/);
1078 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
1080 /* Macro might contain `[{}]' when not multi-arch */
1081 fprintf_unfiltered (file
,
1082 "gdbarch_dump: %s # %s\n",
1083 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
1084 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val
, msym
)));
1087 fprintf_unfiltered (file
,
1088 "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1089 (long) current_gdbarch
->coff_make_msymbol_special
1090 /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
1093 fprintf_unfiltered (file
,
1094 "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
1095 (long) current_gdbarch
->construct_inferior_arguments
);
1096 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1097 fprintf_unfiltered (file
,
1098 "gdbarch_dump: %s # %s\n",
1099 "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
1100 XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr
)));
1102 fprintf_unfiltered (file
,
1103 "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
1104 (long) current_gdbarch
->convert_from_func_ptr_addr
1105 /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
1107 #ifdef CONVERT_REGISTER_P
1108 fprintf_unfiltered (file
,
1109 "gdbarch_dump: %s # %s\n",
1110 "CONVERT_REGISTER_P(regnum)",
1111 XSTRING (CONVERT_REGISTER_P (regnum
)));
1113 fprintf_unfiltered (file
,
1114 "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
1115 (long) current_gdbarch
->convert_register_p
1116 /*CONVERT_REGISTER_P ()*/);
1118 #ifdef DECR_PC_AFTER_BREAK
1119 fprintf_unfiltered (file
,
1120 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1121 XSTRING (DECR_PC_AFTER_BREAK
));
1122 fprintf_unfiltered (file
,
1123 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1124 (long) DECR_PC_AFTER_BREAK
);
1126 #ifdef DEPRECATED_DO_REGISTERS_INFO_P
1127 fprintf_unfiltered (file
,
1128 "gdbarch_dump: %s # %s\n",
1129 "DEPRECATED_DO_REGISTERS_INFO_P()",
1130 XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ()));
1131 fprintf_unfiltered (file
,
1132 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n",
1133 DEPRECATED_DO_REGISTERS_INFO_P ());
1135 #ifdef DEPRECATED_DO_REGISTERS_INFO
1137 /* Macro might contain `[{}]' when not multi-arch */
1138 fprintf_unfiltered (file
,
1139 "gdbarch_dump: %s # %s\n",
1140 "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
1141 XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr
, fpregs
)));
1144 fprintf_unfiltered (file
,
1145 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
1146 (long) current_gdbarch
->deprecated_do_registers_info
1147 /*DEPRECATED_DO_REGISTERS_INFO ()*/);
1149 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
1151 /* Macro might contain `[{}]' when not multi-arch */
1152 fprintf_unfiltered (file
,
1153 "gdbarch_dump: %s # %s\n",
1154 "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1155 XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type
, regbuf
, valbuf
)));
1158 fprintf_unfiltered (file
,
1159 "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1160 (long) current_gdbarch
->deprecated_extract_return_value
1161 /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
1163 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
1164 fprintf_unfiltered (file
,
1165 "gdbarch_dump: %s # %s\n",
1166 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1167 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1168 fprintf_unfiltered (file
,
1169 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1170 DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1172 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
1173 fprintf_unfiltered (file
,
1174 "gdbarch_dump: %s # %s\n",
1175 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1176 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf
)));
1178 fprintf_unfiltered (file
,
1179 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1180 (long) current_gdbarch
->deprecated_extract_struct_value_address
1181 /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1183 #ifdef DEPRECATED_INIT_FRAME_PC_P
1184 fprintf_unfiltered (file
,
1185 "gdbarch_dump: %s # %s\n",
1186 "DEPRECATED_INIT_FRAME_PC_P()",
1187 XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
1188 fprintf_unfiltered (file
,
1189 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
1190 DEPRECATED_INIT_FRAME_PC_P ());
1192 #ifdef DEPRECATED_INIT_FRAME_PC
1193 fprintf_unfiltered (file
,
1194 "gdbarch_dump: %s # %s\n",
1195 "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
1196 XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf
, prev
)));
1198 fprintf_unfiltered (file
,
1199 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
1200 (long) current_gdbarch
->deprecated_init_frame_pc
1201 /*DEPRECATED_INIT_FRAME_PC ()*/);
1203 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
1204 fprintf_unfiltered (file
,
1205 "gdbarch_dump: %s # %s\n",
1206 "DEPRECATED_INIT_FRAME_PC_FIRST_P()",
1207 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ()));
1208 fprintf_unfiltered (file
,
1209 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n",
1210 DEPRECATED_INIT_FRAME_PC_FIRST_P ());
1212 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST
1213 fprintf_unfiltered (file
,
1214 "gdbarch_dump: %s # %s\n",
1215 "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
1216 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
, prev
)));
1218 fprintf_unfiltered (file
,
1219 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
1220 (long) current_gdbarch
->deprecated_init_frame_pc_first
1221 /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
1223 #ifdef DEPRECATED_PC_IN_CALL_DUMMY_P
1224 fprintf_unfiltered (file
,
1225 "gdbarch_dump: %s # %s\n",
1226 "DEPRECATED_PC_IN_CALL_DUMMY_P()",
1227 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ()));
1228 fprintf_unfiltered (file
,
1229 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n",
1230 DEPRECATED_PC_IN_CALL_DUMMY_P ());
1232 #ifdef DEPRECATED_PC_IN_CALL_DUMMY
1233 fprintf_unfiltered (file
,
1234 "gdbarch_dump: %s # %s\n",
1235 "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1236 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc
, sp
, frame_address
)));
1238 fprintf_unfiltered (file
,
1239 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
1240 (long) current_gdbarch
->deprecated_pc_in_call_dummy
1241 /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
1243 #ifdef DEPRECATED_STORE_RETURN_VALUE
1245 /* Macro might contain `[{}]' when not multi-arch */
1246 fprintf_unfiltered (file
,
1247 "gdbarch_dump: %s # %s\n",
1248 "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
1249 XSTRING (DEPRECATED_STORE_RETURN_VALUE (type
, valbuf
)));
1252 fprintf_unfiltered (file
,
1253 "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
1254 (long) current_gdbarch
->deprecated_store_return_value
1255 /*DEPRECATED_STORE_RETURN_VALUE ()*/);
1257 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1258 fprintf_unfiltered (file
,
1259 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
1260 XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
));
1261 fprintf_unfiltered (file
,
1262 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
1263 DEPRECATED_USE_GENERIC_DUMMY_FRAMES
);
1265 #ifdef DWARF2_BUILD_FRAME_INFO_P
1266 fprintf_unfiltered (file
,
1267 "gdbarch_dump: %s # %s\n",
1268 "DWARF2_BUILD_FRAME_INFO_P()",
1269 XSTRING (DWARF2_BUILD_FRAME_INFO_P ()));
1270 fprintf_unfiltered (file
,
1271 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO_P() = %d\n",
1272 DWARF2_BUILD_FRAME_INFO_P ());
1274 #ifdef DWARF2_BUILD_FRAME_INFO
1276 /* Macro might contain `[{}]' when not multi-arch */
1277 fprintf_unfiltered (file
,
1278 "gdbarch_dump: %s # %s\n",
1279 "DWARF2_BUILD_FRAME_INFO(objfile)",
1280 XSTRING (DWARF2_BUILD_FRAME_INFO (objfile
)));
1283 fprintf_unfiltered (file
,
1284 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n",
1285 (long) current_gdbarch
->dwarf2_build_frame_info
1286 /*DWARF2_BUILD_FRAME_INFO ()*/);
1288 #ifdef DWARF2_REG_TO_REGNUM
1289 fprintf_unfiltered (file
,
1290 "gdbarch_dump: %s # %s\n",
1291 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1292 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr
)));
1294 fprintf_unfiltered (file
,
1295 "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
1296 (long) current_gdbarch
->dwarf2_reg_to_regnum
1297 /*DWARF2_REG_TO_REGNUM ()*/);
1299 #ifdef DWARF_REG_TO_REGNUM
1300 fprintf_unfiltered (file
,
1301 "gdbarch_dump: %s # %s\n",
1302 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1303 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr
)));
1305 fprintf_unfiltered (file
,
1306 "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
1307 (long) current_gdbarch
->dwarf_reg_to_regnum
1308 /*DWARF_REG_TO_REGNUM ()*/);
1310 #ifdef ECOFF_REG_TO_REGNUM
1311 fprintf_unfiltered (file
,
1312 "gdbarch_dump: %s # %s\n",
1313 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1314 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr
)));
1316 fprintf_unfiltered (file
,
1317 "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
1318 (long) current_gdbarch
->ecoff_reg_to_regnum
1319 /*ECOFF_REG_TO_REGNUM ()*/);
1321 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1323 /* Macro might contain `[{}]' when not multi-arch */
1324 fprintf_unfiltered (file
,
1325 "gdbarch_dump: %s # %s\n",
1326 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1327 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
)));
1330 fprintf_unfiltered (file
,
1331 "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1332 (long) current_gdbarch
->elf_make_msymbol_special
1333 /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
1335 #ifdef EXTRACT_RETURN_VALUE
1337 /* Macro might contain `[{}]' when not multi-arch */
1338 fprintf_unfiltered (file
,
1339 "gdbarch_dump: %s # %s\n",
1340 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1341 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
1344 fprintf_unfiltered (file
,
1345 "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1346 (long) current_gdbarch
->extract_return_value
1347 /*EXTRACT_RETURN_VALUE ()*/);
1349 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
1350 fprintf_unfiltered (file
,
1351 "gdbarch_dump: %s # %s\n",
1352 "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1353 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1354 fprintf_unfiltered (file
,
1355 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1356 EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1358 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1359 fprintf_unfiltered (file
,
1360 "gdbarch_dump: %s # %s\n",
1361 "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
1362 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
1364 fprintf_unfiltered (file
,
1365 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1366 (long) current_gdbarch
->extract_struct_value_address
1367 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1369 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1370 fprintf_unfiltered (file
,
1371 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1372 XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED
));
1373 fprintf_unfiltered (file
,
1374 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
1375 EXTRA_STACK_ALIGNMENT_NEEDED
);
1377 #ifdef FIX_CALL_DUMMY
1379 /* Macro might contain `[{}]' when not multi-arch */
1380 fprintf_unfiltered (file
,
1381 "gdbarch_dump: %s # %s\n",
1382 "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1383 XSTRING (FIX_CALL_DUMMY (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)));
1386 fprintf_unfiltered (file
,
1387 "gdbarch_dump: FIX_CALL_DUMMY = <0x%08lx>\n",
1388 (long) current_gdbarch
->fix_call_dummy
1389 /*FIX_CALL_DUMMY ()*/);
1392 fprintf_unfiltered (file
,
1393 "gdbarch_dump: FP0_REGNUM # %s\n",
1394 XSTRING (FP0_REGNUM
));
1395 fprintf_unfiltered (file
,
1396 "gdbarch_dump: FP0_REGNUM = %d\n",
1400 fprintf_unfiltered (file
,
1401 "gdbarch_dump: FP_REGNUM # %s\n",
1402 XSTRING (FP_REGNUM
));
1403 fprintf_unfiltered (file
,
1404 "gdbarch_dump: FP_REGNUM = %d\n",
1407 #ifdef FRAMELESS_FUNCTION_INVOCATION
1408 fprintf_unfiltered (file
,
1409 "gdbarch_dump: %s # %s\n",
1410 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1411 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi
)));
1413 fprintf_unfiltered (file
,
1414 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
1415 (long) current_gdbarch
->frameless_function_invocation
1416 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1418 #ifdef FRAME_ARGS_ADDRESS
1419 fprintf_unfiltered (file
,
1420 "gdbarch_dump: %s # %s\n",
1421 "FRAME_ARGS_ADDRESS(fi)",
1422 XSTRING (FRAME_ARGS_ADDRESS (fi
)));
1424 fprintf_unfiltered (file
,
1425 "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n",
1426 (long) current_gdbarch
->frame_args_address
1427 /*FRAME_ARGS_ADDRESS ()*/);
1429 #ifdef FRAME_ARGS_SKIP
1430 fprintf_unfiltered (file
,
1431 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1432 XSTRING (FRAME_ARGS_SKIP
));
1433 fprintf_unfiltered (file
,
1434 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1435 (long) FRAME_ARGS_SKIP
);
1438 fprintf_unfiltered (file
,
1439 "gdbarch_dump: %s # %s\n",
1440 "FRAME_CHAIN(frame)",
1441 XSTRING (FRAME_CHAIN (frame
)));
1443 fprintf_unfiltered (file
,
1444 "gdbarch_dump: FRAME_CHAIN = <0x%08lx>\n",
1445 (long) current_gdbarch
->frame_chain
1446 /*FRAME_CHAIN ()*/);
1448 #ifdef FRAME_CHAIN_VALID
1449 fprintf_unfiltered (file
,
1450 "gdbarch_dump: %s # %s\n",
1451 "FRAME_CHAIN_VALID(chain, thisframe)",
1452 XSTRING (FRAME_CHAIN_VALID (chain
, thisframe
)));
1454 fprintf_unfiltered (file
,
1455 "gdbarch_dump: FRAME_CHAIN_VALID = <0x%08lx>\n",
1456 (long) current_gdbarch
->frame_chain_valid
1457 /*FRAME_CHAIN_VALID ()*/);
1459 #ifdef FRAME_INIT_SAVED_REGS
1461 /* Macro might contain `[{}]' when not multi-arch */
1462 fprintf_unfiltered (file
,
1463 "gdbarch_dump: %s # %s\n",
1464 "FRAME_INIT_SAVED_REGS(frame)",
1465 XSTRING (FRAME_INIT_SAVED_REGS (frame
)));
1468 fprintf_unfiltered (file
,
1469 "gdbarch_dump: FRAME_INIT_SAVED_REGS = <0x%08lx>\n",
1470 (long) current_gdbarch
->frame_init_saved_regs
1471 /*FRAME_INIT_SAVED_REGS ()*/);
1473 #ifdef FRAME_LOCALS_ADDRESS
1474 fprintf_unfiltered (file
,
1475 "gdbarch_dump: %s # %s\n",
1476 "FRAME_LOCALS_ADDRESS(fi)",
1477 XSTRING (FRAME_LOCALS_ADDRESS (fi
)));
1479 fprintf_unfiltered (file
,
1480 "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
1481 (long) current_gdbarch
->frame_locals_address
1482 /*FRAME_LOCALS_ADDRESS ()*/);
1484 #ifdef FRAME_NUM_ARGS
1485 fprintf_unfiltered (file
,
1486 "gdbarch_dump: %s # %s\n",
1487 "FRAME_NUM_ARGS(frame)",
1488 XSTRING (FRAME_NUM_ARGS (frame
)));
1490 fprintf_unfiltered (file
,
1491 "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
1492 (long) current_gdbarch
->frame_num_args
1493 /*FRAME_NUM_ARGS ()*/);
1495 #ifdef FRAME_SAVED_PC
1496 fprintf_unfiltered (file
,
1497 "gdbarch_dump: %s # %s\n",
1498 "FRAME_SAVED_PC(fi)",
1499 XSTRING (FRAME_SAVED_PC (fi
)));
1501 fprintf_unfiltered (file
,
1502 "gdbarch_dump: FRAME_SAVED_PC = <0x%08lx>\n",
1503 (long) current_gdbarch
->frame_saved_pc
1504 /*FRAME_SAVED_PC ()*/);
1506 #ifdef FUNCTION_START_OFFSET
1507 fprintf_unfiltered (file
,
1508 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1509 XSTRING (FUNCTION_START_OFFSET
));
1510 fprintf_unfiltered (file
,
1511 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1512 (long) FUNCTION_START_OFFSET
);
1514 #ifdef GET_LONGJMP_TARGET_P
1515 fprintf_unfiltered (file
,
1516 "gdbarch_dump: %s # %s\n",
1517 "GET_LONGJMP_TARGET_P()",
1518 XSTRING (GET_LONGJMP_TARGET_P ()));
1519 fprintf_unfiltered (file
,
1520 "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n",
1521 GET_LONGJMP_TARGET_P ());
1523 #ifdef GET_LONGJMP_TARGET
1524 fprintf_unfiltered (file
,
1525 "gdbarch_dump: %s # %s\n",
1526 "GET_LONGJMP_TARGET(pc)",
1527 XSTRING (GET_LONGJMP_TARGET (pc
)));
1529 fprintf_unfiltered (file
,
1530 "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
1531 (long) current_gdbarch
->get_longjmp_target
1532 /*GET_LONGJMP_TARGET ()*/);
1534 #ifdef GET_SAVED_REGISTER_P
1535 fprintf_unfiltered (file
,
1536 "gdbarch_dump: %s # %s\n",
1537 "GET_SAVED_REGISTER_P()",
1538 XSTRING (GET_SAVED_REGISTER_P ()));
1539 fprintf_unfiltered (file
,
1540 "gdbarch_dump: GET_SAVED_REGISTER_P() = %d\n",
1541 GET_SAVED_REGISTER_P ());
1543 #ifdef GET_SAVED_REGISTER
1545 /* Macro might contain `[{}]' when not multi-arch */
1546 fprintf_unfiltered (file
,
1547 "gdbarch_dump: %s # %s\n",
1548 "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1549 XSTRING (GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)));
1552 fprintf_unfiltered (file
,
1553 "gdbarch_dump: GET_SAVED_REGISTER = <0x%08lx>\n",
1554 (long) current_gdbarch
->get_saved_register
1555 /*GET_SAVED_REGISTER ()*/);
1557 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1558 fprintf_unfiltered (file
,
1559 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1560 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT
));
1561 fprintf_unfiltered (file
,
1562 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
1563 HAVE_NONSTEPPABLE_WATCHPOINT
);
1565 #ifdef INIT_EXTRA_FRAME_INFO_P
1566 fprintf_unfiltered (file
,
1567 "gdbarch_dump: %s # %s\n",
1568 "INIT_EXTRA_FRAME_INFO_P()",
1569 XSTRING (INIT_EXTRA_FRAME_INFO_P ()));
1570 fprintf_unfiltered (file
,
1571 "gdbarch_dump: INIT_EXTRA_FRAME_INFO_P() = %d\n",
1572 INIT_EXTRA_FRAME_INFO_P ());
1574 #ifdef INIT_EXTRA_FRAME_INFO
1576 /* Macro might contain `[{}]' when not multi-arch */
1577 fprintf_unfiltered (file
,
1578 "gdbarch_dump: %s # %s\n",
1579 "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1580 XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf
, frame
)));
1583 fprintf_unfiltered (file
,
1584 "gdbarch_dump: INIT_EXTRA_FRAME_INFO = <0x%08lx>\n",
1585 (long) current_gdbarch
->init_extra_frame_info
1586 /*INIT_EXTRA_FRAME_INFO ()*/);
1589 fprintf_unfiltered (file
,
1590 "gdbarch_dump: %s # %s\n",
1591 "INNER_THAN(lhs, rhs)",
1592 XSTRING (INNER_THAN (lhs
, rhs
)));
1594 fprintf_unfiltered (file
,
1595 "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
1596 (long) current_gdbarch
->inner_than
1599 #ifdef INTEGER_TO_ADDRESS_P
1600 fprintf_unfiltered (file
,
1601 "gdbarch_dump: %s # %s\n",
1602 "INTEGER_TO_ADDRESS_P()",
1603 XSTRING (INTEGER_TO_ADDRESS_P ()));
1604 fprintf_unfiltered (file
,
1605 "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n",
1606 INTEGER_TO_ADDRESS_P ());
1608 #ifdef INTEGER_TO_ADDRESS
1609 fprintf_unfiltered (file
,
1610 "gdbarch_dump: %s # %s\n",
1611 "INTEGER_TO_ADDRESS(type, buf)",
1612 XSTRING (INTEGER_TO_ADDRESS (type
, buf
)));
1614 fprintf_unfiltered (file
,
1615 "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
1616 (long) current_gdbarch
->integer_to_address
1617 /*INTEGER_TO_ADDRESS ()*/);
1619 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1620 fprintf_unfiltered (file
,
1621 "gdbarch_dump: %s # %s\n",
1622 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1623 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc
, name
)));
1625 fprintf_unfiltered (file
,
1626 "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
1627 (long) current_gdbarch
->in_solib_call_trampoline
1628 /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1630 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1631 fprintf_unfiltered (file
,
1632 "gdbarch_dump: %s # %s\n",
1633 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1634 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc
, name
)));
1636 fprintf_unfiltered (file
,
1637 "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
1638 (long) current_gdbarch
->in_solib_return_trampoline
1639 /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
1641 #ifdef MAX_REGISTER_RAW_SIZE
1642 fprintf_unfiltered (file
,
1643 "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
1644 XSTRING (MAX_REGISTER_RAW_SIZE
));
1645 fprintf_unfiltered (file
,
1646 "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %d\n",
1647 MAX_REGISTER_RAW_SIZE
);
1649 #ifdef MAX_REGISTER_VIRTUAL_SIZE
1650 fprintf_unfiltered (file
,
1651 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1652 XSTRING (MAX_REGISTER_VIRTUAL_SIZE
));
1653 fprintf_unfiltered (file
,
1654 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %d\n",
1655 MAX_REGISTER_VIRTUAL_SIZE
);
1657 #ifdef MEMORY_INSERT_BREAKPOINT
1658 fprintf_unfiltered (file
,
1659 "gdbarch_dump: %s # %s\n",
1660 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1661 XSTRING (MEMORY_INSERT_BREAKPOINT (addr
, contents_cache
)));
1663 fprintf_unfiltered (file
,
1664 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
1665 (long) current_gdbarch
->memory_insert_breakpoint
1666 /*MEMORY_INSERT_BREAKPOINT ()*/);
1668 #ifdef MEMORY_REMOVE_BREAKPOINT
1669 fprintf_unfiltered (file
,
1670 "gdbarch_dump: %s # %s\n",
1671 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1672 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr
, contents_cache
)));
1674 fprintf_unfiltered (file
,
1675 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
1676 (long) current_gdbarch
->memory_remove_breakpoint
1677 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1679 #ifdef NAME_OF_MALLOC
1680 fprintf_unfiltered (file
,
1681 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1682 XSTRING (NAME_OF_MALLOC
));
1683 fprintf_unfiltered (file
,
1684 "gdbarch_dump: NAME_OF_MALLOC = %s\n",
1688 fprintf_unfiltered (file
,
1689 "gdbarch_dump: NPC_REGNUM # %s\n",
1690 XSTRING (NPC_REGNUM
));
1691 fprintf_unfiltered (file
,
1692 "gdbarch_dump: NPC_REGNUM = %d\n",
1695 #ifdef NUM_PSEUDO_REGS
1696 fprintf_unfiltered (file
,
1697 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1698 XSTRING (NUM_PSEUDO_REGS
));
1699 fprintf_unfiltered (file
,
1700 "gdbarch_dump: NUM_PSEUDO_REGS = %d\n",
1704 fprintf_unfiltered (file
,
1705 "gdbarch_dump: NUM_REGS # %s\n",
1706 XSTRING (NUM_REGS
));
1707 fprintf_unfiltered (file
,
1708 "gdbarch_dump: NUM_REGS = %d\n",
1711 #ifdef PARM_BOUNDARY
1712 fprintf_unfiltered (file
,
1713 "gdbarch_dump: PARM_BOUNDARY # %s\n",
1714 XSTRING (PARM_BOUNDARY
));
1715 fprintf_unfiltered (file
,
1716 "gdbarch_dump: PARM_BOUNDARY = %d\n",
1719 #ifdef PC_IN_SIGTRAMP
1720 fprintf_unfiltered (file
,
1721 "gdbarch_dump: %s # %s\n",
1722 "PC_IN_SIGTRAMP(pc, name)",
1723 XSTRING (PC_IN_SIGTRAMP (pc
, name
)));
1725 fprintf_unfiltered (file
,
1726 "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
1727 (long) current_gdbarch
->pc_in_sigtramp
1728 /*PC_IN_SIGTRAMP ()*/);
1731 fprintf_unfiltered (file
,
1732 "gdbarch_dump: PC_REGNUM # %s\n",
1733 XSTRING (PC_REGNUM
));
1734 fprintf_unfiltered (file
,
1735 "gdbarch_dump: PC_REGNUM = %d\n",
1738 #ifdef POINTER_TO_ADDRESS
1739 fprintf_unfiltered (file
,
1740 "gdbarch_dump: %s # %s\n",
1741 "POINTER_TO_ADDRESS(type, buf)",
1742 XSTRING (POINTER_TO_ADDRESS (type
, buf
)));
1744 fprintf_unfiltered (file
,
1745 "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
1746 (long) current_gdbarch
->pointer_to_address
1747 /*POINTER_TO_ADDRESS ()*/);
1751 /* Macro might contain `[{}]' when not multi-arch */
1752 fprintf_unfiltered (file
,
1753 "gdbarch_dump: %s # %s\n",
1755 XSTRING (POP_FRAME (-)));
1758 fprintf_unfiltered (file
,
1759 "gdbarch_dump: POP_FRAME = <0x%08lx>\n",
1760 (long) current_gdbarch
->pop_frame
1763 #ifdef PREPARE_TO_PROCEED
1764 fprintf_unfiltered (file
,
1765 "gdbarch_dump: %s # %s\n",
1766 "PREPARE_TO_PROCEED(select_it)",
1767 XSTRING (PREPARE_TO_PROCEED (select_it
)));
1769 fprintf_unfiltered (file
,
1770 "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n",
1771 (long) current_gdbarch
->prepare_to_proceed
1772 /*PREPARE_TO_PROCEED ()*/);
1775 fprintf_unfiltered (file
,
1776 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1777 gdbarch_print_float_info_p (current_gdbarch
));
1779 fprintf_unfiltered (file
,
1780 "gdbarch_dump: print_float_info = 0x%08lx\n",
1781 (long) current_gdbarch
->print_float_info
);
1783 fprintf_unfiltered (file
,
1784 "gdbarch_dump: print_registers_info = 0x%08lx\n",
1785 (long) current_gdbarch
->print_registers_info
);
1787 fprintf_unfiltered (file
,
1788 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1789 gdbarch_print_vector_info_p (current_gdbarch
));
1791 fprintf_unfiltered (file
,
1792 "gdbarch_dump: print_vector_info = 0x%08lx\n",
1793 (long) current_gdbarch
->print_vector_info
);
1794 #ifdef PROLOGUE_FRAMELESS_P
1795 fprintf_unfiltered (file
,
1796 "gdbarch_dump: %s # %s\n",
1797 "PROLOGUE_FRAMELESS_P(ip)",
1798 XSTRING (PROLOGUE_FRAMELESS_P (ip
)));
1800 fprintf_unfiltered (file
,
1801 "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
1802 (long) current_gdbarch
->prologue_frameless_p
1803 /*PROLOGUE_FRAMELESS_P ()*/);
1806 fprintf_unfiltered (file
,
1807 "gdbarch_dump: PS_REGNUM # %s\n",
1808 XSTRING (PS_REGNUM
));
1809 fprintf_unfiltered (file
,
1810 "gdbarch_dump: PS_REGNUM = %d\n",
1813 #ifdef PUSH_ARGUMENTS
1814 fprintf_unfiltered (file
,
1815 "gdbarch_dump: %s # %s\n",
1816 "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1817 XSTRING (PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
)));
1819 fprintf_unfiltered (file
,
1820 "gdbarch_dump: PUSH_ARGUMENTS = <0x%08lx>\n",
1821 (long) current_gdbarch
->push_arguments
1822 /*PUSH_ARGUMENTS ()*/);
1824 #ifdef PUSH_DUMMY_FRAME
1826 /* Macro might contain `[{}]' when not multi-arch */
1827 fprintf_unfiltered (file
,
1828 "gdbarch_dump: %s # %s\n",
1829 "PUSH_DUMMY_FRAME(-)",
1830 XSTRING (PUSH_DUMMY_FRAME (-)));
1833 fprintf_unfiltered (file
,
1834 "gdbarch_dump: PUSH_DUMMY_FRAME = <0x%08lx>\n",
1835 (long) current_gdbarch
->push_dummy_frame
1836 /*PUSH_DUMMY_FRAME ()*/);
1838 #ifdef PUSH_RETURN_ADDRESS_P
1839 fprintf_unfiltered (file
,
1840 "gdbarch_dump: %s # %s\n",
1841 "PUSH_RETURN_ADDRESS_P()",
1842 XSTRING (PUSH_RETURN_ADDRESS_P ()));
1843 fprintf_unfiltered (file
,
1844 "gdbarch_dump: PUSH_RETURN_ADDRESS_P() = %d\n",
1845 PUSH_RETURN_ADDRESS_P ());
1847 #ifdef PUSH_RETURN_ADDRESS
1848 fprintf_unfiltered (file
,
1849 "gdbarch_dump: %s # %s\n",
1850 "PUSH_RETURN_ADDRESS(pc, sp)",
1851 XSTRING (PUSH_RETURN_ADDRESS (pc
, sp
)));
1853 fprintf_unfiltered (file
,
1854 "gdbarch_dump: PUSH_RETURN_ADDRESS = <0x%08lx>\n",
1855 (long) current_gdbarch
->push_return_address
1856 /*PUSH_RETURN_ADDRESS ()*/);
1858 #ifdef REGISTER_BYTE
1859 fprintf_unfiltered (file
,
1860 "gdbarch_dump: %s # %s\n",
1861 "REGISTER_BYTE(reg_nr)",
1862 XSTRING (REGISTER_BYTE (reg_nr
)));
1864 fprintf_unfiltered (file
,
1865 "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
1866 (long) current_gdbarch
->register_byte
1867 /*REGISTER_BYTE ()*/);
1869 #ifdef REGISTER_BYTES
1870 fprintf_unfiltered (file
,
1871 "gdbarch_dump: REGISTER_BYTES # %s\n",
1872 XSTRING (REGISTER_BYTES
));
1873 fprintf_unfiltered (file
,
1874 "gdbarch_dump: REGISTER_BYTES = %d\n",
1877 #ifdef REGISTER_BYTES_OK_P
1878 fprintf_unfiltered (file
,
1879 "gdbarch_dump: %s # %s\n",
1880 "REGISTER_BYTES_OK_P()",
1881 XSTRING (REGISTER_BYTES_OK_P ()));
1882 fprintf_unfiltered (file
,
1883 "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n",
1884 REGISTER_BYTES_OK_P ());
1886 #ifdef REGISTER_BYTES_OK
1887 fprintf_unfiltered (file
,
1888 "gdbarch_dump: %s # %s\n",
1889 "REGISTER_BYTES_OK(nr_bytes)",
1890 XSTRING (REGISTER_BYTES_OK (nr_bytes
)));
1892 fprintf_unfiltered (file
,
1893 "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
1894 (long) current_gdbarch
->register_bytes_ok
1895 /*REGISTER_BYTES_OK ()*/);
1897 #ifdef REGISTER_CONVERTIBLE
1898 fprintf_unfiltered (file
,
1899 "gdbarch_dump: %s # %s\n",
1900 "REGISTER_CONVERTIBLE(nr)",
1901 XSTRING (REGISTER_CONVERTIBLE (nr
)));
1903 fprintf_unfiltered (file
,
1904 "gdbarch_dump: REGISTER_CONVERTIBLE = <0x%08lx>\n",
1905 (long) current_gdbarch
->register_convertible
1906 /*REGISTER_CONVERTIBLE ()*/);
1908 #ifdef REGISTER_CONVERT_TO_RAW
1910 /* Macro might contain `[{}]' when not multi-arch */
1911 fprintf_unfiltered (file
,
1912 "gdbarch_dump: %s # %s\n",
1913 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1914 XSTRING (REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
)));
1917 fprintf_unfiltered (file
,
1918 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
1919 (long) current_gdbarch
->register_convert_to_raw
1920 /*REGISTER_CONVERT_TO_RAW ()*/);
1922 #ifdef REGISTER_CONVERT_TO_VIRTUAL
1924 /* Macro might contain `[{}]' when not multi-arch */
1925 fprintf_unfiltered (file
,
1926 "gdbarch_dump: %s # %s\n",
1927 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1928 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
)));
1931 fprintf_unfiltered (file
,
1932 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
1933 (long) current_gdbarch
->register_convert_to_virtual
1934 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
1936 #ifdef REGISTER_NAME
1937 fprintf_unfiltered (file
,
1938 "gdbarch_dump: %s # %s\n",
1939 "REGISTER_NAME(regnr)",
1940 XSTRING (REGISTER_NAME (regnr
)));
1942 fprintf_unfiltered (file
,
1943 "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
1944 (long) current_gdbarch
->register_name
1945 /*REGISTER_NAME ()*/);
1947 #ifdef REGISTER_RAW_SIZE
1948 fprintf_unfiltered (file
,
1949 "gdbarch_dump: %s # %s\n",
1950 "REGISTER_RAW_SIZE(reg_nr)",
1951 XSTRING (REGISTER_RAW_SIZE (reg_nr
)));
1953 fprintf_unfiltered (file
,
1954 "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
1955 (long) current_gdbarch
->register_raw_size
1956 /*REGISTER_RAW_SIZE ()*/);
1958 #ifdef REGISTER_SIM_REGNO
1959 fprintf_unfiltered (file
,
1960 "gdbarch_dump: %s # %s\n",
1961 "REGISTER_SIM_REGNO(reg_nr)",
1962 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
1964 fprintf_unfiltered (file
,
1965 "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
1966 (long) current_gdbarch
->register_sim_regno
1967 /*REGISTER_SIM_REGNO ()*/);
1969 #ifdef REGISTER_SIZE
1970 fprintf_unfiltered (file
,
1971 "gdbarch_dump: REGISTER_SIZE # %s\n",
1972 XSTRING (REGISTER_SIZE
));
1973 fprintf_unfiltered (file
,
1974 "gdbarch_dump: REGISTER_SIZE = %d\n",
1977 #ifdef REGISTER_TO_VALUE
1979 /* Macro might contain `[{}]' when not multi-arch */
1980 fprintf_unfiltered (file
,
1981 "gdbarch_dump: %s # %s\n",
1982 "REGISTER_TO_VALUE(regnum, type, from, to)",
1983 XSTRING (REGISTER_TO_VALUE (regnum
, type
, from
, to
)));
1986 fprintf_unfiltered (file
,
1987 "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
1988 (long) current_gdbarch
->register_to_value
1989 /*REGISTER_TO_VALUE ()*/);
1991 #ifdef REGISTER_VIRTUAL_SIZE
1992 fprintf_unfiltered (file
,
1993 "gdbarch_dump: %s # %s\n",
1994 "REGISTER_VIRTUAL_SIZE(reg_nr)",
1995 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr
)));
1997 fprintf_unfiltered (file
,
1998 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
1999 (long) current_gdbarch
->register_virtual_size
2000 /*REGISTER_VIRTUAL_SIZE ()*/);
2002 #ifdef REGISTER_VIRTUAL_TYPE
2003 fprintf_unfiltered (file
,
2004 "gdbarch_dump: %s # %s\n",
2005 "REGISTER_VIRTUAL_TYPE(reg_nr)",
2006 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr
)));
2008 fprintf_unfiltered (file
,
2009 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
2010 (long) current_gdbarch
->register_virtual_type
2011 /*REGISTER_VIRTUAL_TYPE ()*/);
2013 #ifdef REG_STRUCT_HAS_ADDR_P
2014 fprintf_unfiltered (file
,
2015 "gdbarch_dump: %s # %s\n",
2016 "REG_STRUCT_HAS_ADDR_P()",
2017 XSTRING (REG_STRUCT_HAS_ADDR_P ()));
2018 fprintf_unfiltered (file
,
2019 "gdbarch_dump: REG_STRUCT_HAS_ADDR_P() = %d\n",
2020 REG_STRUCT_HAS_ADDR_P ());
2022 #ifdef REG_STRUCT_HAS_ADDR
2023 fprintf_unfiltered (file
,
2024 "gdbarch_dump: %s # %s\n",
2025 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
2026 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
2028 fprintf_unfiltered (file
,
2029 "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
2030 (long) current_gdbarch
->reg_struct_has_addr
2031 /*REG_STRUCT_HAS_ADDR ()*/);
2033 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
2035 /* Macro might contain `[{}]' when not multi-arch */
2036 fprintf_unfiltered (file
,
2037 "gdbarch_dump: %s # %s\n",
2038 "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
2039 XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr
, gdb_len
, rem_addr
, rem_len
)));
2042 fprintf_unfiltered (file
,
2043 "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = <0x%08lx>\n",
2044 (long) current_gdbarch
->remote_translate_xfer_address
2045 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
2047 #ifdef RETURN_VALUE_ON_STACK
2048 fprintf_unfiltered (file
,
2049 "gdbarch_dump: %s # %s\n",
2050 "RETURN_VALUE_ON_STACK(type)",
2051 XSTRING (RETURN_VALUE_ON_STACK (type
)));
2053 fprintf_unfiltered (file
,
2054 "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
2055 (long) current_gdbarch
->return_value_on_stack
2056 /*RETURN_VALUE_ON_STACK ()*/);
2058 #ifdef SAVED_PC_AFTER_CALL
2059 fprintf_unfiltered (file
,
2060 "gdbarch_dump: %s # %s\n",
2061 "SAVED_PC_AFTER_CALL(frame)",
2062 XSTRING (SAVED_PC_AFTER_CALL (frame
)));
2064 fprintf_unfiltered (file
,
2065 "gdbarch_dump: SAVED_PC_AFTER_CALL = <0x%08lx>\n",
2066 (long) current_gdbarch
->saved_pc_after_call
2067 /*SAVED_PC_AFTER_CALL ()*/);
2069 #ifdef SAVE_DUMMY_FRAME_TOS_P
2070 fprintf_unfiltered (file
,
2071 "gdbarch_dump: %s # %s\n",
2072 "SAVE_DUMMY_FRAME_TOS_P()",
2073 XSTRING (SAVE_DUMMY_FRAME_TOS_P ()));
2074 fprintf_unfiltered (file
,
2075 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS_P() = %d\n",
2076 SAVE_DUMMY_FRAME_TOS_P ());
2078 #ifdef SAVE_DUMMY_FRAME_TOS
2080 /* Macro might contain `[{}]' when not multi-arch */
2081 fprintf_unfiltered (file
,
2082 "gdbarch_dump: %s # %s\n",
2083 "SAVE_DUMMY_FRAME_TOS(sp)",
2084 XSTRING (SAVE_DUMMY_FRAME_TOS (sp
)));
2087 fprintf_unfiltered (file
,
2088 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
2089 (long) current_gdbarch
->save_dummy_frame_tos
2090 /*SAVE_DUMMY_FRAME_TOS ()*/);
2092 #ifdef SDB_REG_TO_REGNUM
2093 fprintf_unfiltered (file
,
2094 "gdbarch_dump: %s # %s\n",
2095 "SDB_REG_TO_REGNUM(sdb_regnr)",
2096 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
2098 fprintf_unfiltered (file
,
2099 "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
2100 (long) current_gdbarch
->sdb_reg_to_regnum
2101 /*SDB_REG_TO_REGNUM ()*/);
2103 #ifdef SIGTRAMP_END_P
2104 fprintf_unfiltered (file
,
2105 "gdbarch_dump: %s # %s\n",
2107 XSTRING (SIGTRAMP_END_P ()));
2108 fprintf_unfiltered (file
,
2109 "gdbarch_dump: SIGTRAMP_END_P() = %d\n",
2113 fprintf_unfiltered (file
,
2114 "gdbarch_dump: %s # %s\n",
2116 XSTRING (SIGTRAMP_END (pc
)));
2118 fprintf_unfiltered (file
,
2119 "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
2120 (long) current_gdbarch
->sigtramp_end
2121 /*SIGTRAMP_END ()*/);
2123 #ifdef SIGTRAMP_START_P
2124 fprintf_unfiltered (file
,
2125 "gdbarch_dump: %s # %s\n",
2126 "SIGTRAMP_START_P()",
2127 XSTRING (SIGTRAMP_START_P ()));
2128 fprintf_unfiltered (file
,
2129 "gdbarch_dump: SIGTRAMP_START_P() = %d\n",
2130 SIGTRAMP_START_P ());
2132 #ifdef SIGTRAMP_START
2133 fprintf_unfiltered (file
,
2134 "gdbarch_dump: %s # %s\n",
2135 "SIGTRAMP_START(pc)",
2136 XSTRING (SIGTRAMP_START (pc
)));
2138 fprintf_unfiltered (file
,
2139 "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
2140 (long) current_gdbarch
->sigtramp_start
2141 /*SIGTRAMP_START ()*/);
2143 #ifdef SIZEOF_CALL_DUMMY_WORDS
2144 fprintf_unfiltered (file
,
2145 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
2146 XSTRING (SIZEOF_CALL_DUMMY_WORDS
));
2147 fprintf_unfiltered (file
,
2148 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
2149 (long) SIZEOF_CALL_DUMMY_WORDS
);
2151 #ifdef SKIP_PROLOGUE
2152 fprintf_unfiltered (file
,
2153 "gdbarch_dump: %s # %s\n",
2154 "SKIP_PROLOGUE(ip)",
2155 XSTRING (SKIP_PROLOGUE (ip
)));
2157 fprintf_unfiltered (file
,
2158 "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
2159 (long) current_gdbarch
->skip_prologue
2160 /*SKIP_PROLOGUE ()*/);
2162 #ifdef SKIP_TRAMPOLINE_CODE
2163 fprintf_unfiltered (file
,
2164 "gdbarch_dump: %s # %s\n",
2165 "SKIP_TRAMPOLINE_CODE(pc)",
2166 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
2168 fprintf_unfiltered (file
,
2169 "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
2170 (long) current_gdbarch
->skip_trampoline_code
2171 /*SKIP_TRAMPOLINE_CODE ()*/);
2173 #ifdef SMASH_TEXT_ADDRESS
2174 fprintf_unfiltered (file
,
2175 "gdbarch_dump: %s # %s\n",
2176 "SMASH_TEXT_ADDRESS(addr)",
2177 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
2179 fprintf_unfiltered (file
,
2180 "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
2181 (long) current_gdbarch
->smash_text_address
2182 /*SMASH_TEXT_ADDRESS ()*/);
2184 #ifdef SOFTWARE_SINGLE_STEP_P
2185 fprintf_unfiltered (file
,
2186 "gdbarch_dump: %s # %s\n",
2187 "SOFTWARE_SINGLE_STEP_P()",
2188 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
2189 fprintf_unfiltered (file
,
2190 "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n",
2191 SOFTWARE_SINGLE_STEP_P ());
2193 #ifdef SOFTWARE_SINGLE_STEP
2195 /* Macro might contain `[{}]' when not multi-arch */
2196 fprintf_unfiltered (file
,
2197 "gdbarch_dump: %s # %s\n",
2198 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
2199 XSTRING (SOFTWARE_SINGLE_STEP (sig
, insert_breakpoints_p
)));
2202 fprintf_unfiltered (file
,
2203 "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
2204 (long) current_gdbarch
->software_single_step
2205 /*SOFTWARE_SINGLE_STEP ()*/);
2208 fprintf_unfiltered (file
,
2209 "gdbarch_dump: SP_REGNUM # %s\n",
2210 XSTRING (SP_REGNUM
));
2211 fprintf_unfiltered (file
,
2212 "gdbarch_dump: SP_REGNUM = %d\n",
2215 #ifdef STAB_REG_TO_REGNUM
2216 fprintf_unfiltered (file
,
2217 "gdbarch_dump: %s # %s\n",
2218 "STAB_REG_TO_REGNUM(stab_regnr)",
2219 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
2221 fprintf_unfiltered (file
,
2222 "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
2223 (long) current_gdbarch
->stab_reg_to_regnum
2224 /*STAB_REG_TO_REGNUM ()*/);
2226 #ifdef STACK_ALIGN_P
2227 fprintf_unfiltered (file
,
2228 "gdbarch_dump: %s # %s\n",
2230 XSTRING (STACK_ALIGN_P ()));
2231 fprintf_unfiltered (file
,
2232 "gdbarch_dump: STACK_ALIGN_P() = %d\n",
2236 fprintf_unfiltered (file
,
2237 "gdbarch_dump: %s # %s\n",
2239 XSTRING (STACK_ALIGN (sp
)));
2241 fprintf_unfiltered (file
,
2242 "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
2243 (long) current_gdbarch
->stack_align
2244 /*STACK_ALIGN ()*/);
2246 #ifdef STORE_RETURN_VALUE
2248 /* Macro might contain `[{}]' when not multi-arch */
2249 fprintf_unfiltered (file
,
2250 "gdbarch_dump: %s # %s\n",
2251 "STORE_RETURN_VALUE(type, regcache, valbuf)",
2252 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
2255 fprintf_unfiltered (file
,
2256 "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
2257 (long) current_gdbarch
->store_return_value
2258 /*STORE_RETURN_VALUE ()*/);
2260 #ifdef STORE_STRUCT_RETURN
2262 /* Macro might contain `[{}]' when not multi-arch */
2263 fprintf_unfiltered (file
,
2264 "gdbarch_dump: %s # %s\n",
2265 "STORE_STRUCT_RETURN(addr, sp)",
2266 XSTRING (STORE_STRUCT_RETURN (addr
, sp
)));
2269 fprintf_unfiltered (file
,
2270 "gdbarch_dump: STORE_STRUCT_RETURN = <0x%08lx>\n",
2271 (long) current_gdbarch
->store_struct_return
2272 /*STORE_STRUCT_RETURN ()*/);
2274 #ifdef TARGET_ADDR_BIT
2275 fprintf_unfiltered (file
,
2276 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
2277 XSTRING (TARGET_ADDR_BIT
));
2278 fprintf_unfiltered (file
,
2279 "gdbarch_dump: TARGET_ADDR_BIT = %d\n",
2282 #ifdef TARGET_ARCHITECTURE
2283 fprintf_unfiltered (file
,
2284 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
2285 XSTRING (TARGET_ARCHITECTURE
));
2286 if (TARGET_ARCHITECTURE
!= NULL
)
2287 fprintf_unfiltered (file
,
2288 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
2289 TARGET_ARCHITECTURE
->printable_name
);
2291 #ifdef TARGET_BFD_VMA_BIT
2292 fprintf_unfiltered (file
,
2293 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
2294 XSTRING (TARGET_BFD_VMA_BIT
));
2295 fprintf_unfiltered (file
,
2296 "gdbarch_dump: TARGET_BFD_VMA_BIT = %d\n",
2297 TARGET_BFD_VMA_BIT
);
2299 #ifdef TARGET_BYTE_ORDER
2300 fprintf_unfiltered (file
,
2301 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
2302 XSTRING (TARGET_BYTE_ORDER
));
2303 fprintf_unfiltered (file
,
2304 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
2305 (long) TARGET_BYTE_ORDER
);
2307 #ifdef TARGET_CHAR_SIGNED
2308 fprintf_unfiltered (file
,
2309 "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
2310 XSTRING (TARGET_CHAR_SIGNED
));
2311 fprintf_unfiltered (file
,
2312 "gdbarch_dump: TARGET_CHAR_SIGNED = %d\n",
2313 TARGET_CHAR_SIGNED
);
2315 #ifdef TARGET_DOUBLE_BIT
2316 fprintf_unfiltered (file
,
2317 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
2318 XSTRING (TARGET_DOUBLE_BIT
));
2319 fprintf_unfiltered (file
,
2320 "gdbarch_dump: TARGET_DOUBLE_BIT = %d\n",
2323 #ifdef TARGET_DOUBLE_FORMAT
2324 fprintf_unfiltered (file
,
2325 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
2326 XSTRING (TARGET_DOUBLE_FORMAT
));
2327 fprintf_unfiltered (file
,
2328 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
2329 (TARGET_DOUBLE_FORMAT
)->name
);
2331 #ifdef TARGET_FLOAT_BIT
2332 fprintf_unfiltered (file
,
2333 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
2334 XSTRING (TARGET_FLOAT_BIT
));
2335 fprintf_unfiltered (file
,
2336 "gdbarch_dump: TARGET_FLOAT_BIT = %d\n",
2339 #ifdef TARGET_FLOAT_FORMAT
2340 fprintf_unfiltered (file
,
2341 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
2342 XSTRING (TARGET_FLOAT_FORMAT
));
2343 fprintf_unfiltered (file
,
2344 "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
2345 (TARGET_FLOAT_FORMAT
)->name
);
2347 #ifdef TARGET_INT_BIT
2348 fprintf_unfiltered (file
,
2349 "gdbarch_dump: TARGET_INT_BIT # %s\n",
2350 XSTRING (TARGET_INT_BIT
));
2351 fprintf_unfiltered (file
,
2352 "gdbarch_dump: TARGET_INT_BIT = %d\n",
2355 #ifdef TARGET_LONG_BIT
2356 fprintf_unfiltered (file
,
2357 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
2358 XSTRING (TARGET_LONG_BIT
));
2359 fprintf_unfiltered (file
,
2360 "gdbarch_dump: TARGET_LONG_BIT = %d\n",
2363 #ifdef TARGET_LONG_DOUBLE_BIT
2364 fprintf_unfiltered (file
,
2365 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
2366 XSTRING (TARGET_LONG_DOUBLE_BIT
));
2367 fprintf_unfiltered (file
,
2368 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %d\n",
2369 TARGET_LONG_DOUBLE_BIT
);
2371 #ifdef TARGET_LONG_DOUBLE_FORMAT
2372 fprintf_unfiltered (file
,
2373 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
2374 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
2375 fprintf_unfiltered (file
,
2376 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
2377 (TARGET_LONG_DOUBLE_FORMAT
)->name
);
2379 #ifdef TARGET_LONG_LONG_BIT
2380 fprintf_unfiltered (file
,
2381 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
2382 XSTRING (TARGET_LONG_LONG_BIT
));
2383 fprintf_unfiltered (file
,
2384 "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
2385 TARGET_LONG_LONG_BIT
);
2388 fprintf_unfiltered (file
,
2389 "gdbarch_dump: TARGET_OSABI # %s\n",
2390 XSTRING (TARGET_OSABI
));
2391 fprintf_unfiltered (file
,
2392 "gdbarch_dump: TARGET_OSABI = %ld\n",
2393 (long) TARGET_OSABI
);
2395 #ifdef TARGET_PRINT_INSN
2396 fprintf_unfiltered (file
,
2397 "gdbarch_dump: %s # %s\n",
2398 "TARGET_PRINT_INSN(vma, info)",
2399 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
2401 fprintf_unfiltered (file
,
2402 "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
2403 (long) current_gdbarch
->print_insn
2404 /*TARGET_PRINT_INSN ()*/);
2406 #ifdef TARGET_PTR_BIT
2407 fprintf_unfiltered (file
,
2408 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
2409 XSTRING (TARGET_PTR_BIT
));
2410 fprintf_unfiltered (file
,
2411 "gdbarch_dump: TARGET_PTR_BIT = %d\n",
2414 #ifdef TARGET_READ_FP
2415 fprintf_unfiltered (file
,
2416 "gdbarch_dump: %s # %s\n",
2418 XSTRING (TARGET_READ_FP ()));
2420 fprintf_unfiltered (file
,
2421 "gdbarch_dump: TARGET_READ_FP = <0x%08lx>\n",
2422 (long) current_gdbarch
->read_fp
2423 /*TARGET_READ_FP ()*/);
2425 #ifdef TARGET_READ_PC
2426 fprintf_unfiltered (file
,
2427 "gdbarch_dump: %s # %s\n",
2428 "TARGET_READ_PC(ptid)",
2429 XSTRING (TARGET_READ_PC (ptid
)));
2431 fprintf_unfiltered (file
,
2432 "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
2433 (long) current_gdbarch
->read_pc
2434 /*TARGET_READ_PC ()*/);
2436 #ifdef TARGET_READ_SP
2437 fprintf_unfiltered (file
,
2438 "gdbarch_dump: %s # %s\n",
2440 XSTRING (TARGET_READ_SP ()));
2442 fprintf_unfiltered (file
,
2443 "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
2444 (long) current_gdbarch
->read_sp
2445 /*TARGET_READ_SP ()*/);
2447 #ifdef TARGET_SHORT_BIT
2448 fprintf_unfiltered (file
,
2449 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
2450 XSTRING (TARGET_SHORT_BIT
));
2451 fprintf_unfiltered (file
,
2452 "gdbarch_dump: TARGET_SHORT_BIT = %d\n",
2455 #ifdef TARGET_VIRTUAL_FRAME_POINTER
2457 /* Macro might contain `[{}]' when not multi-arch */
2458 fprintf_unfiltered (file
,
2459 "gdbarch_dump: %s # %s\n",
2460 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
2461 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
2464 fprintf_unfiltered (file
,
2465 "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
2466 (long) current_gdbarch
->virtual_frame_pointer
2467 /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
2469 #ifdef TARGET_WRITE_PC
2471 /* Macro might contain `[{}]' when not multi-arch */
2472 fprintf_unfiltered (file
,
2473 "gdbarch_dump: %s # %s\n",
2474 "TARGET_WRITE_PC(val, ptid)",
2475 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
2478 fprintf_unfiltered (file
,
2479 "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
2480 (long) current_gdbarch
->write_pc
2481 /*TARGET_WRITE_PC ()*/);
2483 #ifdef TARGET_WRITE_SP
2485 /* Macro might contain `[{}]' when not multi-arch */
2486 fprintf_unfiltered (file
,
2487 "gdbarch_dump: %s # %s\n",
2488 "TARGET_WRITE_SP(val)",
2489 XSTRING (TARGET_WRITE_SP (val
)));
2492 fprintf_unfiltered (file
,
2493 "gdbarch_dump: TARGET_WRITE_SP = <0x%08lx>\n",
2494 (long) current_gdbarch
->write_sp
2495 /*TARGET_WRITE_SP ()*/);
2497 #ifdef USE_STRUCT_CONVENTION
2498 fprintf_unfiltered (file
,
2499 "gdbarch_dump: %s # %s\n",
2500 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2501 XSTRING (USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
2503 fprintf_unfiltered (file
,
2504 "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
2505 (long) current_gdbarch
->use_struct_convention
2506 /*USE_STRUCT_CONVENTION ()*/);
2508 #ifdef VALUE_TO_REGISTER
2510 /* Macro might contain `[{}]' when not multi-arch */
2511 fprintf_unfiltered (file
,
2512 "gdbarch_dump: %s # %s\n",
2513 "VALUE_TO_REGISTER(type, regnum, from, to)",
2514 XSTRING (VALUE_TO_REGISTER (type
, regnum
, from
, to
)));
2517 fprintf_unfiltered (file
,
2518 "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
2519 (long) current_gdbarch
->value_to_register
2520 /*VALUE_TO_REGISTER ()*/);
2522 if (current_gdbarch
->dump_tdep
!= NULL
)
2523 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
2526 struct gdbarch_tdep
*
2527 gdbarch_tdep (struct gdbarch
*gdbarch
)
2529 if (gdbarch_debug
>= 2)
2530 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
2531 return gdbarch
->tdep
;
2535 const struct bfd_arch_info
*
2536 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
2538 gdb_assert (gdbarch
!= NULL
);
2539 if (gdbarch_debug
>= 2)
2540 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
2541 return gdbarch
->bfd_arch_info
;
2545 gdbarch_byte_order (struct gdbarch
*gdbarch
)
2547 gdb_assert (gdbarch
!= NULL
);
2548 if (gdbarch_debug
>= 2)
2549 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
2550 return gdbarch
->byte_order
;
2554 gdbarch_osabi (struct gdbarch
*gdbarch
)
2556 gdb_assert (gdbarch
!= NULL
);
2557 if (gdbarch_debug
>= 2)
2558 fprintf_unfiltered (gdb_stdlog
, "gdbarch_osabi called\n");
2559 return gdbarch
->osabi
;
2563 gdbarch_short_bit (struct gdbarch
*gdbarch
)
2565 gdb_assert (gdbarch
!= NULL
);
2566 /* Skip verify of short_bit, invalid_p == 0 */
2567 if (gdbarch_debug
>= 2)
2568 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
2569 return gdbarch
->short_bit
;
2573 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
2576 gdbarch
->short_bit
= short_bit
;
2580 gdbarch_int_bit (struct gdbarch
*gdbarch
)
2582 gdb_assert (gdbarch
!= NULL
);
2583 /* Skip verify of int_bit, invalid_p == 0 */
2584 if (gdbarch_debug
>= 2)
2585 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
2586 return gdbarch
->int_bit
;
2590 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
2593 gdbarch
->int_bit
= int_bit
;
2597 gdbarch_long_bit (struct gdbarch
*gdbarch
)
2599 gdb_assert (gdbarch
!= NULL
);
2600 /* Skip verify of long_bit, invalid_p == 0 */
2601 if (gdbarch_debug
>= 2)
2602 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
2603 return gdbarch
->long_bit
;
2607 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
2610 gdbarch
->long_bit
= long_bit
;
2614 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
2616 gdb_assert (gdbarch
!= NULL
);
2617 /* Skip verify of long_long_bit, invalid_p == 0 */
2618 if (gdbarch_debug
>= 2)
2619 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
2620 return gdbarch
->long_long_bit
;
2624 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
2627 gdbarch
->long_long_bit
= long_long_bit
;
2631 gdbarch_float_bit (struct gdbarch
*gdbarch
)
2633 gdb_assert (gdbarch
!= NULL
);
2634 /* Skip verify of float_bit, invalid_p == 0 */
2635 if (gdbarch_debug
>= 2)
2636 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
2637 return gdbarch
->float_bit
;
2641 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
2644 gdbarch
->float_bit
= float_bit
;
2648 gdbarch_double_bit (struct gdbarch
*gdbarch
)
2650 gdb_assert (gdbarch
!= NULL
);
2651 /* Skip verify of double_bit, invalid_p == 0 */
2652 if (gdbarch_debug
>= 2)
2653 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
2654 return gdbarch
->double_bit
;
2658 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
2661 gdbarch
->double_bit
= double_bit
;
2665 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
2667 gdb_assert (gdbarch
!= NULL
);
2668 /* Skip verify of long_double_bit, invalid_p == 0 */
2669 if (gdbarch_debug
>= 2)
2670 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
2671 return gdbarch
->long_double_bit
;
2675 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
2676 int long_double_bit
)
2678 gdbarch
->long_double_bit
= long_double_bit
;
2682 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
2684 gdb_assert (gdbarch
!= NULL
);
2685 /* Skip verify of ptr_bit, invalid_p == 0 */
2686 if (gdbarch_debug
>= 2)
2687 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
2688 return gdbarch
->ptr_bit
;
2692 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
2695 gdbarch
->ptr_bit
= ptr_bit
;
2699 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
2701 gdb_assert (gdbarch
!= NULL
);
2702 if (gdbarch
->addr_bit
== 0)
2703 internal_error (__FILE__
, __LINE__
,
2704 "gdbarch: gdbarch_addr_bit invalid");
2705 if (gdbarch_debug
>= 2)
2706 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
2707 return gdbarch
->addr_bit
;
2711 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
2714 gdbarch
->addr_bit
= addr_bit
;
2718 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
2720 gdb_assert (gdbarch
!= NULL
);
2721 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2722 if (gdbarch_debug
>= 2)
2723 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
2724 return gdbarch
->bfd_vma_bit
;
2728 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
2731 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
2735 gdbarch_char_signed (struct gdbarch
*gdbarch
)
2737 gdb_assert (gdbarch
!= NULL
);
2738 if (gdbarch
->char_signed
== -1)
2739 internal_error (__FILE__
, __LINE__
,
2740 "gdbarch: gdbarch_char_signed invalid");
2741 if (gdbarch_debug
>= 2)
2742 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
2743 return gdbarch
->char_signed
;
2747 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
2750 gdbarch
->char_signed
= char_signed
;
2754 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
2756 gdb_assert (gdbarch
!= NULL
);
2757 if (gdbarch
->read_pc
== 0)
2758 internal_error (__FILE__
, __LINE__
,
2759 "gdbarch: gdbarch_read_pc invalid");
2760 if (gdbarch_debug
>= 2)
2761 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
2762 return gdbarch
->read_pc (ptid
);
2766 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
2767 gdbarch_read_pc_ftype read_pc
)
2769 gdbarch
->read_pc
= read_pc
;
2773 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
2775 gdb_assert (gdbarch
!= NULL
);
2776 if (gdbarch
->write_pc
== 0)
2777 internal_error (__FILE__
, __LINE__
,
2778 "gdbarch: gdbarch_write_pc invalid");
2779 if (gdbarch_debug
>= 2)
2780 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
2781 gdbarch
->write_pc (val
, ptid
);
2785 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
2786 gdbarch_write_pc_ftype write_pc
)
2788 gdbarch
->write_pc
= write_pc
;
2792 gdbarch_read_fp (struct gdbarch
*gdbarch
)
2794 gdb_assert (gdbarch
!= NULL
);
2795 if (gdbarch
->read_fp
== 0)
2796 internal_error (__FILE__
, __LINE__
,
2797 "gdbarch: gdbarch_read_fp invalid");
2798 if (gdbarch_debug
>= 2)
2799 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_fp called\n");
2800 return gdbarch
->read_fp ();
2804 set_gdbarch_read_fp (struct gdbarch
*gdbarch
,
2805 gdbarch_read_fp_ftype read_fp
)
2807 gdbarch
->read_fp
= read_fp
;
2811 gdbarch_read_sp (struct gdbarch
*gdbarch
)
2813 gdb_assert (gdbarch
!= NULL
);
2814 if (gdbarch
->read_sp
== 0)
2815 internal_error (__FILE__
, __LINE__
,
2816 "gdbarch: gdbarch_read_sp invalid");
2817 if (gdbarch_debug
>= 2)
2818 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_sp called\n");
2819 return gdbarch
->read_sp ();
2823 set_gdbarch_read_sp (struct gdbarch
*gdbarch
,
2824 gdbarch_read_sp_ftype read_sp
)
2826 gdbarch
->read_sp
= read_sp
;
2830 gdbarch_write_sp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2832 gdb_assert (gdbarch
!= NULL
);
2833 if (gdbarch
->write_sp
== 0)
2834 internal_error (__FILE__
, __LINE__
,
2835 "gdbarch: gdbarch_write_sp invalid");
2836 if (gdbarch_debug
>= 2)
2837 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_sp called\n");
2838 gdbarch
->write_sp (val
);
2842 set_gdbarch_write_sp (struct gdbarch
*gdbarch
,
2843 gdbarch_write_sp_ftype write_sp
)
2845 gdbarch
->write_sp
= write_sp
;
2849 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
2851 gdb_assert (gdbarch
!= NULL
);
2852 if (gdbarch
->virtual_frame_pointer
== 0)
2853 internal_error (__FILE__
, __LINE__
,
2854 "gdbarch: gdbarch_virtual_frame_pointer invalid");
2855 if (gdbarch_debug
>= 2)
2856 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
2857 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
2861 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
2862 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
2864 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
2868 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
2870 gdb_assert (gdbarch
!= NULL
);
2871 return gdbarch
->pseudo_register_read
!= 0;
2875 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, void *buf
)
2877 gdb_assert (gdbarch
!= NULL
);
2878 if (gdbarch
->pseudo_register_read
== 0)
2879 internal_error (__FILE__
, __LINE__
,
2880 "gdbarch: gdbarch_pseudo_register_read invalid");
2881 if (gdbarch_debug
>= 2)
2882 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
2883 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
2887 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
2888 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
2890 gdbarch
->pseudo_register_read
= pseudo_register_read
;
2894 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
2896 gdb_assert (gdbarch
!= NULL
);
2897 return gdbarch
->pseudo_register_write
!= 0;
2901 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const void *buf
)
2903 gdb_assert (gdbarch
!= NULL
);
2904 if (gdbarch
->pseudo_register_write
== 0)
2905 internal_error (__FILE__
, __LINE__
,
2906 "gdbarch: gdbarch_pseudo_register_write invalid");
2907 if (gdbarch_debug
>= 2)
2908 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
2909 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
2913 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
2914 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
2916 gdbarch
->pseudo_register_write
= pseudo_register_write
;
2920 gdbarch_num_regs (struct gdbarch
*gdbarch
)
2922 gdb_assert (gdbarch
!= NULL
);
2923 if (gdbarch
->num_regs
== -1)
2924 internal_error (__FILE__
, __LINE__
,
2925 "gdbarch: gdbarch_num_regs invalid");
2926 if (gdbarch_debug
>= 2)
2927 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
2928 return gdbarch
->num_regs
;
2932 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
2935 gdbarch
->num_regs
= num_regs
;
2939 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
2941 gdb_assert (gdbarch
!= NULL
);
2942 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2943 if (gdbarch_debug
>= 2)
2944 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
2945 return gdbarch
->num_pseudo_regs
;
2949 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
2950 int num_pseudo_regs
)
2952 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
2956 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
2958 gdb_assert (gdbarch
!= NULL
);
2959 /* Skip verify of sp_regnum, invalid_p == 0 */
2960 if (gdbarch_debug
>= 2)
2961 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
2962 return gdbarch
->sp_regnum
;
2966 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
2969 gdbarch
->sp_regnum
= sp_regnum
;
2973 gdbarch_fp_regnum (struct gdbarch
*gdbarch
)
2975 gdb_assert (gdbarch
!= NULL
);
2976 /* Skip verify of fp_regnum, invalid_p == 0 */
2977 if (gdbarch_debug
>= 2)
2978 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp_regnum called\n");
2979 return gdbarch
->fp_regnum
;
2983 set_gdbarch_fp_regnum (struct gdbarch
*gdbarch
,
2986 gdbarch
->fp_regnum
= fp_regnum
;
2990 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
2992 gdb_assert (gdbarch
!= NULL
);
2993 /* Skip verify of pc_regnum, invalid_p == 0 */
2994 if (gdbarch_debug
>= 2)
2995 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
2996 return gdbarch
->pc_regnum
;
3000 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
3003 gdbarch
->pc_regnum
= pc_regnum
;
3007 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
3009 gdb_assert (gdbarch
!= NULL
);
3010 /* Skip verify of ps_regnum, invalid_p == 0 */
3011 if (gdbarch_debug
>= 2)
3012 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
3013 return gdbarch
->ps_regnum
;
3017 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
3020 gdbarch
->ps_regnum
= ps_regnum
;
3024 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
3026 gdb_assert (gdbarch
!= NULL
);
3027 /* Skip verify of fp0_regnum, invalid_p == 0 */
3028 if (gdbarch_debug
>= 2)
3029 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
3030 return gdbarch
->fp0_regnum
;
3034 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
3037 gdbarch
->fp0_regnum
= fp0_regnum
;
3041 gdbarch_npc_regnum (struct gdbarch
*gdbarch
)
3043 gdb_assert (gdbarch
!= NULL
);
3044 /* Skip verify of npc_regnum, invalid_p == 0 */
3045 if (gdbarch_debug
>= 2)
3046 fprintf_unfiltered (gdb_stdlog
, "gdbarch_npc_regnum called\n");
3047 return gdbarch
->npc_regnum
;
3051 set_gdbarch_npc_regnum (struct gdbarch
*gdbarch
,
3054 gdbarch
->npc_regnum
= npc_regnum
;
3058 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
3060 gdb_assert (gdbarch
!= NULL
);
3061 if (gdbarch
->stab_reg_to_regnum
== 0)
3062 internal_error (__FILE__
, __LINE__
,
3063 "gdbarch: gdbarch_stab_reg_to_regnum invalid");
3064 if (gdbarch_debug
>= 2)
3065 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
3066 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
3070 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
3071 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
3073 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
3077 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
3079 gdb_assert (gdbarch
!= NULL
);
3080 if (gdbarch
->ecoff_reg_to_regnum
== 0)
3081 internal_error (__FILE__
, __LINE__
,
3082 "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
3083 if (gdbarch_debug
>= 2)
3084 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
3085 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
3089 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
3090 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
3092 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
3096 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
3098 gdb_assert (gdbarch
!= NULL
);
3099 if (gdbarch
->dwarf_reg_to_regnum
== 0)
3100 internal_error (__FILE__
, __LINE__
,
3101 "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
3102 if (gdbarch_debug
>= 2)
3103 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
3104 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
3108 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
3109 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
3111 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
3115 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
3117 gdb_assert (gdbarch
!= NULL
);
3118 if (gdbarch
->sdb_reg_to_regnum
== 0)
3119 internal_error (__FILE__
, __LINE__
,
3120 "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
3121 if (gdbarch_debug
>= 2)
3122 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
3123 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
3127 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
3128 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
3130 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
3134 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
3136 gdb_assert (gdbarch
!= NULL
);
3137 if (gdbarch
->dwarf2_reg_to_regnum
== 0)
3138 internal_error (__FILE__
, __LINE__
,
3139 "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
3140 if (gdbarch_debug
>= 2)
3141 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
3142 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
3146 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
3147 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
3149 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
3153 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
3155 gdb_assert (gdbarch
!= NULL
);
3156 if (gdbarch
->register_name
== 0)
3157 internal_error (__FILE__
, __LINE__
,
3158 "gdbarch: gdbarch_register_name invalid");
3159 if (gdbarch_debug
>= 2)
3160 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
3161 return gdbarch
->register_name (regnr
);
3165 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
3166 gdbarch_register_name_ftype register_name
)
3168 gdbarch
->register_name
= register_name
;
3172 gdbarch_register_size (struct gdbarch
*gdbarch
)
3174 gdb_assert (gdbarch
!= NULL
);
3175 if (gdbarch
->register_size
== -1)
3176 internal_error (__FILE__
, __LINE__
,
3177 "gdbarch: gdbarch_register_size invalid");
3178 if (gdbarch_debug
>= 2)
3179 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_size called\n");
3180 return gdbarch
->register_size
;
3184 set_gdbarch_register_size (struct gdbarch
*gdbarch
,
3187 gdbarch
->register_size
= register_size
;
3191 gdbarch_register_bytes (struct gdbarch
*gdbarch
)
3193 gdb_assert (gdbarch
!= NULL
);
3194 if (gdbarch
->register_bytes
== -1)
3195 internal_error (__FILE__
, __LINE__
,
3196 "gdbarch: gdbarch_register_bytes invalid");
3197 if (gdbarch_debug
>= 2)
3198 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes called\n");
3199 return gdbarch
->register_bytes
;
3203 set_gdbarch_register_bytes (struct gdbarch
*gdbarch
,
3206 gdbarch
->register_bytes
= register_bytes
;
3210 gdbarch_register_byte (struct gdbarch
*gdbarch
, int reg_nr
)
3212 gdb_assert (gdbarch
!= NULL
);
3213 if (gdbarch
->register_byte
== 0)
3214 internal_error (__FILE__
, __LINE__
,
3215 "gdbarch: gdbarch_register_byte invalid");
3216 if (gdbarch_debug
>= 2)
3217 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_byte called\n");
3218 return gdbarch
->register_byte (reg_nr
);
3222 set_gdbarch_register_byte (struct gdbarch
*gdbarch
,
3223 gdbarch_register_byte_ftype register_byte
)
3225 gdbarch
->register_byte
= register_byte
;
3229 gdbarch_register_raw_size (struct gdbarch
*gdbarch
, int reg_nr
)
3231 gdb_assert (gdbarch
!= NULL
);
3232 if (gdbarch
->register_raw_size
== 0)
3233 internal_error (__FILE__
, __LINE__
,
3234 "gdbarch: gdbarch_register_raw_size invalid");
3235 if (gdbarch_debug
>= 2)
3236 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_raw_size called\n");
3237 return gdbarch
->register_raw_size (reg_nr
);
3241 set_gdbarch_register_raw_size (struct gdbarch
*gdbarch
,
3242 gdbarch_register_raw_size_ftype register_raw_size
)
3244 gdbarch
->register_raw_size
= register_raw_size
;
3248 gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
)
3250 gdb_assert (gdbarch
!= NULL
);
3251 if (gdbarch
->max_register_raw_size
== -1)
3252 internal_error (__FILE__
, __LINE__
,
3253 "gdbarch: gdbarch_max_register_raw_size invalid");
3254 if (gdbarch_debug
>= 2)
3255 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_raw_size called\n");
3256 return gdbarch
->max_register_raw_size
;
3260 set_gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
,
3261 int max_register_raw_size
)
3263 gdbarch
->max_register_raw_size
= max_register_raw_size
;
3267 gdbarch_register_virtual_size (struct gdbarch
*gdbarch
, int reg_nr
)
3269 gdb_assert (gdbarch
!= NULL
);
3270 if (gdbarch
->register_virtual_size
== 0)
3271 internal_error (__FILE__
, __LINE__
,
3272 "gdbarch: gdbarch_register_virtual_size invalid");
3273 if (gdbarch_debug
>= 2)
3274 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_size called\n");
3275 return gdbarch
->register_virtual_size (reg_nr
);
3279 set_gdbarch_register_virtual_size (struct gdbarch
*gdbarch
,
3280 gdbarch_register_virtual_size_ftype register_virtual_size
)
3282 gdbarch
->register_virtual_size
= register_virtual_size
;
3286 gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
)
3288 gdb_assert (gdbarch
!= NULL
);
3289 if (gdbarch
->max_register_virtual_size
== -1)
3290 internal_error (__FILE__
, __LINE__
,
3291 "gdbarch: gdbarch_max_register_virtual_size invalid");
3292 if (gdbarch_debug
>= 2)
3293 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_virtual_size called\n");
3294 return gdbarch
->max_register_virtual_size
;
3298 set_gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
,
3299 int max_register_virtual_size
)
3301 gdbarch
->max_register_virtual_size
= max_register_virtual_size
;
3305 gdbarch_register_virtual_type (struct gdbarch
*gdbarch
, int reg_nr
)
3307 gdb_assert (gdbarch
!= NULL
);
3308 if (gdbarch
->register_virtual_type
== 0)
3309 internal_error (__FILE__
, __LINE__
,
3310 "gdbarch: gdbarch_register_virtual_type invalid");
3311 if (gdbarch_debug
>= 2)
3312 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_type called\n");
3313 return gdbarch
->register_virtual_type (reg_nr
);
3317 set_gdbarch_register_virtual_type (struct gdbarch
*gdbarch
,
3318 gdbarch_register_virtual_type_ftype register_virtual_type
)
3320 gdbarch
->register_virtual_type
= register_virtual_type
;
3324 gdbarch_deprecated_do_registers_info_p (struct gdbarch
*gdbarch
)
3326 gdb_assert (gdbarch
!= NULL
);
3327 return gdbarch
->deprecated_do_registers_info
!= 0;
3331 gdbarch_deprecated_do_registers_info (struct gdbarch
*gdbarch
, int reg_nr
, int fpregs
)
3333 gdb_assert (gdbarch
!= NULL
);
3334 if (gdbarch
->deprecated_do_registers_info
== 0)
3335 internal_error (__FILE__
, __LINE__
,
3336 "gdbarch: gdbarch_deprecated_do_registers_info invalid");
3337 if (gdbarch_debug
>= 2)
3338 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_do_registers_info called\n");
3339 gdbarch
->deprecated_do_registers_info (reg_nr
, fpregs
);
3343 set_gdbarch_deprecated_do_registers_info (struct gdbarch
*gdbarch
,
3344 gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info
)
3346 gdbarch
->deprecated_do_registers_info
= deprecated_do_registers_info
;
3350 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
3352 gdb_assert (gdbarch
!= NULL
);
3353 if (gdbarch
->print_registers_info
== 0)
3354 internal_error (__FILE__
, __LINE__
,
3355 "gdbarch: gdbarch_print_registers_info invalid");
3356 if (gdbarch_debug
>= 2)
3357 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
3358 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
3362 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
3363 gdbarch_print_registers_info_ftype print_registers_info
)
3365 gdbarch
->print_registers_info
= print_registers_info
;
3369 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
3371 gdb_assert (gdbarch
!= NULL
);
3372 return gdbarch
->print_float_info
!= 0;
3376 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
3378 gdb_assert (gdbarch
!= NULL
);
3379 if (gdbarch
->print_float_info
== 0)
3380 internal_error (__FILE__
, __LINE__
,
3381 "gdbarch: gdbarch_print_float_info invalid");
3382 if (gdbarch_debug
>= 2)
3383 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
3384 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
3388 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
3389 gdbarch_print_float_info_ftype print_float_info
)
3391 gdbarch
->print_float_info
= print_float_info
;
3395 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
3397 gdb_assert (gdbarch
!= NULL
);
3398 return gdbarch
->print_vector_info
!= 0;
3402 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
3404 gdb_assert (gdbarch
!= NULL
);
3405 if (gdbarch
->print_vector_info
== 0)
3406 internal_error (__FILE__
, __LINE__
,
3407 "gdbarch: gdbarch_print_vector_info invalid");
3408 if (gdbarch_debug
>= 2)
3409 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
3410 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
3414 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
3415 gdbarch_print_vector_info_ftype print_vector_info
)
3417 gdbarch
->print_vector_info
= print_vector_info
;
3421 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
3423 gdb_assert (gdbarch
!= NULL
);
3424 if (gdbarch
->register_sim_regno
== 0)
3425 internal_error (__FILE__
, __LINE__
,
3426 "gdbarch: gdbarch_register_sim_regno invalid");
3427 if (gdbarch_debug
>= 2)
3428 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
3429 return gdbarch
->register_sim_regno (reg_nr
);
3433 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
3434 gdbarch_register_sim_regno_ftype register_sim_regno
)
3436 gdbarch
->register_sim_regno
= register_sim_regno
;
3440 gdbarch_register_bytes_ok_p (struct gdbarch
*gdbarch
)
3442 gdb_assert (gdbarch
!= NULL
);
3443 return gdbarch
->register_bytes_ok
!= 0;
3447 gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
, long nr_bytes
)
3449 gdb_assert (gdbarch
!= NULL
);
3450 if (gdbarch
->register_bytes_ok
== 0)
3451 internal_error (__FILE__
, __LINE__
,
3452 "gdbarch: gdbarch_register_bytes_ok invalid");
3453 if (gdbarch_debug
>= 2)
3454 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes_ok called\n");
3455 return gdbarch
->register_bytes_ok (nr_bytes
);
3459 set_gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
,
3460 gdbarch_register_bytes_ok_ftype register_bytes_ok
)
3462 gdbarch
->register_bytes_ok
= register_bytes_ok
;
3466 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
3468 gdb_assert (gdbarch
!= NULL
);
3469 if (gdbarch
->cannot_fetch_register
== 0)
3470 internal_error (__FILE__
, __LINE__
,
3471 "gdbarch: gdbarch_cannot_fetch_register invalid");
3472 if (gdbarch_debug
>= 2)
3473 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
3474 return gdbarch
->cannot_fetch_register (regnum
);
3478 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
3479 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
3481 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
3485 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
3487 gdb_assert (gdbarch
!= NULL
);
3488 if (gdbarch
->cannot_store_register
== 0)
3489 internal_error (__FILE__
, __LINE__
,
3490 "gdbarch: gdbarch_cannot_store_register invalid");
3491 if (gdbarch_debug
>= 2)
3492 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
3493 return gdbarch
->cannot_store_register (regnum
);
3497 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
3498 gdbarch_cannot_store_register_ftype cannot_store_register
)
3500 gdbarch
->cannot_store_register
= cannot_store_register
;
3504 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
3506 gdb_assert (gdbarch
!= NULL
);
3507 return gdbarch
->get_longjmp_target
!= 0;
3511 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
3513 gdb_assert (gdbarch
!= NULL
);
3514 if (gdbarch
->get_longjmp_target
== 0)
3515 internal_error (__FILE__
, __LINE__
,
3516 "gdbarch: gdbarch_get_longjmp_target invalid");
3517 if (gdbarch_debug
>= 2)
3518 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
3519 return gdbarch
->get_longjmp_target (pc
);
3523 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
3524 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
3526 gdbarch
->get_longjmp_target
= get_longjmp_target
;
3530 gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch
*gdbarch
)
3532 gdb_assert (gdbarch
!= NULL
);
3533 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
3534 if (gdbarch_debug
>= 2)
3535 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_generic_dummy_frames called\n");
3536 return gdbarch
->deprecated_use_generic_dummy_frames
;
3540 set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch
*gdbarch
,
3541 int deprecated_use_generic_dummy_frames
)
3543 gdbarch
->deprecated_use_generic_dummy_frames
= deprecated_use_generic_dummy_frames
;
3547 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
3549 gdb_assert (gdbarch
!= NULL
);
3550 /* Skip verify of call_dummy_location, invalid_p == 0 */
3551 if (gdbarch_debug
>= 2)
3552 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
3553 return gdbarch
->call_dummy_location
;
3557 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
3558 int call_dummy_location
)
3560 gdbarch
->call_dummy_location
= call_dummy_location
;
3564 gdbarch_call_dummy_address (struct gdbarch
*gdbarch
)
3566 gdb_assert (gdbarch
!= NULL
);
3567 if (gdbarch
->call_dummy_address
== 0)
3568 internal_error (__FILE__
, __LINE__
,
3569 "gdbarch: gdbarch_call_dummy_address invalid");
3570 if (gdbarch_debug
>= 2)
3571 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_address called\n");
3572 return gdbarch
->call_dummy_address ();
3576 set_gdbarch_call_dummy_address (struct gdbarch
*gdbarch
,
3577 gdbarch_call_dummy_address_ftype call_dummy_address
)
3579 gdbarch
->call_dummy_address
= call_dummy_address
;
3583 gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
)
3585 gdb_assert (gdbarch
!= NULL
);
3586 if (gdbarch
->call_dummy_start_offset
== -1)
3587 internal_error (__FILE__
, __LINE__
,
3588 "gdbarch: gdbarch_call_dummy_start_offset invalid");
3589 if (gdbarch_debug
>= 2)
3590 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_start_offset called\n");
3591 return gdbarch
->call_dummy_start_offset
;
3595 set_gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
,
3596 CORE_ADDR call_dummy_start_offset
)
3598 gdbarch
->call_dummy_start_offset
= call_dummy_start_offset
;
3602 gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
)
3604 gdb_assert (gdbarch
!= NULL
);
3605 if (gdbarch
->call_dummy_breakpoint_offset_p
&& gdbarch
->call_dummy_breakpoint_offset
== -1)
3606 internal_error (__FILE__
, __LINE__
,
3607 "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
3608 if (gdbarch_debug
>= 2)
3609 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset called\n");
3610 return gdbarch
->call_dummy_breakpoint_offset
;
3614 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
,
3615 CORE_ADDR call_dummy_breakpoint_offset
)
3617 gdbarch
->call_dummy_breakpoint_offset
= call_dummy_breakpoint_offset
;
3621 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
)
3623 gdb_assert (gdbarch
!= NULL
);
3624 if (gdbarch
->call_dummy_breakpoint_offset_p
== -1)
3625 internal_error (__FILE__
, __LINE__
,
3626 "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
3627 if (gdbarch_debug
>= 2)
3628 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset_p called\n");
3629 return gdbarch
->call_dummy_breakpoint_offset_p
;
3633 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
,
3634 int call_dummy_breakpoint_offset_p
)
3636 gdbarch
->call_dummy_breakpoint_offset_p
= call_dummy_breakpoint_offset_p
;
3640 gdbarch_call_dummy_length (struct gdbarch
*gdbarch
)
3642 gdb_assert (gdbarch
!= NULL
);
3643 if (gdbarch
->call_dummy_length
== -1)
3644 internal_error (__FILE__
, __LINE__
,
3645 "gdbarch: gdbarch_call_dummy_length invalid");
3646 if (gdbarch_debug
>= 2)
3647 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_length called\n");
3648 return gdbarch
->call_dummy_length
;
3652 set_gdbarch_call_dummy_length (struct gdbarch
*gdbarch
,
3653 int call_dummy_length
)
3655 gdbarch
->call_dummy_length
= call_dummy_length
;
3659 gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch
*gdbarch
)
3661 gdb_assert (gdbarch
!= NULL
);
3662 return gdbarch
->deprecated_pc_in_call_dummy
!= generic_pc_in_call_dummy
;
3666 gdbarch_deprecated_pc_in_call_dummy (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
3668 gdb_assert (gdbarch
!= NULL
);
3669 if (gdbarch
->deprecated_pc_in_call_dummy
== 0)
3670 internal_error (__FILE__
, __LINE__
,
3671 "gdbarch: gdbarch_deprecated_pc_in_call_dummy invalid");
3672 /* Ignore predicate (gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy). */
3673 if (gdbarch_debug
>= 2)
3674 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_pc_in_call_dummy called\n");
3675 return gdbarch
->deprecated_pc_in_call_dummy (pc
, sp
, frame_address
);
3679 set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch
*gdbarch
,
3680 gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy
)
3682 gdbarch
->deprecated_pc_in_call_dummy
= deprecated_pc_in_call_dummy
;
3686 gdbarch_call_dummy_p (struct gdbarch
*gdbarch
)
3688 gdb_assert (gdbarch
!= NULL
);
3689 if (gdbarch
->call_dummy_p
== -1)
3690 internal_error (__FILE__
, __LINE__
,
3691 "gdbarch: gdbarch_call_dummy_p invalid");
3692 if (gdbarch_debug
>= 2)
3693 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_p called\n");
3694 return gdbarch
->call_dummy_p
;
3698 set_gdbarch_call_dummy_p (struct gdbarch
*gdbarch
,
3701 gdbarch
->call_dummy_p
= call_dummy_p
;
3705 gdbarch_call_dummy_words (struct gdbarch
*gdbarch
)
3707 gdb_assert (gdbarch
!= NULL
);
3708 /* Skip verify of call_dummy_words, invalid_p == 0 */
3709 if (gdbarch_debug
>= 2)
3710 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_words called\n");
3711 return gdbarch
->call_dummy_words
;
3715 set_gdbarch_call_dummy_words (struct gdbarch
*gdbarch
,
3716 LONGEST
* call_dummy_words
)
3718 gdbarch
->call_dummy_words
= call_dummy_words
;
3722 gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
)
3724 gdb_assert (gdbarch
!= NULL
);
3725 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
3726 if (gdbarch_debug
>= 2)
3727 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sizeof_call_dummy_words called\n");
3728 return gdbarch
->sizeof_call_dummy_words
;
3732 set_gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
,
3733 int sizeof_call_dummy_words
)
3735 gdbarch
->sizeof_call_dummy_words
= sizeof_call_dummy_words
;
3739 gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
)
3741 gdb_assert (gdbarch
!= NULL
);
3742 if (gdbarch
->call_dummy_stack_adjust_p
== -1)
3743 internal_error (__FILE__
, __LINE__
,
3744 "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
3745 if (gdbarch_debug
>= 2)
3746 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust_p called\n");
3747 return gdbarch
->call_dummy_stack_adjust_p
;
3751 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
,
3752 int call_dummy_stack_adjust_p
)
3754 gdbarch
->call_dummy_stack_adjust_p
= call_dummy_stack_adjust_p
;
3758 gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
)
3760 gdb_assert (gdbarch
!= NULL
);
3761 if (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0)
3762 internal_error (__FILE__
, __LINE__
,
3763 "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
3764 if (gdbarch_debug
>= 2)
3765 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust called\n");
3766 return gdbarch
->call_dummy_stack_adjust
;
3770 set_gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
,
3771 int call_dummy_stack_adjust
)
3773 gdbarch
->call_dummy_stack_adjust
= call_dummy_stack_adjust
;
3777 gdbarch_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
)
3779 gdb_assert (gdbarch
!= NULL
);
3780 if (gdbarch
->fix_call_dummy
== 0)
3781 internal_error (__FILE__
, __LINE__
,
3782 "gdbarch: gdbarch_fix_call_dummy invalid");
3783 if (gdbarch_debug
>= 2)
3784 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fix_call_dummy called\n");
3785 gdbarch
->fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
);
3789 set_gdbarch_fix_call_dummy (struct gdbarch
*gdbarch
,
3790 gdbarch_fix_call_dummy_ftype fix_call_dummy
)
3792 gdbarch
->fix_call_dummy
= fix_call_dummy
;
3796 gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch
*gdbarch
)
3798 gdb_assert (gdbarch
!= NULL
);
3799 return gdbarch
->deprecated_init_frame_pc_first
!= 0;
3803 gdbarch_deprecated_init_frame_pc_first (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*prev
)
3805 gdb_assert (gdbarch
!= NULL
);
3806 if (gdbarch
->deprecated_init_frame_pc_first
== 0)
3807 internal_error (__FILE__
, __LINE__
,
3808 "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid");
3809 if (gdbarch_debug
>= 2)
3810 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_init_frame_pc_first called\n");
3811 return gdbarch
->deprecated_init_frame_pc_first (fromleaf
, prev
);
3815 set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch
*gdbarch
,
3816 gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first
)
3818 gdbarch
->deprecated_init_frame_pc_first
= deprecated_init_frame_pc_first
;
3822 gdbarch_deprecated_init_frame_pc_p (struct gdbarch
*gdbarch
)
3824 gdb_assert (gdbarch
!= NULL
);
3825 return gdbarch
->deprecated_init_frame_pc
!= 0;
3829 gdbarch_deprecated_init_frame_pc (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*prev
)
3831 gdb_assert (gdbarch
!= NULL
);
3832 if (gdbarch
->deprecated_init_frame_pc
== 0)
3833 internal_error (__FILE__
, __LINE__
,
3834 "gdbarch: gdbarch_deprecated_init_frame_pc invalid");
3835 if (gdbarch_debug
>= 2)
3836 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_init_frame_pc called\n");
3837 return gdbarch
->deprecated_init_frame_pc (fromleaf
, prev
);
3841 set_gdbarch_deprecated_init_frame_pc (struct gdbarch
*gdbarch
,
3842 gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc
)
3844 gdbarch
->deprecated_init_frame_pc
= deprecated_init_frame_pc
;
3848 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
3850 gdb_assert (gdbarch
!= NULL
);
3851 if (gdbarch_debug
>= 2)
3852 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
3853 return gdbarch
->believe_pcc_promotion
;
3857 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
3858 int believe_pcc_promotion
)
3860 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
3864 gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
)
3866 gdb_assert (gdbarch
!= NULL
);
3867 if (gdbarch_debug
>= 2)
3868 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion_type called\n");
3869 return gdbarch
->believe_pcc_promotion_type
;
3873 set_gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
,
3874 int believe_pcc_promotion_type
)
3876 gdbarch
->believe_pcc_promotion_type
= believe_pcc_promotion_type
;
3880 gdbarch_get_saved_register_p (struct gdbarch
*gdbarch
)
3882 gdb_assert (gdbarch
!= NULL
);
3883 return gdbarch
->get_saved_register
!= 0;
3887 gdbarch_get_saved_register (struct gdbarch
*gdbarch
, char *raw_buffer
, int *optimized
, CORE_ADDR
*addrp
, struct frame_info
*frame
, int regnum
, enum lval_type
*lval
)
3889 gdb_assert (gdbarch
!= NULL
);
3890 if (gdbarch
->get_saved_register
== 0)
3891 internal_error (__FILE__
, __LINE__
,
3892 "gdbarch: gdbarch_get_saved_register invalid");
3893 if (gdbarch_debug
>= 2)
3894 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_saved_register called\n");
3895 gdbarch
->get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
3899 set_gdbarch_get_saved_register (struct gdbarch
*gdbarch
,
3900 gdbarch_get_saved_register_ftype get_saved_register
)
3902 gdbarch
->get_saved_register
= get_saved_register
;
3906 gdbarch_register_convertible (struct gdbarch
*gdbarch
, int nr
)
3908 gdb_assert (gdbarch
!= NULL
);
3909 if (gdbarch
->register_convertible
== 0)
3910 internal_error (__FILE__
, __LINE__
,
3911 "gdbarch: gdbarch_register_convertible invalid");
3912 if (gdbarch_debug
>= 2)
3913 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convertible called\n");
3914 return gdbarch
->register_convertible (nr
);
3918 set_gdbarch_register_convertible (struct gdbarch
*gdbarch
,
3919 gdbarch_register_convertible_ftype register_convertible
)
3921 gdbarch
->register_convertible
= register_convertible
;
3925 gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
3927 gdb_assert (gdbarch
!= NULL
);
3928 if (gdbarch
->register_convert_to_virtual
== 0)
3929 internal_error (__FILE__
, __LINE__
,
3930 "gdbarch: gdbarch_register_convert_to_virtual invalid");
3931 if (gdbarch_debug
>= 2)
3932 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_virtual called\n");
3933 gdbarch
->register_convert_to_virtual (regnum
, type
, from
, to
);
3937 set_gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
,
3938 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual
)
3940 gdbarch
->register_convert_to_virtual
= register_convert_to_virtual
;
3944 gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
3946 gdb_assert (gdbarch
!= NULL
);
3947 if (gdbarch
->register_convert_to_raw
== 0)
3948 internal_error (__FILE__
, __LINE__
,
3949 "gdbarch: gdbarch_register_convert_to_raw invalid");
3950 if (gdbarch_debug
>= 2)
3951 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_raw called\n");
3952 gdbarch
->register_convert_to_raw (type
, regnum
, from
, to
);
3956 set_gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
,
3957 gdbarch_register_convert_to_raw_ftype register_convert_to_raw
)
3959 gdbarch
->register_convert_to_raw
= register_convert_to_raw
;
3963 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
)
3965 gdb_assert (gdbarch
!= NULL
);
3966 if (gdbarch
->convert_register_p
== 0)
3967 internal_error (__FILE__
, __LINE__
,
3968 "gdbarch: gdbarch_convert_register_p invalid");
3969 if (gdbarch_debug
>= 2)
3970 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
3971 return gdbarch
->convert_register_p (regnum
);
3975 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
3976 gdbarch_convert_register_p_ftype convert_register_p
)
3978 gdbarch
->convert_register_p
= convert_register_p
;
3982 gdbarch_register_to_value (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
3984 gdb_assert (gdbarch
!= NULL
);
3985 if (gdbarch
->register_to_value
== 0)
3986 internal_error (__FILE__
, __LINE__
,
3987 "gdbarch: gdbarch_register_to_value invalid");
3988 if (gdbarch_debug
>= 2)
3989 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
3990 gdbarch
->register_to_value (regnum
, type
, from
, to
);
3994 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
3995 gdbarch_register_to_value_ftype register_to_value
)
3997 gdbarch
->register_to_value
= register_to_value
;
4001 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
4003 gdb_assert (gdbarch
!= NULL
);
4004 if (gdbarch
->value_to_register
== 0)
4005 internal_error (__FILE__
, __LINE__
,
4006 "gdbarch: gdbarch_value_to_register invalid");
4007 if (gdbarch_debug
>= 2)
4008 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
4009 gdbarch
->value_to_register (type
, regnum
, from
, to
);
4013 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
4014 gdbarch_value_to_register_ftype value_to_register
)
4016 gdbarch
->value_to_register
= value_to_register
;
4020 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
4022 gdb_assert (gdbarch
!= NULL
);
4023 if (gdbarch
->pointer_to_address
== 0)
4024 internal_error (__FILE__
, __LINE__
,
4025 "gdbarch: gdbarch_pointer_to_address invalid");
4026 if (gdbarch_debug
>= 2)
4027 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
4028 return gdbarch
->pointer_to_address (type
, buf
);
4032 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
4033 gdbarch_pointer_to_address_ftype pointer_to_address
)
4035 gdbarch
->pointer_to_address
= pointer_to_address
;
4039 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
, CORE_ADDR addr
)
4041 gdb_assert (gdbarch
!= NULL
);
4042 if (gdbarch
->address_to_pointer
== 0)
4043 internal_error (__FILE__
, __LINE__
,
4044 "gdbarch: gdbarch_address_to_pointer invalid");
4045 if (gdbarch_debug
>= 2)
4046 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
4047 gdbarch
->address_to_pointer (type
, buf
, addr
);
4051 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
4052 gdbarch_address_to_pointer_ftype address_to_pointer
)
4054 gdbarch
->address_to_pointer
= address_to_pointer
;
4058 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
4060 gdb_assert (gdbarch
!= NULL
);
4061 return gdbarch
->integer_to_address
!= 0;
4065 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
4067 gdb_assert (gdbarch
!= NULL
);
4068 if (gdbarch
->integer_to_address
== 0)
4069 internal_error (__FILE__
, __LINE__
,
4070 "gdbarch: gdbarch_integer_to_address invalid");
4071 if (gdbarch_debug
>= 2)
4072 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
4073 return gdbarch
->integer_to_address (type
, buf
);
4077 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
4078 gdbarch_integer_to_address_ftype integer_to_address
)
4080 gdbarch
->integer_to_address
= integer_to_address
;
4084 gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
, struct type
*type
)
4086 gdb_assert (gdbarch
!= NULL
);
4087 if (gdbarch
->return_value_on_stack
== 0)
4088 internal_error (__FILE__
, __LINE__
,
4089 "gdbarch: gdbarch_return_value_on_stack invalid");
4090 if (gdbarch_debug
>= 2)
4091 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value_on_stack called\n");
4092 return gdbarch
->return_value_on_stack (type
);
4096 set_gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
,
4097 gdbarch_return_value_on_stack_ftype return_value_on_stack
)
4099 gdbarch
->return_value_on_stack
= return_value_on_stack
;
4103 gdbarch_push_arguments (struct gdbarch
*gdbarch
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
4105 gdb_assert (gdbarch
!= NULL
);
4106 if (gdbarch
->push_arguments
== 0)
4107 internal_error (__FILE__
, __LINE__
,
4108 "gdbarch: gdbarch_push_arguments invalid");
4109 if (gdbarch_debug
>= 2)
4110 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_arguments called\n");
4111 return gdbarch
->push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
4115 set_gdbarch_push_arguments (struct gdbarch
*gdbarch
,
4116 gdbarch_push_arguments_ftype push_arguments
)
4118 gdbarch
->push_arguments
= push_arguments
;
4122 gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
)
4124 gdb_assert (gdbarch
!= NULL
);
4125 if (gdbarch
->push_dummy_frame
== 0)
4126 internal_error (__FILE__
, __LINE__
,
4127 "gdbarch: gdbarch_push_dummy_frame invalid");
4128 if (gdbarch_debug
>= 2)
4129 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_frame called\n");
4130 gdbarch
->push_dummy_frame ();
4134 set_gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
,
4135 gdbarch_push_dummy_frame_ftype push_dummy_frame
)
4137 gdbarch
->push_dummy_frame
= push_dummy_frame
;
4141 gdbarch_push_return_address_p (struct gdbarch
*gdbarch
)
4143 gdb_assert (gdbarch
!= NULL
);
4144 return gdbarch
->push_return_address
!= 0;
4148 gdbarch_push_return_address (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
)
4150 gdb_assert (gdbarch
!= NULL
);
4151 if (gdbarch
->push_return_address
== 0)
4152 internal_error (__FILE__
, __LINE__
,
4153 "gdbarch: gdbarch_push_return_address invalid");
4154 if (gdbarch_debug
>= 2)
4155 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_return_address called\n");
4156 return gdbarch
->push_return_address (pc
, sp
);
4160 set_gdbarch_push_return_address (struct gdbarch
*gdbarch
,
4161 gdbarch_push_return_address_ftype push_return_address
)
4163 gdbarch
->push_return_address
= push_return_address
;
4167 gdbarch_pop_frame (struct gdbarch
*gdbarch
)
4169 gdb_assert (gdbarch
!= NULL
);
4170 if (gdbarch
->pop_frame
== 0)
4171 internal_error (__FILE__
, __LINE__
,
4172 "gdbarch: gdbarch_pop_frame invalid");
4173 if (gdbarch_debug
>= 2)
4174 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pop_frame called\n");
4175 gdbarch
->pop_frame ();
4179 set_gdbarch_pop_frame (struct gdbarch
*gdbarch
,
4180 gdbarch_pop_frame_ftype pop_frame
)
4182 gdbarch
->pop_frame
= pop_frame
;
4186 gdbarch_store_struct_return (struct gdbarch
*gdbarch
, CORE_ADDR addr
, CORE_ADDR sp
)
4188 gdb_assert (gdbarch
!= NULL
);
4189 if (gdbarch
->store_struct_return
== 0)
4190 internal_error (__FILE__
, __LINE__
,
4191 "gdbarch: gdbarch_store_struct_return invalid");
4192 if (gdbarch_debug
>= 2)
4193 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_struct_return called\n");
4194 gdbarch
->store_struct_return (addr
, sp
);
4198 set_gdbarch_store_struct_return (struct gdbarch
*gdbarch
,
4199 gdbarch_store_struct_return_ftype store_struct_return
)
4201 gdbarch
->store_struct_return
= store_struct_return
;
4205 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, void *valbuf
)
4207 gdb_assert (gdbarch
!= NULL
);
4208 if (gdbarch
->extract_return_value
== 0)
4209 internal_error (__FILE__
, __LINE__
,
4210 "gdbarch: gdbarch_extract_return_value invalid");
4211 if (gdbarch_debug
>= 2)
4212 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
4213 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
4217 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
4218 gdbarch_extract_return_value_ftype extract_return_value
)
4220 gdbarch
->extract_return_value
= extract_return_value
;
4224 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const void *valbuf
)
4226 gdb_assert (gdbarch
!= NULL
);
4227 if (gdbarch
->store_return_value
== 0)
4228 internal_error (__FILE__
, __LINE__
,
4229 "gdbarch: gdbarch_store_return_value invalid");
4230 if (gdbarch_debug
>= 2)
4231 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
4232 gdbarch
->store_return_value (type
, regcache
, valbuf
);
4236 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
4237 gdbarch_store_return_value_ftype store_return_value
)
4239 gdbarch
->store_return_value
= store_return_value
;
4243 gdbarch_deprecated_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *regbuf
, char *valbuf
)
4245 gdb_assert (gdbarch
!= NULL
);
4246 if (gdbarch
->deprecated_extract_return_value
== 0)
4247 internal_error (__FILE__
, __LINE__
,
4248 "gdbarch: gdbarch_deprecated_extract_return_value invalid");
4249 if (gdbarch_debug
>= 2)
4250 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_return_value called\n");
4251 gdbarch
->deprecated_extract_return_value (type
, regbuf
, valbuf
);
4255 set_gdbarch_deprecated_extract_return_value (struct gdbarch
*gdbarch
,
4256 gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value
)
4258 gdbarch
->deprecated_extract_return_value
= deprecated_extract_return_value
;
4262 gdbarch_deprecated_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *valbuf
)
4264 gdb_assert (gdbarch
!= NULL
);
4265 if (gdbarch
->deprecated_store_return_value
== 0)
4266 internal_error (__FILE__
, __LINE__
,
4267 "gdbarch: gdbarch_deprecated_store_return_value invalid");
4268 if (gdbarch_debug
>= 2)
4269 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_store_return_value called\n");
4270 gdbarch
->deprecated_store_return_value (type
, valbuf
);
4274 set_gdbarch_deprecated_store_return_value (struct gdbarch
*gdbarch
,
4275 gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value
)
4277 gdbarch
->deprecated_store_return_value
= deprecated_store_return_value
;
4281 gdbarch_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
4283 gdb_assert (gdbarch
!= NULL
);
4284 return gdbarch
->extract_struct_value_address
!= 0;
4288 gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
4290 gdb_assert (gdbarch
!= NULL
);
4291 if (gdbarch
->extract_struct_value_address
== 0)
4292 internal_error (__FILE__
, __LINE__
,
4293 "gdbarch: gdbarch_extract_struct_value_address invalid");
4294 if (gdbarch_debug
>= 2)
4295 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_struct_value_address called\n");
4296 return gdbarch
->extract_struct_value_address (regcache
);
4300 set_gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
,
4301 gdbarch_extract_struct_value_address_ftype extract_struct_value_address
)
4303 gdbarch
->extract_struct_value_address
= extract_struct_value_address
;
4307 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
4309 gdb_assert (gdbarch
!= NULL
);
4310 return gdbarch
->deprecated_extract_struct_value_address
!= 0;
4314 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, char *regbuf
)
4316 gdb_assert (gdbarch
!= NULL
);
4317 if (gdbarch
->deprecated_extract_struct_value_address
== 0)
4318 internal_error (__FILE__
, __LINE__
,
4319 "gdbarch: gdbarch_deprecated_extract_struct_value_address invalid");
4320 if (gdbarch_debug
>= 2)
4321 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
4322 return gdbarch
->deprecated_extract_struct_value_address (regbuf
);
4326 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
4327 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
4329 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
4333 gdbarch_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
4335 gdb_assert (gdbarch
!= NULL
);
4336 if (gdbarch
->use_struct_convention
== 0)
4337 internal_error (__FILE__
, __LINE__
,
4338 "gdbarch: gdbarch_use_struct_convention invalid");
4339 if (gdbarch_debug
>= 2)
4340 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_struct_convention called\n");
4341 return gdbarch
->use_struct_convention (gcc_p
, value_type
);
4345 set_gdbarch_use_struct_convention (struct gdbarch
*gdbarch
,
4346 gdbarch_use_struct_convention_ftype use_struct_convention
)
4348 gdbarch
->use_struct_convention
= use_struct_convention
;
4352 gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4354 gdb_assert (gdbarch
!= NULL
);
4355 if (gdbarch
->frame_init_saved_regs
== 0)
4356 internal_error (__FILE__
, __LINE__
,
4357 "gdbarch: gdbarch_frame_init_saved_regs invalid");
4358 if (gdbarch_debug
>= 2)
4359 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_init_saved_regs called\n");
4360 gdbarch
->frame_init_saved_regs (frame
);
4364 set_gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
,
4365 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs
)
4367 gdbarch
->frame_init_saved_regs
= frame_init_saved_regs
;
4371 gdbarch_init_extra_frame_info_p (struct gdbarch
*gdbarch
)
4373 gdb_assert (gdbarch
!= NULL
);
4374 return gdbarch
->init_extra_frame_info
!= 0;
4378 gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*frame
)
4380 gdb_assert (gdbarch
!= NULL
);
4381 if (gdbarch
->init_extra_frame_info
== 0)
4382 internal_error (__FILE__
, __LINE__
,
4383 "gdbarch: gdbarch_init_extra_frame_info invalid");
4384 if (gdbarch_debug
>= 2)
4385 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_extra_frame_info called\n");
4386 gdbarch
->init_extra_frame_info (fromleaf
, frame
);
4390 set_gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
,
4391 gdbarch_init_extra_frame_info_ftype init_extra_frame_info
)
4393 gdbarch
->init_extra_frame_info
= init_extra_frame_info
;
4397 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
4399 gdb_assert (gdbarch
!= NULL
);
4400 if (gdbarch
->skip_prologue
== 0)
4401 internal_error (__FILE__
, __LINE__
,
4402 "gdbarch: gdbarch_skip_prologue invalid");
4403 if (gdbarch_debug
>= 2)
4404 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
4405 return gdbarch
->skip_prologue (ip
);
4409 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
4410 gdbarch_skip_prologue_ftype skip_prologue
)
4412 gdbarch
->skip_prologue
= skip_prologue
;
4416 gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
4418 gdb_assert (gdbarch
!= NULL
);
4419 if (gdbarch
->prologue_frameless_p
== 0)
4420 internal_error (__FILE__
, __LINE__
,
4421 "gdbarch: gdbarch_prologue_frameless_p invalid");
4422 if (gdbarch_debug
>= 2)
4423 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prologue_frameless_p called\n");
4424 return gdbarch
->prologue_frameless_p (ip
);
4428 set_gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
,
4429 gdbarch_prologue_frameless_p_ftype prologue_frameless_p
)
4431 gdbarch
->prologue_frameless_p
= prologue_frameless_p
;
4435 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
4437 gdb_assert (gdbarch
!= NULL
);
4438 if (gdbarch
->inner_than
== 0)
4439 internal_error (__FILE__
, __LINE__
,
4440 "gdbarch: gdbarch_inner_than invalid");
4441 if (gdbarch_debug
>= 2)
4442 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
4443 return gdbarch
->inner_than (lhs
, rhs
);
4447 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
4448 gdbarch_inner_than_ftype inner_than
)
4450 gdbarch
->inner_than
= inner_than
;
4453 const unsigned char *
4454 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
4456 gdb_assert (gdbarch
!= NULL
);
4457 if (gdbarch
->breakpoint_from_pc
== 0)
4458 internal_error (__FILE__
, __LINE__
,
4459 "gdbarch: gdbarch_breakpoint_from_pc invalid");
4460 if (gdbarch_debug
>= 2)
4461 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
4462 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
4466 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
4467 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
4469 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
4473 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
4475 gdb_assert (gdbarch
!= NULL
);
4476 if (gdbarch
->memory_insert_breakpoint
== 0)
4477 internal_error (__FILE__
, __LINE__
,
4478 "gdbarch: gdbarch_memory_insert_breakpoint invalid");
4479 if (gdbarch_debug
>= 2)
4480 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
4481 return gdbarch
->memory_insert_breakpoint (addr
, contents_cache
);
4485 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
4486 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
4488 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
4492 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
4494 gdb_assert (gdbarch
!= NULL
);
4495 if (gdbarch
->memory_remove_breakpoint
== 0)
4496 internal_error (__FILE__
, __LINE__
,
4497 "gdbarch: gdbarch_memory_remove_breakpoint invalid");
4498 if (gdbarch_debug
>= 2)
4499 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
4500 return gdbarch
->memory_remove_breakpoint (addr
, contents_cache
);
4504 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
4505 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
4507 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
4511 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
4513 gdb_assert (gdbarch
!= NULL
);
4514 if (gdbarch
->decr_pc_after_break
== -1)
4515 internal_error (__FILE__
, __LINE__
,
4516 "gdbarch: gdbarch_decr_pc_after_break invalid");
4517 if (gdbarch_debug
>= 2)
4518 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
4519 return gdbarch
->decr_pc_after_break
;
4523 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
4524 CORE_ADDR decr_pc_after_break
)
4526 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
4530 gdbarch_prepare_to_proceed (struct gdbarch
*gdbarch
, int select_it
)
4532 gdb_assert (gdbarch
!= NULL
);
4533 if (gdbarch
->prepare_to_proceed
== 0)
4534 internal_error (__FILE__
, __LINE__
,
4535 "gdbarch: gdbarch_prepare_to_proceed invalid");
4536 if (gdbarch_debug
>= 2)
4537 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prepare_to_proceed called\n");
4538 return gdbarch
->prepare_to_proceed (select_it
);
4542 set_gdbarch_prepare_to_proceed (struct gdbarch
*gdbarch
,
4543 gdbarch_prepare_to_proceed_ftype prepare_to_proceed
)
4545 gdbarch
->prepare_to_proceed
= prepare_to_proceed
;
4549 gdbarch_function_start_offset (struct gdbarch
*gdbarch
)
4551 gdb_assert (gdbarch
!= NULL
);
4552 if (gdbarch
->function_start_offset
== -1)
4553 internal_error (__FILE__
, __LINE__
,
4554 "gdbarch: gdbarch_function_start_offset invalid");
4555 if (gdbarch_debug
>= 2)
4556 fprintf_unfiltered (gdb_stdlog
, "gdbarch_function_start_offset called\n");
4557 return gdbarch
->function_start_offset
;
4561 set_gdbarch_function_start_offset (struct gdbarch
*gdbarch
,
4562 CORE_ADDR function_start_offset
)
4564 gdbarch
->function_start_offset
= function_start_offset
;
4568 gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
, CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
)
4570 gdb_assert (gdbarch
!= NULL
);
4571 if (gdbarch
->remote_translate_xfer_address
== 0)
4572 internal_error (__FILE__
, __LINE__
,
4573 "gdbarch: gdbarch_remote_translate_xfer_address invalid");
4574 if (gdbarch_debug
>= 2)
4575 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_translate_xfer_address called\n");
4576 gdbarch
->remote_translate_xfer_address (gdb_addr
, gdb_len
, rem_addr
, rem_len
);
4580 set_gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
4581 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address
)
4583 gdbarch
->remote_translate_xfer_address
= remote_translate_xfer_address
;
4587 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
4589 gdb_assert (gdbarch
!= NULL
);
4590 if (gdbarch
->frame_args_skip
== -1)
4591 internal_error (__FILE__
, __LINE__
,
4592 "gdbarch: gdbarch_frame_args_skip invalid");
4593 if (gdbarch_debug
>= 2)
4594 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
4595 return gdbarch
->frame_args_skip
;
4599 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
4600 CORE_ADDR frame_args_skip
)
4602 gdbarch
->frame_args_skip
= frame_args_skip
;
4606 gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4608 gdb_assert (gdbarch
!= NULL
);
4609 if (gdbarch
->frameless_function_invocation
== 0)
4610 internal_error (__FILE__
, __LINE__
,
4611 "gdbarch: gdbarch_frameless_function_invocation invalid");
4612 if (gdbarch_debug
>= 2)
4613 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frameless_function_invocation called\n");
4614 return gdbarch
->frameless_function_invocation (fi
);
4618 set_gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
,
4619 gdbarch_frameless_function_invocation_ftype frameless_function_invocation
)
4621 gdbarch
->frameless_function_invocation
= frameless_function_invocation
;
4625 gdbarch_frame_chain (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4627 gdb_assert (gdbarch
!= NULL
);
4628 if (gdbarch
->frame_chain
== 0)
4629 internal_error (__FILE__
, __LINE__
,
4630 "gdbarch: gdbarch_frame_chain invalid");
4631 if (gdbarch_debug
>= 2)
4632 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain called\n");
4633 return gdbarch
->frame_chain (frame
);
4637 set_gdbarch_frame_chain (struct gdbarch
*gdbarch
,
4638 gdbarch_frame_chain_ftype frame_chain
)
4640 gdbarch
->frame_chain
= frame_chain
;
4644 gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
, CORE_ADDR chain
, struct frame_info
*thisframe
)
4646 gdb_assert (gdbarch
!= NULL
);
4647 if (gdbarch
->frame_chain_valid
== 0)
4648 internal_error (__FILE__
, __LINE__
,
4649 "gdbarch: gdbarch_frame_chain_valid invalid");
4650 if (gdbarch_debug
>= 2)
4651 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain_valid called\n");
4652 return gdbarch
->frame_chain_valid (chain
, thisframe
);
4656 set_gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
,
4657 gdbarch_frame_chain_valid_ftype frame_chain_valid
)
4659 gdbarch
->frame_chain_valid
= frame_chain_valid
;
4663 gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4665 gdb_assert (gdbarch
!= NULL
);
4666 if (gdbarch
->frame_saved_pc
== 0)
4667 internal_error (__FILE__
, __LINE__
,
4668 "gdbarch: gdbarch_frame_saved_pc invalid");
4669 if (gdbarch_debug
>= 2)
4670 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_saved_pc called\n");
4671 return gdbarch
->frame_saved_pc (fi
);
4675 set_gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
,
4676 gdbarch_frame_saved_pc_ftype frame_saved_pc
)
4678 gdbarch
->frame_saved_pc
= frame_saved_pc
;
4682 gdbarch_frame_args_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4684 gdb_assert (gdbarch
!= NULL
);
4685 if (gdbarch
->frame_args_address
== 0)
4686 internal_error (__FILE__
, __LINE__
,
4687 "gdbarch: gdbarch_frame_args_address invalid");
4688 if (gdbarch_debug
>= 2)
4689 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_address called\n");
4690 return gdbarch
->frame_args_address (fi
);
4694 set_gdbarch_frame_args_address (struct gdbarch
*gdbarch
,
4695 gdbarch_frame_args_address_ftype frame_args_address
)
4697 gdbarch
->frame_args_address
= frame_args_address
;
4701 gdbarch_frame_locals_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4703 gdb_assert (gdbarch
!= NULL
);
4704 if (gdbarch
->frame_locals_address
== 0)
4705 internal_error (__FILE__
, __LINE__
,
4706 "gdbarch: gdbarch_frame_locals_address invalid");
4707 if (gdbarch_debug
>= 2)
4708 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_locals_address called\n");
4709 return gdbarch
->frame_locals_address (fi
);
4713 set_gdbarch_frame_locals_address (struct gdbarch
*gdbarch
,
4714 gdbarch_frame_locals_address_ftype frame_locals_address
)
4716 gdbarch
->frame_locals_address
= frame_locals_address
;
4720 gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4722 gdb_assert (gdbarch
!= NULL
);
4723 if (gdbarch
->saved_pc_after_call
== 0)
4724 internal_error (__FILE__
, __LINE__
,
4725 "gdbarch: gdbarch_saved_pc_after_call invalid");
4726 if (gdbarch_debug
>= 2)
4727 fprintf_unfiltered (gdb_stdlog
, "gdbarch_saved_pc_after_call called\n");
4728 return gdbarch
->saved_pc_after_call (frame
);
4732 set_gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
,
4733 gdbarch_saved_pc_after_call_ftype saved_pc_after_call
)
4735 gdbarch
->saved_pc_after_call
= saved_pc_after_call
;
4739 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4741 gdb_assert (gdbarch
!= NULL
);
4742 if (gdbarch
->frame_num_args
== 0)
4743 internal_error (__FILE__
, __LINE__
,
4744 "gdbarch: gdbarch_frame_num_args invalid");
4745 if (gdbarch_debug
>= 2)
4746 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
4747 return gdbarch
->frame_num_args (frame
);
4751 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
4752 gdbarch_frame_num_args_ftype frame_num_args
)
4754 gdbarch
->frame_num_args
= frame_num_args
;
4758 gdbarch_stack_align_p (struct gdbarch
*gdbarch
)
4760 gdb_assert (gdbarch
!= NULL
);
4761 return gdbarch
->stack_align
!= 0;
4765 gdbarch_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
4767 gdb_assert (gdbarch
!= NULL
);
4768 if (gdbarch
->stack_align
== 0)
4769 internal_error (__FILE__
, __LINE__
,
4770 "gdbarch: gdbarch_stack_align invalid");
4771 if (gdbarch_debug
>= 2)
4772 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stack_align called\n");
4773 return gdbarch
->stack_align (sp
);
4777 set_gdbarch_stack_align (struct gdbarch
*gdbarch
,
4778 gdbarch_stack_align_ftype stack_align
)
4780 gdbarch
->stack_align
= stack_align
;
4784 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
4786 gdb_assert (gdbarch
!= NULL
);
4787 return gdbarch
->frame_align
!= 0;
4791 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4793 gdb_assert (gdbarch
!= NULL
);
4794 if (gdbarch
->frame_align
== 0)
4795 internal_error (__FILE__
, __LINE__
,
4796 "gdbarch: gdbarch_frame_align invalid");
4797 if (gdbarch_debug
>= 2)
4798 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
4799 return gdbarch
->frame_align (gdbarch
, address
);
4803 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
4804 gdbarch_frame_align_ftype frame_align
)
4806 gdbarch
->frame_align
= frame_align
;
4810 gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
)
4812 gdb_assert (gdbarch
!= NULL
);
4813 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
4814 if (gdbarch_debug
>= 2)
4815 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extra_stack_alignment_needed called\n");
4816 return gdbarch
->extra_stack_alignment_needed
;
4820 set_gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
,
4821 int extra_stack_alignment_needed
)
4823 gdbarch
->extra_stack_alignment_needed
= extra_stack_alignment_needed
;
4827 gdbarch_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
4829 gdb_assert (gdbarch
!= NULL
);
4830 return gdbarch
->reg_struct_has_addr
!= 0;
4834 gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
4836 gdb_assert (gdbarch
!= NULL
);
4837 if (gdbarch
->reg_struct_has_addr
== 0)
4838 internal_error (__FILE__
, __LINE__
,
4839 "gdbarch: gdbarch_reg_struct_has_addr invalid");
4840 if (gdbarch_debug
>= 2)
4841 fprintf_unfiltered (gdb_stdlog
, "gdbarch_reg_struct_has_addr called\n");
4842 return gdbarch
->reg_struct_has_addr (gcc_p
, type
);
4846 set_gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
,
4847 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr
)
4849 gdbarch
->reg_struct_has_addr
= reg_struct_has_addr
;
4853 gdbarch_save_dummy_frame_tos_p (struct gdbarch
*gdbarch
)
4855 gdb_assert (gdbarch
!= NULL
);
4856 return gdbarch
->save_dummy_frame_tos
!= 0;
4860 gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
4862 gdb_assert (gdbarch
!= NULL
);
4863 if (gdbarch
->save_dummy_frame_tos
== 0)
4864 internal_error (__FILE__
, __LINE__
,
4865 "gdbarch: gdbarch_save_dummy_frame_tos invalid");
4866 if (gdbarch_debug
>= 2)
4867 fprintf_unfiltered (gdb_stdlog
, "gdbarch_save_dummy_frame_tos called\n");
4868 gdbarch
->save_dummy_frame_tos (sp
);
4872 set_gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
,
4873 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos
)
4875 gdbarch
->save_dummy_frame_tos
= save_dummy_frame_tos
;
4879 gdbarch_parm_boundary (struct gdbarch
*gdbarch
)
4881 gdb_assert (gdbarch
!= NULL
);
4882 if (gdbarch_debug
>= 2)
4883 fprintf_unfiltered (gdb_stdlog
, "gdbarch_parm_boundary called\n");
4884 return gdbarch
->parm_boundary
;
4888 set_gdbarch_parm_boundary (struct gdbarch
*gdbarch
,
4891 gdbarch
->parm_boundary
= parm_boundary
;
4894 const struct floatformat
*
4895 gdbarch_float_format (struct gdbarch
*gdbarch
)
4897 gdb_assert (gdbarch
!= NULL
);
4898 if (gdbarch_debug
>= 2)
4899 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
4900 return gdbarch
->float_format
;
4904 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
4905 const struct floatformat
* float_format
)
4907 gdbarch
->float_format
= float_format
;
4910 const struct floatformat
*
4911 gdbarch_double_format (struct gdbarch
*gdbarch
)
4913 gdb_assert (gdbarch
!= NULL
);
4914 if (gdbarch_debug
>= 2)
4915 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
4916 return gdbarch
->double_format
;
4920 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
4921 const struct floatformat
* double_format
)
4923 gdbarch
->double_format
= double_format
;
4926 const struct floatformat
*
4927 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
4929 gdb_assert (gdbarch
!= NULL
);
4930 if (gdbarch_debug
>= 2)
4931 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
4932 return gdbarch
->long_double_format
;
4936 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
4937 const struct floatformat
* long_double_format
)
4939 gdbarch
->long_double_format
= long_double_format
;
4943 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4945 gdb_assert (gdbarch
!= NULL
);
4946 if (gdbarch
->convert_from_func_ptr_addr
== 0)
4947 internal_error (__FILE__
, __LINE__
,
4948 "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
4949 if (gdbarch_debug
>= 2)
4950 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
4951 return gdbarch
->convert_from_func_ptr_addr (addr
);
4955 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
4956 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
4958 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
4962 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4964 gdb_assert (gdbarch
!= NULL
);
4965 if (gdbarch
->addr_bits_remove
== 0)
4966 internal_error (__FILE__
, __LINE__
,
4967 "gdbarch: gdbarch_addr_bits_remove invalid");
4968 if (gdbarch_debug
>= 2)
4969 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
4970 return gdbarch
->addr_bits_remove (addr
);
4974 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
4975 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
4977 gdbarch
->addr_bits_remove
= addr_bits_remove
;
4981 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4983 gdb_assert (gdbarch
!= NULL
);
4984 if (gdbarch
->smash_text_address
== 0)
4985 internal_error (__FILE__
, __LINE__
,
4986 "gdbarch: gdbarch_smash_text_address invalid");
4987 if (gdbarch_debug
>= 2)
4988 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
4989 return gdbarch
->smash_text_address (addr
);
4993 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
4994 gdbarch_smash_text_address_ftype smash_text_address
)
4996 gdbarch
->smash_text_address
= smash_text_address
;
5000 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
5002 gdb_assert (gdbarch
!= NULL
);
5003 return gdbarch
->software_single_step
!= 0;
5007 gdbarch_software_single_step (struct gdbarch
*gdbarch
, enum target_signal sig
, int insert_breakpoints_p
)
5009 gdb_assert (gdbarch
!= NULL
);
5010 if (gdbarch
->software_single_step
== 0)
5011 internal_error (__FILE__
, __LINE__
,
5012 "gdbarch: gdbarch_software_single_step invalid");
5013 if (gdbarch_debug
>= 2)
5014 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
5015 gdbarch
->software_single_step (sig
, insert_breakpoints_p
);
5019 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
5020 gdbarch_software_single_step_ftype software_single_step
)
5022 gdbarch
->software_single_step
= software_single_step
;
5026 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, disassemble_info
*info
)
5028 gdb_assert (gdbarch
!= NULL
);
5029 if (gdbarch
->print_insn
== 0)
5030 internal_error (__FILE__
, __LINE__
,
5031 "gdbarch: gdbarch_print_insn invalid");
5032 if (gdbarch_debug
>= 2)
5033 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
5034 return gdbarch
->print_insn (vma
, info
);
5038 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
5039 gdbarch_print_insn_ftype print_insn
)
5041 gdbarch
->print_insn
= print_insn
;
5045 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5047 gdb_assert (gdbarch
!= NULL
);
5048 if (gdbarch
->skip_trampoline_code
== 0)
5049 internal_error (__FILE__
, __LINE__
,
5050 "gdbarch: gdbarch_skip_trampoline_code invalid");
5051 if (gdbarch_debug
>= 2)
5052 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
5053 return gdbarch
->skip_trampoline_code (pc
);
5057 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
5058 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
5060 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
5064 gdbarch_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
5066 gdb_assert (gdbarch
!= NULL
);
5067 if (gdbarch
->in_solib_call_trampoline
== 0)
5068 internal_error (__FILE__
, __LINE__
,
5069 "gdbarch: gdbarch_in_solib_call_trampoline invalid");
5070 if (gdbarch_debug
>= 2)
5071 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_call_trampoline called\n");
5072 return gdbarch
->in_solib_call_trampoline (pc
, name
);
5076 set_gdbarch_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
5077 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline
)
5079 gdbarch
->in_solib_call_trampoline
= in_solib_call_trampoline
;
5083 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
5085 gdb_assert (gdbarch
!= NULL
);
5086 if (gdbarch
->in_solib_return_trampoline
== 0)
5087 internal_error (__FILE__
, __LINE__
,
5088 "gdbarch: gdbarch_in_solib_return_trampoline invalid");
5089 if (gdbarch_debug
>= 2)
5090 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
5091 return gdbarch
->in_solib_return_trampoline (pc
, name
);
5095 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
5096 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
5098 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
5102 gdbarch_pc_in_sigtramp (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
5104 gdb_assert (gdbarch
!= NULL
);
5105 if (gdbarch
->pc_in_sigtramp
== 0)
5106 internal_error (__FILE__
, __LINE__
,
5107 "gdbarch: gdbarch_pc_in_sigtramp invalid");
5108 if (gdbarch_debug
>= 2)
5109 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_sigtramp called\n");
5110 return gdbarch
->pc_in_sigtramp (pc
, name
);
5114 set_gdbarch_pc_in_sigtramp (struct gdbarch
*gdbarch
,
5115 gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp
)
5117 gdbarch
->pc_in_sigtramp
= pc_in_sigtramp
;
5121 gdbarch_sigtramp_start_p (struct gdbarch
*gdbarch
)
5123 gdb_assert (gdbarch
!= NULL
);
5124 return gdbarch
->sigtramp_start
!= 0;
5128 gdbarch_sigtramp_start (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5130 gdb_assert (gdbarch
!= NULL
);
5131 if (gdbarch
->sigtramp_start
== 0)
5132 internal_error (__FILE__
, __LINE__
,
5133 "gdbarch: gdbarch_sigtramp_start invalid");
5134 if (gdbarch_debug
>= 2)
5135 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sigtramp_start called\n");
5136 return gdbarch
->sigtramp_start (pc
);
5140 set_gdbarch_sigtramp_start (struct gdbarch
*gdbarch
,
5141 gdbarch_sigtramp_start_ftype sigtramp_start
)
5143 gdbarch
->sigtramp_start
= sigtramp_start
;
5147 gdbarch_sigtramp_end_p (struct gdbarch
*gdbarch
)
5149 gdb_assert (gdbarch
!= NULL
);
5150 return gdbarch
->sigtramp_end
!= 0;
5154 gdbarch_sigtramp_end (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
5156 gdb_assert (gdbarch
!= NULL
);
5157 if (gdbarch
->sigtramp_end
== 0)
5158 internal_error (__FILE__
, __LINE__
,
5159 "gdbarch: gdbarch_sigtramp_end invalid");
5160 if (gdbarch_debug
>= 2)
5161 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sigtramp_end called\n");
5162 return gdbarch
->sigtramp_end (pc
);
5166 set_gdbarch_sigtramp_end (struct gdbarch
*gdbarch
,
5167 gdbarch_sigtramp_end_ftype sigtramp_end
)
5169 gdbarch
->sigtramp_end
= sigtramp_end
;
5173 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
5175 gdb_assert (gdbarch
!= NULL
);
5176 if (gdbarch
->in_function_epilogue_p
== 0)
5177 internal_error (__FILE__
, __LINE__
,
5178 "gdbarch: gdbarch_in_function_epilogue_p invalid");
5179 if (gdbarch_debug
>= 2)
5180 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
5181 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
5185 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
5186 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
5188 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
5192 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
5194 gdb_assert (gdbarch
!= NULL
);
5195 if (gdbarch
->construct_inferior_arguments
== 0)
5196 internal_error (__FILE__
, __LINE__
,
5197 "gdbarch: gdbarch_construct_inferior_arguments invalid");
5198 if (gdbarch_debug
>= 2)
5199 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
5200 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
5204 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
5205 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
5207 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
5211 gdbarch_dwarf2_build_frame_info_p (struct gdbarch
*gdbarch
)
5213 gdb_assert (gdbarch
!= NULL
);
5214 return gdbarch
->dwarf2_build_frame_info
!= 0;
5218 gdbarch_dwarf2_build_frame_info (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
5220 gdb_assert (gdbarch
!= NULL
);
5221 if (gdbarch
->dwarf2_build_frame_info
== 0)
5222 internal_error (__FILE__
, __LINE__
,
5223 "gdbarch: gdbarch_dwarf2_build_frame_info invalid");
5224 if (gdbarch_debug
>= 2)
5225 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_build_frame_info called\n");
5226 gdbarch
->dwarf2_build_frame_info (objfile
);
5230 set_gdbarch_dwarf2_build_frame_info (struct gdbarch
*gdbarch
,
5231 gdbarch_dwarf2_build_frame_info_ftype dwarf2_build_frame_info
)
5233 gdbarch
->dwarf2_build_frame_info
= dwarf2_build_frame_info
;
5237 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
5239 gdb_assert (gdbarch
!= NULL
);
5240 if (gdbarch
->elf_make_msymbol_special
== 0)
5241 internal_error (__FILE__
, __LINE__
,
5242 "gdbarch: gdbarch_elf_make_msymbol_special invalid");
5243 if (gdbarch_debug
>= 2)
5244 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
5245 gdbarch
->elf_make_msymbol_special (sym
, msym
);
5249 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
5250 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
5252 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
5256 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
5258 gdb_assert (gdbarch
!= NULL
);
5259 if (gdbarch
->coff_make_msymbol_special
== 0)
5260 internal_error (__FILE__
, __LINE__
,
5261 "gdbarch: gdbarch_coff_make_msymbol_special invalid");
5262 if (gdbarch_debug
>= 2)
5263 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
5264 gdbarch
->coff_make_msymbol_special (val
, msym
);
5268 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
5269 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
5271 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
5275 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
5277 gdb_assert (gdbarch
!= NULL
);
5278 /* Skip verify of name_of_malloc, invalid_p == 0 */
5279 if (gdbarch_debug
>= 2)
5280 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
5281 return gdbarch
->name_of_malloc
;
5285 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
5286 const char * name_of_malloc
)
5288 gdbarch
->name_of_malloc
= name_of_malloc
;
5292 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
5294 gdb_assert (gdbarch
!= NULL
);
5295 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
5296 if (gdbarch_debug
>= 2)
5297 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
5298 return gdbarch
->cannot_step_breakpoint
;
5302 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
5303 int cannot_step_breakpoint
)
5305 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
5309 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
5311 gdb_assert (gdbarch
!= NULL
);
5312 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
5313 if (gdbarch_debug
>= 2)
5314 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
5315 return gdbarch
->have_nonsteppable_watchpoint
;
5319 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
5320 int have_nonsteppable_watchpoint
)
5322 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
5326 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
5328 gdb_assert (gdbarch
!= NULL
);
5329 return gdbarch
->address_class_type_flags
!= 0;
5333 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
5335 gdb_assert (gdbarch
!= NULL
);
5336 if (gdbarch
->address_class_type_flags
== 0)
5337 internal_error (__FILE__
, __LINE__
,
5338 "gdbarch: gdbarch_address_class_type_flags invalid");
5339 if (gdbarch_debug
>= 2)
5340 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
5341 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
5345 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
5346 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
5348 gdbarch
->address_class_type_flags
= address_class_type_flags
;
5352 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
5354 gdb_assert (gdbarch
!= NULL
);
5355 return gdbarch
->address_class_type_flags_to_name
!= 0;
5359 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
5361 gdb_assert (gdbarch
!= NULL
);
5362 if (gdbarch
->address_class_type_flags_to_name
== 0)
5363 internal_error (__FILE__
, __LINE__
,
5364 "gdbarch: gdbarch_address_class_type_flags_to_name invalid");
5365 if (gdbarch_debug
>= 2)
5366 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
5367 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
5371 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
5372 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
5374 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
5378 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
5380 gdb_assert (gdbarch
!= NULL
);
5381 return gdbarch
->address_class_name_to_type_flags
!= 0;
5385 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, const char *name
, int *type_flags_ptr
)
5387 gdb_assert (gdbarch
!= NULL
);
5388 if (gdbarch
->address_class_name_to_type_flags
== 0)
5389 internal_error (__FILE__
, __LINE__
,
5390 "gdbarch: gdbarch_address_class_name_to_type_flags invalid");
5391 if (gdbarch_debug
>= 2)
5392 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
5393 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
5397 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
5398 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
5400 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
5404 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
5406 gdb_assert (gdbarch
!= NULL
);
5407 if (gdbarch
->register_reggroup_p
== 0)
5408 internal_error (__FILE__
, __LINE__
,
5409 "gdbarch: gdbarch_register_reggroup_p invalid");
5410 if (gdbarch_debug
>= 2)
5411 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
5412 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
5416 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
5417 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
5419 gdbarch
->register_reggroup_p
= register_reggroup_p
;
5423 /* Keep a registry of per-architecture data-pointers required by GDB
5430 gdbarch_data_init_ftype
*init
;
5431 gdbarch_data_free_ftype
*free
;
5434 struct gdbarch_data_registration
5436 struct gdbarch_data
*data
;
5437 struct gdbarch_data_registration
*next
;
5440 struct gdbarch_data_registry
5443 struct gdbarch_data_registration
*registrations
;
5446 struct gdbarch_data_registry gdbarch_data_registry
=
5451 struct gdbarch_data
*
5452 register_gdbarch_data (gdbarch_data_init_ftype
*init
,
5453 gdbarch_data_free_ftype
*free
)
5455 struct gdbarch_data_registration
**curr
;
5456 /* Append the new registraration. */
5457 for (curr
= &gdbarch_data_registry
.registrations
;
5459 curr
= &(*curr
)->next
);
5460 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
5461 (*curr
)->next
= NULL
;
5462 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
5463 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
5464 (*curr
)->data
->init
= init
;
5465 (*curr
)->data
->init_p
= 1;
5466 (*curr
)->data
->free
= free
;
5467 return (*curr
)->data
;
5471 /* Create/delete the gdbarch data vector. */
5474 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
5476 gdb_assert (gdbarch
->data
== NULL
);
5477 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
5478 gdbarch
->data
= xcalloc (gdbarch
->nr_data
, sizeof (void*));
5482 free_gdbarch_data (struct gdbarch
*gdbarch
)
5484 struct gdbarch_data_registration
*rego
;
5485 gdb_assert (gdbarch
->data
!= NULL
);
5486 for (rego
= gdbarch_data_registry
.registrations
;
5490 struct gdbarch_data
*data
= rego
->data
;
5491 gdb_assert (data
->index
< gdbarch
->nr_data
);
5492 if (data
->free
!= NULL
&& gdbarch
->data
[data
->index
] != NULL
)
5494 data
->free (gdbarch
, gdbarch
->data
[data
->index
]);
5495 gdbarch
->data
[data
->index
] = NULL
;
5498 xfree (gdbarch
->data
);
5499 gdbarch
->data
= NULL
;
5503 /* Initialize the current value of the specified per-architecture
5507 set_gdbarch_data (struct gdbarch
*gdbarch
,
5508 struct gdbarch_data
*data
,
5511 gdb_assert (data
->index
< gdbarch
->nr_data
);
5512 if (gdbarch
->data
[data
->index
] != NULL
)
5514 gdb_assert (data
->free
!= NULL
);
5515 data
->free (gdbarch
, gdbarch
->data
[data
->index
]);
5517 gdbarch
->data
[data
->index
] = pointer
;
5520 /* Return the current value of the specified per-architecture
5524 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
5526 gdb_assert (data
->index
< gdbarch
->nr_data
);
5527 /* The data-pointer isn't initialized, call init() to get a value but
5528 only if the architecture initializaiton has completed. Otherwise
5529 punt - hope that the caller knows what they are doing. */
5530 if (gdbarch
->data
[data
->index
] == NULL
5531 && gdbarch
->initialized_p
)
5533 /* Be careful to detect an initialization cycle. */
5534 gdb_assert (data
->init_p
);
5536 gdb_assert (data
->init
!= NULL
);
5537 gdbarch
->data
[data
->index
] = data
->init (gdbarch
);
5539 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
5541 return gdbarch
->data
[data
->index
];
5546 /* Keep a registry of swapped data required by GDB modules. */
5551 struct gdbarch_swap_registration
*source
;
5552 struct gdbarch_swap
*next
;
5555 struct gdbarch_swap_registration
5558 unsigned long sizeof_data
;
5559 gdbarch_swap_ftype
*init
;
5560 struct gdbarch_swap_registration
*next
;
5563 struct gdbarch_swap_registry
5566 struct gdbarch_swap_registration
*registrations
;
5569 struct gdbarch_swap_registry gdbarch_swap_registry
=
5575 register_gdbarch_swap (void *data
,
5576 unsigned long sizeof_data
,
5577 gdbarch_swap_ftype
*init
)
5579 struct gdbarch_swap_registration
**rego
;
5580 for (rego
= &gdbarch_swap_registry
.registrations
;
5582 rego
= &(*rego
)->next
);
5583 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
5584 (*rego
)->next
= NULL
;
5585 (*rego
)->init
= init
;
5586 (*rego
)->data
= data
;
5587 (*rego
)->sizeof_data
= sizeof_data
;
5591 clear_gdbarch_swap (struct gdbarch
*gdbarch
)
5593 struct gdbarch_swap
*curr
;
5594 for (curr
= gdbarch
->swap
;
5598 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
5603 init_gdbarch_swap (struct gdbarch
*gdbarch
)
5605 struct gdbarch_swap_registration
*rego
;
5606 struct gdbarch_swap
**curr
= &gdbarch
->swap
;
5607 for (rego
= gdbarch_swap_registry
.registrations
;
5611 if (rego
->data
!= NULL
)
5613 (*curr
) = XMALLOC (struct gdbarch_swap
);
5614 (*curr
)->source
= rego
;
5615 (*curr
)->swap
= xmalloc (rego
->sizeof_data
);
5616 (*curr
)->next
= NULL
;
5617 curr
= &(*curr
)->next
;
5619 if (rego
->init
!= NULL
)
5625 swapout_gdbarch_swap (struct gdbarch
*gdbarch
)
5627 struct gdbarch_swap
*curr
;
5628 for (curr
= gdbarch
->swap
;
5631 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
5635 swapin_gdbarch_swap (struct gdbarch
*gdbarch
)
5637 struct gdbarch_swap
*curr
;
5638 for (curr
= gdbarch
->swap
;
5641 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
5645 /* Keep a registry of the architectures known by GDB. */
5647 struct gdbarch_registration
5649 enum bfd_architecture bfd_architecture
;
5650 gdbarch_init_ftype
*init
;
5651 gdbarch_dump_tdep_ftype
*dump_tdep
;
5652 struct gdbarch_list
*arches
;
5653 struct gdbarch_registration
*next
;
5656 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
5659 append_name (const char ***buf
, int *nr
, const char *name
)
5661 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
5667 gdbarch_printable_names (void)
5671 /* Accumulate a list of names based on the registed list of
5673 enum bfd_architecture a
;
5675 const char **arches
= NULL
;
5676 struct gdbarch_registration
*rego
;
5677 for (rego
= gdbarch_registry
;
5681 const struct bfd_arch_info
*ap
;
5682 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
5684 internal_error (__FILE__
, __LINE__
,
5685 "gdbarch_architecture_names: multi-arch unknown");
5688 append_name (&arches
, &nr_arches
, ap
->printable_name
);
5693 append_name (&arches
, &nr_arches
, NULL
);
5697 /* Just return all the architectures that BFD knows. Assume that
5698 the legacy architecture framework supports them. */
5699 return bfd_arch_list ();
5704 gdbarch_register (enum bfd_architecture bfd_architecture
,
5705 gdbarch_init_ftype
*init
,
5706 gdbarch_dump_tdep_ftype
*dump_tdep
)
5708 struct gdbarch_registration
**curr
;
5709 const struct bfd_arch_info
*bfd_arch_info
;
5710 /* Check that BFD recognizes this architecture */
5711 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
5712 if (bfd_arch_info
== NULL
)
5714 internal_error (__FILE__
, __LINE__
,
5715 "gdbarch: Attempt to register unknown architecture (%d)",
5718 /* Check that we haven't seen this architecture before */
5719 for (curr
= &gdbarch_registry
;
5721 curr
= &(*curr
)->next
)
5723 if (bfd_architecture
== (*curr
)->bfd_architecture
)
5724 internal_error (__FILE__
, __LINE__
,
5725 "gdbarch: Duplicate registraration of architecture (%s)",
5726 bfd_arch_info
->printable_name
);
5730 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
5731 bfd_arch_info
->printable_name
,
5734 (*curr
) = XMALLOC (struct gdbarch_registration
);
5735 (*curr
)->bfd_architecture
= bfd_architecture
;
5736 (*curr
)->init
= init
;
5737 (*curr
)->dump_tdep
= dump_tdep
;
5738 (*curr
)->arches
= NULL
;
5739 (*curr
)->next
= NULL
;
5740 /* When non- multi-arch, install whatever target dump routine we've
5741 been provided - hopefully that routine has been written correctly
5742 and works regardless of multi-arch. */
5743 if (!GDB_MULTI_ARCH
&& dump_tdep
!= NULL
5744 && startup_gdbarch
.dump_tdep
== NULL
)
5745 startup_gdbarch
.dump_tdep
= dump_tdep
;
5749 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
5750 gdbarch_init_ftype
*init
)
5752 gdbarch_register (bfd_architecture
, init
, NULL
);
5756 /* Look for an architecture using gdbarch_info. Base search on only
5757 BFD_ARCH_INFO and BYTE_ORDER. */
5759 struct gdbarch_list
*
5760 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
5761 const struct gdbarch_info
*info
)
5763 for (; arches
!= NULL
; arches
= arches
->next
)
5765 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
5767 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
5769 if (info
->osabi
!= arches
->gdbarch
->osabi
)
5777 /* Update the current architecture. Return ZERO if the update request
5781 gdbarch_update_p (struct gdbarch_info info
)
5783 struct gdbarch
*new_gdbarch
;
5784 struct gdbarch
*old_gdbarch
;
5785 struct gdbarch_registration
*rego
;
5787 /* Fill in missing parts of the INFO struct using a number of
5788 sources: ``set ...''; INFOabfd supplied; existing target. */
5790 /* ``(gdb) set architecture ...'' */
5791 if (info
.bfd_arch_info
== NULL
5792 && !TARGET_ARCHITECTURE_AUTO
)
5793 info
.bfd_arch_info
= TARGET_ARCHITECTURE
;
5794 if (info
.bfd_arch_info
== NULL
5795 && info
.abfd
!= NULL
5796 && bfd_get_arch (info
.abfd
) != bfd_arch_unknown
5797 && bfd_get_arch (info
.abfd
) != bfd_arch_obscure
)
5798 info
.bfd_arch_info
= bfd_get_arch_info (info
.abfd
);
5799 if (info
.bfd_arch_info
== NULL
)
5800 info
.bfd_arch_info
= TARGET_ARCHITECTURE
;
5802 /* ``(gdb) set byte-order ...'' */
5803 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
5804 && !TARGET_BYTE_ORDER_AUTO
)
5805 info
.byte_order
= TARGET_BYTE_ORDER
;
5806 /* From the INFO struct. */
5807 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
5808 && info
.abfd
!= NULL
)
5809 info
.byte_order
= (bfd_big_endian (info
.abfd
) ? BFD_ENDIAN_BIG
5810 : bfd_little_endian (info
.abfd
) ? BFD_ENDIAN_LITTLE
5811 : BFD_ENDIAN_UNKNOWN
);
5812 /* From the current target. */
5813 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
5814 info
.byte_order
= TARGET_BYTE_ORDER
;
5816 /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi. */
5817 if (info
.osabi
== GDB_OSABI_UNINITIALIZED
)
5818 info
.osabi
= gdbarch_lookup_osabi (info
.abfd
);
5819 if (info
.osabi
== GDB_OSABI_UNINITIALIZED
)
5820 info
.osabi
= current_gdbarch
->osabi
;
5822 /* Must have found some sort of architecture. */
5823 gdb_assert (info
.bfd_arch_info
!= NULL
);
5827 fprintf_unfiltered (gdb_stdlog
,
5828 "gdbarch_update: info.bfd_arch_info %s\n",
5829 (info
.bfd_arch_info
!= NULL
5830 ? info
.bfd_arch_info
->printable_name
5832 fprintf_unfiltered (gdb_stdlog
,
5833 "gdbarch_update: info.byte_order %d (%s)\n",
5835 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
5836 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
5838 fprintf_unfiltered (gdb_stdlog
,
5839 "gdbarch_update: info.osabi %d (%s)\n",
5840 info
.osabi
, gdbarch_osabi_name (info
.osabi
));
5841 fprintf_unfiltered (gdb_stdlog
,
5842 "gdbarch_update: info.abfd 0x%lx\n",
5844 fprintf_unfiltered (gdb_stdlog
,
5845 "gdbarch_update: info.tdep_info 0x%lx\n",
5846 (long) info
.tdep_info
);
5849 /* Find the target that knows about this architecture. */
5850 for (rego
= gdbarch_registry
;
5853 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
5858 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: No matching architecture\n");
5862 /* Swap the data belonging to the old target out setting the
5863 installed data to zero. This stops the ->init() function trying
5864 to refer to the previous architecture's global data structures. */
5865 swapout_gdbarch_swap (current_gdbarch
);
5866 clear_gdbarch_swap (current_gdbarch
);
5868 /* Save the previously selected architecture, setting the global to
5869 NULL. This stops ->init() trying to use the previous
5870 architecture's configuration. The previous architecture may not
5871 even be of the same architecture family. The most recent
5872 architecture of the same family is found at the head of the
5873 rego->arches list. */
5874 old_gdbarch
= current_gdbarch
;
5875 current_gdbarch
= NULL
;
5877 /* Ask the target for a replacement architecture. */
5878 new_gdbarch
= rego
->init (info
, rego
->arches
);
5880 /* Did the target like it? No. Reject the change and revert to the
5881 old architecture. */
5882 if (new_gdbarch
== NULL
)
5885 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Target rejected architecture\n");
5886 swapin_gdbarch_swap (old_gdbarch
);
5887 current_gdbarch
= old_gdbarch
;
5891 /* Did the architecture change? No. Oops, put the old architecture
5893 if (old_gdbarch
== new_gdbarch
)
5896 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
5898 new_gdbarch
->bfd_arch_info
->printable_name
);
5899 swapin_gdbarch_swap (old_gdbarch
);
5900 current_gdbarch
= old_gdbarch
;
5904 /* Is this a pre-existing architecture? Yes. Move it to the front
5905 of the list of architectures (keeping the list sorted Most
5906 Recently Used) and then copy it in. */
5908 struct gdbarch_list
**list
;
5909 for (list
= ®o
->arches
;
5911 list
= &(*list
)->next
)
5913 if ((*list
)->gdbarch
== new_gdbarch
)
5915 struct gdbarch_list
*this;
5917 fprintf_unfiltered (gdb_stdlog
,
5918 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
5920 new_gdbarch
->bfd_arch_info
->printable_name
);
5923 (*list
) = this->next
;
5924 /* Insert in the front. */
5925 this->next
= rego
->arches
;
5926 rego
->arches
= this;
5927 /* Copy the new architecture in. */
5928 current_gdbarch
= new_gdbarch
;
5929 swapin_gdbarch_swap (new_gdbarch
);
5930 architecture_changed_event ();
5936 /* Prepend this new architecture to the architecture list (keep the
5937 list sorted Most Recently Used). */
5939 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
5940 this->next
= rego
->arches
;
5941 this->gdbarch
= new_gdbarch
;
5942 rego
->arches
= this;
5945 /* Switch to this new architecture marking it initialized. */
5946 current_gdbarch
= new_gdbarch
;
5947 current_gdbarch
->initialized_p
= 1;
5950 fprintf_unfiltered (gdb_stdlog
,
5951 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
5953 new_gdbarch
->bfd_arch_info
->printable_name
);
5956 /* Check that the newly installed architecture is valid. Plug in
5957 any post init values. */
5958 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
5959 verify_gdbarch (new_gdbarch
);
5961 /* Initialize the per-architecture memory (swap) areas.
5962 CURRENT_GDBARCH must be update before these modules are
5964 init_gdbarch_swap (new_gdbarch
);
5966 /* Initialize the per-architecture data. CURRENT_GDBARCH
5967 must be updated before these modules are called. */
5968 architecture_changed_event ();
5971 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
5979 /* Pointer to the target-dependent disassembly function. */
5980 int (*tm_print_insn
) (bfd_vma
, disassemble_info
*);
5981 disassemble_info tm_print_insn_info
;
5984 extern void _initialize_gdbarch (void);
5987 _initialize_gdbarch (void)
5989 struct cmd_list_element
*c
;
5991 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
5992 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
5993 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
5994 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
5995 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;
5997 add_show_from_set (add_set_cmd ("arch",
6000 (char *)&gdbarch_debug
,
6001 "Set architecture debugging.\n\
6002 When non-zero, architecture debugging is enabled.", &setdebuglist
),
6004 c
= add_set_cmd ("archdebug",
6007 (char *)&gdbarch_debug
,
6008 "Set architecture debugging.\n\
6009 When non-zero, architecture debugging is enabled.", &setlist
);
6011 deprecate_cmd (c
, "set debug arch");
6012 deprecate_cmd (add_show_from_set (c
, &showlist
), "show debug arch");