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_deprecated_dummy_write_sp_ftype *deprecated_dummy_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 deprecated_max_register_raw_size;
174 gdbarch_register_virtual_size_ftype *register_virtual_size;
175 int deprecated_max_register_virtual_size;
176 gdbarch_register_virtual_type_ftype *register_virtual_type;
177 gdbarch_register_type_ftype *register_type;
178 gdbarch_deprecated_do_registers_info_ftype *deprecated_do_registers_info;
179 gdbarch_print_registers_info_ftype *print_registers_info;
180 gdbarch_print_float_info_ftype *print_float_info;
181 gdbarch_print_vector_info_ftype *print_vector_info;
182 gdbarch_register_sim_regno_ftype *register_sim_regno;
183 gdbarch_register_bytes_ok_ftype *register_bytes_ok;
184 gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
185 gdbarch_cannot_store_register_ftype *cannot_store_register;
186 gdbarch_get_longjmp_target_ftype *get_longjmp_target;
187 int deprecated_use_generic_dummy_frames;
188 int call_dummy_location;
189 gdbarch_call_dummy_address_ftype *call_dummy_address;
190 CORE_ADDR call_dummy_start_offset;
191 CORE_ADDR call_dummy_breakpoint_offset;
192 int call_dummy_breakpoint_offset_p;
193 int call_dummy_length;
194 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 deprecated_call_dummy_stack_adjust;
198 gdbarch_fix_call_dummy_ftype *fix_call_dummy;
199 gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first;
200 gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
201 int believe_pcc_promotion;
202 int believe_pcc_promotion_type;
203 gdbarch_deprecated_get_saved_register_ftype *deprecated_get_saved_register;
204 gdbarch_register_convertible_ftype *register_convertible;
205 gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
206 gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
207 gdbarch_convert_register_p_ftype *convert_register_p;
208 gdbarch_register_to_value_ftype *register_to_value;
209 gdbarch_value_to_register_ftype *value_to_register;
210 gdbarch_pointer_to_address_ftype *pointer_to_address;
211 gdbarch_address_to_pointer_ftype *address_to_pointer;
212 gdbarch_integer_to_address_ftype *integer_to_address;
213 gdbarch_return_value_on_stack_ftype *return_value_on_stack;
214 gdbarch_deprecated_push_arguments_ftype *deprecated_push_arguments;
215 gdbarch_push_dummy_call_ftype *push_dummy_call;
216 gdbarch_deprecated_push_dummy_frame_ftype *deprecated_push_dummy_frame;
217 gdbarch_deprecated_push_return_address_ftype *deprecated_push_return_address;
218 gdbarch_deprecated_pop_frame_ftype *deprecated_pop_frame;
219 gdbarch_deprecated_store_struct_return_ftype *deprecated_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_deprecated_frame_init_saved_regs_ftype *deprecated_frame_init_saved_regs;
228 gdbarch_deprecated_init_extra_frame_info_ftype *deprecated_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_deprecated_frame_chain_ftype *deprecated_frame_chain;
242 gdbarch_deprecated_frame_chain_valid_ftype *deprecated_frame_chain_valid;
243 gdbarch_deprecated_frame_saved_pc_ftype *deprecated_frame_saved_pc;
244 gdbarch_unwind_pc_ftype *unwind_pc;
245 gdbarch_frame_args_address_ftype *frame_args_address;
246 gdbarch_frame_locals_address_ftype *frame_locals_address;
247 gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
248 gdbarch_frame_num_args_ftype *frame_num_args;
249 gdbarch_stack_align_ftype *stack_align;
250 gdbarch_frame_align_ftype *frame_align;
251 int deprecated_extra_stack_alignment_needed;
252 gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
253 gdbarch_save_dummy_frame_tos_ftype *save_dummy_frame_tos;
254 gdbarch_unwind_dummy_id_ftype *unwind_dummy_id;
256 const struct floatformat * float_format;
257 const struct floatformat * double_format;
258 const struct floatformat * long_double_format;
259 gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr;
260 gdbarch_addr_bits_remove_ftype *addr_bits_remove;
261 gdbarch_smash_text_address_ftype *smash_text_address;
262 gdbarch_software_single_step_ftype *software_single_step;
263 gdbarch_print_insn_ftype *print_insn;
264 gdbarch_skip_trampoline_code_ftype *skip_trampoline_code;
265 gdbarch_in_solib_call_trampoline_ftype *in_solib_call_trampoline;
266 gdbarch_in_solib_return_trampoline_ftype *in_solib_return_trampoline;
267 gdbarch_pc_in_sigtramp_ftype *pc_in_sigtramp;
268 gdbarch_sigtramp_start_ftype *sigtramp_start;
269 gdbarch_sigtramp_end_ftype *sigtramp_end;
270 gdbarch_in_function_epilogue_p_ftype *in_function_epilogue_p;
271 gdbarch_construct_inferior_arguments_ftype *construct_inferior_arguments;
272 gdbarch_dwarf2_build_frame_info_ftype *dwarf2_build_frame_info;
273 gdbarch_elf_make_msymbol_special_ftype *elf_make_msymbol_special;
274 gdbarch_coff_make_msymbol_special_ftype *coff_make_msymbol_special;
275 const char * name_of_malloc;
276 int cannot_step_breakpoint;
277 int have_nonsteppable_watchpoint;
278 gdbarch_address_class_type_flags_ftype *address_class_type_flags;
279 gdbarch_address_class_type_flags_to_name_ftype *address_class_type_flags_to_name;
280 gdbarch_address_class_name_to_type_flags_ftype *address_class_name_to_type_flags;
281 gdbarch_register_reggroup_p_ftype *register_reggroup_p;
285 /* The default architecture uses host values (for want of a better
288 extern const struct bfd_arch_info bfd_default_arch_struct;
290 struct gdbarch startup_gdbarch =
292 1, /* Always initialized. */
293 /* basic architecture information */
294 &bfd_default_arch_struct,
297 /* target specific vector and its dump routine */
299 /*per-architecture data-pointers and swap regions */
301 /* Multi-arch values */
305 8 * sizeof (LONGEST),
308 8 * sizeof (long double),
337 generic_register_byte,
338 generic_register_size,
340 generic_register_size,
345 default_print_registers_info,
360 generic_pc_in_call_dummy,
436 generic_in_function_epilogue_p,
437 construct_inferior_arguments,
447 default_register_reggroup_p,
448 /* startup_gdbarch() */
451 struct gdbarch *current_gdbarch = &startup_gdbarch;
453 /* Do any initialization needed for a non-multiarch configuration
454 after the _initialize_MODULE functions have been run. */
456 initialize_non_multiarch (void)
458 alloc_gdbarch_data (&startup_gdbarch);
459 /* Ensure that all swap areas are zeroed so that they again think
460 they are starting from scratch. */
461 clear_gdbarch_swap (&startup_gdbarch);
462 init_gdbarch_swap (&startup_gdbarch);
466 /* Create a new ``struct gdbarch'' based on information provided by
467 ``struct gdbarch_info''. */
470 gdbarch_alloc (const struct gdbarch_info *info,
471 struct gdbarch_tdep *tdep)
473 /* NOTE: The new architecture variable is named ``current_gdbarch''
474 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
475 the current local architecture and not the previous global
476 architecture. This ensures that the new architectures initial
477 values are not influenced by the previous architecture. Once
478 everything is parameterised with gdbarch, this will go away. */
479 struct gdbarch *current_gdbarch = XMALLOC (struct gdbarch);
480 memset (current_gdbarch, 0, sizeof (*current_gdbarch));
482 alloc_gdbarch_data (current_gdbarch);
484 current_gdbarch->tdep = tdep;
486 current_gdbarch->bfd_arch_info = info->bfd_arch_info;
487 current_gdbarch->byte_order = info->byte_order;
488 current_gdbarch->osabi = info->osabi;
490 /* Force the explicit initialization of these. */
491 current_gdbarch->short_bit = 2*TARGET_CHAR_BIT;
492 current_gdbarch->int_bit = 4*TARGET_CHAR_BIT;
493 current_gdbarch->long_bit = 4*TARGET_CHAR_BIT;
494 current_gdbarch->long_long_bit = 2*TARGET_LONG_BIT;
495 current_gdbarch->float_bit = 4*TARGET_CHAR_BIT;
496 current_gdbarch->double_bit = 8*TARGET_CHAR_BIT;
497 current_gdbarch->long_double_bit = 8*TARGET_CHAR_BIT;
498 current_gdbarch->ptr_bit = TARGET_INT_BIT;
499 current_gdbarch->bfd_vma_bit = TARGET_ARCHITECTURE->bits_per_address;
500 current_gdbarch->char_signed = -1;
501 current_gdbarch->read_pc = generic_target_read_pc;
502 current_gdbarch->write_pc = generic_target_write_pc;
503 current_gdbarch->read_fp = generic_target_read_fp;
504 current_gdbarch->read_sp = generic_target_read_sp;
505 current_gdbarch->virtual_frame_pointer = legacy_virtual_frame_pointer;
506 current_gdbarch->num_regs = -1;
507 current_gdbarch->sp_regnum = -1;
508 current_gdbarch->fp_regnum = -1;
509 current_gdbarch->pc_regnum = -1;
510 current_gdbarch->ps_regnum = -1;
511 current_gdbarch->fp0_regnum = -1;
512 current_gdbarch->npc_regnum = -1;
513 current_gdbarch->stab_reg_to_regnum = no_op_reg_to_regnum;
514 current_gdbarch->ecoff_reg_to_regnum = no_op_reg_to_regnum;
515 current_gdbarch->dwarf_reg_to_regnum = no_op_reg_to_regnum;
516 current_gdbarch->sdb_reg_to_regnum = no_op_reg_to_regnum;
517 current_gdbarch->dwarf2_reg_to_regnum = no_op_reg_to_regnum;
518 current_gdbarch->register_name = legacy_register_name;
519 current_gdbarch->register_size = -1;
520 current_gdbarch->register_bytes = -1;
521 current_gdbarch->register_byte = generic_register_byte;
522 current_gdbarch->register_raw_size = generic_register_size;
523 current_gdbarch->register_virtual_size = generic_register_size;
524 current_gdbarch->print_registers_info = default_print_registers_info;
525 current_gdbarch->register_sim_regno = legacy_register_sim_regno;
526 current_gdbarch->cannot_fetch_register = cannot_register_not;
527 current_gdbarch->cannot_store_register = cannot_register_not;
528 current_gdbarch->deprecated_use_generic_dummy_frames = 1;
529 current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
530 current_gdbarch->call_dummy_start_offset = -1;
531 current_gdbarch->call_dummy_breakpoint_offset = -1;
532 current_gdbarch->call_dummy_breakpoint_offset_p = -1;
533 current_gdbarch->call_dummy_length = -1;
534 current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy;
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->register_convertible = generic_register_convertible_not;
538 current_gdbarch->convert_register_p = legacy_convert_register_p;
539 current_gdbarch->register_to_value = legacy_register_to_value;
540 current_gdbarch->value_to_register = legacy_value_to_register;
541 current_gdbarch->pointer_to_address = unsigned_pointer_to_address;
542 current_gdbarch->address_to_pointer = unsigned_address_to_pointer;
543 current_gdbarch->return_value_on_stack = generic_return_value_on_stack_not;
544 current_gdbarch->extract_return_value = legacy_extract_return_value;
545 current_gdbarch->store_return_value = legacy_store_return_value;
546 current_gdbarch->use_struct_convention = generic_use_struct_convention;
547 current_gdbarch->prologue_frameless_p = generic_prologue_frameless_p;
548 current_gdbarch->breakpoint_from_pc = legacy_breakpoint_from_pc;
549 current_gdbarch->memory_insert_breakpoint = default_memory_insert_breakpoint;
550 current_gdbarch->memory_remove_breakpoint = default_memory_remove_breakpoint;
551 current_gdbarch->decr_pc_after_break = -1;
552 current_gdbarch->prepare_to_proceed = default_prepare_to_proceed;
553 current_gdbarch->function_start_offset = -1;
554 current_gdbarch->remote_translate_xfer_address = generic_remote_translate_xfer_address;
555 current_gdbarch->frame_args_skip = -1;
556 current_gdbarch->frameless_function_invocation = generic_frameless_function_invocation_not;
557 current_gdbarch->frame_args_address = get_frame_base;
558 current_gdbarch->frame_locals_address = get_frame_base;
559 current_gdbarch->convert_from_func_ptr_addr = core_addr_identity;
560 current_gdbarch->addr_bits_remove = core_addr_identity;
561 current_gdbarch->smash_text_address = core_addr_identity;
562 current_gdbarch->print_insn = legacy_print_insn;
563 current_gdbarch->skip_trampoline_code = generic_skip_trampoline_code;
564 current_gdbarch->in_solib_call_trampoline = generic_in_solib_call_trampoline;
565 current_gdbarch->in_solib_return_trampoline = generic_in_solib_return_trampoline;
566 current_gdbarch->pc_in_sigtramp = legacy_pc_in_sigtramp;
567 current_gdbarch->in_function_epilogue_p = generic_in_function_epilogue_p;
568 current_gdbarch->construct_inferior_arguments = construct_inferior_arguments;
569 current_gdbarch->elf_make_msymbol_special = default_elf_make_msymbol_special;
570 current_gdbarch->coff_make_msymbol_special = default_coff_make_msymbol_special;
571 current_gdbarch->name_of_malloc = "malloc";
572 current_gdbarch->register_reggroup_p = default_register_reggroup_p;
573 /* gdbarch_alloc() */
575 return current_gdbarch;
579 /* Free a gdbarch struct. This should never happen in normal
580 operation --- once you've created a gdbarch, you keep it around.
581 However, if an architecture's init function encounters an error
582 building the structure, it may need to clean up a partially
583 constructed gdbarch. */
586 gdbarch_free (struct gdbarch *arch)
588 gdb_assert (arch != NULL);
589 free_gdbarch_data (arch);
594 /* Ensure that all values in a GDBARCH are reasonable. */
597 verify_gdbarch (struct gdbarch *gdbarch)
600 struct cleanup *cleanups;
603 /* Only perform sanity checks on a multi-arch target. */
606 log = mem_fileopen ();
607 cleanups = make_cleanup_ui_file_delete (log);
609 if (gdbarch->byte_order == BFD_ENDIAN_UNKNOWN)
610 fprintf_unfiltered (log, "\n\tbyte-order");
611 if (gdbarch->bfd_arch_info == NULL)
612 fprintf_unfiltered (log, "\n\tbfd_arch_info");
613 /* Check those that need to be defined for the given multi-arch level. */
614 /* Skip verify of short_bit, invalid_p == 0 */
615 /* Skip verify of int_bit, invalid_p == 0 */
616 /* Skip verify of long_bit, invalid_p == 0 */
617 /* Skip verify of long_long_bit, invalid_p == 0 */
618 /* Skip verify of float_bit, invalid_p == 0 */
619 /* Skip verify of double_bit, invalid_p == 0 */
620 /* Skip verify of long_double_bit, invalid_p == 0 */
621 /* Skip verify of ptr_bit, invalid_p == 0 */
622 if (gdbarch->addr_bit == 0)
623 gdbarch->addr_bit = TARGET_PTR_BIT;
624 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
625 if (gdbarch->char_signed == -1)
626 gdbarch->char_signed = 1;
627 /* Skip verify of read_pc, invalid_p == 0 */
628 /* Skip verify of write_pc, invalid_p == 0 */
629 /* Skip verify of read_fp, invalid_p == 0 */
630 /* Skip verify of read_sp, invalid_p == 0 */
631 /* Skip verify of deprecated_dummy_write_sp, has predicate */
632 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
633 /* Skip verify of pseudo_register_read, has predicate */
634 /* Skip verify of pseudo_register_write, has predicate */
635 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
636 && (gdbarch->num_regs == -1))
637 fprintf_unfiltered (log, "\n\tnum_regs");
638 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
639 /* Skip verify of sp_regnum, invalid_p == 0 */
640 /* Skip verify of fp_regnum, invalid_p == 0 */
641 /* Skip verify of pc_regnum, invalid_p == 0 */
642 /* Skip verify of ps_regnum, invalid_p == 0 */
643 /* Skip verify of fp0_regnum, invalid_p == 0 */
644 /* Skip verify of npc_regnum, invalid_p == 0 */
645 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
646 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
647 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
648 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
649 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
650 /* Skip verify of register_name, invalid_p == 0 */
651 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
652 && (gdbarch->register_size == -1))
653 fprintf_unfiltered (log, "\n\tregister_size");
654 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
655 && (gdbarch->register_bytes == -1))
656 fprintf_unfiltered (log, "\n\tregister_bytes");
657 /* Skip verify of register_byte, invalid_p == 0 */
658 /* Skip verify of register_raw_size, invalid_p == 0 */
659 /* Skip verify of deprecated_max_register_raw_size, has predicate */
660 /* Skip verify of register_virtual_size, invalid_p == 0 */
661 /* Skip verify of deprecated_max_register_virtual_size, has predicate */
662 /* Skip verify of register_virtual_type, has predicate */
663 /* Skip verify of register_type, has predicate */
664 /* Skip verify of deprecated_do_registers_info, has predicate */
665 /* Skip verify of print_registers_info, invalid_p == 0 */
666 /* Skip verify of print_float_info, has predicate */
667 /* Skip verify of print_vector_info, has predicate */
668 /* Skip verify of register_sim_regno, invalid_p == 0 */
669 /* Skip verify of register_bytes_ok, has predicate */
670 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
671 /* Skip verify of cannot_store_register, invalid_p == 0 */
672 /* Skip verify of get_longjmp_target, has predicate */
673 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
674 /* Skip verify of call_dummy_location, invalid_p == 0 */
675 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
676 && (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
677 fprintf_unfiltered (log, "\n\tcall_dummy_address");
678 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
679 && (gdbarch->call_dummy_start_offset == -1))
680 fprintf_unfiltered (log, "\n\tcall_dummy_start_offset");
681 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
682 && (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1))
683 fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset");
684 if ((GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL)
685 && (gdbarch->call_dummy_breakpoint_offset_p == -1))
686 fprintf_unfiltered (log, "\n\tcall_dummy_breakpoint_offset_p");
687 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
688 && (gdbarch->call_dummy_length == -1))
689 fprintf_unfiltered (log, "\n\tcall_dummy_length");
690 /* Skip verify of deprecated_pc_in_call_dummy, has predicate */
691 /* Skip verify of call_dummy_words, invalid_p == 0 */
692 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
693 /* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
694 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
695 && (gdbarch->fix_call_dummy == 0))
696 fprintf_unfiltered (log, "\n\tfix_call_dummy");
697 /* Skip verify of deprecated_init_frame_pc_first, has predicate */
698 /* Skip verify of deprecated_init_frame_pc, has predicate */
699 /* Skip verify of deprecated_get_saved_register, has predicate */
700 /* Skip verify of register_convertible, invalid_p == 0 */
701 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
702 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
703 /* Skip verify of convert_register_p, invalid_p == 0 */
704 /* Skip verify of register_to_value, invalid_p == 0 */
705 /* Skip verify of value_to_register, invalid_p == 0 */
706 /* Skip verify of pointer_to_address, invalid_p == 0 */
707 /* Skip verify of address_to_pointer, invalid_p == 0 */
708 /* Skip verify of integer_to_address, has predicate */
709 /* Skip verify of return_value_on_stack, invalid_p == 0 */
710 /* Skip verify of deprecated_push_arguments, has predicate */
711 /* Skip verify of push_dummy_call, has predicate */
712 /* Skip verify of deprecated_push_dummy_frame, has predicate */
713 /* Skip verify of deprecated_push_return_address, has predicate */
714 /* Skip verify of deprecated_pop_frame, has predicate */
715 /* Skip verify of deprecated_store_struct_return, has predicate */
716 /* Skip verify of extract_return_value, invalid_p == 0 */
717 /* Skip verify of store_return_value, invalid_p == 0 */
718 /* Skip verify of extract_struct_value_address, has predicate */
719 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
720 /* Skip verify of use_struct_convention, invalid_p == 0 */
721 /* Skip verify of deprecated_frame_init_saved_regs, has predicate */
722 /* Skip verify of deprecated_init_extra_frame_info, has predicate */
723 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
724 && (gdbarch->skip_prologue == 0))
725 fprintf_unfiltered (log, "\n\tskip_prologue");
726 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
727 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
728 && (gdbarch->inner_than == 0))
729 fprintf_unfiltered (log, "\n\tinner_than");
730 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
731 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
732 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
733 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
734 && (gdbarch->decr_pc_after_break == -1))
735 fprintf_unfiltered (log, "\n\tdecr_pc_after_break");
736 /* Skip verify of prepare_to_proceed, invalid_p == 0 */
737 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
738 && (gdbarch->function_start_offset == -1))
739 fprintf_unfiltered (log, "\n\tfunction_start_offset");
740 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
741 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
742 && (gdbarch->frame_args_skip == -1))
743 fprintf_unfiltered (log, "\n\tframe_args_skip");
744 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
745 /* Skip verify of deprecated_frame_chain, has predicate */
746 /* Skip verify of deprecated_frame_chain_valid, has predicate */
747 /* Skip verify of deprecated_frame_saved_pc, has predicate */
748 /* Skip verify of unwind_pc, has predicate */
749 /* Skip verify of frame_args_address, invalid_p == 0 */
750 /* Skip verify of frame_locals_address, invalid_p == 0 */
751 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
752 && (gdbarch->saved_pc_after_call == 0))
753 fprintf_unfiltered (log, "\n\tsaved_pc_after_call");
754 if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
755 && (gdbarch->frame_num_args == 0))
756 fprintf_unfiltered (log, "\n\tframe_num_args");
757 /* Skip verify of stack_align, has predicate */
758 /* Skip verify of frame_align, has predicate */
759 /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
760 /* Skip verify of reg_struct_has_addr, has predicate */
761 /* Skip verify of save_dummy_frame_tos, has predicate */
762 /* Skip verify of unwind_dummy_id, has predicate */
763 if (gdbarch->float_format == 0)
764 gdbarch->float_format = default_float_format (gdbarch);
765 if (gdbarch->double_format == 0)
766 gdbarch->double_format = default_double_format (gdbarch);
767 if (gdbarch->long_double_format == 0)
768 gdbarch->long_double_format = default_double_format (gdbarch);
769 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
770 /* Skip verify of addr_bits_remove, invalid_p == 0 */
771 /* Skip verify of smash_text_address, invalid_p == 0 */
772 /* Skip verify of software_single_step, has predicate */
773 /* Skip verify of print_insn, invalid_p == 0 */
774 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
775 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
776 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
777 /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
778 /* Skip verify of sigtramp_start, has predicate */
779 /* Skip verify of sigtramp_end, has predicate */
780 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
781 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
782 /* Skip verify of dwarf2_build_frame_info, has predicate */
783 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
784 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
785 /* Skip verify of name_of_malloc, invalid_p == 0 */
786 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
787 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
788 /* Skip verify of address_class_type_flags, has predicate */
789 /* Skip verify of address_class_type_flags_to_name, has predicate */
790 /* Skip verify of address_class_name_to_type_flags, has predicate */
791 /* Skip verify of register_reggroup_p, invalid_p == 0 */
792 buf = ui_file_xstrdup (log, &dummy);
793 make_cleanup (xfree, buf);
794 if (strlen (buf) > 0)
795 internal_error (__FILE__, __LINE__,
796 "verify_gdbarch: the following are invalid ...%s",
798 do_cleanups (cleanups);
802 /* Print out the details of the current architecture. */
804 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
805 just happens to match the global variable ``current_gdbarch''. That
806 way macros refering to that variable get the local and not the global
807 version - ulgh. Once everything is parameterised with gdbarch, this
811 gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
813 fprintf_unfiltered (file,
814 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
817 fprintf_unfiltered (file,
818 "gdbarch_dump: gdbarch_frame_align_p() = %d\n",
819 gdbarch_frame_align_p (current_gdbarch));
821 fprintf_unfiltered (file,
822 "gdbarch_dump: frame_align = 0x%08lx\n",
823 (long) current_gdbarch->frame_align);
825 fprintf_unfiltered (file,
826 "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
827 (long) current_gdbarch->in_function_epilogue_p);
829 fprintf_unfiltered (file,
830 "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
831 (long) current_gdbarch->register_reggroup_p);
833 fprintf_unfiltered (file,
834 "gdbarch_dump: gdbarch_pseudo_register_read_p() = %d\n",
835 gdbarch_pseudo_register_read_p (current_gdbarch));
837 fprintf_unfiltered (file,
838 "gdbarch_dump: pseudo_register_read = 0x%08lx\n",
839 (long) current_gdbarch->pseudo_register_read);
841 fprintf_unfiltered (file,
842 "gdbarch_dump: gdbarch_pseudo_register_write_p() = %d\n",
843 gdbarch_pseudo_register_write_p (current_gdbarch));
845 fprintf_unfiltered (file,
846 "gdbarch_dump: pseudo_register_write = 0x%08lx\n",
847 (long) current_gdbarch->pseudo_register_write);
849 fprintf_unfiltered (file,
850 "gdbarch_dump: gdbarch_address_class_name_to_type_flags_p() = %d\n",
851 gdbarch_address_class_name_to_type_flags_p (current_gdbarch));
853 fprintf_unfiltered (file,
854 "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
855 (long) current_gdbarch->address_class_name_to_type_flags);
856 #ifdef ADDRESS_CLASS_TYPE_FLAGS_P
857 fprintf_unfiltered (file,
858 "gdbarch_dump: %s # %s\n",
859 "ADDRESS_CLASS_TYPE_FLAGS_P()",
860 XSTRING (ADDRESS_CLASS_TYPE_FLAGS_P ()));
861 fprintf_unfiltered (file,
862 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS_P() = %d\n",
863 ADDRESS_CLASS_TYPE_FLAGS_P ());
865 #ifdef ADDRESS_CLASS_TYPE_FLAGS
866 fprintf_unfiltered (file,
867 "gdbarch_dump: %s # %s\n",
868 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
869 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size, dwarf2_addr_class)));
871 fprintf_unfiltered (file,
872 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = <0x%08lx>\n",
873 (long) current_gdbarch->address_class_type_flags
874 /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
877 fprintf_unfiltered (file,
878 "gdbarch_dump: gdbarch_address_class_type_flags_to_name_p() = %d\n",
879 gdbarch_address_class_type_flags_to_name_p (current_gdbarch));
881 fprintf_unfiltered (file,
882 "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
883 (long) current_gdbarch->address_class_type_flags_to_name);
884 #ifdef ADDRESS_TO_POINTER
886 /* Macro might contain `[{}]' when not multi-arch */
887 fprintf_unfiltered (file,
888 "gdbarch_dump: %s # %s\n",
889 "ADDRESS_TO_POINTER(type, buf, addr)",
890 XSTRING (ADDRESS_TO_POINTER (type, buf, addr)));
893 fprintf_unfiltered (file,
894 "gdbarch_dump: ADDRESS_TO_POINTER = <0x%08lx>\n",
895 (long) current_gdbarch->address_to_pointer
896 /*ADDRESS_TO_POINTER ()*/);
898 #ifdef ADDR_BITS_REMOVE
899 fprintf_unfiltered (file,
900 "gdbarch_dump: %s # %s\n",
901 "ADDR_BITS_REMOVE(addr)",
902 XSTRING (ADDR_BITS_REMOVE (addr)));
904 fprintf_unfiltered (file,
905 "gdbarch_dump: ADDR_BITS_REMOVE = <0x%08lx>\n",
906 (long) current_gdbarch->addr_bits_remove
907 /*ADDR_BITS_REMOVE ()*/);
909 #ifdef BELIEVE_PCC_PROMOTION
910 fprintf_unfiltered (file,
911 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
912 XSTRING (BELIEVE_PCC_PROMOTION));
913 fprintf_unfiltered (file,
914 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %d\n",
915 BELIEVE_PCC_PROMOTION);
917 #ifdef BELIEVE_PCC_PROMOTION_TYPE
918 fprintf_unfiltered (file,
919 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
920 XSTRING (BELIEVE_PCC_PROMOTION_TYPE));
921 fprintf_unfiltered (file,
922 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %d\n",
923 BELIEVE_PCC_PROMOTION_TYPE);
925 #ifdef BREAKPOINT_FROM_PC
926 fprintf_unfiltered (file,
927 "gdbarch_dump: %s # %s\n",
928 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
929 XSTRING (BREAKPOINT_FROM_PC (pcptr, lenptr)));
931 fprintf_unfiltered (file,
932 "gdbarch_dump: BREAKPOINT_FROM_PC = <0x%08lx>\n",
933 (long) current_gdbarch->breakpoint_from_pc
934 /*BREAKPOINT_FROM_PC ()*/);
936 #ifdef CALL_DUMMY_ADDRESS
937 fprintf_unfiltered (file,
938 "gdbarch_dump: %s # %s\n",
939 "CALL_DUMMY_ADDRESS()",
940 XSTRING (CALL_DUMMY_ADDRESS ()));
942 fprintf_unfiltered (file,
943 "gdbarch_dump: CALL_DUMMY_ADDRESS = <0x%08lx>\n",
944 (long) current_gdbarch->call_dummy_address
945 /*CALL_DUMMY_ADDRESS ()*/);
947 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
948 fprintf_unfiltered (file,
949 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
950 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET));
951 if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
952 fprintf_unfiltered (file,
953 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
954 (long) CALL_DUMMY_BREAKPOINT_OFFSET);
956 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
957 fprintf_unfiltered (file,
958 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
959 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P));
960 fprintf_unfiltered (file,
961 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %d\n",
962 CALL_DUMMY_BREAKPOINT_OFFSET_P);
964 #ifdef CALL_DUMMY_LENGTH
965 fprintf_unfiltered (file,
966 "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
967 XSTRING (CALL_DUMMY_LENGTH));
968 if (gdbarch->call_dummy_length >= 0)
969 fprintf_unfiltered (file,
970 "gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
973 #ifdef CALL_DUMMY_LOCATION
974 fprintf_unfiltered (file,
975 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
976 XSTRING (CALL_DUMMY_LOCATION));
977 fprintf_unfiltered (file,
978 "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
979 CALL_DUMMY_LOCATION);
981 #ifdef CALL_DUMMY_START_OFFSET
982 fprintf_unfiltered (file,
983 "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
984 XSTRING (CALL_DUMMY_START_OFFSET));
985 fprintf_unfiltered (file,
986 "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
987 (long) CALL_DUMMY_START_OFFSET);
989 #ifdef CALL_DUMMY_WORDS
990 fprintf_unfiltered (file,
991 "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
992 XSTRING (CALL_DUMMY_WORDS));
993 fprintf_unfiltered (file,
994 "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
995 (long) CALL_DUMMY_WORDS);
997 #ifdef CANNOT_FETCH_REGISTER
998 fprintf_unfiltered (file,
999 "gdbarch_dump: %s # %s\n",
1000 "CANNOT_FETCH_REGISTER(regnum)",
1001 XSTRING (CANNOT_FETCH_REGISTER (regnum)));
1003 fprintf_unfiltered (file,
1004 "gdbarch_dump: CANNOT_FETCH_REGISTER = <0x%08lx>\n",
1005 (long) current_gdbarch->cannot_fetch_register
1006 /*CANNOT_FETCH_REGISTER ()*/);
1008 #ifdef CANNOT_STEP_BREAKPOINT
1009 fprintf_unfiltered (file,
1010 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
1011 XSTRING (CANNOT_STEP_BREAKPOINT));
1012 fprintf_unfiltered (file,
1013 "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n",
1014 CANNOT_STEP_BREAKPOINT);
1016 #ifdef CANNOT_STORE_REGISTER
1017 fprintf_unfiltered (file,
1018 "gdbarch_dump: %s # %s\n",
1019 "CANNOT_STORE_REGISTER(regnum)",
1020 XSTRING (CANNOT_STORE_REGISTER (regnum)));
1022 fprintf_unfiltered (file,
1023 "gdbarch_dump: CANNOT_STORE_REGISTER = <0x%08lx>\n",
1024 (long) current_gdbarch->cannot_store_register
1025 /*CANNOT_STORE_REGISTER ()*/);
1027 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
1029 /* Macro might contain `[{}]' when not multi-arch */
1030 fprintf_unfiltered (file,
1031 "gdbarch_dump: %s # %s\n",
1032 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
1033 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val, msym)));
1036 fprintf_unfiltered (file,
1037 "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1038 (long) current_gdbarch->coff_make_msymbol_special
1039 /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
1042 fprintf_unfiltered (file,
1043 "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
1044 (long) current_gdbarch->construct_inferior_arguments);
1045 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1046 fprintf_unfiltered (file,
1047 "gdbarch_dump: %s # %s\n",
1048 "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
1049 XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr)));
1051 fprintf_unfiltered (file,
1052 "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = <0x%08lx>\n",
1053 (long) current_gdbarch->convert_from_func_ptr_addr
1054 /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
1056 #ifdef CONVERT_REGISTER_P
1057 fprintf_unfiltered (file,
1058 "gdbarch_dump: %s # %s\n",
1059 "CONVERT_REGISTER_P(regnum)",
1060 XSTRING (CONVERT_REGISTER_P (regnum)));
1062 fprintf_unfiltered (file,
1063 "gdbarch_dump: CONVERT_REGISTER_P = <0x%08lx>\n",
1064 (long) current_gdbarch->convert_register_p
1065 /*CONVERT_REGISTER_P ()*/);
1067 #ifdef DECR_PC_AFTER_BREAK
1068 fprintf_unfiltered (file,
1069 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1070 XSTRING (DECR_PC_AFTER_BREAK));
1071 fprintf_unfiltered (file,
1072 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1073 (long) DECR_PC_AFTER_BREAK);
1075 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST_P
1076 fprintf_unfiltered (file,
1077 "gdbarch_dump: %s # %s\n",
1078 "DEPRECATED_CALL_DUMMY_STACK_ADJUST_P()",
1079 XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()));
1080 fprintf_unfiltered (file,
1081 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST_P() = %d\n",
1082 DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ());
1084 #ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST
1085 fprintf_unfiltered (file,
1086 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST # %s\n",
1087 XSTRING (DEPRECATED_CALL_DUMMY_STACK_ADJUST));
1088 fprintf_unfiltered (file,
1089 "gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST = %d\n",
1090 DEPRECATED_CALL_DUMMY_STACK_ADJUST);
1092 #ifdef DEPRECATED_DO_REGISTERS_INFO_P
1093 fprintf_unfiltered (file,
1094 "gdbarch_dump: %s # %s\n",
1095 "DEPRECATED_DO_REGISTERS_INFO_P()",
1096 XSTRING (DEPRECATED_DO_REGISTERS_INFO_P ()));
1097 fprintf_unfiltered (file,
1098 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO_P() = %d\n",
1099 DEPRECATED_DO_REGISTERS_INFO_P ());
1101 #ifdef DEPRECATED_DO_REGISTERS_INFO
1103 /* Macro might contain `[{}]' when not multi-arch */
1104 fprintf_unfiltered (file,
1105 "gdbarch_dump: %s # %s\n",
1106 "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
1107 XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr, fpregs)));
1110 fprintf_unfiltered (file,
1111 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = <0x%08lx>\n",
1112 (long) current_gdbarch->deprecated_do_registers_info
1113 /*DEPRECATED_DO_REGISTERS_INFO ()*/);
1115 #ifdef DEPRECATED_DUMMY_WRITE_SP_P
1116 fprintf_unfiltered (file,
1117 "gdbarch_dump: %s # %s\n",
1118 "DEPRECATED_DUMMY_WRITE_SP_P()",
1119 XSTRING (DEPRECATED_DUMMY_WRITE_SP_P ()));
1120 fprintf_unfiltered (file,
1121 "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP_P() = %d\n",
1122 DEPRECATED_DUMMY_WRITE_SP_P ());
1124 #ifdef DEPRECATED_DUMMY_WRITE_SP
1126 /* Macro might contain `[{}]' when not multi-arch */
1127 fprintf_unfiltered (file,
1128 "gdbarch_dump: %s # %s\n",
1129 "DEPRECATED_DUMMY_WRITE_SP(val)",
1130 XSTRING (DEPRECATED_DUMMY_WRITE_SP (val)));
1133 fprintf_unfiltered (file,
1134 "gdbarch_dump: DEPRECATED_DUMMY_WRITE_SP = <0x%08lx>\n",
1135 (long) current_gdbarch->deprecated_dummy_write_sp
1136 /*DEPRECATED_DUMMY_WRITE_SP ()*/);
1138 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
1140 /* Macro might contain `[{}]' when not multi-arch */
1141 fprintf_unfiltered (file,
1142 "gdbarch_dump: %s # %s\n",
1143 "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1144 XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type, regbuf, valbuf)));
1147 fprintf_unfiltered (file,
1148 "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1149 (long) current_gdbarch->deprecated_extract_return_value
1150 /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
1152 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P
1153 fprintf_unfiltered (file,
1154 "gdbarch_dump: %s # %s\n",
1155 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1156 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1157 fprintf_unfiltered (file,
1158 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1159 DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1161 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
1162 fprintf_unfiltered (file,
1163 "gdbarch_dump: %s # %s\n",
1164 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1165 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf)));
1167 fprintf_unfiltered (file,
1168 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1169 (long) current_gdbarch->deprecated_extract_struct_value_address
1170 /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1172 #ifdef DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED
1173 fprintf_unfiltered (file,
1174 "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1175 XSTRING (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED));
1176 fprintf_unfiltered (file,
1177 "gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
1178 DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED);
1180 #ifdef DEPRECATED_FRAME_CHAIN_P
1181 fprintf_unfiltered (file,
1182 "gdbarch_dump: %s # %s\n",
1183 "DEPRECATED_FRAME_CHAIN_P()",
1184 XSTRING (DEPRECATED_FRAME_CHAIN_P ()));
1185 fprintf_unfiltered (file,
1186 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n",
1187 DEPRECATED_FRAME_CHAIN_P ());
1189 #ifdef DEPRECATED_FRAME_CHAIN
1190 fprintf_unfiltered (file,
1191 "gdbarch_dump: %s # %s\n",
1192 "DEPRECATED_FRAME_CHAIN(frame)",
1193 XSTRING (DEPRECATED_FRAME_CHAIN (frame)));
1195 fprintf_unfiltered (file,
1196 "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n",
1197 (long) current_gdbarch->deprecated_frame_chain
1198 /*DEPRECATED_FRAME_CHAIN ()*/);
1200 #ifdef DEPRECATED_FRAME_CHAIN_VALID_P
1201 fprintf_unfiltered (file,
1202 "gdbarch_dump: %s # %s\n",
1203 "DEPRECATED_FRAME_CHAIN_VALID_P()",
1204 XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ()));
1205 fprintf_unfiltered (file,
1206 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n",
1207 DEPRECATED_FRAME_CHAIN_VALID_P ());
1209 #ifdef DEPRECATED_FRAME_CHAIN_VALID
1210 fprintf_unfiltered (file,
1211 "gdbarch_dump: %s # %s\n",
1212 "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)",
1213 XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain, thisframe)));
1215 fprintf_unfiltered (file,
1216 "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n",
1217 (long) current_gdbarch->deprecated_frame_chain_valid
1218 /*DEPRECATED_FRAME_CHAIN_VALID ()*/);
1220 #ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P
1221 fprintf_unfiltered (file,
1222 "gdbarch_dump: %s # %s\n",
1223 "DEPRECATED_FRAME_INIT_SAVED_REGS_P()",
1224 XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()));
1225 fprintf_unfiltered (file,
1226 "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS_P() = %d\n",
1227 DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
1229 #ifdef DEPRECATED_FRAME_INIT_SAVED_REGS
1231 /* Macro might contain `[{}]' when not multi-arch */
1232 fprintf_unfiltered (file,
1233 "gdbarch_dump: %s # %s\n",
1234 "DEPRECATED_FRAME_INIT_SAVED_REGS(frame)",
1235 XSTRING (DEPRECATED_FRAME_INIT_SAVED_REGS (frame)));
1238 fprintf_unfiltered (file,
1239 "gdbarch_dump: DEPRECATED_FRAME_INIT_SAVED_REGS = <0x%08lx>\n",
1240 (long) current_gdbarch->deprecated_frame_init_saved_regs
1241 /*DEPRECATED_FRAME_INIT_SAVED_REGS ()*/);
1243 #ifdef DEPRECATED_FRAME_SAVED_PC_P
1244 fprintf_unfiltered (file,
1245 "gdbarch_dump: %s # %s\n",
1246 "DEPRECATED_FRAME_SAVED_PC_P()",
1247 XSTRING (DEPRECATED_FRAME_SAVED_PC_P ()));
1248 fprintf_unfiltered (file,
1249 "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC_P() = %d\n",
1250 DEPRECATED_FRAME_SAVED_PC_P ());
1252 #ifdef DEPRECATED_FRAME_SAVED_PC
1253 fprintf_unfiltered (file,
1254 "gdbarch_dump: %s # %s\n",
1255 "DEPRECATED_FRAME_SAVED_PC(fi)",
1256 XSTRING (DEPRECATED_FRAME_SAVED_PC (fi)));
1258 fprintf_unfiltered (file,
1259 "gdbarch_dump: DEPRECATED_FRAME_SAVED_PC = <0x%08lx>\n",
1260 (long) current_gdbarch->deprecated_frame_saved_pc
1261 /*DEPRECATED_FRAME_SAVED_PC ()*/);
1263 #ifdef DEPRECATED_GET_SAVED_REGISTER_P
1264 fprintf_unfiltered (file,
1265 "gdbarch_dump: %s # %s\n",
1266 "DEPRECATED_GET_SAVED_REGISTER_P()",
1267 XSTRING (DEPRECATED_GET_SAVED_REGISTER_P ()));
1268 fprintf_unfiltered (file,
1269 "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER_P() = %d\n",
1270 DEPRECATED_GET_SAVED_REGISTER_P ());
1272 #ifdef DEPRECATED_GET_SAVED_REGISTER
1274 /* Macro might contain `[{}]' when not multi-arch */
1275 fprintf_unfiltered (file,
1276 "gdbarch_dump: %s # %s\n",
1277 "DEPRECATED_GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1278 XSTRING (DEPRECATED_GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval)));
1281 fprintf_unfiltered (file,
1282 "gdbarch_dump: DEPRECATED_GET_SAVED_REGISTER = <0x%08lx>\n",
1283 (long) current_gdbarch->deprecated_get_saved_register
1284 /*DEPRECATED_GET_SAVED_REGISTER ()*/);
1286 #ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO_P
1287 fprintf_unfiltered (file,
1288 "gdbarch_dump: %s # %s\n",
1289 "DEPRECATED_INIT_EXTRA_FRAME_INFO_P()",
1290 XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()));
1291 fprintf_unfiltered (file,
1292 "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO_P() = %d\n",
1293 DEPRECATED_INIT_EXTRA_FRAME_INFO_P ());
1295 #ifdef DEPRECATED_INIT_EXTRA_FRAME_INFO
1297 /* Macro might contain `[{}]' when not multi-arch */
1298 fprintf_unfiltered (file,
1299 "gdbarch_dump: %s # %s\n",
1300 "DEPRECATED_INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1301 XSTRING (DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf, frame)));
1304 fprintf_unfiltered (file,
1305 "gdbarch_dump: DEPRECATED_INIT_EXTRA_FRAME_INFO = <0x%08lx>\n",
1306 (long) current_gdbarch->deprecated_init_extra_frame_info
1307 /*DEPRECATED_INIT_EXTRA_FRAME_INFO ()*/);
1309 #ifdef DEPRECATED_INIT_FRAME_PC_P
1310 fprintf_unfiltered (file,
1311 "gdbarch_dump: %s # %s\n",
1312 "DEPRECATED_INIT_FRAME_PC_P()",
1313 XSTRING (DEPRECATED_INIT_FRAME_PC_P ()));
1314 fprintf_unfiltered (file,
1315 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_P() = %d\n",
1316 DEPRECATED_INIT_FRAME_PC_P ());
1318 #ifdef DEPRECATED_INIT_FRAME_PC
1319 fprintf_unfiltered (file,
1320 "gdbarch_dump: %s # %s\n",
1321 "DEPRECATED_INIT_FRAME_PC(fromleaf, prev)",
1322 XSTRING (DEPRECATED_INIT_FRAME_PC (fromleaf, prev)));
1324 fprintf_unfiltered (file,
1325 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC = <0x%08lx>\n",
1326 (long) current_gdbarch->deprecated_init_frame_pc
1327 /*DEPRECATED_INIT_FRAME_PC ()*/);
1329 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST_P
1330 fprintf_unfiltered (file,
1331 "gdbarch_dump: %s # %s\n",
1332 "DEPRECATED_INIT_FRAME_PC_FIRST_P()",
1333 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST_P ()));
1334 fprintf_unfiltered (file,
1335 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST_P() = %d\n",
1336 DEPRECATED_INIT_FRAME_PC_FIRST_P ());
1338 #ifdef DEPRECATED_INIT_FRAME_PC_FIRST
1339 fprintf_unfiltered (file,
1340 "gdbarch_dump: %s # %s\n",
1341 "DEPRECATED_INIT_FRAME_PC_FIRST(fromleaf, prev)",
1342 XSTRING (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev)));
1344 fprintf_unfiltered (file,
1345 "gdbarch_dump: DEPRECATED_INIT_FRAME_PC_FIRST = <0x%08lx>\n",
1346 (long) current_gdbarch->deprecated_init_frame_pc_first
1347 /*DEPRECATED_INIT_FRAME_PC_FIRST ()*/);
1349 #ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE_P
1350 fprintf_unfiltered (file,
1351 "gdbarch_dump: %s # %s\n",
1352 "DEPRECATED_MAX_REGISTER_RAW_SIZE_P()",
1353 XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ()));
1354 fprintf_unfiltered (file,
1355 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE_P() = %d\n",
1356 DEPRECATED_MAX_REGISTER_RAW_SIZE_P ());
1358 #ifdef DEPRECATED_MAX_REGISTER_RAW_SIZE
1359 fprintf_unfiltered (file,
1360 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE # %s\n",
1361 XSTRING (DEPRECATED_MAX_REGISTER_RAW_SIZE));
1362 fprintf_unfiltered (file,
1363 "gdbarch_dump: DEPRECATED_MAX_REGISTER_RAW_SIZE = %d\n",
1364 DEPRECATED_MAX_REGISTER_RAW_SIZE);
1366 #ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P
1367 fprintf_unfiltered (file,
1368 "gdbarch_dump: %s # %s\n",
1369 "DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P()",
1370 XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ()));
1371 fprintf_unfiltered (file,
1372 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P() = %d\n",
1373 DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ());
1375 #ifdef DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE
1376 fprintf_unfiltered (file,
1377 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1378 XSTRING (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE));
1379 fprintf_unfiltered (file,
1380 "gdbarch_dump: DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE = %d\n",
1381 DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE);
1383 #ifdef DEPRECATED_PC_IN_CALL_DUMMY_P
1384 fprintf_unfiltered (file,
1385 "gdbarch_dump: %s # %s\n",
1386 "DEPRECATED_PC_IN_CALL_DUMMY_P()",
1387 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY_P ()));
1388 fprintf_unfiltered (file,
1389 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY_P() = %d\n",
1390 DEPRECATED_PC_IN_CALL_DUMMY_P ());
1392 #ifdef DEPRECATED_PC_IN_CALL_DUMMY
1393 fprintf_unfiltered (file,
1394 "gdbarch_dump: %s # %s\n",
1395 "DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1396 XSTRING (DEPRECATED_PC_IN_CALL_DUMMY (pc, sp, frame_address)));
1398 fprintf_unfiltered (file,
1399 "gdbarch_dump: DEPRECATED_PC_IN_CALL_DUMMY = <0x%08lx>\n",
1400 (long) current_gdbarch->deprecated_pc_in_call_dummy
1401 /*DEPRECATED_PC_IN_CALL_DUMMY ()*/);
1403 #ifdef DEPRECATED_POP_FRAME_P
1404 fprintf_unfiltered (file,
1405 "gdbarch_dump: %s # %s\n",
1406 "DEPRECATED_POP_FRAME_P()",
1407 XSTRING (DEPRECATED_POP_FRAME_P ()));
1408 fprintf_unfiltered (file,
1409 "gdbarch_dump: DEPRECATED_POP_FRAME_P() = %d\n",
1410 DEPRECATED_POP_FRAME_P ());
1412 #ifdef DEPRECATED_POP_FRAME
1414 /* Macro might contain `[{}]' when not multi-arch */
1415 fprintf_unfiltered (file,
1416 "gdbarch_dump: %s # %s\n",
1417 "DEPRECATED_POP_FRAME(-)",
1418 XSTRING (DEPRECATED_POP_FRAME (-)));
1421 fprintf_unfiltered (file,
1422 "gdbarch_dump: DEPRECATED_POP_FRAME = <0x%08lx>\n",
1423 (long) current_gdbarch->deprecated_pop_frame
1424 /*DEPRECATED_POP_FRAME ()*/);
1426 #ifdef DEPRECATED_PUSH_ARGUMENTS_P
1427 fprintf_unfiltered (file,
1428 "gdbarch_dump: %s # %s\n",
1429 "DEPRECATED_PUSH_ARGUMENTS_P()",
1430 XSTRING (DEPRECATED_PUSH_ARGUMENTS_P ()));
1431 fprintf_unfiltered (file,
1432 "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS_P() = %d\n",
1433 DEPRECATED_PUSH_ARGUMENTS_P ());
1435 #ifdef DEPRECATED_PUSH_ARGUMENTS
1436 fprintf_unfiltered (file,
1437 "gdbarch_dump: %s # %s\n",
1438 "DEPRECATED_PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1439 XSTRING (DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr)));
1441 fprintf_unfiltered (file,
1442 "gdbarch_dump: DEPRECATED_PUSH_ARGUMENTS = <0x%08lx>\n",
1443 (long) current_gdbarch->deprecated_push_arguments
1444 /*DEPRECATED_PUSH_ARGUMENTS ()*/);
1446 #ifdef DEPRECATED_PUSH_DUMMY_FRAME_P
1447 fprintf_unfiltered (file,
1448 "gdbarch_dump: %s # %s\n",
1449 "DEPRECATED_PUSH_DUMMY_FRAME_P()",
1450 XSTRING (DEPRECATED_PUSH_DUMMY_FRAME_P ()));
1451 fprintf_unfiltered (file,
1452 "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME_P() = %d\n",
1453 DEPRECATED_PUSH_DUMMY_FRAME_P ());
1455 #ifdef DEPRECATED_PUSH_DUMMY_FRAME
1457 /* Macro might contain `[{}]' when not multi-arch */
1458 fprintf_unfiltered (file,
1459 "gdbarch_dump: %s # %s\n",
1460 "DEPRECATED_PUSH_DUMMY_FRAME(-)",
1461 XSTRING (DEPRECATED_PUSH_DUMMY_FRAME (-)));
1464 fprintf_unfiltered (file,
1465 "gdbarch_dump: DEPRECATED_PUSH_DUMMY_FRAME = <0x%08lx>\n",
1466 (long) current_gdbarch->deprecated_push_dummy_frame
1467 /*DEPRECATED_PUSH_DUMMY_FRAME ()*/);
1469 #ifdef DEPRECATED_PUSH_RETURN_ADDRESS_P
1470 fprintf_unfiltered (file,
1471 "gdbarch_dump: %s # %s\n",
1472 "DEPRECATED_PUSH_RETURN_ADDRESS_P()",
1473 XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS_P ()));
1474 fprintf_unfiltered (file,
1475 "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS_P() = %d\n",
1476 DEPRECATED_PUSH_RETURN_ADDRESS_P ());
1478 #ifdef DEPRECATED_PUSH_RETURN_ADDRESS
1479 fprintf_unfiltered (file,
1480 "gdbarch_dump: %s # %s\n",
1481 "DEPRECATED_PUSH_RETURN_ADDRESS(pc, sp)",
1482 XSTRING (DEPRECATED_PUSH_RETURN_ADDRESS (pc, sp)));
1484 fprintf_unfiltered (file,
1485 "gdbarch_dump: DEPRECATED_PUSH_RETURN_ADDRESS = <0x%08lx>\n",
1486 (long) current_gdbarch->deprecated_push_return_address
1487 /*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
1489 #ifdef DEPRECATED_STORE_RETURN_VALUE
1491 /* Macro might contain `[{}]' when not multi-arch */
1492 fprintf_unfiltered (file,
1493 "gdbarch_dump: %s # %s\n",
1494 "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
1495 XSTRING (DEPRECATED_STORE_RETURN_VALUE (type, valbuf)));
1498 fprintf_unfiltered (file,
1499 "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = <0x%08lx>\n",
1500 (long) current_gdbarch->deprecated_store_return_value
1501 /*DEPRECATED_STORE_RETURN_VALUE ()*/);
1503 #ifdef DEPRECATED_STORE_STRUCT_RETURN_P
1504 fprintf_unfiltered (file,
1505 "gdbarch_dump: %s # %s\n",
1506 "DEPRECATED_STORE_STRUCT_RETURN_P()",
1507 XSTRING (DEPRECATED_STORE_STRUCT_RETURN_P ()));
1508 fprintf_unfiltered (file,
1509 "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN_P() = %d\n",
1510 DEPRECATED_STORE_STRUCT_RETURN_P ());
1512 #ifdef DEPRECATED_STORE_STRUCT_RETURN
1514 /* Macro might contain `[{}]' when not multi-arch */
1515 fprintf_unfiltered (file,
1516 "gdbarch_dump: %s # %s\n",
1517 "DEPRECATED_STORE_STRUCT_RETURN(addr, sp)",
1518 XSTRING (DEPRECATED_STORE_STRUCT_RETURN (addr, sp)));
1521 fprintf_unfiltered (file,
1522 "gdbarch_dump: DEPRECATED_STORE_STRUCT_RETURN = <0x%08lx>\n",
1523 (long) current_gdbarch->deprecated_store_struct_return
1524 /*DEPRECATED_STORE_STRUCT_RETURN ()*/);
1526 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1527 fprintf_unfiltered (file,
1528 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
1529 XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES));
1530 fprintf_unfiltered (file,
1531 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
1532 DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
1534 #ifdef DWARF2_BUILD_FRAME_INFO_P
1535 fprintf_unfiltered (file,
1536 "gdbarch_dump: %s # %s\n",
1537 "DWARF2_BUILD_FRAME_INFO_P()",
1538 XSTRING (DWARF2_BUILD_FRAME_INFO_P ()));
1539 fprintf_unfiltered (file,
1540 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO_P() = %d\n",
1541 DWARF2_BUILD_FRAME_INFO_P ());
1543 #ifdef DWARF2_BUILD_FRAME_INFO
1545 /* Macro might contain `[{}]' when not multi-arch */
1546 fprintf_unfiltered (file,
1547 "gdbarch_dump: %s # %s\n",
1548 "DWARF2_BUILD_FRAME_INFO(objfile)",
1549 XSTRING (DWARF2_BUILD_FRAME_INFO (objfile)));
1552 fprintf_unfiltered (file,
1553 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = <0x%08lx>\n",
1554 (long) current_gdbarch->dwarf2_build_frame_info
1555 /*DWARF2_BUILD_FRAME_INFO ()*/);
1557 #ifdef DWARF2_REG_TO_REGNUM
1558 fprintf_unfiltered (file,
1559 "gdbarch_dump: %s # %s\n",
1560 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1561 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr)));
1563 fprintf_unfiltered (file,
1564 "gdbarch_dump: DWARF2_REG_TO_REGNUM = <0x%08lx>\n",
1565 (long) current_gdbarch->dwarf2_reg_to_regnum
1566 /*DWARF2_REG_TO_REGNUM ()*/);
1568 #ifdef DWARF_REG_TO_REGNUM
1569 fprintf_unfiltered (file,
1570 "gdbarch_dump: %s # %s\n",
1571 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1572 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr)));
1574 fprintf_unfiltered (file,
1575 "gdbarch_dump: DWARF_REG_TO_REGNUM = <0x%08lx>\n",
1576 (long) current_gdbarch->dwarf_reg_to_regnum
1577 /*DWARF_REG_TO_REGNUM ()*/);
1579 #ifdef ECOFF_REG_TO_REGNUM
1580 fprintf_unfiltered (file,
1581 "gdbarch_dump: %s # %s\n",
1582 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1583 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr)));
1585 fprintf_unfiltered (file,
1586 "gdbarch_dump: ECOFF_REG_TO_REGNUM = <0x%08lx>\n",
1587 (long) current_gdbarch->ecoff_reg_to_regnum
1588 /*ECOFF_REG_TO_REGNUM ()*/);
1590 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1592 /* Macro might contain `[{}]' when not multi-arch */
1593 fprintf_unfiltered (file,
1594 "gdbarch_dump: %s # %s\n",
1595 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1596 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym, msym)));
1599 fprintf_unfiltered (file,
1600 "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = <0x%08lx>\n",
1601 (long) current_gdbarch->elf_make_msymbol_special
1602 /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
1604 #ifdef EXTRACT_RETURN_VALUE
1606 /* Macro might contain `[{}]' when not multi-arch */
1607 fprintf_unfiltered (file,
1608 "gdbarch_dump: %s # %s\n",
1609 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1610 XSTRING (EXTRACT_RETURN_VALUE (type, regcache, valbuf)));
1613 fprintf_unfiltered (file,
1614 "gdbarch_dump: EXTRACT_RETURN_VALUE = <0x%08lx>\n",
1615 (long) current_gdbarch->extract_return_value
1616 /*EXTRACT_RETURN_VALUE ()*/);
1618 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS_P
1619 fprintf_unfiltered (file,
1620 "gdbarch_dump: %s # %s\n",
1621 "EXTRACT_STRUCT_VALUE_ADDRESS_P()",
1622 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS_P ()));
1623 fprintf_unfiltered (file,
1624 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS_P() = %d\n",
1625 EXTRACT_STRUCT_VALUE_ADDRESS_P ());
1627 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1628 fprintf_unfiltered (file,
1629 "gdbarch_dump: %s # %s\n",
1630 "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
1631 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache)));
1633 fprintf_unfiltered (file,
1634 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = <0x%08lx>\n",
1635 (long) current_gdbarch->extract_struct_value_address
1636 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1638 #ifdef FIX_CALL_DUMMY
1640 /* Macro might contain `[{}]' when not multi-arch */
1641 fprintf_unfiltered (file,
1642 "gdbarch_dump: %s # %s\n",
1643 "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1644 XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
1647 fprintf_unfiltered (file,
1648 "gdbarch_dump: FIX_CALL_DUMMY = <0x%08lx>\n",
1649 (long) current_gdbarch->fix_call_dummy
1650 /*FIX_CALL_DUMMY ()*/);
1653 fprintf_unfiltered (file,
1654 "gdbarch_dump: FP0_REGNUM # %s\n",
1655 XSTRING (FP0_REGNUM));
1656 fprintf_unfiltered (file,
1657 "gdbarch_dump: FP0_REGNUM = %d\n",
1661 fprintf_unfiltered (file,
1662 "gdbarch_dump: FP_REGNUM # %s\n",
1663 XSTRING (FP_REGNUM));
1664 fprintf_unfiltered (file,
1665 "gdbarch_dump: FP_REGNUM = %d\n",
1668 #ifdef FRAMELESS_FUNCTION_INVOCATION
1669 fprintf_unfiltered (file,
1670 "gdbarch_dump: %s # %s\n",
1671 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1672 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi)));
1674 fprintf_unfiltered (file,
1675 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = <0x%08lx>\n",
1676 (long) current_gdbarch->frameless_function_invocation
1677 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1679 #ifdef FRAME_ARGS_ADDRESS
1680 fprintf_unfiltered (file,
1681 "gdbarch_dump: %s # %s\n",
1682 "FRAME_ARGS_ADDRESS(fi)",
1683 XSTRING (FRAME_ARGS_ADDRESS (fi)));
1685 fprintf_unfiltered (file,
1686 "gdbarch_dump: FRAME_ARGS_ADDRESS = <0x%08lx>\n",
1687 (long) current_gdbarch->frame_args_address
1688 /*FRAME_ARGS_ADDRESS ()*/);
1690 #ifdef FRAME_ARGS_SKIP
1691 fprintf_unfiltered (file,
1692 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1693 XSTRING (FRAME_ARGS_SKIP));
1694 fprintf_unfiltered (file,
1695 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1696 (long) FRAME_ARGS_SKIP);
1698 #ifdef FRAME_LOCALS_ADDRESS
1699 fprintf_unfiltered (file,
1700 "gdbarch_dump: %s # %s\n",
1701 "FRAME_LOCALS_ADDRESS(fi)",
1702 XSTRING (FRAME_LOCALS_ADDRESS (fi)));
1704 fprintf_unfiltered (file,
1705 "gdbarch_dump: FRAME_LOCALS_ADDRESS = <0x%08lx>\n",
1706 (long) current_gdbarch->frame_locals_address
1707 /*FRAME_LOCALS_ADDRESS ()*/);
1709 #ifdef FRAME_NUM_ARGS
1710 fprintf_unfiltered (file,
1711 "gdbarch_dump: %s # %s\n",
1712 "FRAME_NUM_ARGS(frame)",
1713 XSTRING (FRAME_NUM_ARGS (frame)));
1715 fprintf_unfiltered (file,
1716 "gdbarch_dump: FRAME_NUM_ARGS = <0x%08lx>\n",
1717 (long) current_gdbarch->frame_num_args
1718 /*FRAME_NUM_ARGS ()*/);
1720 #ifdef FUNCTION_START_OFFSET
1721 fprintf_unfiltered (file,
1722 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1723 XSTRING (FUNCTION_START_OFFSET));
1724 fprintf_unfiltered (file,
1725 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1726 (long) FUNCTION_START_OFFSET);
1728 #ifdef GET_LONGJMP_TARGET_P
1729 fprintf_unfiltered (file,
1730 "gdbarch_dump: %s # %s\n",
1731 "GET_LONGJMP_TARGET_P()",
1732 XSTRING (GET_LONGJMP_TARGET_P ()));
1733 fprintf_unfiltered (file,
1734 "gdbarch_dump: GET_LONGJMP_TARGET_P() = %d\n",
1735 GET_LONGJMP_TARGET_P ());
1737 #ifdef GET_LONGJMP_TARGET
1738 fprintf_unfiltered (file,
1739 "gdbarch_dump: %s # %s\n",
1740 "GET_LONGJMP_TARGET(pc)",
1741 XSTRING (GET_LONGJMP_TARGET (pc)));
1743 fprintf_unfiltered (file,
1744 "gdbarch_dump: GET_LONGJMP_TARGET = <0x%08lx>\n",
1745 (long) current_gdbarch->get_longjmp_target
1746 /*GET_LONGJMP_TARGET ()*/);
1748 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1749 fprintf_unfiltered (file,
1750 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1751 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT));
1752 fprintf_unfiltered (file,
1753 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
1754 HAVE_NONSTEPPABLE_WATCHPOINT);
1757 fprintf_unfiltered (file,
1758 "gdbarch_dump: %s # %s\n",
1759 "INNER_THAN(lhs, rhs)",
1760 XSTRING (INNER_THAN (lhs, rhs)));
1762 fprintf_unfiltered (file,
1763 "gdbarch_dump: INNER_THAN = <0x%08lx>\n",
1764 (long) current_gdbarch->inner_than
1767 #ifdef INTEGER_TO_ADDRESS_P
1768 fprintf_unfiltered (file,
1769 "gdbarch_dump: %s # %s\n",
1770 "INTEGER_TO_ADDRESS_P()",
1771 XSTRING (INTEGER_TO_ADDRESS_P ()));
1772 fprintf_unfiltered (file,
1773 "gdbarch_dump: INTEGER_TO_ADDRESS_P() = %d\n",
1774 INTEGER_TO_ADDRESS_P ());
1776 #ifdef INTEGER_TO_ADDRESS
1777 fprintf_unfiltered (file,
1778 "gdbarch_dump: %s # %s\n",
1779 "INTEGER_TO_ADDRESS(type, buf)",
1780 XSTRING (INTEGER_TO_ADDRESS (type, buf)));
1782 fprintf_unfiltered (file,
1783 "gdbarch_dump: INTEGER_TO_ADDRESS = <0x%08lx>\n",
1784 (long) current_gdbarch->integer_to_address
1785 /*INTEGER_TO_ADDRESS ()*/);
1787 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1788 fprintf_unfiltered (file,
1789 "gdbarch_dump: %s # %s\n",
1790 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1791 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc, name)));
1793 fprintf_unfiltered (file,
1794 "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = <0x%08lx>\n",
1795 (long) current_gdbarch->in_solib_call_trampoline
1796 /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1798 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1799 fprintf_unfiltered (file,
1800 "gdbarch_dump: %s # %s\n",
1801 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1802 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc, name)));
1804 fprintf_unfiltered (file,
1805 "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = <0x%08lx>\n",
1806 (long) current_gdbarch->in_solib_return_trampoline
1807 /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
1809 #ifdef MEMORY_INSERT_BREAKPOINT
1810 fprintf_unfiltered (file,
1811 "gdbarch_dump: %s # %s\n",
1812 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1813 XSTRING (MEMORY_INSERT_BREAKPOINT (addr, contents_cache)));
1815 fprintf_unfiltered (file,
1816 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = <0x%08lx>\n",
1817 (long) current_gdbarch->memory_insert_breakpoint
1818 /*MEMORY_INSERT_BREAKPOINT ()*/);
1820 #ifdef MEMORY_REMOVE_BREAKPOINT
1821 fprintf_unfiltered (file,
1822 "gdbarch_dump: %s # %s\n",
1823 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1824 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr, contents_cache)));
1826 fprintf_unfiltered (file,
1827 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = <0x%08lx>\n",
1828 (long) current_gdbarch->memory_remove_breakpoint
1829 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1831 #ifdef NAME_OF_MALLOC
1832 fprintf_unfiltered (file,
1833 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1834 XSTRING (NAME_OF_MALLOC));
1835 fprintf_unfiltered (file,
1836 "gdbarch_dump: NAME_OF_MALLOC = %s\n",
1840 fprintf_unfiltered (file,
1841 "gdbarch_dump: NPC_REGNUM # %s\n",
1842 XSTRING (NPC_REGNUM));
1843 fprintf_unfiltered (file,
1844 "gdbarch_dump: NPC_REGNUM = %d\n",
1847 #ifdef NUM_PSEUDO_REGS
1848 fprintf_unfiltered (file,
1849 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1850 XSTRING (NUM_PSEUDO_REGS));
1851 fprintf_unfiltered (file,
1852 "gdbarch_dump: NUM_PSEUDO_REGS = %d\n",
1856 fprintf_unfiltered (file,
1857 "gdbarch_dump: NUM_REGS # %s\n",
1858 XSTRING (NUM_REGS));
1859 fprintf_unfiltered (file,
1860 "gdbarch_dump: NUM_REGS = %d\n",
1863 #ifdef PARM_BOUNDARY
1864 fprintf_unfiltered (file,
1865 "gdbarch_dump: PARM_BOUNDARY # %s\n",
1866 XSTRING (PARM_BOUNDARY));
1867 fprintf_unfiltered (file,
1868 "gdbarch_dump: PARM_BOUNDARY = %d\n",
1871 #ifdef PC_IN_SIGTRAMP
1872 fprintf_unfiltered (file,
1873 "gdbarch_dump: %s # %s\n",
1874 "PC_IN_SIGTRAMP(pc, name)",
1875 XSTRING (PC_IN_SIGTRAMP (pc, name)));
1877 fprintf_unfiltered (file,
1878 "gdbarch_dump: PC_IN_SIGTRAMP = <0x%08lx>\n",
1879 (long) current_gdbarch->pc_in_sigtramp
1880 /*PC_IN_SIGTRAMP ()*/);
1883 fprintf_unfiltered (file,
1884 "gdbarch_dump: PC_REGNUM # %s\n",
1885 XSTRING (PC_REGNUM));
1886 fprintf_unfiltered (file,
1887 "gdbarch_dump: PC_REGNUM = %d\n",
1890 #ifdef POINTER_TO_ADDRESS
1891 fprintf_unfiltered (file,
1892 "gdbarch_dump: %s # %s\n",
1893 "POINTER_TO_ADDRESS(type, buf)",
1894 XSTRING (POINTER_TO_ADDRESS (type, buf)));
1896 fprintf_unfiltered (file,
1897 "gdbarch_dump: POINTER_TO_ADDRESS = <0x%08lx>\n",
1898 (long) current_gdbarch->pointer_to_address
1899 /*POINTER_TO_ADDRESS ()*/);
1901 #ifdef PREPARE_TO_PROCEED
1902 fprintf_unfiltered (file,
1903 "gdbarch_dump: %s # %s\n",
1904 "PREPARE_TO_PROCEED(select_it)",
1905 XSTRING (PREPARE_TO_PROCEED (select_it)));
1907 fprintf_unfiltered (file,
1908 "gdbarch_dump: PREPARE_TO_PROCEED = <0x%08lx>\n",
1909 (long) current_gdbarch->prepare_to_proceed
1910 /*PREPARE_TO_PROCEED ()*/);
1913 fprintf_unfiltered (file,
1914 "gdbarch_dump: gdbarch_print_float_info_p() = %d\n",
1915 gdbarch_print_float_info_p (current_gdbarch));
1917 fprintf_unfiltered (file,
1918 "gdbarch_dump: print_float_info = 0x%08lx\n",
1919 (long) current_gdbarch->print_float_info);
1921 fprintf_unfiltered (file,
1922 "gdbarch_dump: print_registers_info = 0x%08lx\n",
1923 (long) current_gdbarch->print_registers_info);
1925 fprintf_unfiltered (file,
1926 "gdbarch_dump: gdbarch_print_vector_info_p() = %d\n",
1927 gdbarch_print_vector_info_p (current_gdbarch));
1929 fprintf_unfiltered (file,
1930 "gdbarch_dump: print_vector_info = 0x%08lx\n",
1931 (long) current_gdbarch->print_vector_info);
1932 #ifdef PROLOGUE_FRAMELESS_P
1933 fprintf_unfiltered (file,
1934 "gdbarch_dump: %s # %s\n",
1935 "PROLOGUE_FRAMELESS_P(ip)",
1936 XSTRING (PROLOGUE_FRAMELESS_P (ip)));
1938 fprintf_unfiltered (file,
1939 "gdbarch_dump: PROLOGUE_FRAMELESS_P = <0x%08lx>\n",
1940 (long) current_gdbarch->prologue_frameless_p
1941 /*PROLOGUE_FRAMELESS_P ()*/);
1944 fprintf_unfiltered (file,
1945 "gdbarch_dump: PS_REGNUM # %s\n",
1946 XSTRING (PS_REGNUM));
1947 fprintf_unfiltered (file,
1948 "gdbarch_dump: PS_REGNUM = %d\n",
1952 fprintf_unfiltered (file,
1953 "gdbarch_dump: gdbarch_push_dummy_call_p() = %d\n",
1954 gdbarch_push_dummy_call_p (current_gdbarch));
1956 fprintf_unfiltered (file,
1957 "gdbarch_dump: push_dummy_call = 0x%08lx\n",
1958 (long) current_gdbarch->push_dummy_call);
1959 #ifdef REGISTER_BYTE
1960 fprintf_unfiltered (file,
1961 "gdbarch_dump: %s # %s\n",
1962 "REGISTER_BYTE(reg_nr)",
1963 XSTRING (REGISTER_BYTE (reg_nr)));
1965 fprintf_unfiltered (file,
1966 "gdbarch_dump: REGISTER_BYTE = <0x%08lx>\n",
1967 (long) current_gdbarch->register_byte
1968 /*REGISTER_BYTE ()*/);
1970 #ifdef REGISTER_BYTES
1971 fprintf_unfiltered (file,
1972 "gdbarch_dump: REGISTER_BYTES # %s\n",
1973 XSTRING (REGISTER_BYTES));
1974 fprintf_unfiltered (file,
1975 "gdbarch_dump: REGISTER_BYTES = %d\n",
1978 #ifdef REGISTER_BYTES_OK_P
1979 fprintf_unfiltered (file,
1980 "gdbarch_dump: %s # %s\n",
1981 "REGISTER_BYTES_OK_P()",
1982 XSTRING (REGISTER_BYTES_OK_P ()));
1983 fprintf_unfiltered (file,
1984 "gdbarch_dump: REGISTER_BYTES_OK_P() = %d\n",
1985 REGISTER_BYTES_OK_P ());
1987 #ifdef REGISTER_BYTES_OK
1988 fprintf_unfiltered (file,
1989 "gdbarch_dump: %s # %s\n",
1990 "REGISTER_BYTES_OK(nr_bytes)",
1991 XSTRING (REGISTER_BYTES_OK (nr_bytes)));
1993 fprintf_unfiltered (file,
1994 "gdbarch_dump: REGISTER_BYTES_OK = <0x%08lx>\n",
1995 (long) current_gdbarch->register_bytes_ok
1996 /*REGISTER_BYTES_OK ()*/);
1998 #ifdef REGISTER_CONVERTIBLE
1999 fprintf_unfiltered (file,
2000 "gdbarch_dump: %s # %s\n",
2001 "REGISTER_CONVERTIBLE(nr)",
2002 XSTRING (REGISTER_CONVERTIBLE (nr)));
2004 fprintf_unfiltered (file,
2005 "gdbarch_dump: REGISTER_CONVERTIBLE = <0x%08lx>\n",
2006 (long) current_gdbarch->register_convertible
2007 /*REGISTER_CONVERTIBLE ()*/);
2009 #ifdef REGISTER_CONVERT_TO_RAW
2011 /* Macro might contain `[{}]' when not multi-arch */
2012 fprintf_unfiltered (file,
2013 "gdbarch_dump: %s # %s\n",
2014 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
2015 XSTRING (REGISTER_CONVERT_TO_RAW (type, regnum, from, to)));
2018 fprintf_unfiltered (file,
2019 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = <0x%08lx>\n",
2020 (long) current_gdbarch->register_convert_to_raw
2021 /*REGISTER_CONVERT_TO_RAW ()*/);
2023 #ifdef REGISTER_CONVERT_TO_VIRTUAL
2025 /* Macro might contain `[{}]' when not multi-arch */
2026 fprintf_unfiltered (file,
2027 "gdbarch_dump: %s # %s\n",
2028 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
2029 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum, type, from, to)));
2032 fprintf_unfiltered (file,
2033 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = <0x%08lx>\n",
2034 (long) current_gdbarch->register_convert_to_virtual
2035 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
2037 #ifdef REGISTER_NAME
2038 fprintf_unfiltered (file,
2039 "gdbarch_dump: %s # %s\n",
2040 "REGISTER_NAME(regnr)",
2041 XSTRING (REGISTER_NAME (regnr)));
2043 fprintf_unfiltered (file,
2044 "gdbarch_dump: REGISTER_NAME = <0x%08lx>\n",
2045 (long) current_gdbarch->register_name
2046 /*REGISTER_NAME ()*/);
2048 #ifdef REGISTER_RAW_SIZE
2049 fprintf_unfiltered (file,
2050 "gdbarch_dump: %s # %s\n",
2051 "REGISTER_RAW_SIZE(reg_nr)",
2052 XSTRING (REGISTER_RAW_SIZE (reg_nr)));
2054 fprintf_unfiltered (file,
2055 "gdbarch_dump: REGISTER_RAW_SIZE = <0x%08lx>\n",
2056 (long) current_gdbarch->register_raw_size
2057 /*REGISTER_RAW_SIZE ()*/);
2059 #ifdef REGISTER_SIM_REGNO
2060 fprintf_unfiltered (file,
2061 "gdbarch_dump: %s # %s\n",
2062 "REGISTER_SIM_REGNO(reg_nr)",
2063 XSTRING (REGISTER_SIM_REGNO (reg_nr)));
2065 fprintf_unfiltered (file,
2066 "gdbarch_dump: REGISTER_SIM_REGNO = <0x%08lx>\n",
2067 (long) current_gdbarch->register_sim_regno
2068 /*REGISTER_SIM_REGNO ()*/);
2070 #ifdef REGISTER_SIZE
2071 fprintf_unfiltered (file,
2072 "gdbarch_dump: REGISTER_SIZE # %s\n",
2073 XSTRING (REGISTER_SIZE));
2074 fprintf_unfiltered (file,
2075 "gdbarch_dump: REGISTER_SIZE = %d\n",
2078 #ifdef REGISTER_TO_VALUE
2080 /* Macro might contain `[{}]' when not multi-arch */
2081 fprintf_unfiltered (file,
2082 "gdbarch_dump: %s # %s\n",
2083 "REGISTER_TO_VALUE(regnum, type, from, to)",
2084 XSTRING (REGISTER_TO_VALUE (regnum, type, from, to)));
2087 fprintf_unfiltered (file,
2088 "gdbarch_dump: REGISTER_TO_VALUE = <0x%08lx>\n",
2089 (long) current_gdbarch->register_to_value
2090 /*REGISTER_TO_VALUE ()*/);
2093 fprintf_unfiltered (file,
2094 "gdbarch_dump: gdbarch_register_type_p() = %d\n",
2095 gdbarch_register_type_p (current_gdbarch));
2097 fprintf_unfiltered (file,
2098 "gdbarch_dump: register_type = 0x%08lx\n",
2099 (long) current_gdbarch->register_type);
2100 #ifdef REGISTER_VIRTUAL_SIZE
2101 fprintf_unfiltered (file,
2102 "gdbarch_dump: %s # %s\n",
2103 "REGISTER_VIRTUAL_SIZE(reg_nr)",
2104 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr)));
2106 fprintf_unfiltered (file,
2107 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = <0x%08lx>\n",
2108 (long) current_gdbarch->register_virtual_size
2109 /*REGISTER_VIRTUAL_SIZE ()*/);
2111 #ifdef REGISTER_VIRTUAL_TYPE_P
2112 fprintf_unfiltered (file,
2113 "gdbarch_dump: %s # %s\n",
2114 "REGISTER_VIRTUAL_TYPE_P()",
2115 XSTRING (REGISTER_VIRTUAL_TYPE_P ()));
2116 fprintf_unfiltered (file,
2117 "gdbarch_dump: REGISTER_VIRTUAL_TYPE_P() = %d\n",
2118 REGISTER_VIRTUAL_TYPE_P ());
2120 #ifdef REGISTER_VIRTUAL_TYPE
2121 fprintf_unfiltered (file,
2122 "gdbarch_dump: %s # %s\n",
2123 "REGISTER_VIRTUAL_TYPE(reg_nr)",
2124 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr)));
2126 fprintf_unfiltered (file,
2127 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = <0x%08lx>\n",
2128 (long) current_gdbarch->register_virtual_type
2129 /*REGISTER_VIRTUAL_TYPE ()*/);
2131 #ifdef REG_STRUCT_HAS_ADDR_P
2132 fprintf_unfiltered (file,
2133 "gdbarch_dump: %s # %s\n",
2134 "REG_STRUCT_HAS_ADDR_P()",
2135 XSTRING (REG_STRUCT_HAS_ADDR_P ()));
2136 fprintf_unfiltered (file,
2137 "gdbarch_dump: REG_STRUCT_HAS_ADDR_P() = %d\n",
2138 REG_STRUCT_HAS_ADDR_P ());
2140 #ifdef REG_STRUCT_HAS_ADDR
2141 fprintf_unfiltered (file,
2142 "gdbarch_dump: %s # %s\n",
2143 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
2144 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p, type)));
2146 fprintf_unfiltered (file,
2147 "gdbarch_dump: REG_STRUCT_HAS_ADDR = <0x%08lx>\n",
2148 (long) current_gdbarch->reg_struct_has_addr
2149 /*REG_STRUCT_HAS_ADDR ()*/);
2151 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
2153 /* Macro might contain `[{}]' when not multi-arch */
2154 fprintf_unfiltered (file,
2155 "gdbarch_dump: %s # %s\n",
2156 "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
2157 XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr, gdb_len, rem_addr, rem_len)));
2160 fprintf_unfiltered (file,
2161 "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = <0x%08lx>\n",
2162 (long) current_gdbarch->remote_translate_xfer_address
2163 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
2165 #ifdef RETURN_VALUE_ON_STACK
2166 fprintf_unfiltered (file,
2167 "gdbarch_dump: %s # %s\n",
2168 "RETURN_VALUE_ON_STACK(type)",
2169 XSTRING (RETURN_VALUE_ON_STACK (type)));
2171 fprintf_unfiltered (file,
2172 "gdbarch_dump: RETURN_VALUE_ON_STACK = <0x%08lx>\n",
2173 (long) current_gdbarch->return_value_on_stack
2174 /*RETURN_VALUE_ON_STACK ()*/);
2176 #ifdef SAVED_PC_AFTER_CALL
2177 fprintf_unfiltered (file,
2178 "gdbarch_dump: %s # %s\n",
2179 "SAVED_PC_AFTER_CALL(frame)",
2180 XSTRING (SAVED_PC_AFTER_CALL (frame)));
2182 fprintf_unfiltered (file,
2183 "gdbarch_dump: SAVED_PC_AFTER_CALL = <0x%08lx>\n",
2184 (long) current_gdbarch->saved_pc_after_call
2185 /*SAVED_PC_AFTER_CALL ()*/);
2187 #ifdef SAVE_DUMMY_FRAME_TOS_P
2188 fprintf_unfiltered (file,
2189 "gdbarch_dump: %s # %s\n",
2190 "SAVE_DUMMY_FRAME_TOS_P()",
2191 XSTRING (SAVE_DUMMY_FRAME_TOS_P ()));
2192 fprintf_unfiltered (file,
2193 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS_P() = %d\n",
2194 SAVE_DUMMY_FRAME_TOS_P ());
2196 #ifdef SAVE_DUMMY_FRAME_TOS
2198 /* Macro might contain `[{}]' when not multi-arch */
2199 fprintf_unfiltered (file,
2200 "gdbarch_dump: %s # %s\n",
2201 "SAVE_DUMMY_FRAME_TOS(sp)",
2202 XSTRING (SAVE_DUMMY_FRAME_TOS (sp)));
2205 fprintf_unfiltered (file,
2206 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = <0x%08lx>\n",
2207 (long) current_gdbarch->save_dummy_frame_tos
2208 /*SAVE_DUMMY_FRAME_TOS ()*/);
2210 #ifdef SDB_REG_TO_REGNUM
2211 fprintf_unfiltered (file,
2212 "gdbarch_dump: %s # %s\n",
2213 "SDB_REG_TO_REGNUM(sdb_regnr)",
2214 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr)));
2216 fprintf_unfiltered (file,
2217 "gdbarch_dump: SDB_REG_TO_REGNUM = <0x%08lx>\n",
2218 (long) current_gdbarch->sdb_reg_to_regnum
2219 /*SDB_REG_TO_REGNUM ()*/);
2221 #ifdef SIGTRAMP_END_P
2222 fprintf_unfiltered (file,
2223 "gdbarch_dump: %s # %s\n",
2225 XSTRING (SIGTRAMP_END_P ()));
2226 fprintf_unfiltered (file,
2227 "gdbarch_dump: SIGTRAMP_END_P() = %d\n",
2231 fprintf_unfiltered (file,
2232 "gdbarch_dump: %s # %s\n",
2234 XSTRING (SIGTRAMP_END (pc)));
2236 fprintf_unfiltered (file,
2237 "gdbarch_dump: SIGTRAMP_END = <0x%08lx>\n",
2238 (long) current_gdbarch->sigtramp_end
2239 /*SIGTRAMP_END ()*/);
2241 #ifdef SIGTRAMP_START_P
2242 fprintf_unfiltered (file,
2243 "gdbarch_dump: %s # %s\n",
2244 "SIGTRAMP_START_P()",
2245 XSTRING (SIGTRAMP_START_P ()));
2246 fprintf_unfiltered (file,
2247 "gdbarch_dump: SIGTRAMP_START_P() = %d\n",
2248 SIGTRAMP_START_P ());
2250 #ifdef SIGTRAMP_START
2251 fprintf_unfiltered (file,
2252 "gdbarch_dump: %s # %s\n",
2253 "SIGTRAMP_START(pc)",
2254 XSTRING (SIGTRAMP_START (pc)));
2256 fprintf_unfiltered (file,
2257 "gdbarch_dump: SIGTRAMP_START = <0x%08lx>\n",
2258 (long) current_gdbarch->sigtramp_start
2259 /*SIGTRAMP_START ()*/);
2261 #ifdef SIZEOF_CALL_DUMMY_WORDS
2262 fprintf_unfiltered (file,
2263 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
2264 XSTRING (SIZEOF_CALL_DUMMY_WORDS));
2265 fprintf_unfiltered (file,
2266 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = %d\n",
2267 SIZEOF_CALL_DUMMY_WORDS);
2269 #ifdef SKIP_PROLOGUE
2270 fprintf_unfiltered (file,
2271 "gdbarch_dump: %s # %s\n",
2272 "SKIP_PROLOGUE(ip)",
2273 XSTRING (SKIP_PROLOGUE (ip)));
2275 fprintf_unfiltered (file,
2276 "gdbarch_dump: SKIP_PROLOGUE = <0x%08lx>\n",
2277 (long) current_gdbarch->skip_prologue
2278 /*SKIP_PROLOGUE ()*/);
2280 #ifdef SKIP_TRAMPOLINE_CODE
2281 fprintf_unfiltered (file,
2282 "gdbarch_dump: %s # %s\n",
2283 "SKIP_TRAMPOLINE_CODE(pc)",
2284 XSTRING (SKIP_TRAMPOLINE_CODE (pc)));
2286 fprintf_unfiltered (file,
2287 "gdbarch_dump: SKIP_TRAMPOLINE_CODE = <0x%08lx>\n",
2288 (long) current_gdbarch->skip_trampoline_code
2289 /*SKIP_TRAMPOLINE_CODE ()*/);
2291 #ifdef SMASH_TEXT_ADDRESS
2292 fprintf_unfiltered (file,
2293 "gdbarch_dump: %s # %s\n",
2294 "SMASH_TEXT_ADDRESS(addr)",
2295 XSTRING (SMASH_TEXT_ADDRESS (addr)));
2297 fprintf_unfiltered (file,
2298 "gdbarch_dump: SMASH_TEXT_ADDRESS = <0x%08lx>\n",
2299 (long) current_gdbarch->smash_text_address
2300 /*SMASH_TEXT_ADDRESS ()*/);
2302 #ifdef SOFTWARE_SINGLE_STEP_P
2303 fprintf_unfiltered (file,
2304 "gdbarch_dump: %s # %s\n",
2305 "SOFTWARE_SINGLE_STEP_P()",
2306 XSTRING (SOFTWARE_SINGLE_STEP_P ()));
2307 fprintf_unfiltered (file,
2308 "gdbarch_dump: SOFTWARE_SINGLE_STEP_P() = %d\n",
2309 SOFTWARE_SINGLE_STEP_P ());
2311 #ifdef SOFTWARE_SINGLE_STEP
2313 /* Macro might contain `[{}]' when not multi-arch */
2314 fprintf_unfiltered (file,
2315 "gdbarch_dump: %s # %s\n",
2316 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
2317 XSTRING (SOFTWARE_SINGLE_STEP (sig, insert_breakpoints_p)));
2320 fprintf_unfiltered (file,
2321 "gdbarch_dump: SOFTWARE_SINGLE_STEP = <0x%08lx>\n",
2322 (long) current_gdbarch->software_single_step
2323 /*SOFTWARE_SINGLE_STEP ()*/);
2326 fprintf_unfiltered (file,
2327 "gdbarch_dump: SP_REGNUM # %s\n",
2328 XSTRING (SP_REGNUM));
2329 fprintf_unfiltered (file,
2330 "gdbarch_dump: SP_REGNUM = %d\n",
2333 #ifdef STAB_REG_TO_REGNUM
2334 fprintf_unfiltered (file,
2335 "gdbarch_dump: %s # %s\n",
2336 "STAB_REG_TO_REGNUM(stab_regnr)",
2337 XSTRING (STAB_REG_TO_REGNUM (stab_regnr)));
2339 fprintf_unfiltered (file,
2340 "gdbarch_dump: STAB_REG_TO_REGNUM = <0x%08lx>\n",
2341 (long) current_gdbarch->stab_reg_to_regnum
2342 /*STAB_REG_TO_REGNUM ()*/);
2344 #ifdef STACK_ALIGN_P
2345 fprintf_unfiltered (file,
2346 "gdbarch_dump: %s # %s\n",
2348 XSTRING (STACK_ALIGN_P ()));
2349 fprintf_unfiltered (file,
2350 "gdbarch_dump: STACK_ALIGN_P() = %d\n",
2354 fprintf_unfiltered (file,
2355 "gdbarch_dump: %s # %s\n",
2357 XSTRING (STACK_ALIGN (sp)));
2359 fprintf_unfiltered (file,
2360 "gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
2361 (long) current_gdbarch->stack_align
2362 /*STACK_ALIGN ()*/);
2364 #ifdef STORE_RETURN_VALUE
2366 /* Macro might contain `[{}]' when not multi-arch */
2367 fprintf_unfiltered (file,
2368 "gdbarch_dump: %s # %s\n",
2369 "STORE_RETURN_VALUE(type, regcache, valbuf)",
2370 XSTRING (STORE_RETURN_VALUE (type, regcache, valbuf)));
2373 fprintf_unfiltered (file,
2374 "gdbarch_dump: STORE_RETURN_VALUE = <0x%08lx>\n",
2375 (long) current_gdbarch->store_return_value
2376 /*STORE_RETURN_VALUE ()*/);
2378 #ifdef TARGET_ADDR_BIT
2379 fprintf_unfiltered (file,
2380 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
2381 XSTRING (TARGET_ADDR_BIT));
2382 fprintf_unfiltered (file,
2383 "gdbarch_dump: TARGET_ADDR_BIT = %d\n",
2386 #ifdef TARGET_ARCHITECTURE
2387 fprintf_unfiltered (file,
2388 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
2389 XSTRING (TARGET_ARCHITECTURE));
2390 if (TARGET_ARCHITECTURE != NULL)
2391 fprintf_unfiltered (file,
2392 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
2393 TARGET_ARCHITECTURE->printable_name);
2395 #ifdef TARGET_BFD_VMA_BIT
2396 fprintf_unfiltered (file,
2397 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
2398 XSTRING (TARGET_BFD_VMA_BIT));
2399 fprintf_unfiltered (file,
2400 "gdbarch_dump: TARGET_BFD_VMA_BIT = %d\n",
2401 TARGET_BFD_VMA_BIT);
2403 #ifdef TARGET_BYTE_ORDER
2404 fprintf_unfiltered (file,
2405 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
2406 XSTRING (TARGET_BYTE_ORDER));
2407 fprintf_unfiltered (file,
2408 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
2409 (long) TARGET_BYTE_ORDER);
2411 #ifdef TARGET_CHAR_SIGNED
2412 fprintf_unfiltered (file,
2413 "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
2414 XSTRING (TARGET_CHAR_SIGNED));
2415 fprintf_unfiltered (file,
2416 "gdbarch_dump: TARGET_CHAR_SIGNED = %d\n",
2417 TARGET_CHAR_SIGNED);
2419 #ifdef TARGET_DOUBLE_BIT
2420 fprintf_unfiltered (file,
2421 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
2422 XSTRING (TARGET_DOUBLE_BIT));
2423 fprintf_unfiltered (file,
2424 "gdbarch_dump: TARGET_DOUBLE_BIT = %d\n",
2427 #ifdef TARGET_DOUBLE_FORMAT
2428 fprintf_unfiltered (file,
2429 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
2430 XSTRING (TARGET_DOUBLE_FORMAT));
2431 fprintf_unfiltered (file,
2432 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
2433 (TARGET_DOUBLE_FORMAT)->name);
2435 #ifdef TARGET_FLOAT_BIT
2436 fprintf_unfiltered (file,
2437 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
2438 XSTRING (TARGET_FLOAT_BIT));
2439 fprintf_unfiltered (file,
2440 "gdbarch_dump: TARGET_FLOAT_BIT = %d\n",
2443 #ifdef TARGET_FLOAT_FORMAT
2444 fprintf_unfiltered (file,
2445 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
2446 XSTRING (TARGET_FLOAT_FORMAT));
2447 fprintf_unfiltered (file,
2448 "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
2449 (TARGET_FLOAT_FORMAT)->name);
2451 #ifdef TARGET_INT_BIT
2452 fprintf_unfiltered (file,
2453 "gdbarch_dump: TARGET_INT_BIT # %s\n",
2454 XSTRING (TARGET_INT_BIT));
2455 fprintf_unfiltered (file,
2456 "gdbarch_dump: TARGET_INT_BIT = %d\n",
2459 #ifdef TARGET_LONG_BIT
2460 fprintf_unfiltered (file,
2461 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
2462 XSTRING (TARGET_LONG_BIT));
2463 fprintf_unfiltered (file,
2464 "gdbarch_dump: TARGET_LONG_BIT = %d\n",
2467 #ifdef TARGET_LONG_DOUBLE_BIT
2468 fprintf_unfiltered (file,
2469 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
2470 XSTRING (TARGET_LONG_DOUBLE_BIT));
2471 fprintf_unfiltered (file,
2472 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %d\n",
2473 TARGET_LONG_DOUBLE_BIT);
2475 #ifdef TARGET_LONG_DOUBLE_FORMAT
2476 fprintf_unfiltered (file,
2477 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
2478 XSTRING (TARGET_LONG_DOUBLE_FORMAT));
2479 fprintf_unfiltered (file,
2480 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
2481 (TARGET_LONG_DOUBLE_FORMAT)->name);
2483 #ifdef TARGET_LONG_LONG_BIT
2484 fprintf_unfiltered (file,
2485 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
2486 XSTRING (TARGET_LONG_LONG_BIT));
2487 fprintf_unfiltered (file,
2488 "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
2489 TARGET_LONG_LONG_BIT);
2492 fprintf_unfiltered (file,
2493 "gdbarch_dump: TARGET_OSABI # %s\n",
2494 XSTRING (TARGET_OSABI));
2495 fprintf_unfiltered (file,
2496 "gdbarch_dump: TARGET_OSABI = %ld\n",
2497 (long) TARGET_OSABI);
2499 #ifdef TARGET_PRINT_INSN
2500 fprintf_unfiltered (file,
2501 "gdbarch_dump: %s # %s\n",
2502 "TARGET_PRINT_INSN(vma, info)",
2503 XSTRING (TARGET_PRINT_INSN (vma, info)));
2505 fprintf_unfiltered (file,
2506 "gdbarch_dump: TARGET_PRINT_INSN = <0x%08lx>\n",
2507 (long) current_gdbarch->print_insn
2508 /*TARGET_PRINT_INSN ()*/);
2510 #ifdef TARGET_PTR_BIT
2511 fprintf_unfiltered (file,
2512 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
2513 XSTRING (TARGET_PTR_BIT));
2514 fprintf_unfiltered (file,
2515 "gdbarch_dump: TARGET_PTR_BIT = %d\n",
2518 #ifdef TARGET_READ_FP
2519 fprintf_unfiltered (file,
2520 "gdbarch_dump: %s # %s\n",
2522 XSTRING (TARGET_READ_FP ()));
2524 fprintf_unfiltered (file,
2525 "gdbarch_dump: TARGET_READ_FP = <0x%08lx>\n",
2526 (long) current_gdbarch->read_fp
2527 /*TARGET_READ_FP ()*/);
2529 #ifdef TARGET_READ_PC
2530 fprintf_unfiltered (file,
2531 "gdbarch_dump: %s # %s\n",
2532 "TARGET_READ_PC(ptid)",
2533 XSTRING (TARGET_READ_PC (ptid)));
2535 fprintf_unfiltered (file,
2536 "gdbarch_dump: TARGET_READ_PC = <0x%08lx>\n",
2537 (long) current_gdbarch->read_pc
2538 /*TARGET_READ_PC ()*/);
2540 #ifdef TARGET_READ_SP
2541 fprintf_unfiltered (file,
2542 "gdbarch_dump: %s # %s\n",
2544 XSTRING (TARGET_READ_SP ()));
2546 fprintf_unfiltered (file,
2547 "gdbarch_dump: TARGET_READ_SP = <0x%08lx>\n",
2548 (long) current_gdbarch->read_sp
2549 /*TARGET_READ_SP ()*/);
2551 #ifdef TARGET_SHORT_BIT
2552 fprintf_unfiltered (file,
2553 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
2554 XSTRING (TARGET_SHORT_BIT));
2555 fprintf_unfiltered (file,
2556 "gdbarch_dump: TARGET_SHORT_BIT = %d\n",
2559 #ifdef TARGET_VIRTUAL_FRAME_POINTER
2561 /* Macro might contain `[{}]' when not multi-arch */
2562 fprintf_unfiltered (file,
2563 "gdbarch_dump: %s # %s\n",
2564 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
2565 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc, frame_regnum, frame_offset)));
2568 fprintf_unfiltered (file,
2569 "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = <0x%08lx>\n",
2570 (long) current_gdbarch->virtual_frame_pointer
2571 /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
2573 #ifdef TARGET_WRITE_PC
2575 /* Macro might contain `[{}]' when not multi-arch */
2576 fprintf_unfiltered (file,
2577 "gdbarch_dump: %s # %s\n",
2578 "TARGET_WRITE_PC(val, ptid)",
2579 XSTRING (TARGET_WRITE_PC (val, ptid)));
2582 fprintf_unfiltered (file,
2583 "gdbarch_dump: TARGET_WRITE_PC = <0x%08lx>\n",
2584 (long) current_gdbarch->write_pc
2585 /*TARGET_WRITE_PC ()*/);
2588 fprintf_unfiltered (file,
2589 "gdbarch_dump: gdbarch_unwind_dummy_id_p() = %d\n",
2590 gdbarch_unwind_dummy_id_p (current_gdbarch));
2592 fprintf_unfiltered (file,
2593 "gdbarch_dump: unwind_dummy_id = 0x%08lx\n",
2594 (long) current_gdbarch->unwind_dummy_id);
2596 fprintf_unfiltered (file,
2597 "gdbarch_dump: gdbarch_unwind_pc_p() = %d\n",
2598 gdbarch_unwind_pc_p (current_gdbarch));
2600 fprintf_unfiltered (file,
2601 "gdbarch_dump: unwind_pc = 0x%08lx\n",
2602 (long) current_gdbarch->unwind_pc);
2603 #ifdef USE_STRUCT_CONVENTION
2604 fprintf_unfiltered (file,
2605 "gdbarch_dump: %s # %s\n",
2606 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2607 XSTRING (USE_STRUCT_CONVENTION (gcc_p, value_type)));
2609 fprintf_unfiltered (file,
2610 "gdbarch_dump: USE_STRUCT_CONVENTION = <0x%08lx>\n",
2611 (long) current_gdbarch->use_struct_convention
2612 /*USE_STRUCT_CONVENTION ()*/);
2614 #ifdef VALUE_TO_REGISTER
2616 /* Macro might contain `[{}]' when not multi-arch */
2617 fprintf_unfiltered (file,
2618 "gdbarch_dump: %s # %s\n",
2619 "VALUE_TO_REGISTER(type, regnum, from, to)",
2620 XSTRING (VALUE_TO_REGISTER (type, regnum, from, to)));
2623 fprintf_unfiltered (file,
2624 "gdbarch_dump: VALUE_TO_REGISTER = <0x%08lx>\n",
2625 (long) current_gdbarch->value_to_register
2626 /*VALUE_TO_REGISTER ()*/);
2628 if (current_gdbarch->dump_tdep != NULL)
2629 current_gdbarch->dump_tdep (current_gdbarch, file);
2632 struct gdbarch_tdep *
2633 gdbarch_tdep (struct gdbarch *gdbarch)
2635 if (gdbarch_debug >= 2)
2636 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
2637 return gdbarch->tdep;
2641 const struct bfd_arch_info *
2642 gdbarch_bfd_arch_info (struct gdbarch *gdbarch)
2644 gdb_assert (gdbarch != NULL);
2645 if (gdbarch_debug >= 2)
2646 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_arch_info called\n");
2647 return gdbarch->bfd_arch_info;
2651 gdbarch_byte_order (struct gdbarch *gdbarch)
2653 gdb_assert (gdbarch != NULL);
2654 if (gdbarch_debug >= 2)
2655 fprintf_unfiltered (gdb_stdlog, "gdbarch_byte_order called\n");
2656 return gdbarch->byte_order;
2660 gdbarch_osabi (struct gdbarch *gdbarch)
2662 gdb_assert (gdbarch != NULL);
2663 if (gdbarch_debug >= 2)
2664 fprintf_unfiltered (gdb_stdlog, "gdbarch_osabi called\n");
2665 return gdbarch->osabi;
2669 gdbarch_short_bit (struct gdbarch *gdbarch)
2671 gdb_assert (gdbarch != NULL);
2672 /* Skip verify of short_bit, invalid_p == 0 */
2673 if (gdbarch_debug >= 2)
2674 fprintf_unfiltered (gdb_stdlog, "gdbarch_short_bit called\n");
2675 return gdbarch->short_bit;
2679 set_gdbarch_short_bit (struct gdbarch *gdbarch,
2682 gdbarch->short_bit = short_bit;
2686 gdbarch_int_bit (struct gdbarch *gdbarch)
2688 gdb_assert (gdbarch != NULL);
2689 /* Skip verify of int_bit, invalid_p == 0 */
2690 if (gdbarch_debug >= 2)
2691 fprintf_unfiltered (gdb_stdlog, "gdbarch_int_bit called\n");
2692 return gdbarch->int_bit;
2696 set_gdbarch_int_bit (struct gdbarch *gdbarch,
2699 gdbarch->int_bit = int_bit;
2703 gdbarch_long_bit (struct gdbarch *gdbarch)
2705 gdb_assert (gdbarch != NULL);
2706 /* Skip verify of long_bit, invalid_p == 0 */
2707 if (gdbarch_debug >= 2)
2708 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_bit called\n");
2709 return gdbarch->long_bit;
2713 set_gdbarch_long_bit (struct gdbarch *gdbarch,
2716 gdbarch->long_bit = long_bit;
2720 gdbarch_long_long_bit (struct gdbarch *gdbarch)
2722 gdb_assert (gdbarch != NULL);
2723 /* Skip verify of long_long_bit, invalid_p == 0 */
2724 if (gdbarch_debug >= 2)
2725 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_long_bit called\n");
2726 return gdbarch->long_long_bit;
2730 set_gdbarch_long_long_bit (struct gdbarch *gdbarch,
2733 gdbarch->long_long_bit = long_long_bit;
2737 gdbarch_float_bit (struct gdbarch *gdbarch)
2739 gdb_assert (gdbarch != NULL);
2740 /* Skip verify of float_bit, invalid_p == 0 */
2741 if (gdbarch_debug >= 2)
2742 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_bit called\n");
2743 return gdbarch->float_bit;
2747 set_gdbarch_float_bit (struct gdbarch *gdbarch,
2750 gdbarch->float_bit = float_bit;
2754 gdbarch_double_bit (struct gdbarch *gdbarch)
2756 gdb_assert (gdbarch != NULL);
2757 /* Skip verify of double_bit, invalid_p == 0 */
2758 if (gdbarch_debug >= 2)
2759 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_bit called\n");
2760 return gdbarch->double_bit;
2764 set_gdbarch_double_bit (struct gdbarch *gdbarch,
2767 gdbarch->double_bit = double_bit;
2771 gdbarch_long_double_bit (struct gdbarch *gdbarch)
2773 gdb_assert (gdbarch != NULL);
2774 /* Skip verify of long_double_bit, invalid_p == 0 */
2775 if (gdbarch_debug >= 2)
2776 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_bit called\n");
2777 return gdbarch->long_double_bit;
2781 set_gdbarch_long_double_bit (struct gdbarch *gdbarch,
2782 int long_double_bit)
2784 gdbarch->long_double_bit = long_double_bit;
2788 gdbarch_ptr_bit (struct gdbarch *gdbarch)
2790 gdb_assert (gdbarch != NULL);
2791 /* Skip verify of ptr_bit, invalid_p == 0 */
2792 if (gdbarch_debug >= 2)
2793 fprintf_unfiltered (gdb_stdlog, "gdbarch_ptr_bit called\n");
2794 return gdbarch->ptr_bit;
2798 set_gdbarch_ptr_bit (struct gdbarch *gdbarch,
2801 gdbarch->ptr_bit = ptr_bit;
2805 gdbarch_addr_bit (struct gdbarch *gdbarch)
2807 gdb_assert (gdbarch != NULL);
2808 if (gdbarch->addr_bit == 0)
2809 internal_error (__FILE__, __LINE__,
2810 "gdbarch: gdbarch_addr_bit invalid");
2811 if (gdbarch_debug >= 2)
2812 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bit called\n");
2813 return gdbarch->addr_bit;
2817 set_gdbarch_addr_bit (struct gdbarch *gdbarch,
2820 gdbarch->addr_bit = addr_bit;
2824 gdbarch_bfd_vma_bit (struct gdbarch *gdbarch)
2826 gdb_assert (gdbarch != NULL);
2827 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2828 if (gdbarch_debug >= 2)
2829 fprintf_unfiltered (gdb_stdlog, "gdbarch_bfd_vma_bit called\n");
2830 return gdbarch->bfd_vma_bit;
2834 set_gdbarch_bfd_vma_bit (struct gdbarch *gdbarch,
2837 gdbarch->bfd_vma_bit = bfd_vma_bit;
2841 gdbarch_char_signed (struct gdbarch *gdbarch)
2843 gdb_assert (gdbarch != NULL);
2844 if (gdbarch->char_signed == -1)
2845 internal_error (__FILE__, __LINE__,
2846 "gdbarch: gdbarch_char_signed invalid");
2847 if (gdbarch_debug >= 2)
2848 fprintf_unfiltered (gdb_stdlog, "gdbarch_char_signed called\n");
2849 return gdbarch->char_signed;
2853 set_gdbarch_char_signed (struct gdbarch *gdbarch,
2856 gdbarch->char_signed = char_signed;
2860 gdbarch_read_pc (struct gdbarch *gdbarch, ptid_t ptid)
2862 gdb_assert (gdbarch != NULL);
2863 if (gdbarch->read_pc == 0)
2864 internal_error (__FILE__, __LINE__,
2865 "gdbarch: gdbarch_read_pc invalid");
2866 if (gdbarch_debug >= 2)
2867 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_pc called\n");
2868 return gdbarch->read_pc (ptid);
2872 set_gdbarch_read_pc (struct gdbarch *gdbarch,
2873 gdbarch_read_pc_ftype read_pc)
2875 gdbarch->read_pc = read_pc;
2879 gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, ptid_t ptid)
2881 gdb_assert (gdbarch != NULL);
2882 if (gdbarch->write_pc == 0)
2883 internal_error (__FILE__, __LINE__,
2884 "gdbarch: gdbarch_write_pc invalid");
2885 if (gdbarch_debug >= 2)
2886 fprintf_unfiltered (gdb_stdlog, "gdbarch_write_pc called\n");
2887 gdbarch->write_pc (val, ptid);
2891 set_gdbarch_write_pc (struct gdbarch *gdbarch,
2892 gdbarch_write_pc_ftype write_pc)
2894 gdbarch->write_pc = write_pc;
2898 gdbarch_read_fp (struct gdbarch *gdbarch)
2900 gdb_assert (gdbarch != NULL);
2901 if (gdbarch->read_fp == 0)
2902 internal_error (__FILE__, __LINE__,
2903 "gdbarch: gdbarch_read_fp invalid");
2904 if (gdbarch_debug >= 2)
2905 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_fp called\n");
2906 return gdbarch->read_fp ();
2910 set_gdbarch_read_fp (struct gdbarch *gdbarch,
2911 gdbarch_read_fp_ftype read_fp)
2913 gdbarch->read_fp = read_fp;
2917 gdbarch_read_sp (struct gdbarch *gdbarch)
2919 gdb_assert (gdbarch != NULL);
2920 if (gdbarch->read_sp == 0)
2921 internal_error (__FILE__, __LINE__,
2922 "gdbarch: gdbarch_read_sp invalid");
2923 if (gdbarch_debug >= 2)
2924 fprintf_unfiltered (gdb_stdlog, "gdbarch_read_sp called\n");
2925 return gdbarch->read_sp ();
2929 set_gdbarch_read_sp (struct gdbarch *gdbarch,
2930 gdbarch_read_sp_ftype read_sp)
2932 gdbarch->read_sp = read_sp;
2936 gdbarch_deprecated_dummy_write_sp_p (struct gdbarch *gdbarch)
2938 gdb_assert (gdbarch != NULL);
2939 return gdbarch->deprecated_dummy_write_sp != 0;
2943 gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
2945 gdb_assert (gdbarch != NULL);
2946 if (gdbarch->deprecated_dummy_write_sp == 0)
2947 internal_error (__FILE__, __LINE__,
2948 "gdbarch: gdbarch_deprecated_dummy_write_sp invalid");
2949 if (gdbarch_debug >= 2)
2950 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_dummy_write_sp called\n");
2951 gdbarch->deprecated_dummy_write_sp (val);
2955 set_gdbarch_deprecated_dummy_write_sp (struct gdbarch *gdbarch,
2956 gdbarch_deprecated_dummy_write_sp_ftype deprecated_dummy_write_sp)
2958 gdbarch->deprecated_dummy_write_sp = deprecated_dummy_write_sp;
2962 gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, int *frame_regnum, LONGEST *frame_offset)
2964 gdb_assert (gdbarch != NULL);
2965 if (gdbarch->virtual_frame_pointer == 0)
2966 internal_error (__FILE__, __LINE__,
2967 "gdbarch: gdbarch_virtual_frame_pointer invalid");
2968 if (gdbarch_debug >= 2)
2969 fprintf_unfiltered (gdb_stdlog, "gdbarch_virtual_frame_pointer called\n");
2970 gdbarch->virtual_frame_pointer (pc, frame_regnum, frame_offset);
2974 set_gdbarch_virtual_frame_pointer (struct gdbarch *gdbarch,
2975 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
2977 gdbarch->virtual_frame_pointer = virtual_frame_pointer;
2981 gdbarch_pseudo_register_read_p (struct gdbarch *gdbarch)
2983 gdb_assert (gdbarch != NULL);
2984 return gdbarch->pseudo_register_read != 0;
2988 gdbarch_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, void *buf)
2990 gdb_assert (gdbarch != NULL);
2991 if (gdbarch->pseudo_register_read == 0)
2992 internal_error (__FILE__, __LINE__,
2993 "gdbarch: gdbarch_pseudo_register_read invalid");
2994 if (gdbarch_debug >= 2)
2995 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_read called\n");
2996 gdbarch->pseudo_register_read (gdbarch, regcache, cookednum, buf);
3000 set_gdbarch_pseudo_register_read (struct gdbarch *gdbarch,
3001 gdbarch_pseudo_register_read_ftype pseudo_register_read)
3003 gdbarch->pseudo_register_read = pseudo_register_read;
3007 gdbarch_pseudo_register_write_p (struct gdbarch *gdbarch)
3009 gdb_assert (gdbarch != NULL);
3010 return gdbarch->pseudo_register_write != 0;
3014 gdbarch_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const void *buf)
3016 gdb_assert (gdbarch != NULL);
3017 if (gdbarch->pseudo_register_write == 0)
3018 internal_error (__FILE__, __LINE__,
3019 "gdbarch: gdbarch_pseudo_register_write invalid");
3020 if (gdbarch_debug >= 2)
3021 fprintf_unfiltered (gdb_stdlog, "gdbarch_pseudo_register_write called\n");
3022 gdbarch->pseudo_register_write (gdbarch, regcache, cookednum, buf);
3026 set_gdbarch_pseudo_register_write (struct gdbarch *gdbarch,
3027 gdbarch_pseudo_register_write_ftype pseudo_register_write)
3029 gdbarch->pseudo_register_write = pseudo_register_write;
3033 gdbarch_num_regs (struct gdbarch *gdbarch)
3035 gdb_assert (gdbarch != NULL);
3036 if (gdbarch->num_regs == -1)
3037 internal_error (__FILE__, __LINE__,
3038 "gdbarch: gdbarch_num_regs invalid");
3039 if (gdbarch_debug >= 2)
3040 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_regs called\n");
3041 return gdbarch->num_regs;
3045 set_gdbarch_num_regs (struct gdbarch *gdbarch,
3048 gdbarch->num_regs = num_regs;
3052 gdbarch_num_pseudo_regs (struct gdbarch *gdbarch)
3054 gdb_assert (gdbarch != NULL);
3055 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
3056 if (gdbarch_debug >= 2)
3057 fprintf_unfiltered (gdb_stdlog, "gdbarch_num_pseudo_regs called\n");
3058 return gdbarch->num_pseudo_regs;
3062 set_gdbarch_num_pseudo_regs (struct gdbarch *gdbarch,
3063 int num_pseudo_regs)
3065 gdbarch->num_pseudo_regs = num_pseudo_regs;
3069 gdbarch_sp_regnum (struct gdbarch *gdbarch)
3071 gdb_assert (gdbarch != NULL);
3072 /* Skip verify of sp_regnum, invalid_p == 0 */
3073 if (gdbarch_debug >= 2)
3074 fprintf_unfiltered (gdb_stdlog, "gdbarch_sp_regnum called\n");
3075 return gdbarch->sp_regnum;
3079 set_gdbarch_sp_regnum (struct gdbarch *gdbarch,
3082 gdbarch->sp_regnum = sp_regnum;
3086 gdbarch_fp_regnum (struct gdbarch *gdbarch)
3088 gdb_assert (gdbarch != NULL);
3089 /* Skip verify of fp_regnum, invalid_p == 0 */
3090 if (gdbarch_debug >= 2)
3091 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp_regnum called\n");
3092 return gdbarch->fp_regnum;
3096 set_gdbarch_fp_regnum (struct gdbarch *gdbarch,
3099 gdbarch->fp_regnum = fp_regnum;
3103 gdbarch_pc_regnum (struct gdbarch *gdbarch)
3105 gdb_assert (gdbarch != NULL);
3106 /* Skip verify of pc_regnum, invalid_p == 0 */
3107 if (gdbarch_debug >= 2)
3108 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_regnum called\n");
3109 return gdbarch->pc_regnum;
3113 set_gdbarch_pc_regnum (struct gdbarch *gdbarch,
3116 gdbarch->pc_regnum = pc_regnum;
3120 gdbarch_ps_regnum (struct gdbarch *gdbarch)
3122 gdb_assert (gdbarch != NULL);
3123 /* Skip verify of ps_regnum, invalid_p == 0 */
3124 if (gdbarch_debug >= 2)
3125 fprintf_unfiltered (gdb_stdlog, "gdbarch_ps_regnum called\n");
3126 return gdbarch->ps_regnum;
3130 set_gdbarch_ps_regnum (struct gdbarch *gdbarch,
3133 gdbarch->ps_regnum = ps_regnum;
3137 gdbarch_fp0_regnum (struct gdbarch *gdbarch)
3139 gdb_assert (gdbarch != NULL);
3140 /* Skip verify of fp0_regnum, invalid_p == 0 */
3141 if (gdbarch_debug >= 2)
3142 fprintf_unfiltered (gdb_stdlog, "gdbarch_fp0_regnum called\n");
3143 return gdbarch->fp0_regnum;
3147 set_gdbarch_fp0_regnum (struct gdbarch *gdbarch,
3150 gdbarch->fp0_regnum = fp0_regnum;
3154 gdbarch_npc_regnum (struct gdbarch *gdbarch)
3156 gdb_assert (gdbarch != NULL);
3157 /* Skip verify of npc_regnum, invalid_p == 0 */
3158 if (gdbarch_debug >= 2)
3159 fprintf_unfiltered (gdb_stdlog, "gdbarch_npc_regnum called\n");
3160 return gdbarch->npc_regnum;
3164 set_gdbarch_npc_regnum (struct gdbarch *gdbarch,
3167 gdbarch->npc_regnum = npc_regnum;
3171 gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch, int stab_regnr)
3173 gdb_assert (gdbarch != NULL);
3174 if (gdbarch->stab_reg_to_regnum == 0)
3175 internal_error (__FILE__, __LINE__,
3176 "gdbarch: gdbarch_stab_reg_to_regnum invalid");
3177 if (gdbarch_debug >= 2)
3178 fprintf_unfiltered (gdb_stdlog, "gdbarch_stab_reg_to_regnum called\n");
3179 return gdbarch->stab_reg_to_regnum (stab_regnr);
3183 set_gdbarch_stab_reg_to_regnum (struct gdbarch *gdbarch,
3184 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
3186 gdbarch->stab_reg_to_regnum = stab_reg_to_regnum;
3190 gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch, int ecoff_regnr)
3192 gdb_assert (gdbarch != NULL);
3193 if (gdbarch->ecoff_reg_to_regnum == 0)
3194 internal_error (__FILE__, __LINE__,
3195 "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
3196 if (gdbarch_debug >= 2)
3197 fprintf_unfiltered (gdb_stdlog, "gdbarch_ecoff_reg_to_regnum called\n");
3198 return gdbarch->ecoff_reg_to_regnum (ecoff_regnr);
3202 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch *gdbarch,
3203 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum)
3205 gdbarch->ecoff_reg_to_regnum = ecoff_reg_to_regnum;
3209 gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dwarf_regnr)
3211 gdb_assert (gdbarch != NULL);
3212 if (gdbarch->dwarf_reg_to_regnum == 0)
3213 internal_error (__FILE__, __LINE__,
3214 "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
3215 if (gdbarch_debug >= 2)
3216 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf_reg_to_regnum called\n");
3217 return gdbarch->dwarf_reg_to_regnum (dwarf_regnr);
3221 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch *gdbarch,
3222 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum)
3224 gdbarch->dwarf_reg_to_regnum = dwarf_reg_to_regnum;
3228 gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch, int sdb_regnr)
3230 gdb_assert (gdbarch != NULL);
3231 if (gdbarch->sdb_reg_to_regnum == 0)
3232 internal_error (__FILE__, __LINE__,
3233 "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
3234 if (gdbarch_debug >= 2)
3235 fprintf_unfiltered (gdb_stdlog, "gdbarch_sdb_reg_to_regnum called\n");
3236 return gdbarch->sdb_reg_to_regnum (sdb_regnr);
3240 set_gdbarch_sdb_reg_to_regnum (struct gdbarch *gdbarch,
3241 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
3243 gdbarch->sdb_reg_to_regnum = sdb_reg_to_regnum;
3247 gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2_regnr)
3249 gdb_assert (gdbarch != NULL);
3250 if (gdbarch->dwarf2_reg_to_regnum == 0)
3251 internal_error (__FILE__, __LINE__,
3252 "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
3253 if (gdbarch_debug >= 2)
3254 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_reg_to_regnum called\n");
3255 return gdbarch->dwarf2_reg_to_regnum (dwarf2_regnr);
3259 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch *gdbarch,
3260 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
3262 gdbarch->dwarf2_reg_to_regnum = dwarf2_reg_to_regnum;
3266 gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
3268 gdb_assert (gdbarch != NULL);
3269 if (gdbarch->register_name == 0)
3270 internal_error (__FILE__, __LINE__,
3271 "gdbarch: gdbarch_register_name invalid");
3272 if (gdbarch_debug >= 2)
3273 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_name called\n");
3274 return gdbarch->register_name (regnr);
3278 set_gdbarch_register_name (struct gdbarch *gdbarch,
3279 gdbarch_register_name_ftype register_name)
3281 gdbarch->register_name = register_name;
3285 gdbarch_register_size (struct gdbarch *gdbarch)
3287 gdb_assert (gdbarch != NULL);
3288 if (gdbarch->register_size == -1)
3289 internal_error (__FILE__, __LINE__,
3290 "gdbarch: gdbarch_register_size invalid");
3291 if (gdbarch_debug >= 2)
3292 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
3293 return gdbarch->register_size;
3297 set_gdbarch_register_size (struct gdbarch *gdbarch,
3300 gdbarch->register_size = register_size;
3304 gdbarch_register_bytes (struct gdbarch *gdbarch)
3306 gdb_assert (gdbarch != NULL);
3307 if (gdbarch->register_bytes == -1)
3308 internal_error (__FILE__, __LINE__,
3309 "gdbarch: gdbarch_register_bytes invalid");
3310 if (gdbarch_debug >= 2)
3311 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes called\n");
3312 return gdbarch->register_bytes;
3316 set_gdbarch_register_bytes (struct gdbarch *gdbarch,
3319 gdbarch->register_bytes = register_bytes;
3323 gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
3325 gdb_assert (gdbarch != NULL);
3326 if (gdbarch->register_byte == 0)
3327 internal_error (__FILE__, __LINE__,
3328 "gdbarch: gdbarch_register_byte invalid");
3329 if (gdbarch_debug >= 2)
3330 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n");
3331 return gdbarch->register_byte (reg_nr);
3335 set_gdbarch_register_byte (struct gdbarch *gdbarch,
3336 gdbarch_register_byte_ftype register_byte)
3338 gdbarch->register_byte = register_byte;
3342 gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
3344 gdb_assert (gdbarch != NULL);
3345 if (gdbarch->register_raw_size == 0)
3346 internal_error (__FILE__, __LINE__,
3347 "gdbarch: gdbarch_register_raw_size invalid");
3348 if (gdbarch_debug >= 2)
3349 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_raw_size called\n");
3350 return gdbarch->register_raw_size (reg_nr);
3354 set_gdbarch_register_raw_size (struct gdbarch *gdbarch,
3355 gdbarch_register_raw_size_ftype register_raw_size)
3357 gdbarch->register_raw_size = register_raw_size;
3361 gdbarch_deprecated_max_register_raw_size_p (struct gdbarch *gdbarch)
3363 gdb_assert (gdbarch != NULL);
3364 return gdbarch->deprecated_max_register_raw_size != 0;
3368 gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch)
3370 gdb_assert (gdbarch != NULL);
3371 if (gdbarch_debug >= 2)
3372 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_raw_size called\n");
3373 return gdbarch->deprecated_max_register_raw_size;
3377 set_gdbarch_deprecated_max_register_raw_size (struct gdbarch *gdbarch,
3378 int deprecated_max_register_raw_size)
3380 gdbarch->deprecated_max_register_raw_size = deprecated_max_register_raw_size;
3384 gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
3386 gdb_assert (gdbarch != NULL);
3387 if (gdbarch->register_virtual_size == 0)
3388 internal_error (__FILE__, __LINE__,
3389 "gdbarch: gdbarch_register_virtual_size invalid");
3390 if (gdbarch_debug >= 2)
3391 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_size called\n");
3392 return gdbarch->register_virtual_size (reg_nr);
3396 set_gdbarch_register_virtual_size (struct gdbarch *gdbarch,
3397 gdbarch_register_virtual_size_ftype register_virtual_size)
3399 gdbarch->register_virtual_size = register_virtual_size;
3403 gdbarch_deprecated_max_register_virtual_size_p (struct gdbarch *gdbarch)
3405 gdb_assert (gdbarch != NULL);
3406 return gdbarch->deprecated_max_register_virtual_size != 0;
3410 gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch)
3412 gdb_assert (gdbarch != NULL);
3413 if (gdbarch_debug >= 2)
3414 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_max_register_virtual_size called\n");
3415 return gdbarch->deprecated_max_register_virtual_size;
3419 set_gdbarch_deprecated_max_register_virtual_size (struct gdbarch *gdbarch,
3420 int deprecated_max_register_virtual_size)
3422 gdbarch->deprecated_max_register_virtual_size = deprecated_max_register_virtual_size;
3426 gdbarch_register_virtual_type_p (struct gdbarch *gdbarch)
3428 gdb_assert (gdbarch != NULL);
3429 return gdbarch->register_virtual_type != 0;
3433 gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
3435 gdb_assert (gdbarch != NULL);
3436 if (gdbarch->register_virtual_type == 0)
3437 internal_error (__FILE__, __LINE__,
3438 "gdbarch: gdbarch_register_virtual_type invalid");
3439 if (gdbarch_debug >= 2)
3440 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_virtual_type called\n");
3441 return gdbarch->register_virtual_type (reg_nr);
3445 set_gdbarch_register_virtual_type (struct gdbarch *gdbarch,
3446 gdbarch_register_virtual_type_ftype register_virtual_type)
3448 gdbarch->register_virtual_type = register_virtual_type;
3452 gdbarch_register_type_p (struct gdbarch *gdbarch)
3454 gdb_assert (gdbarch != NULL);
3455 return gdbarch->register_type != 0;
3459 gdbarch_register_type (struct gdbarch *gdbarch, int reg_nr)
3461 gdb_assert (gdbarch != NULL);
3462 if (gdbarch->register_type == 0)
3463 internal_error (__FILE__, __LINE__,
3464 "gdbarch: gdbarch_register_type invalid");
3465 if (gdbarch_debug >= 2)
3466 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_type called\n");
3467 return gdbarch->register_type (gdbarch, reg_nr);
3471 set_gdbarch_register_type (struct gdbarch *gdbarch,
3472 gdbarch_register_type_ftype register_type)
3474 gdbarch->register_type = register_type;
3478 gdbarch_deprecated_do_registers_info_p (struct gdbarch *gdbarch)
3480 gdb_assert (gdbarch != NULL);
3481 return gdbarch->deprecated_do_registers_info != 0;
3485 gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch, int reg_nr, int fpregs)
3487 gdb_assert (gdbarch != NULL);
3488 if (gdbarch->deprecated_do_registers_info == 0)
3489 internal_error (__FILE__, __LINE__,
3490 "gdbarch: gdbarch_deprecated_do_registers_info invalid");
3491 if (gdbarch_debug >= 2)
3492 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_do_registers_info called\n");
3493 gdbarch->deprecated_do_registers_info (reg_nr, fpregs);
3497 set_gdbarch_deprecated_do_registers_info (struct gdbarch *gdbarch,
3498 gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info)
3500 gdbarch->deprecated_do_registers_info = deprecated_do_registers_info;
3504 gdbarch_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
3506 gdb_assert (gdbarch != NULL);
3507 if (gdbarch->print_registers_info == 0)
3508 internal_error (__FILE__, __LINE__,
3509 "gdbarch: gdbarch_print_registers_info invalid");
3510 if (gdbarch_debug >= 2)
3511 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_registers_info called\n");
3512 gdbarch->print_registers_info (gdbarch, file, frame, regnum, all);
3516 set_gdbarch_print_registers_info (struct gdbarch *gdbarch,
3517 gdbarch_print_registers_info_ftype print_registers_info)
3519 gdbarch->print_registers_info = print_registers_info;
3523 gdbarch_print_float_info_p (struct gdbarch *gdbarch)
3525 gdb_assert (gdbarch != NULL);
3526 return gdbarch->print_float_info != 0;
3530 gdbarch_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
3532 gdb_assert (gdbarch != NULL);
3533 if (gdbarch->print_float_info == 0)
3534 internal_error (__FILE__, __LINE__,
3535 "gdbarch: gdbarch_print_float_info invalid");
3536 if (gdbarch_debug >= 2)
3537 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_float_info called\n");
3538 gdbarch->print_float_info (gdbarch, file, frame, args);
3542 set_gdbarch_print_float_info (struct gdbarch *gdbarch,
3543 gdbarch_print_float_info_ftype print_float_info)
3545 gdbarch->print_float_info = print_float_info;
3549 gdbarch_print_vector_info_p (struct gdbarch *gdbarch)
3551 gdb_assert (gdbarch != NULL);
3552 return gdbarch->print_vector_info != 0;
3556 gdbarch_print_vector_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
3558 gdb_assert (gdbarch != NULL);
3559 if (gdbarch->print_vector_info == 0)
3560 internal_error (__FILE__, __LINE__,
3561 "gdbarch: gdbarch_print_vector_info invalid");
3562 if (gdbarch_debug >= 2)
3563 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_vector_info called\n");
3564 gdbarch->print_vector_info (gdbarch, file, frame, args);
3568 set_gdbarch_print_vector_info (struct gdbarch *gdbarch,
3569 gdbarch_print_vector_info_ftype print_vector_info)
3571 gdbarch->print_vector_info = print_vector_info;
3575 gdbarch_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
3577 gdb_assert (gdbarch != NULL);
3578 if (gdbarch->register_sim_regno == 0)
3579 internal_error (__FILE__, __LINE__,
3580 "gdbarch: gdbarch_register_sim_regno invalid");
3581 if (gdbarch_debug >= 2)
3582 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_sim_regno called\n");
3583 return gdbarch->register_sim_regno (reg_nr);
3587 set_gdbarch_register_sim_regno (struct gdbarch *gdbarch,
3588 gdbarch_register_sim_regno_ftype register_sim_regno)
3590 gdbarch->register_sim_regno = register_sim_regno;
3594 gdbarch_register_bytes_ok_p (struct gdbarch *gdbarch)
3596 gdb_assert (gdbarch != NULL);
3597 return gdbarch->register_bytes_ok != 0;
3601 gdbarch_register_bytes_ok (struct gdbarch *gdbarch, long nr_bytes)
3603 gdb_assert (gdbarch != NULL);
3604 if (gdbarch->register_bytes_ok == 0)
3605 internal_error (__FILE__, __LINE__,
3606 "gdbarch: gdbarch_register_bytes_ok invalid");
3607 if (gdbarch_debug >= 2)
3608 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_bytes_ok called\n");
3609 return gdbarch->register_bytes_ok (nr_bytes);
3613 set_gdbarch_register_bytes_ok (struct gdbarch *gdbarch,
3614 gdbarch_register_bytes_ok_ftype register_bytes_ok)
3616 gdbarch->register_bytes_ok = register_bytes_ok;
3620 gdbarch_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
3622 gdb_assert (gdbarch != NULL);
3623 if (gdbarch->cannot_fetch_register == 0)
3624 internal_error (__FILE__, __LINE__,
3625 "gdbarch: gdbarch_cannot_fetch_register invalid");
3626 if (gdbarch_debug >= 2)
3627 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_fetch_register called\n");
3628 return gdbarch->cannot_fetch_register (regnum);
3632 set_gdbarch_cannot_fetch_register (struct gdbarch *gdbarch,
3633 gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
3635 gdbarch->cannot_fetch_register = cannot_fetch_register;
3639 gdbarch_cannot_store_register (struct gdbarch *gdbarch, int regnum)
3641 gdb_assert (gdbarch != NULL);
3642 if (gdbarch->cannot_store_register == 0)
3643 internal_error (__FILE__, __LINE__,
3644 "gdbarch: gdbarch_cannot_store_register invalid");
3645 if (gdbarch_debug >= 2)
3646 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_store_register called\n");
3647 return gdbarch->cannot_store_register (regnum);
3651 set_gdbarch_cannot_store_register (struct gdbarch *gdbarch,
3652 gdbarch_cannot_store_register_ftype cannot_store_register)
3654 gdbarch->cannot_store_register = cannot_store_register;
3658 gdbarch_get_longjmp_target_p (struct gdbarch *gdbarch)
3660 gdb_assert (gdbarch != NULL);
3661 return gdbarch->get_longjmp_target != 0;
3665 gdbarch_get_longjmp_target (struct gdbarch *gdbarch, CORE_ADDR *pc)
3667 gdb_assert (gdbarch != NULL);
3668 if (gdbarch->get_longjmp_target == 0)
3669 internal_error (__FILE__, __LINE__,
3670 "gdbarch: gdbarch_get_longjmp_target invalid");
3671 if (gdbarch_debug >= 2)
3672 fprintf_unfiltered (gdb_stdlog, "gdbarch_get_longjmp_target called\n");
3673 return gdbarch->get_longjmp_target (pc);
3677 set_gdbarch_get_longjmp_target (struct gdbarch *gdbarch,
3678 gdbarch_get_longjmp_target_ftype get_longjmp_target)
3680 gdbarch->get_longjmp_target = get_longjmp_target;
3684 gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch)
3686 gdb_assert (gdbarch != NULL);
3687 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
3688 if (gdbarch_debug >= 2)
3689 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_generic_dummy_frames called\n");
3690 return gdbarch->deprecated_use_generic_dummy_frames;
3694 set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch,
3695 int deprecated_use_generic_dummy_frames)
3697 gdbarch->deprecated_use_generic_dummy_frames = deprecated_use_generic_dummy_frames;
3701 gdbarch_call_dummy_location (struct gdbarch *gdbarch)
3703 gdb_assert (gdbarch != NULL);
3704 /* Skip verify of call_dummy_location, invalid_p == 0 */
3705 if (gdbarch_debug >= 2)
3706 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_location called\n");
3707 return gdbarch->call_dummy_location;
3711 set_gdbarch_call_dummy_location (struct gdbarch *gdbarch,
3712 int call_dummy_location)
3714 gdbarch->call_dummy_location = call_dummy_location;
3718 gdbarch_call_dummy_address (struct gdbarch *gdbarch)
3720 gdb_assert (gdbarch != NULL);
3721 if (gdbarch->call_dummy_address == 0)
3722 internal_error (__FILE__, __LINE__,
3723 "gdbarch: gdbarch_call_dummy_address invalid");
3724 if (gdbarch_debug >= 2)
3725 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_address called\n");
3726 return gdbarch->call_dummy_address ();
3730 set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
3731 gdbarch_call_dummy_address_ftype call_dummy_address)
3733 gdbarch->call_dummy_address = call_dummy_address;
3737 gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
3739 gdb_assert (gdbarch != NULL);
3740 if (gdbarch->call_dummy_start_offset == -1)
3741 internal_error (__FILE__, __LINE__,
3742 "gdbarch: gdbarch_call_dummy_start_offset invalid");
3743 if (gdbarch_debug >= 2)
3744 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
3745 return gdbarch->call_dummy_start_offset;
3749 set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
3750 CORE_ADDR call_dummy_start_offset)
3752 gdbarch->call_dummy_start_offset = call_dummy_start_offset;
3756 gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
3758 gdb_assert (gdbarch != NULL);
3759 if (gdbarch->call_dummy_breakpoint_offset_p && gdbarch->call_dummy_breakpoint_offset == -1)
3760 internal_error (__FILE__, __LINE__,
3761 "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
3762 if (gdbarch_debug >= 2)
3763 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
3764 return gdbarch->call_dummy_breakpoint_offset;
3768 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
3769 CORE_ADDR call_dummy_breakpoint_offset)
3771 gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
3775 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch)
3777 gdb_assert (gdbarch != NULL);
3778 if (gdbarch->call_dummy_breakpoint_offset_p == -1)
3779 internal_error (__FILE__, __LINE__,
3780 "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
3781 if (gdbarch_debug >= 2)
3782 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset_p called\n");
3783 return gdbarch->call_dummy_breakpoint_offset_p;
3787 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch *gdbarch,
3788 int call_dummy_breakpoint_offset_p)
3790 gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
3794 gdbarch_call_dummy_length (struct gdbarch *gdbarch)
3796 gdb_assert (gdbarch != NULL);
3797 if (gdbarch->call_dummy_length == -1)
3798 internal_error (__FILE__, __LINE__,
3799 "gdbarch: gdbarch_call_dummy_length invalid");
3800 if (gdbarch_debug >= 2)
3801 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
3802 return gdbarch->call_dummy_length;
3806 set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
3807 int call_dummy_length)
3809 gdbarch->call_dummy_length = call_dummy_length;
3813 gdbarch_deprecated_pc_in_call_dummy_p (struct gdbarch *gdbarch)
3815 gdb_assert (gdbarch != NULL);
3816 return gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy;
3820 gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
3822 gdb_assert (gdbarch != NULL);
3823 if (gdbarch->deprecated_pc_in_call_dummy == 0)
3824 internal_error (__FILE__, __LINE__,
3825 "gdbarch: gdbarch_deprecated_pc_in_call_dummy invalid");
3826 /* Ignore predicate (gdbarch->deprecated_pc_in_call_dummy != generic_pc_in_call_dummy). */
3827 if (gdbarch_debug >= 2)
3828 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pc_in_call_dummy called\n");
3829 return gdbarch->deprecated_pc_in_call_dummy (pc, sp, frame_address);
3833 set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
3834 gdbarch_deprecated_pc_in_call_dummy_ftype deprecated_pc_in_call_dummy)
3836 gdbarch->deprecated_pc_in_call_dummy = deprecated_pc_in_call_dummy;
3840 gdbarch_call_dummy_words (struct gdbarch *gdbarch)
3842 gdb_assert (gdbarch != NULL);
3843 /* Skip verify of call_dummy_words, invalid_p == 0 */
3844 if (gdbarch_debug >= 2)
3845 fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
3846 return gdbarch->call_dummy_words;
3850 set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
3851 LONGEST * call_dummy_words)
3853 gdbarch->call_dummy_words = call_dummy_words;
3857 gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
3859 gdb_assert (gdbarch != NULL);
3860 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
3861 if (gdbarch_debug >= 2)
3862 fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
3863 return gdbarch->sizeof_call_dummy_words;
3867 set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
3868 int sizeof_call_dummy_words)
3870 gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
3874 gdbarch_deprecated_call_dummy_stack_adjust_p (struct gdbarch *gdbarch)
3876 gdb_assert (gdbarch != NULL);
3877 return gdbarch->deprecated_call_dummy_stack_adjust != 0;
3881 gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch)
3883 gdb_assert (gdbarch != NULL);
3884 if (gdbarch_debug >= 2)
3885 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_stack_adjust called\n");
3886 return gdbarch->deprecated_call_dummy_stack_adjust;
3890 set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
3891 int deprecated_call_dummy_stack_adjust)
3893 gdbarch->deprecated_call_dummy_stack_adjust = deprecated_call_dummy_stack_adjust;
3897 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)
3899 gdb_assert (gdbarch != NULL);
3900 if (gdbarch->fix_call_dummy == 0)
3901 internal_error (__FILE__, __LINE__,
3902 "gdbarch: gdbarch_fix_call_dummy invalid");
3903 if (gdbarch_debug >= 2)
3904 fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
3905 gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
3909 set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
3910 gdbarch_fix_call_dummy_ftype fix_call_dummy)
3912 gdbarch->fix_call_dummy = fix_call_dummy;
3916 gdbarch_deprecated_init_frame_pc_first_p (struct gdbarch *gdbarch)
3918 gdb_assert (gdbarch != NULL);
3919 return gdbarch->deprecated_init_frame_pc_first != 0;
3923 gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3925 gdb_assert (gdbarch != NULL);
3926 if (gdbarch->deprecated_init_frame_pc_first == 0)
3927 internal_error (__FILE__, __LINE__,
3928 "gdbarch: gdbarch_deprecated_init_frame_pc_first invalid");
3929 if (gdbarch_debug >= 2)
3930 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc_first called\n");
3931 return gdbarch->deprecated_init_frame_pc_first (fromleaf, prev);
3935 set_gdbarch_deprecated_init_frame_pc_first (struct gdbarch *gdbarch,
3936 gdbarch_deprecated_init_frame_pc_first_ftype deprecated_init_frame_pc_first)
3938 gdbarch->deprecated_init_frame_pc_first = deprecated_init_frame_pc_first;
3942 gdbarch_deprecated_init_frame_pc_p (struct gdbarch *gdbarch)
3944 gdb_assert (gdbarch != NULL);
3945 return gdbarch->deprecated_init_frame_pc != 0;
3949 gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch, int fromleaf, struct frame_info *prev)
3951 gdb_assert (gdbarch != NULL);
3952 if (gdbarch->deprecated_init_frame_pc == 0)
3953 internal_error (__FILE__, __LINE__,
3954 "gdbarch: gdbarch_deprecated_init_frame_pc invalid");
3955 if (gdbarch_debug >= 2)
3956 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_frame_pc called\n");
3957 return gdbarch->deprecated_init_frame_pc (fromleaf, prev);
3961 set_gdbarch_deprecated_init_frame_pc (struct gdbarch *gdbarch,
3962 gdbarch_deprecated_init_frame_pc_ftype deprecated_init_frame_pc)
3964 gdbarch->deprecated_init_frame_pc = deprecated_init_frame_pc;
3968 gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch)
3970 gdb_assert (gdbarch != NULL);
3971 if (gdbarch_debug >= 2)
3972 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion called\n");
3973 return gdbarch->believe_pcc_promotion;
3977 set_gdbarch_believe_pcc_promotion (struct gdbarch *gdbarch,
3978 int believe_pcc_promotion)
3980 gdbarch->believe_pcc_promotion = believe_pcc_promotion;
3984 gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch)
3986 gdb_assert (gdbarch != NULL);
3987 if (gdbarch_debug >= 2)
3988 fprintf_unfiltered (gdb_stdlog, "gdbarch_believe_pcc_promotion_type called\n");
3989 return gdbarch->believe_pcc_promotion_type;
3993 set_gdbarch_believe_pcc_promotion_type (struct gdbarch *gdbarch,
3994 int believe_pcc_promotion_type)
3996 gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
4000 gdbarch_deprecated_get_saved_register_p (struct gdbarch *gdbarch)
4002 gdb_assert (gdbarch != NULL);
4003 return gdbarch->deprecated_get_saved_register != 0;
4007 gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
4009 gdb_assert (gdbarch != NULL);
4010 if (gdbarch->deprecated_get_saved_register == 0)
4011 internal_error (__FILE__, __LINE__,
4012 "gdbarch: gdbarch_deprecated_get_saved_register invalid");
4013 if (gdbarch_debug >= 2)
4014 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_get_saved_register called\n");
4015 gdbarch->deprecated_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval);
4019 set_gdbarch_deprecated_get_saved_register (struct gdbarch *gdbarch,
4020 gdbarch_deprecated_get_saved_register_ftype deprecated_get_saved_register)
4022 gdbarch->deprecated_get_saved_register = deprecated_get_saved_register;
4026 gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
4028 gdb_assert (gdbarch != NULL);
4029 if (gdbarch->register_convertible == 0)
4030 internal_error (__FILE__, __LINE__,
4031 "gdbarch: gdbarch_register_convertible invalid");
4032 if (gdbarch_debug >= 2)
4033 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convertible called\n");
4034 return gdbarch->register_convertible (nr);
4038 set_gdbarch_register_convertible (struct gdbarch *gdbarch,
4039 gdbarch_register_convertible_ftype register_convertible)
4041 gdbarch->register_convertible = register_convertible;
4045 gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
4047 gdb_assert (gdbarch != NULL);
4048 if (gdbarch->register_convert_to_virtual == 0)
4049 internal_error (__FILE__, __LINE__,
4050 "gdbarch: gdbarch_register_convert_to_virtual invalid");
4051 if (gdbarch_debug >= 2)
4052 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_virtual called\n");
4053 gdbarch->register_convert_to_virtual (regnum, type, from, to);
4057 set_gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch,
4058 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual)
4060 gdbarch->register_convert_to_virtual = register_convert_to_virtual;
4064 gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
4066 gdb_assert (gdbarch != NULL);
4067 if (gdbarch->register_convert_to_raw == 0)
4068 internal_error (__FILE__, __LINE__,
4069 "gdbarch: gdbarch_register_convert_to_raw invalid");
4070 if (gdbarch_debug >= 2)
4071 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_convert_to_raw called\n");
4072 gdbarch->register_convert_to_raw (type, regnum, from, to);
4076 set_gdbarch_register_convert_to_raw (struct gdbarch *gdbarch,
4077 gdbarch_register_convert_to_raw_ftype register_convert_to_raw)
4079 gdbarch->register_convert_to_raw = register_convert_to_raw;
4083 gdbarch_convert_register_p (struct gdbarch *gdbarch, int regnum)
4085 gdb_assert (gdbarch != NULL);
4086 if (gdbarch->convert_register_p == 0)
4087 internal_error (__FILE__, __LINE__,
4088 "gdbarch: gdbarch_convert_register_p invalid");
4089 if (gdbarch_debug >= 2)
4090 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_register_p called\n");
4091 return gdbarch->convert_register_p (regnum);
4095 set_gdbarch_convert_register_p (struct gdbarch *gdbarch,
4096 gdbarch_convert_register_p_ftype convert_register_p)
4098 gdbarch->convert_register_p = convert_register_p;
4102 gdbarch_register_to_value (struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to)
4104 gdb_assert (gdbarch != NULL);
4105 if (gdbarch->register_to_value == 0)
4106 internal_error (__FILE__, __LINE__,
4107 "gdbarch: gdbarch_register_to_value invalid");
4108 if (gdbarch_debug >= 2)
4109 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_to_value called\n");
4110 gdbarch->register_to_value (regnum, type, from, to);
4114 set_gdbarch_register_to_value (struct gdbarch *gdbarch,
4115 gdbarch_register_to_value_ftype register_to_value)
4117 gdbarch->register_to_value = register_to_value;
4121 gdbarch_value_to_register (struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to)
4123 gdb_assert (gdbarch != NULL);
4124 if (gdbarch->value_to_register == 0)
4125 internal_error (__FILE__, __LINE__,
4126 "gdbarch: gdbarch_value_to_register invalid");
4127 if (gdbarch_debug >= 2)
4128 fprintf_unfiltered (gdb_stdlog, "gdbarch_value_to_register called\n");
4129 gdbarch->value_to_register (type, regnum, from, to);
4133 set_gdbarch_value_to_register (struct gdbarch *gdbarch,
4134 gdbarch_value_to_register_ftype value_to_register)
4136 gdbarch->value_to_register = value_to_register;
4140 gdbarch_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const void *buf)
4142 gdb_assert (gdbarch != NULL);
4143 if (gdbarch->pointer_to_address == 0)
4144 internal_error (__FILE__, __LINE__,
4145 "gdbarch: gdbarch_pointer_to_address invalid");
4146 if (gdbarch_debug >= 2)
4147 fprintf_unfiltered (gdb_stdlog, "gdbarch_pointer_to_address called\n");
4148 return gdbarch->pointer_to_address (type, buf);
4152 set_gdbarch_pointer_to_address (struct gdbarch *gdbarch,
4153 gdbarch_pointer_to_address_ftype pointer_to_address)
4155 gdbarch->pointer_to_address = pointer_to_address;
4159 gdbarch_address_to_pointer (struct gdbarch *gdbarch, struct type *type, void *buf, CORE_ADDR addr)
4161 gdb_assert (gdbarch != NULL);
4162 if (gdbarch->address_to_pointer == 0)
4163 internal_error (__FILE__, __LINE__,
4164 "gdbarch: gdbarch_address_to_pointer invalid");
4165 if (gdbarch_debug >= 2)
4166 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_to_pointer called\n");
4167 gdbarch->address_to_pointer (type, buf, addr);
4171 set_gdbarch_address_to_pointer (struct gdbarch *gdbarch,
4172 gdbarch_address_to_pointer_ftype address_to_pointer)
4174 gdbarch->address_to_pointer = address_to_pointer;
4178 gdbarch_integer_to_address_p (struct gdbarch *gdbarch)
4180 gdb_assert (gdbarch != NULL);
4181 return gdbarch->integer_to_address != 0;
4185 gdbarch_integer_to_address (struct gdbarch *gdbarch, struct type *type, void *buf)
4187 gdb_assert (gdbarch != NULL);
4188 if (gdbarch->integer_to_address == 0)
4189 internal_error (__FILE__, __LINE__,
4190 "gdbarch: gdbarch_integer_to_address invalid");
4191 if (gdbarch_debug >= 2)
4192 fprintf_unfiltered (gdb_stdlog, "gdbarch_integer_to_address called\n");
4193 return gdbarch->integer_to_address (type, buf);
4197 set_gdbarch_integer_to_address (struct gdbarch *gdbarch,
4198 gdbarch_integer_to_address_ftype integer_to_address)
4200 gdbarch->integer_to_address = integer_to_address;
4204 gdbarch_return_value_on_stack (struct gdbarch *gdbarch, struct type *type)
4206 gdb_assert (gdbarch != NULL);
4207 if (gdbarch->return_value_on_stack == 0)
4208 internal_error (__FILE__, __LINE__,
4209 "gdbarch: gdbarch_return_value_on_stack invalid");
4210 if (gdbarch_debug >= 2)
4211 fprintf_unfiltered (gdb_stdlog, "gdbarch_return_value_on_stack called\n");
4212 return gdbarch->return_value_on_stack (type);
4216 set_gdbarch_return_value_on_stack (struct gdbarch *gdbarch,
4217 gdbarch_return_value_on_stack_ftype return_value_on_stack)
4219 gdbarch->return_value_on_stack = return_value_on_stack;
4223 gdbarch_deprecated_push_arguments_p (struct gdbarch *gdbarch)
4225 gdb_assert (gdbarch != NULL);
4226 return gdbarch->deprecated_push_arguments != 0;
4230 gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
4232 gdb_assert (gdbarch != NULL);
4233 if (gdbarch->deprecated_push_arguments == 0)
4234 internal_error (__FILE__, __LINE__,
4235 "gdbarch: gdbarch_deprecated_push_arguments invalid");
4236 if (gdbarch_debug >= 2)
4237 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_arguments called\n");
4238 return gdbarch->deprecated_push_arguments (nargs, args, sp, struct_return, struct_addr);
4242 set_gdbarch_deprecated_push_arguments (struct gdbarch *gdbarch,
4243 gdbarch_deprecated_push_arguments_ftype deprecated_push_arguments)
4245 gdbarch->deprecated_push_arguments = deprecated_push_arguments;
4249 gdbarch_push_dummy_call_p (struct gdbarch *gdbarch)
4251 gdb_assert (gdbarch != NULL);
4252 return gdbarch->push_dummy_call != 0;
4256 gdbarch_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR dummy_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
4258 gdb_assert (gdbarch != NULL);
4259 if (gdbarch->push_dummy_call == 0)
4260 internal_error (__FILE__, __LINE__,
4261 "gdbarch: gdbarch_push_dummy_call invalid");
4262 if (gdbarch_debug >= 2)
4263 fprintf_unfiltered (gdb_stdlog, "gdbarch_push_dummy_call called\n");
4264 return gdbarch->push_dummy_call (gdbarch, regcache, dummy_addr, nargs, args, sp, struct_return, struct_addr);
4268 set_gdbarch_push_dummy_call (struct gdbarch *gdbarch,
4269 gdbarch_push_dummy_call_ftype push_dummy_call)
4271 gdbarch->push_dummy_call = push_dummy_call;
4275 gdbarch_deprecated_push_dummy_frame_p (struct gdbarch *gdbarch)
4277 gdb_assert (gdbarch != NULL);
4278 return gdbarch->deprecated_push_dummy_frame != 0;
4282 gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch)
4284 gdb_assert (gdbarch != NULL);
4285 if (gdbarch->deprecated_push_dummy_frame == 0)
4286 internal_error (__FILE__, __LINE__,
4287 "gdbarch: gdbarch_deprecated_push_dummy_frame invalid");
4288 if (gdbarch_debug >= 2)
4289 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_dummy_frame called\n");
4290 gdbarch->deprecated_push_dummy_frame ();
4294 set_gdbarch_deprecated_push_dummy_frame (struct gdbarch *gdbarch,
4295 gdbarch_deprecated_push_dummy_frame_ftype deprecated_push_dummy_frame)
4297 gdbarch->deprecated_push_dummy_frame = deprecated_push_dummy_frame;
4301 gdbarch_deprecated_push_return_address_p (struct gdbarch *gdbarch)
4303 gdb_assert (gdbarch != NULL);
4304 return gdbarch->deprecated_push_return_address != 0;
4308 gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp)
4310 gdb_assert (gdbarch != NULL);
4311 if (gdbarch->deprecated_push_return_address == 0)
4312 internal_error (__FILE__, __LINE__,
4313 "gdbarch: gdbarch_deprecated_push_return_address invalid");
4314 if (gdbarch_debug >= 2)
4315 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_push_return_address called\n");
4316 return gdbarch->deprecated_push_return_address (pc, sp);
4320 set_gdbarch_deprecated_push_return_address (struct gdbarch *gdbarch,
4321 gdbarch_deprecated_push_return_address_ftype deprecated_push_return_address)
4323 gdbarch->deprecated_push_return_address = deprecated_push_return_address;
4327 gdbarch_deprecated_pop_frame_p (struct gdbarch *gdbarch)
4329 gdb_assert (gdbarch != NULL);
4330 return gdbarch->deprecated_pop_frame != 0;
4334 gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch)
4336 gdb_assert (gdbarch != NULL);
4337 if (gdbarch->deprecated_pop_frame == 0)
4338 internal_error (__FILE__, __LINE__,
4339 "gdbarch: gdbarch_deprecated_pop_frame invalid");
4340 if (gdbarch_debug >= 2)
4341 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_pop_frame called\n");
4342 gdbarch->deprecated_pop_frame ();
4346 set_gdbarch_deprecated_pop_frame (struct gdbarch *gdbarch,
4347 gdbarch_deprecated_pop_frame_ftype deprecated_pop_frame)
4349 gdbarch->deprecated_pop_frame = deprecated_pop_frame;
4353 gdbarch_deprecated_store_struct_return_p (struct gdbarch *gdbarch)
4355 gdb_assert (gdbarch != NULL);
4356 return gdbarch->deprecated_store_struct_return != 0;
4360 gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp)
4362 gdb_assert (gdbarch != NULL);
4363 if (gdbarch->deprecated_store_struct_return == 0)
4364 internal_error (__FILE__, __LINE__,
4365 "gdbarch: gdbarch_deprecated_store_struct_return invalid");
4366 if (gdbarch_debug >= 2)
4367 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_struct_return called\n");
4368 gdbarch->deprecated_store_struct_return (addr, sp);
4372 set_gdbarch_deprecated_store_struct_return (struct gdbarch *gdbarch,
4373 gdbarch_deprecated_store_struct_return_ftype deprecated_store_struct_return)
4375 gdbarch->deprecated_store_struct_return = deprecated_store_struct_return;
4379 gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, void *valbuf)
4381 gdb_assert (gdbarch != NULL);
4382 if (gdbarch->extract_return_value == 0)
4383 internal_error (__FILE__, __LINE__,
4384 "gdbarch: gdbarch_extract_return_value invalid");
4385 if (gdbarch_debug >= 2)
4386 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_return_value called\n");
4387 gdbarch->extract_return_value (type, regcache, valbuf);
4391 set_gdbarch_extract_return_value (struct gdbarch *gdbarch,
4392 gdbarch_extract_return_value_ftype extract_return_value)
4394 gdbarch->extract_return_value = extract_return_value;
4398 gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const void *valbuf)
4400 gdb_assert (gdbarch != NULL);
4401 if (gdbarch->store_return_value == 0)
4402 internal_error (__FILE__, __LINE__,
4403 "gdbarch: gdbarch_store_return_value invalid");
4404 if (gdbarch_debug >= 2)
4405 fprintf_unfiltered (gdb_stdlog, "gdbarch_store_return_value called\n");
4406 gdbarch->store_return_value (type, regcache, valbuf);
4410 set_gdbarch_store_return_value (struct gdbarch *gdbarch,
4411 gdbarch_store_return_value_ftype store_return_value)
4413 gdbarch->store_return_value = store_return_value;
4417 gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf)
4419 gdb_assert (gdbarch != NULL);
4420 if (gdbarch->deprecated_extract_return_value == 0)
4421 internal_error (__FILE__, __LINE__,
4422 "gdbarch: gdbarch_deprecated_extract_return_value invalid");
4423 if (gdbarch_debug >= 2)
4424 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_return_value called\n");
4425 gdbarch->deprecated_extract_return_value (type, regbuf, valbuf);
4429 set_gdbarch_deprecated_extract_return_value (struct gdbarch *gdbarch,
4430 gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value)
4432 gdbarch->deprecated_extract_return_value = deprecated_extract_return_value;
4436 gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch, struct type *type, char *valbuf)
4438 gdb_assert (gdbarch != NULL);
4439 if (gdbarch->deprecated_store_return_value == 0)
4440 internal_error (__FILE__, __LINE__,
4441 "gdbarch: gdbarch_deprecated_store_return_value invalid");
4442 if (gdbarch_debug >= 2)
4443 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_store_return_value called\n");
4444 gdbarch->deprecated_store_return_value (type, valbuf);
4448 set_gdbarch_deprecated_store_return_value (struct gdbarch *gdbarch,
4449 gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value)
4451 gdbarch->deprecated_store_return_value = deprecated_store_return_value;
4455 gdbarch_extract_struct_value_address_p (struct gdbarch *gdbarch)
4457 gdb_assert (gdbarch != NULL);
4458 return gdbarch->extract_struct_value_address != 0;
4462 gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, struct regcache *regcache)
4464 gdb_assert (gdbarch != NULL);
4465 if (gdbarch->extract_struct_value_address == 0)
4466 internal_error (__FILE__, __LINE__,
4467 "gdbarch: gdbarch_extract_struct_value_address invalid");
4468 if (gdbarch_debug >= 2)
4469 fprintf_unfiltered (gdb_stdlog, "gdbarch_extract_struct_value_address called\n");
4470 return gdbarch->extract_struct_value_address (regcache);
4474 set_gdbarch_extract_struct_value_address (struct gdbarch *gdbarch,
4475 gdbarch_extract_struct_value_address_ftype extract_struct_value_address)
4477 gdbarch->extract_struct_value_address = extract_struct_value_address;
4481 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch *gdbarch)
4483 gdb_assert (gdbarch != NULL);
4484 return gdbarch->deprecated_extract_struct_value_address != 0;
4488 gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
4490 gdb_assert (gdbarch != NULL);
4491 if (gdbarch->deprecated_extract_struct_value_address == 0)
4492 internal_error (__FILE__, __LINE__,
4493 "gdbarch: gdbarch_deprecated_extract_struct_value_address invalid");
4494 if (gdbarch_debug >= 2)
4495 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extract_struct_value_address called\n");
4496 return gdbarch->deprecated_extract_struct_value_address (regbuf);
4500 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch *gdbarch,
4501 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address)
4503 gdbarch->deprecated_extract_struct_value_address = deprecated_extract_struct_value_address;
4507 gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *value_type)
4509 gdb_assert (gdbarch != NULL);
4510 if (gdbarch->use_struct_convention == 0)
4511 internal_error (__FILE__, __LINE__,
4512 "gdbarch: gdbarch_use_struct_convention invalid");
4513 if (gdbarch_debug >= 2)
4514 fprintf_unfiltered (gdb_stdlog, "gdbarch_use_struct_convention called\n");
4515 return gdbarch->use_struct_convention (gcc_p, value_type);
4519 set_gdbarch_use_struct_convention (struct gdbarch *gdbarch,
4520 gdbarch_use_struct_convention_ftype use_struct_convention)
4522 gdbarch->use_struct_convention = use_struct_convention;
4526 gdbarch_deprecated_frame_init_saved_regs_p (struct gdbarch *gdbarch)
4528 gdb_assert (gdbarch != NULL);
4529 return gdbarch->deprecated_frame_init_saved_regs != 0;
4533 gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame)
4535 gdb_assert (gdbarch != NULL);
4536 if (gdbarch->deprecated_frame_init_saved_regs == 0)
4537 internal_error (__FILE__, __LINE__,
4538 "gdbarch: gdbarch_deprecated_frame_init_saved_regs invalid");
4539 if (gdbarch_debug >= 2)
4540 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_init_saved_regs called\n");
4541 gdbarch->deprecated_frame_init_saved_regs (frame);
4545 set_gdbarch_deprecated_frame_init_saved_regs (struct gdbarch *gdbarch,
4546 gdbarch_deprecated_frame_init_saved_regs_ftype deprecated_frame_init_saved_regs)
4548 gdbarch->deprecated_frame_init_saved_regs = deprecated_frame_init_saved_regs;
4552 gdbarch_deprecated_init_extra_frame_info_p (struct gdbarch *gdbarch)
4554 gdb_assert (gdbarch != NULL);
4555 return gdbarch->deprecated_init_extra_frame_info != 0;
4559 gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame)
4561 gdb_assert (gdbarch != NULL);
4562 if (gdbarch->deprecated_init_extra_frame_info == 0)
4563 internal_error (__FILE__, __LINE__,
4564 "gdbarch: gdbarch_deprecated_init_extra_frame_info invalid");
4565 if (gdbarch_debug >= 2)
4566 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_init_extra_frame_info called\n");
4567 gdbarch->deprecated_init_extra_frame_info (fromleaf, frame);
4571 set_gdbarch_deprecated_init_extra_frame_info (struct gdbarch *gdbarch,
4572 gdbarch_deprecated_init_extra_frame_info_ftype deprecated_init_extra_frame_info)
4574 gdbarch->deprecated_init_extra_frame_info = deprecated_init_extra_frame_info;
4578 gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
4580 gdb_assert (gdbarch != NULL);
4581 if (gdbarch->skip_prologue == 0)
4582 internal_error (__FILE__, __LINE__,
4583 "gdbarch: gdbarch_skip_prologue invalid");
4584 if (gdbarch_debug >= 2)
4585 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_prologue called\n");
4586 return gdbarch->skip_prologue (ip);
4590 set_gdbarch_skip_prologue (struct gdbarch *gdbarch,
4591 gdbarch_skip_prologue_ftype skip_prologue)
4593 gdbarch->skip_prologue = skip_prologue;
4597 gdbarch_prologue_frameless_p (struct gdbarch *gdbarch, CORE_ADDR ip)
4599 gdb_assert (gdbarch != NULL);
4600 if (gdbarch->prologue_frameless_p == 0)
4601 internal_error (__FILE__, __LINE__,
4602 "gdbarch: gdbarch_prologue_frameless_p invalid");
4603 if (gdbarch_debug >= 2)
4604 fprintf_unfiltered (gdb_stdlog, "gdbarch_prologue_frameless_p called\n");
4605 return gdbarch->prologue_frameless_p (ip);
4609 set_gdbarch_prologue_frameless_p (struct gdbarch *gdbarch,
4610 gdbarch_prologue_frameless_p_ftype prologue_frameless_p)
4612 gdbarch->prologue_frameless_p = prologue_frameless_p;
4616 gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
4618 gdb_assert (gdbarch != NULL);
4619 if (gdbarch->inner_than == 0)
4620 internal_error (__FILE__, __LINE__,
4621 "gdbarch: gdbarch_inner_than invalid");
4622 if (gdbarch_debug >= 2)
4623 fprintf_unfiltered (gdb_stdlog, "gdbarch_inner_than called\n");
4624 return gdbarch->inner_than (lhs, rhs);
4628 set_gdbarch_inner_than (struct gdbarch *gdbarch,
4629 gdbarch_inner_than_ftype inner_than)
4631 gdbarch->inner_than = inner_than;
4634 const unsigned char *
4635 gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
4637 gdb_assert (gdbarch != NULL);
4638 if (gdbarch->breakpoint_from_pc == 0)
4639 internal_error (__FILE__, __LINE__,
4640 "gdbarch: gdbarch_breakpoint_from_pc invalid");
4641 if (gdbarch_debug >= 2)
4642 fprintf_unfiltered (gdb_stdlog, "gdbarch_breakpoint_from_pc called\n");
4643 return gdbarch->breakpoint_from_pc (pcptr, lenptr);
4647 set_gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch,
4648 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
4650 gdbarch->breakpoint_from_pc = breakpoint_from_pc;
4654 gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
4656 gdb_assert (gdbarch != NULL);
4657 if (gdbarch->memory_insert_breakpoint == 0)
4658 internal_error (__FILE__, __LINE__,
4659 "gdbarch: gdbarch_memory_insert_breakpoint invalid");
4660 if (gdbarch_debug >= 2)
4661 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_insert_breakpoint called\n");
4662 return gdbarch->memory_insert_breakpoint (addr, contents_cache);
4666 set_gdbarch_memory_insert_breakpoint (struct gdbarch *gdbarch,
4667 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint)
4669 gdbarch->memory_insert_breakpoint = memory_insert_breakpoint;
4673 gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch, CORE_ADDR addr, char *contents_cache)
4675 gdb_assert (gdbarch != NULL);
4676 if (gdbarch->memory_remove_breakpoint == 0)
4677 internal_error (__FILE__, __LINE__,
4678 "gdbarch: gdbarch_memory_remove_breakpoint invalid");
4679 if (gdbarch_debug >= 2)
4680 fprintf_unfiltered (gdb_stdlog, "gdbarch_memory_remove_breakpoint called\n");
4681 return gdbarch->memory_remove_breakpoint (addr, contents_cache);
4685 set_gdbarch_memory_remove_breakpoint (struct gdbarch *gdbarch,
4686 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
4688 gdbarch->memory_remove_breakpoint = memory_remove_breakpoint;
4692 gdbarch_decr_pc_after_break (struct gdbarch *gdbarch)
4694 gdb_assert (gdbarch != NULL);
4695 if (gdbarch->decr_pc_after_break == -1)
4696 internal_error (__FILE__, __LINE__,
4697 "gdbarch: gdbarch_decr_pc_after_break invalid");
4698 if (gdbarch_debug >= 2)
4699 fprintf_unfiltered (gdb_stdlog, "gdbarch_decr_pc_after_break called\n");
4700 return gdbarch->decr_pc_after_break;
4704 set_gdbarch_decr_pc_after_break (struct gdbarch *gdbarch,
4705 CORE_ADDR decr_pc_after_break)
4707 gdbarch->decr_pc_after_break = decr_pc_after_break;
4711 gdbarch_prepare_to_proceed (struct gdbarch *gdbarch, int select_it)
4713 gdb_assert (gdbarch != NULL);
4714 if (gdbarch->prepare_to_proceed == 0)
4715 internal_error (__FILE__, __LINE__,
4716 "gdbarch: gdbarch_prepare_to_proceed invalid");
4717 if (gdbarch_debug >= 2)
4718 fprintf_unfiltered (gdb_stdlog, "gdbarch_prepare_to_proceed called\n");
4719 return gdbarch->prepare_to_proceed (select_it);
4723 set_gdbarch_prepare_to_proceed (struct gdbarch *gdbarch,
4724 gdbarch_prepare_to_proceed_ftype prepare_to_proceed)
4726 gdbarch->prepare_to_proceed = prepare_to_proceed;
4730 gdbarch_function_start_offset (struct gdbarch *gdbarch)
4732 gdb_assert (gdbarch != NULL);
4733 if (gdbarch->function_start_offset == -1)
4734 internal_error (__FILE__, __LINE__,
4735 "gdbarch: gdbarch_function_start_offset invalid");
4736 if (gdbarch_debug >= 2)
4737 fprintf_unfiltered (gdb_stdlog, "gdbarch_function_start_offset called\n");
4738 return gdbarch->function_start_offset;
4742 set_gdbarch_function_start_offset (struct gdbarch *gdbarch,
4743 CORE_ADDR function_start_offset)
4745 gdbarch->function_start_offset = function_start_offset;
4749 gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
4751 gdb_assert (gdbarch != NULL);
4752 if (gdbarch->remote_translate_xfer_address == 0)
4753 internal_error (__FILE__, __LINE__,
4754 "gdbarch: gdbarch_remote_translate_xfer_address invalid");
4755 if (gdbarch_debug >= 2)
4756 fprintf_unfiltered (gdb_stdlog, "gdbarch_remote_translate_xfer_address called\n");
4757 gdbarch->remote_translate_xfer_address (gdb_addr, gdb_len, rem_addr, rem_len);
4761 set_gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch,
4762 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address)
4764 gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
4768 gdbarch_frame_args_skip (struct gdbarch *gdbarch)
4770 gdb_assert (gdbarch != NULL);
4771 if (gdbarch->frame_args_skip == -1)
4772 internal_error (__FILE__, __LINE__,
4773 "gdbarch: gdbarch_frame_args_skip invalid");
4774 if (gdbarch_debug >= 2)
4775 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_skip called\n");
4776 return gdbarch->frame_args_skip;
4780 set_gdbarch_frame_args_skip (struct gdbarch *gdbarch,
4781 CORE_ADDR frame_args_skip)
4783 gdbarch->frame_args_skip = frame_args_skip;
4787 gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_info *fi)
4789 gdb_assert (gdbarch != NULL);
4790 if (gdbarch->frameless_function_invocation == 0)
4791 internal_error (__FILE__, __LINE__,
4792 "gdbarch: gdbarch_frameless_function_invocation invalid");
4793 if (gdbarch_debug >= 2)
4794 fprintf_unfiltered (gdb_stdlog, "gdbarch_frameless_function_invocation called\n");
4795 return gdbarch->frameless_function_invocation (fi);
4799 set_gdbarch_frameless_function_invocation (struct gdbarch *gdbarch,
4800 gdbarch_frameless_function_invocation_ftype frameless_function_invocation)
4802 gdbarch->frameless_function_invocation = frameless_function_invocation;
4806 gdbarch_deprecated_frame_chain_p (struct gdbarch *gdbarch)
4808 gdb_assert (gdbarch != NULL);
4809 return gdbarch->deprecated_frame_chain != 0;
4813 gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
4815 gdb_assert (gdbarch != NULL);
4816 if (gdbarch->deprecated_frame_chain == 0)
4817 internal_error (__FILE__, __LINE__,
4818 "gdbarch: gdbarch_deprecated_frame_chain invalid");
4819 if (gdbarch_debug >= 2)
4820 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain called\n");
4821 return gdbarch->deprecated_frame_chain (frame);
4825 set_gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch,
4826 gdbarch_deprecated_frame_chain_ftype deprecated_frame_chain)
4828 gdbarch->deprecated_frame_chain = deprecated_frame_chain;
4832 gdbarch_deprecated_frame_chain_valid_p (struct gdbarch *gdbarch)
4834 gdb_assert (gdbarch != NULL);
4835 return gdbarch->deprecated_frame_chain_valid != 0;
4839 gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
4841 gdb_assert (gdbarch != NULL);
4842 if (gdbarch->deprecated_frame_chain_valid == 0)
4843 internal_error (__FILE__, __LINE__,
4844 "gdbarch: gdbarch_deprecated_frame_chain_valid invalid");
4845 if (gdbarch_debug >= 2)
4846 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain_valid called\n");
4847 return gdbarch->deprecated_frame_chain_valid (chain, thisframe);
4851 set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch,
4852 gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid)
4854 gdbarch->deprecated_frame_chain_valid = deprecated_frame_chain_valid;
4858 gdbarch_deprecated_frame_saved_pc_p (struct gdbarch *gdbarch)
4860 gdb_assert (gdbarch != NULL);
4861 return gdbarch->deprecated_frame_saved_pc != 0;
4865 gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
4867 gdb_assert (gdbarch != NULL);
4868 if (gdbarch->deprecated_frame_saved_pc == 0)
4869 internal_error (__FILE__, __LINE__,
4870 "gdbarch: gdbarch_deprecated_frame_saved_pc invalid");
4871 if (gdbarch_debug >= 2)
4872 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_saved_pc called\n");
4873 return gdbarch->deprecated_frame_saved_pc (fi);
4877 set_gdbarch_deprecated_frame_saved_pc (struct gdbarch *gdbarch,
4878 gdbarch_deprecated_frame_saved_pc_ftype deprecated_frame_saved_pc)
4880 gdbarch->deprecated_frame_saved_pc = deprecated_frame_saved_pc;
4884 gdbarch_unwind_pc_p (struct gdbarch *gdbarch)
4886 gdb_assert (gdbarch != NULL);
4887 return gdbarch->unwind_pc != 0;
4891 gdbarch_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
4893 gdb_assert (gdbarch != NULL);
4894 if (gdbarch->unwind_pc == 0)
4895 internal_error (__FILE__, __LINE__,
4896 "gdbarch: gdbarch_unwind_pc invalid");
4897 if (gdbarch_debug >= 2)
4898 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_pc called\n");
4899 return gdbarch->unwind_pc (gdbarch, next_frame);
4903 set_gdbarch_unwind_pc (struct gdbarch *gdbarch,
4904 gdbarch_unwind_pc_ftype unwind_pc)
4906 gdbarch->unwind_pc = unwind_pc;
4910 gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
4912 gdb_assert (gdbarch != NULL);
4913 if (gdbarch->frame_args_address == 0)
4914 internal_error (__FILE__, __LINE__,
4915 "gdbarch: gdbarch_frame_args_address invalid");
4916 if (gdbarch_debug >= 2)
4917 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_args_address called\n");
4918 return gdbarch->frame_args_address (fi);
4922 set_gdbarch_frame_args_address (struct gdbarch *gdbarch,
4923 gdbarch_frame_args_address_ftype frame_args_address)
4925 gdbarch->frame_args_address = frame_args_address;
4929 gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
4931 gdb_assert (gdbarch != NULL);
4932 if (gdbarch->frame_locals_address == 0)
4933 internal_error (__FILE__, __LINE__,
4934 "gdbarch: gdbarch_frame_locals_address invalid");
4935 if (gdbarch_debug >= 2)
4936 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_locals_address called\n");
4937 return gdbarch->frame_locals_address (fi);
4941 set_gdbarch_frame_locals_address (struct gdbarch *gdbarch,
4942 gdbarch_frame_locals_address_ftype frame_locals_address)
4944 gdbarch->frame_locals_address = frame_locals_address;
4948 gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
4950 gdb_assert (gdbarch != NULL);
4951 if (gdbarch->saved_pc_after_call == 0)
4952 internal_error (__FILE__, __LINE__,
4953 "gdbarch: gdbarch_saved_pc_after_call invalid");
4954 if (gdbarch_debug >= 2)
4955 fprintf_unfiltered (gdb_stdlog, "gdbarch_saved_pc_after_call called\n");
4956 return gdbarch->saved_pc_after_call (frame);
4960 set_gdbarch_saved_pc_after_call (struct gdbarch *gdbarch,
4961 gdbarch_saved_pc_after_call_ftype saved_pc_after_call)
4963 gdbarch->saved_pc_after_call = saved_pc_after_call;
4967 gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
4969 gdb_assert (gdbarch != NULL);
4970 if (gdbarch->frame_num_args == 0)
4971 internal_error (__FILE__, __LINE__,
4972 "gdbarch: gdbarch_frame_num_args invalid");
4973 if (gdbarch_debug >= 2)
4974 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_num_args called\n");
4975 return gdbarch->frame_num_args (frame);
4979 set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
4980 gdbarch_frame_num_args_ftype frame_num_args)
4982 gdbarch->frame_num_args = frame_num_args;
4986 gdbarch_stack_align_p (struct gdbarch *gdbarch)
4988 gdb_assert (gdbarch != NULL);
4989 return gdbarch->stack_align != 0;
4993 gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
4995 gdb_assert (gdbarch != NULL);
4996 if (gdbarch->stack_align == 0)
4997 internal_error (__FILE__, __LINE__,
4998 "gdbarch: gdbarch_stack_align invalid");
4999 if (gdbarch_debug >= 2)
5000 fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_align called\n");
5001 return gdbarch->stack_align (sp);
5005 set_gdbarch_stack_align (struct gdbarch *gdbarch,
5006 gdbarch_stack_align_ftype stack_align)
5008 gdbarch->stack_align = stack_align;
5012 gdbarch_frame_align_p (struct gdbarch *gdbarch)
5014 gdb_assert (gdbarch != NULL);
5015 return gdbarch->frame_align != 0;
5019 gdbarch_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
5021 gdb_assert (gdbarch != NULL);
5022 if (gdbarch->frame_align == 0)
5023 internal_error (__FILE__, __LINE__,
5024 "gdbarch: gdbarch_frame_align invalid");
5025 if (gdbarch_debug >= 2)
5026 fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_align called\n");
5027 return gdbarch->frame_align (gdbarch, address);
5031 set_gdbarch_frame_align (struct gdbarch *gdbarch,
5032 gdbarch_frame_align_ftype frame_align)
5034 gdbarch->frame_align = frame_align;
5038 gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch)
5040 gdb_assert (gdbarch != NULL);
5041 /* Skip verify of deprecated_extra_stack_alignment_needed, invalid_p == 0 */
5042 if (gdbarch_debug >= 2)
5043 fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_extra_stack_alignment_needed called\n");
5044 return gdbarch->deprecated_extra_stack_alignment_needed;
5048 set_gdbarch_deprecated_extra_stack_alignment_needed (struct gdbarch *gdbarch,
5049 int deprecated_extra_stack_alignment_needed)
5051 gdbarch->deprecated_extra_stack_alignment_needed = deprecated_extra_stack_alignment_needed;
5055 gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
5057 gdb_assert (gdbarch != NULL);
5058 return gdbarch->reg_struct_has_addr != 0;
5062 gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
5064 gdb_assert (gdbarch != NULL);
5065 if (gdbarch->reg_struct_has_addr == 0)
5066 internal_error (__FILE__, __LINE__,
5067 "gdbarch: gdbarch_reg_struct_has_addr invalid");
5068 if (gdbarch_debug >= 2)
5069 fprintf_unfiltered (gdb_stdlog, "gdbarch_reg_struct_has_addr called\n");
5070 return gdbarch->reg_struct_has_addr (gcc_p, type);
5074 set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
5075 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr)
5077 gdbarch->reg_struct_has_addr = reg_struct_has_addr;
5081 gdbarch_save_dummy_frame_tos_p (struct gdbarch *gdbarch)
5083 gdb_assert (gdbarch != NULL);
5084 return gdbarch->save_dummy_frame_tos != 0;
5088 gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch, CORE_ADDR sp)
5090 gdb_assert (gdbarch != NULL);
5091 if (gdbarch->save_dummy_frame_tos == 0)
5092 internal_error (__FILE__, __LINE__,
5093 "gdbarch: gdbarch_save_dummy_frame_tos invalid");
5094 if (gdbarch_debug >= 2)
5095 fprintf_unfiltered (gdb_stdlog, "gdbarch_save_dummy_frame_tos called\n");
5096 gdbarch->save_dummy_frame_tos (sp);
5100 set_gdbarch_save_dummy_frame_tos (struct gdbarch *gdbarch,
5101 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos)
5103 gdbarch->save_dummy_frame_tos = save_dummy_frame_tos;
5107 gdbarch_unwind_dummy_id_p (struct gdbarch *gdbarch)
5109 gdb_assert (gdbarch != NULL);
5110 return gdbarch->unwind_dummy_id != 0;
5114 gdbarch_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *info)
5116 gdb_assert (gdbarch != NULL);
5117 if (gdbarch->unwind_dummy_id == 0)
5118 internal_error (__FILE__, __LINE__,
5119 "gdbarch: gdbarch_unwind_dummy_id invalid");
5120 if (gdbarch_debug >= 2)
5121 fprintf_unfiltered (gdb_stdlog, "gdbarch_unwind_dummy_id called\n");
5122 return gdbarch->unwind_dummy_id (gdbarch, info);
5126 set_gdbarch_unwind_dummy_id (struct gdbarch *gdbarch,
5127 gdbarch_unwind_dummy_id_ftype unwind_dummy_id)
5129 gdbarch->unwind_dummy_id = unwind_dummy_id;
5133 gdbarch_parm_boundary (struct gdbarch *gdbarch)
5135 gdb_assert (gdbarch != NULL);
5136 if (gdbarch_debug >= 2)
5137 fprintf_unfiltered (gdb_stdlog, "gdbarch_parm_boundary called\n");
5138 return gdbarch->parm_boundary;
5142 set_gdbarch_parm_boundary (struct gdbarch *gdbarch,
5145 gdbarch->parm_boundary = parm_boundary;
5148 const struct floatformat *
5149 gdbarch_float_format (struct gdbarch *gdbarch)
5151 gdb_assert (gdbarch != NULL);
5152 if (gdbarch_debug >= 2)
5153 fprintf_unfiltered (gdb_stdlog, "gdbarch_float_format called\n");
5154 return gdbarch->float_format;
5158 set_gdbarch_float_format (struct gdbarch *gdbarch,
5159 const struct floatformat * float_format)
5161 gdbarch->float_format = float_format;
5164 const struct floatformat *
5165 gdbarch_double_format (struct gdbarch *gdbarch)
5167 gdb_assert (gdbarch != NULL);
5168 if (gdbarch_debug >= 2)
5169 fprintf_unfiltered (gdb_stdlog, "gdbarch_double_format called\n");
5170 return gdbarch->double_format;
5174 set_gdbarch_double_format (struct gdbarch *gdbarch,
5175 const struct floatformat * double_format)
5177 gdbarch->double_format = double_format;
5180 const struct floatformat *
5181 gdbarch_long_double_format (struct gdbarch *gdbarch)
5183 gdb_assert (gdbarch != NULL);
5184 if (gdbarch_debug >= 2)
5185 fprintf_unfiltered (gdb_stdlog, "gdbarch_long_double_format called\n");
5186 return gdbarch->long_double_format;
5190 set_gdbarch_long_double_format (struct gdbarch *gdbarch,
5191 const struct floatformat * long_double_format)
5193 gdbarch->long_double_format = long_double_format;
5197 gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
5199 gdb_assert (gdbarch != NULL);
5200 if (gdbarch->convert_from_func_ptr_addr == 0)
5201 internal_error (__FILE__, __LINE__,
5202 "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
5203 if (gdbarch_debug >= 2)
5204 fprintf_unfiltered (gdb_stdlog, "gdbarch_convert_from_func_ptr_addr called\n");
5205 return gdbarch->convert_from_func_ptr_addr (addr);
5209 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
5210 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
5212 gdbarch->convert_from_func_ptr_addr = convert_from_func_ptr_addr;
5216 gdbarch_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
5218 gdb_assert (gdbarch != NULL);
5219 if (gdbarch->addr_bits_remove == 0)
5220 internal_error (__FILE__, __LINE__,
5221 "gdbarch: gdbarch_addr_bits_remove invalid");
5222 if (gdbarch_debug >= 2)
5223 fprintf_unfiltered (gdb_stdlog, "gdbarch_addr_bits_remove called\n");
5224 return gdbarch->addr_bits_remove (addr);
5228 set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch,
5229 gdbarch_addr_bits_remove_ftype addr_bits_remove)
5231 gdbarch->addr_bits_remove = addr_bits_remove;
5235 gdbarch_smash_text_address (struct gdbarch *gdbarch, CORE_ADDR addr)
5237 gdb_assert (gdbarch != NULL);
5238 if (gdbarch->smash_text_address == 0)
5239 internal_error (__FILE__, __LINE__,
5240 "gdbarch: gdbarch_smash_text_address invalid");
5241 if (gdbarch_debug >= 2)
5242 fprintf_unfiltered (gdb_stdlog, "gdbarch_smash_text_address called\n");
5243 return gdbarch->smash_text_address (addr);
5247 set_gdbarch_smash_text_address (struct gdbarch *gdbarch,
5248 gdbarch_smash_text_address_ftype smash_text_address)
5250 gdbarch->smash_text_address = smash_text_address;
5254 gdbarch_software_single_step_p (struct gdbarch *gdbarch)
5256 gdb_assert (gdbarch != NULL);
5257 return gdbarch->software_single_step != 0;
5261 gdbarch_software_single_step (struct gdbarch *gdbarch, enum target_signal sig, int insert_breakpoints_p)
5263 gdb_assert (gdbarch != NULL);
5264 if (gdbarch->software_single_step == 0)
5265 internal_error (__FILE__, __LINE__,
5266 "gdbarch: gdbarch_software_single_step invalid");
5267 if (gdbarch_debug >= 2)
5268 fprintf_unfiltered (gdb_stdlog, "gdbarch_software_single_step called\n");
5269 gdbarch->software_single_step (sig, insert_breakpoints_p);
5273 set_gdbarch_software_single_step (struct gdbarch *gdbarch,
5274 gdbarch_software_single_step_ftype software_single_step)
5276 gdbarch->software_single_step = software_single_step;
5280 gdbarch_print_insn (struct gdbarch *gdbarch, bfd_vma vma, disassemble_info *info)
5282 gdb_assert (gdbarch != NULL);
5283 if (gdbarch->print_insn == 0)
5284 internal_error (__FILE__, __LINE__,
5285 "gdbarch: gdbarch_print_insn invalid");
5286 if (gdbarch_debug >= 2)
5287 fprintf_unfiltered (gdb_stdlog, "gdbarch_print_insn called\n");
5288 return gdbarch->print_insn (vma, info);
5292 set_gdbarch_print_insn (struct gdbarch *gdbarch,
5293 gdbarch_print_insn_ftype print_insn)
5295 gdbarch->print_insn = print_insn;
5299 gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc)
5301 gdb_assert (gdbarch != NULL);
5302 if (gdbarch->skip_trampoline_code == 0)
5303 internal_error (__FILE__, __LINE__,
5304 "gdbarch: gdbarch_skip_trampoline_code invalid");
5305 if (gdbarch_debug >= 2)
5306 fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n");
5307 return gdbarch->skip_trampoline_code (pc);
5311 set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch,
5312 gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
5314 gdbarch->skip_trampoline_code = skip_trampoline_code;
5318 gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5320 gdb_assert (gdbarch != NULL);
5321 if (gdbarch->in_solib_call_trampoline == 0)
5322 internal_error (__FILE__, __LINE__,
5323 "gdbarch: gdbarch_in_solib_call_trampoline invalid");
5324 if (gdbarch_debug >= 2)
5325 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_call_trampoline called\n");
5326 return gdbarch->in_solib_call_trampoline (pc, name);
5330 set_gdbarch_in_solib_call_trampoline (struct gdbarch *gdbarch,
5331 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline)
5333 gdbarch->in_solib_call_trampoline = in_solib_call_trampoline;
5337 gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5339 gdb_assert (gdbarch != NULL);
5340 if (gdbarch->in_solib_return_trampoline == 0)
5341 internal_error (__FILE__, __LINE__,
5342 "gdbarch: gdbarch_in_solib_return_trampoline invalid");
5343 if (gdbarch_debug >= 2)
5344 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_solib_return_trampoline called\n");
5345 return gdbarch->in_solib_return_trampoline (pc, name);
5349 set_gdbarch_in_solib_return_trampoline (struct gdbarch *gdbarch,
5350 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
5352 gdbarch->in_solib_return_trampoline = in_solib_return_trampoline;
5356 gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, char *name)
5358 gdb_assert (gdbarch != NULL);
5359 if (gdbarch->pc_in_sigtramp == 0)
5360 internal_error (__FILE__, __LINE__,
5361 "gdbarch: gdbarch_pc_in_sigtramp invalid");
5362 if (gdbarch_debug >= 2)
5363 fprintf_unfiltered (gdb_stdlog, "gdbarch_pc_in_sigtramp called\n");
5364 return gdbarch->pc_in_sigtramp (pc, name);
5368 set_gdbarch_pc_in_sigtramp (struct gdbarch *gdbarch,
5369 gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp)
5371 gdbarch->pc_in_sigtramp = pc_in_sigtramp;
5375 gdbarch_sigtramp_start_p (struct gdbarch *gdbarch)
5377 gdb_assert (gdbarch != NULL);
5378 return gdbarch->sigtramp_start != 0;
5382 gdbarch_sigtramp_start (struct gdbarch *gdbarch, CORE_ADDR pc)
5384 gdb_assert (gdbarch != NULL);
5385 if (gdbarch->sigtramp_start == 0)
5386 internal_error (__FILE__, __LINE__,
5387 "gdbarch: gdbarch_sigtramp_start invalid");
5388 if (gdbarch_debug >= 2)
5389 fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_start called\n");
5390 return gdbarch->sigtramp_start (pc);
5394 set_gdbarch_sigtramp_start (struct gdbarch *gdbarch,
5395 gdbarch_sigtramp_start_ftype sigtramp_start)
5397 gdbarch->sigtramp_start = sigtramp_start;
5401 gdbarch_sigtramp_end_p (struct gdbarch *gdbarch)
5403 gdb_assert (gdbarch != NULL);
5404 return gdbarch->sigtramp_end != 0;
5408 gdbarch_sigtramp_end (struct gdbarch *gdbarch, CORE_ADDR pc)
5410 gdb_assert (gdbarch != NULL);
5411 if (gdbarch->sigtramp_end == 0)
5412 internal_error (__FILE__, __LINE__,
5413 "gdbarch: gdbarch_sigtramp_end invalid");
5414 if (gdbarch_debug >= 2)
5415 fprintf_unfiltered (gdb_stdlog, "gdbarch_sigtramp_end called\n");
5416 return gdbarch->sigtramp_end (pc);
5420 set_gdbarch_sigtramp_end (struct gdbarch *gdbarch,
5421 gdbarch_sigtramp_end_ftype sigtramp_end)
5423 gdbarch->sigtramp_end = sigtramp_end;
5427 gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR addr)
5429 gdb_assert (gdbarch != NULL);
5430 if (gdbarch->in_function_epilogue_p == 0)
5431 internal_error (__FILE__, __LINE__,
5432 "gdbarch: gdbarch_in_function_epilogue_p invalid");
5433 if (gdbarch_debug >= 2)
5434 fprintf_unfiltered (gdb_stdlog, "gdbarch_in_function_epilogue_p called\n");
5435 return gdbarch->in_function_epilogue_p (gdbarch, addr);
5439 set_gdbarch_in_function_epilogue_p (struct gdbarch *gdbarch,
5440 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p)
5442 gdbarch->in_function_epilogue_p = in_function_epilogue_p;
5446 gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
5448 gdb_assert (gdbarch != NULL);
5449 if (gdbarch->construct_inferior_arguments == 0)
5450 internal_error (__FILE__, __LINE__,
5451 "gdbarch: gdbarch_construct_inferior_arguments invalid");
5452 if (gdbarch_debug >= 2)
5453 fprintf_unfiltered (gdb_stdlog, "gdbarch_construct_inferior_arguments called\n");
5454 return gdbarch->construct_inferior_arguments (gdbarch, argc, argv);
5458 set_gdbarch_construct_inferior_arguments (struct gdbarch *gdbarch,
5459 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments)
5461 gdbarch->construct_inferior_arguments = construct_inferior_arguments;
5465 gdbarch_dwarf2_build_frame_info_p (struct gdbarch *gdbarch)
5467 gdb_assert (gdbarch != NULL);
5468 return gdbarch->dwarf2_build_frame_info != 0;
5472 gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch, struct objfile *objfile)
5474 gdb_assert (gdbarch != NULL);
5475 if (gdbarch->dwarf2_build_frame_info == 0)
5476 internal_error (__FILE__, __LINE__,
5477 "gdbarch: gdbarch_dwarf2_build_frame_info invalid");
5478 if (gdbarch_debug >= 2)
5479 fprintf_unfiltered (gdb_stdlog, "gdbarch_dwarf2_build_frame_info called\n");
5480 gdbarch->dwarf2_build_frame_info (objfile);
5484 set_gdbarch_dwarf2_build_frame_info (struct gdbarch *gdbarch,
5485 gdbarch_dwarf2_build_frame_info_ftype dwarf2_build_frame_info)
5487 gdbarch->dwarf2_build_frame_info = dwarf2_build_frame_info;
5491 gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
5493 gdb_assert (gdbarch != NULL);
5494 if (gdbarch->elf_make_msymbol_special == 0)
5495 internal_error (__FILE__, __LINE__,
5496 "gdbarch: gdbarch_elf_make_msymbol_special invalid");
5497 if (gdbarch_debug >= 2)
5498 fprintf_unfiltered (gdb_stdlog, "gdbarch_elf_make_msymbol_special called\n");
5499 gdbarch->elf_make_msymbol_special (sym, msym);
5503 set_gdbarch_elf_make_msymbol_special (struct gdbarch *gdbarch,
5504 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special)
5506 gdbarch->elf_make_msymbol_special = elf_make_msymbol_special;
5510 gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
5512 gdb_assert (gdbarch != NULL);
5513 if (gdbarch->coff_make_msymbol_special == 0)
5514 internal_error (__FILE__, __LINE__,
5515 "gdbarch: gdbarch_coff_make_msymbol_special invalid");
5516 if (gdbarch_debug >= 2)
5517 fprintf_unfiltered (gdb_stdlog, "gdbarch_coff_make_msymbol_special called\n");
5518 gdbarch->coff_make_msymbol_special (val, msym);
5522 set_gdbarch_coff_make_msymbol_special (struct gdbarch *gdbarch,
5523 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special)
5525 gdbarch->coff_make_msymbol_special = coff_make_msymbol_special;
5529 gdbarch_name_of_malloc (struct gdbarch *gdbarch)
5531 gdb_assert (gdbarch != NULL);
5532 /* Skip verify of name_of_malloc, invalid_p == 0 */
5533 if (gdbarch_debug >= 2)
5534 fprintf_unfiltered (gdb_stdlog, "gdbarch_name_of_malloc called\n");
5535 return gdbarch->name_of_malloc;
5539 set_gdbarch_name_of_malloc (struct gdbarch *gdbarch,
5540 const char * name_of_malloc)
5542 gdbarch->name_of_malloc = name_of_malloc;
5546 gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch)
5548 gdb_assert (gdbarch != NULL);
5549 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
5550 if (gdbarch_debug >= 2)
5551 fprintf_unfiltered (gdb_stdlog, "gdbarch_cannot_step_breakpoint called\n");
5552 return gdbarch->cannot_step_breakpoint;
5556 set_gdbarch_cannot_step_breakpoint (struct gdbarch *gdbarch,
5557 int cannot_step_breakpoint)
5559 gdbarch->cannot_step_breakpoint = cannot_step_breakpoint;
5563 gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch)
5565 gdb_assert (gdbarch != NULL);
5566 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
5567 if (gdbarch_debug >= 2)
5568 fprintf_unfiltered (gdb_stdlog, "gdbarch_have_nonsteppable_watchpoint called\n");
5569 return gdbarch->have_nonsteppable_watchpoint;
5573 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch *gdbarch,
5574 int have_nonsteppable_watchpoint)
5576 gdbarch->have_nonsteppable_watchpoint = have_nonsteppable_watchpoint;
5580 gdbarch_address_class_type_flags_p (struct gdbarch *gdbarch)
5582 gdb_assert (gdbarch != NULL);
5583 return gdbarch->address_class_type_flags != 0;
5587 gdbarch_address_class_type_flags (struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
5589 gdb_assert (gdbarch != NULL);
5590 if (gdbarch->address_class_type_flags == 0)
5591 internal_error (__FILE__, __LINE__,
5592 "gdbarch: gdbarch_address_class_type_flags invalid");
5593 if (gdbarch_debug >= 2)
5594 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags called\n");
5595 return gdbarch->address_class_type_flags (byte_size, dwarf2_addr_class);
5599 set_gdbarch_address_class_type_flags (struct gdbarch *gdbarch,
5600 gdbarch_address_class_type_flags_ftype address_class_type_flags)
5602 gdbarch->address_class_type_flags = address_class_type_flags;
5606 gdbarch_address_class_type_flags_to_name_p (struct gdbarch *gdbarch)
5608 gdb_assert (gdbarch != NULL);
5609 return gdbarch->address_class_type_flags_to_name != 0;
5613 gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
5615 gdb_assert (gdbarch != NULL);
5616 if (gdbarch->address_class_type_flags_to_name == 0)
5617 internal_error (__FILE__, __LINE__,
5618 "gdbarch: gdbarch_address_class_type_flags_to_name invalid");
5619 if (gdbarch_debug >= 2)
5620 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_type_flags_to_name called\n");
5621 return gdbarch->address_class_type_flags_to_name (gdbarch, type_flags);
5625 set_gdbarch_address_class_type_flags_to_name (struct gdbarch *gdbarch,
5626 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
5628 gdbarch->address_class_type_flags_to_name = address_class_type_flags_to_name;
5632 gdbarch_address_class_name_to_type_flags_p (struct gdbarch *gdbarch)
5634 gdb_assert (gdbarch != NULL);
5635 return gdbarch->address_class_name_to_type_flags != 0;
5639 gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
5641 gdb_assert (gdbarch != NULL);
5642 if (gdbarch->address_class_name_to_type_flags == 0)
5643 internal_error (__FILE__, __LINE__,
5644 "gdbarch: gdbarch_address_class_name_to_type_flags invalid");
5645 if (gdbarch_debug >= 2)
5646 fprintf_unfiltered (gdb_stdlog, "gdbarch_address_class_name_to_type_flags called\n");
5647 return gdbarch->address_class_name_to_type_flags (gdbarch, name, type_flags_ptr);
5651 set_gdbarch_address_class_name_to_type_flags (struct gdbarch *gdbarch,
5652 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
5654 gdbarch->address_class_name_to_type_flags = address_class_name_to_type_flags;
5658 gdbarch_register_reggroup_p (struct gdbarch *gdbarch, int regnum, struct reggroup *reggroup)
5660 gdb_assert (gdbarch != NULL);
5661 if (gdbarch->register_reggroup_p == 0)
5662 internal_error (__FILE__, __LINE__,
5663 "gdbarch: gdbarch_register_reggroup_p invalid");
5664 if (gdbarch_debug >= 2)
5665 fprintf_unfiltered (gdb_stdlog, "gdbarch_register_reggroup_p called\n");
5666 return gdbarch->register_reggroup_p (gdbarch, regnum, reggroup);
5670 set_gdbarch_register_reggroup_p (struct gdbarch *gdbarch,
5671 gdbarch_register_reggroup_p_ftype register_reggroup_p)
5673 gdbarch->register_reggroup_p = register_reggroup_p;
5677 /* Keep a registry of per-architecture data-pointers required by GDB
5684 gdbarch_data_init_ftype *init;
5685 gdbarch_data_free_ftype *free;
5688 struct gdbarch_data_registration
5690 struct gdbarch_data *data;
5691 struct gdbarch_data_registration *next;
5694 struct gdbarch_data_registry
5697 struct gdbarch_data_registration *registrations;
5700 struct gdbarch_data_registry gdbarch_data_registry =
5705 struct gdbarch_data *
5706 register_gdbarch_data (gdbarch_data_init_ftype *init,
5707 gdbarch_data_free_ftype *free)
5709 struct gdbarch_data_registration **curr;
5710 /* Append the new registraration. */
5711 for (curr = &gdbarch_data_registry.registrations;
5713 curr = &(*curr)->next);
5714 (*curr) = XMALLOC (struct gdbarch_data_registration);
5715 (*curr)->next = NULL;
5716 (*curr)->data = XMALLOC (struct gdbarch_data);
5717 (*curr)->data->index = gdbarch_data_registry.nr++;
5718 (*curr)->data->init = init;
5719 (*curr)->data->init_p = 1;
5720 (*curr)->data->free = free;
5721 return (*curr)->data;
5725 /* Create/delete the gdbarch data vector. */
5728 alloc_gdbarch_data (struct gdbarch *gdbarch)
5730 gdb_assert (gdbarch->data == NULL);
5731 gdbarch->nr_data = gdbarch_data_registry.nr;
5732 gdbarch->data = xcalloc (gdbarch->nr_data, sizeof (void*));
5736 free_gdbarch_data (struct gdbarch *gdbarch)
5738 struct gdbarch_data_registration *rego;
5739 gdb_assert (gdbarch->data != NULL);
5740 for (rego = gdbarch_data_registry.registrations;
5744 struct gdbarch_data *data = rego->data;
5745 gdb_assert (data->index < gdbarch->nr_data);
5746 if (data->free != NULL && gdbarch->data[data->index] != NULL)
5748 data->free (gdbarch, gdbarch->data[data->index]);
5749 gdbarch->data[data->index] = NULL;
5752 xfree (gdbarch->data);
5753 gdbarch->data = NULL;
5757 /* Initialize the current value of the specified per-architecture
5761 set_gdbarch_data (struct gdbarch *gdbarch,
5762 struct gdbarch_data *data,
5765 gdb_assert (data->index < gdbarch->nr_data);
5766 if (gdbarch->data[data->index] != NULL)
5768 gdb_assert (data->free != NULL);
5769 data->free (gdbarch, gdbarch->data[data->index]);
5771 gdbarch->data[data->index] = pointer;
5774 /* Return the current value of the specified per-architecture
5778 gdbarch_data (struct gdbarch *gdbarch, struct gdbarch_data *data)
5780 gdb_assert (data->index < gdbarch->nr_data);
5781 /* The data-pointer isn't initialized, call init() to get a value but
5782 only if the architecture initializaiton has completed. Otherwise
5783 punt - hope that the caller knows what they are doing. */
5784 if (gdbarch->data[data->index] == NULL
5785 && gdbarch->initialized_p)
5787 /* Be careful to detect an initialization cycle. */
5788 gdb_assert (data->init_p);
5790 gdb_assert (data->init != NULL);
5791 gdbarch->data[data->index] = data->init (gdbarch);
5793 gdb_assert (gdbarch->data[data->index] != NULL);
5795 return gdbarch->data[data->index];
5800 /* Keep a registry of swapped data required by GDB modules. */
5805 struct gdbarch_swap_registration *source;
5806 struct gdbarch_swap *next;
5809 struct gdbarch_swap_registration
5812 unsigned long sizeof_data;
5813 gdbarch_swap_ftype *init;
5814 struct gdbarch_swap_registration *next;
5817 struct gdbarch_swap_registry
5820 struct gdbarch_swap_registration *registrations;
5823 struct gdbarch_swap_registry gdbarch_swap_registry =
5829 register_gdbarch_swap (void *data,
5830 unsigned long sizeof_data,
5831 gdbarch_swap_ftype *init)
5833 struct gdbarch_swap_registration **rego;
5834 for (rego = &gdbarch_swap_registry.registrations;
5836 rego = &(*rego)->next);
5837 (*rego) = XMALLOC (struct gdbarch_swap_registration);
5838 (*rego)->next = NULL;
5839 (*rego)->init = init;
5840 (*rego)->data = data;
5841 (*rego)->sizeof_data = sizeof_data;
5845 clear_gdbarch_swap (struct gdbarch *gdbarch)
5847 struct gdbarch_swap *curr;
5848 for (curr = gdbarch->swap;
5852 memset (curr->source->data, 0, curr->source->sizeof_data);
5857 init_gdbarch_swap (struct gdbarch *gdbarch)
5859 struct gdbarch_swap_registration *rego;
5860 struct gdbarch_swap **curr = &gdbarch->swap;
5861 for (rego = gdbarch_swap_registry.registrations;
5865 if (rego->data != NULL)
5867 (*curr) = XMALLOC (struct gdbarch_swap);
5868 (*curr)->source = rego;
5869 (*curr)->swap = xmalloc (rego->sizeof_data);
5870 (*curr)->next = NULL;
5871 curr = &(*curr)->next;
5873 if (rego->init != NULL)
5879 swapout_gdbarch_swap (struct gdbarch *gdbarch)
5881 struct gdbarch_swap *curr;
5882 for (curr = gdbarch->swap;
5885 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
5889 swapin_gdbarch_swap (struct gdbarch *gdbarch)
5891 struct gdbarch_swap *curr;
5892 for (curr = gdbarch->swap;
5895 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
5899 /* Keep a registry of the architectures known by GDB. */
5901 struct gdbarch_registration
5903 enum bfd_architecture bfd_architecture;
5904 gdbarch_init_ftype *init;
5905 gdbarch_dump_tdep_ftype *dump_tdep;
5906 struct gdbarch_list *arches;
5907 struct gdbarch_registration *next;
5910 static struct gdbarch_registration *gdbarch_registry = NULL;
5913 append_name (const char ***buf, int *nr, const char *name)
5915 *buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
5921 gdbarch_printable_names (void)
5925 /* Accumulate a list of names based on the registed list of
5927 enum bfd_architecture a;
5929 const char **arches = NULL;
5930 struct gdbarch_registration *rego;
5931 for (rego = gdbarch_registry;
5935 const struct bfd_arch_info *ap;
5936 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
5938 internal_error (__FILE__, __LINE__,
5939 "gdbarch_architecture_names: multi-arch unknown");
5942 append_name (&arches, &nr_arches, ap->printable_name);
5947 append_name (&arches, &nr_arches, NULL);
5951 /* Just return all the architectures that BFD knows. Assume that
5952 the legacy architecture framework supports them. */
5953 return bfd_arch_list ();
5958 gdbarch_register (enum bfd_architecture bfd_architecture,
5959 gdbarch_init_ftype *init,
5960 gdbarch_dump_tdep_ftype *dump_tdep)
5962 struct gdbarch_registration **curr;
5963 const struct bfd_arch_info *bfd_arch_info;
5964 /* Check that BFD recognizes this architecture */
5965 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
5966 if (bfd_arch_info == NULL)
5968 internal_error (__FILE__, __LINE__,
5969 "gdbarch: Attempt to register unknown architecture (%d)",
5972 /* Check that we haven't seen this architecture before */
5973 for (curr = &gdbarch_registry;
5975 curr = &(*curr)->next)
5977 if (bfd_architecture == (*curr)->bfd_architecture)
5978 internal_error (__FILE__, __LINE__,
5979 "gdbarch: Duplicate registraration of architecture (%s)",
5980 bfd_arch_info->printable_name);
5984 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
5985 bfd_arch_info->printable_name,
5988 (*curr) = XMALLOC (struct gdbarch_registration);
5989 (*curr)->bfd_architecture = bfd_architecture;
5990 (*curr)->init = init;
5991 (*curr)->dump_tdep = dump_tdep;
5992 (*curr)->arches = NULL;
5993 (*curr)->next = NULL;
5994 /* When non- multi-arch, install whatever target dump routine we've
5995 been provided - hopefully that routine has been written correctly
5996 and works regardless of multi-arch. */
5997 if (!GDB_MULTI_ARCH && dump_tdep != NULL
5998 && startup_gdbarch.dump_tdep == NULL)
5999 startup_gdbarch.dump_tdep = dump_tdep;
6003 register_gdbarch_init (enum bfd_architecture bfd_architecture,
6004 gdbarch_init_ftype *init)
6006 gdbarch_register (bfd_architecture, init, NULL);
6010 /* Look for an architecture using gdbarch_info. Base search on only
6011 BFD_ARCH_INFO and BYTE_ORDER. */
6013 struct gdbarch_list *
6014 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
6015 const struct gdbarch_info *info)
6017 for (; arches != NULL; arches = arches->next)
6019 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
6021 if (info->byte_order != arches->gdbarch->byte_order)
6023 if (info->osabi != arches->gdbarch->osabi)
6031 /* Update the current architecture. Return ZERO if the update request
6035 gdbarch_update_p (struct gdbarch_info info)
6037 struct gdbarch *new_gdbarch;
6038 struct gdbarch *old_gdbarch;
6039 struct gdbarch_registration *rego;
6041 /* Fill in missing parts of the INFO struct using a number of
6042 sources: ``set ...''; INFOabfd supplied; existing target. */
6044 /* ``(gdb) set architecture ...'' */
6045 if (info.bfd_arch_info == NULL
6046 && !TARGET_ARCHITECTURE_AUTO)
6047 info.bfd_arch_info = TARGET_ARCHITECTURE;
6048 if (info.bfd_arch_info == NULL
6049 && info.abfd != NULL
6050 && bfd_get_arch (info.abfd) != bfd_arch_unknown
6051 && bfd_get_arch (info.abfd) != bfd_arch_obscure)
6052 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
6053 if (info.bfd_arch_info == NULL)
6054 info.bfd_arch_info = TARGET_ARCHITECTURE;
6056 /* ``(gdb) set byte-order ...'' */
6057 if (info.byte_order == BFD_ENDIAN_UNKNOWN
6058 && !TARGET_BYTE_ORDER_AUTO)
6059 info.byte_order = TARGET_BYTE_ORDER;
6060 /* From the INFO struct. */
6061 if (info.byte_order == BFD_ENDIAN_UNKNOWN
6062 && info.abfd != NULL)
6063 info.byte_order = (bfd_big_endian (info.abfd) ? BFD_ENDIAN_BIG
6064 : bfd_little_endian (info.abfd) ? BFD_ENDIAN_LITTLE
6065 : BFD_ENDIAN_UNKNOWN);
6066 /* From the current target. */
6067 if (info.byte_order == BFD_ENDIAN_UNKNOWN)
6068 info.byte_order = TARGET_BYTE_ORDER;
6070 /* ``(gdb) set osabi ...'' is handled by gdbarch_lookup_osabi. */
6071 if (info.osabi == GDB_OSABI_UNINITIALIZED)
6072 info.osabi = gdbarch_lookup_osabi (info.abfd);
6073 if (info.osabi == GDB_OSABI_UNINITIALIZED)
6074 info.osabi = current_gdbarch->osabi;
6076 /* Must have found some sort of architecture. */
6077 gdb_assert (info.bfd_arch_info != NULL);
6081 fprintf_unfiltered (gdb_stdlog,
6082 "gdbarch_update: info.bfd_arch_info %s\n",
6083 (info.bfd_arch_info != NULL
6084 ? info.bfd_arch_info->printable_name
6086 fprintf_unfiltered (gdb_stdlog,
6087 "gdbarch_update: info.byte_order %d (%s)\n",
6089 (info.byte_order == BFD_ENDIAN_BIG ? "big"
6090 : info.byte_order == BFD_ENDIAN_LITTLE ? "little"
6092 fprintf_unfiltered (gdb_stdlog,
6093 "gdbarch_update: info.osabi %d (%s)\n",
6094 info.osabi, gdbarch_osabi_name (info.osabi));
6095 fprintf_unfiltered (gdb_stdlog,
6096 "gdbarch_update: info.abfd 0x%lx\n",
6098 fprintf_unfiltered (gdb_stdlog,
6099 "gdbarch_update: info.tdep_info 0x%lx\n",
6100 (long) info.tdep_info);
6103 /* Find the target that knows about this architecture. */
6104 for (rego = gdbarch_registry;
6107 if (rego->bfd_architecture == info.bfd_arch_info->arch)
6112 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
6116 /* Swap the data belonging to the old target out setting the
6117 installed data to zero. This stops the ->init() function trying
6118 to refer to the previous architecture's global data structures. */
6119 swapout_gdbarch_swap (current_gdbarch);
6120 clear_gdbarch_swap (current_gdbarch);
6122 /* Save the previously selected architecture, setting the global to
6123 NULL. This stops ->init() trying to use the previous
6124 architecture's configuration. The previous architecture may not
6125 even be of the same architecture family. The most recent
6126 architecture of the same family is found at the head of the
6127 rego->arches list. */
6128 old_gdbarch = current_gdbarch;
6129 current_gdbarch = NULL;
6131 /* Ask the target for a replacement architecture. */
6132 new_gdbarch = rego->init (info, rego->arches);
6134 /* Did the target like it? No. Reject the change and revert to the
6135 old architecture. */
6136 if (new_gdbarch == NULL)
6139 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
6140 swapin_gdbarch_swap (old_gdbarch);
6141 current_gdbarch = old_gdbarch;
6145 /* Did the architecture change? No. Oops, put the old architecture
6147 if (old_gdbarch == new_gdbarch)
6150 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
6152 new_gdbarch->bfd_arch_info->printable_name);
6153 swapin_gdbarch_swap (old_gdbarch);
6154 current_gdbarch = old_gdbarch;
6158 /* Is this a pre-existing architecture? Yes. Move it to the front
6159 of the list of architectures (keeping the list sorted Most
6160 Recently Used) and then copy it in. */
6162 struct gdbarch_list **list;
6163 for (list = ®o->arches;
6165 list = &(*list)->next)
6167 if ((*list)->gdbarch == new_gdbarch)
6169 struct gdbarch_list *this;
6171 fprintf_unfiltered (gdb_stdlog,
6172 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
6174 new_gdbarch->bfd_arch_info->printable_name);
6177 (*list) = this->next;
6178 /* Insert in the front. */
6179 this->next = rego->arches;
6180 rego->arches = this;
6181 /* Copy the new architecture in. */
6182 current_gdbarch = new_gdbarch;
6183 swapin_gdbarch_swap (new_gdbarch);
6184 architecture_changed_event ();
6190 /* Prepend this new architecture to the architecture list (keep the
6191 list sorted Most Recently Used). */
6193 struct gdbarch_list *this = XMALLOC (struct gdbarch_list);
6194 this->next = rego->arches;
6195 this->gdbarch = new_gdbarch;
6196 rego->arches = this;
6199 /* Switch to this new architecture marking it initialized. */
6200 current_gdbarch = new_gdbarch;
6201 current_gdbarch->initialized_p = 1;
6204 fprintf_unfiltered (gdb_stdlog,
6205 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
6207 new_gdbarch->bfd_arch_info->printable_name);
6210 /* Check that the newly installed architecture is valid. Plug in
6211 any post init values. */
6212 new_gdbarch->dump_tdep = rego->dump_tdep;
6213 verify_gdbarch (new_gdbarch);
6215 /* Initialize the per-architecture memory (swap) areas.
6216 CURRENT_GDBARCH must be update before these modules are
6218 init_gdbarch_swap (new_gdbarch);
6220 /* Initialize the per-architecture data. CURRENT_GDBARCH
6221 must be updated before these modules are called. */
6222 architecture_changed_event ();
6225 gdbarch_dump (current_gdbarch, gdb_stdlog);
6233 /* Pointer to the target-dependent disassembly function. */
6234 int (*tm_print_insn) (bfd_vma, disassemble_info *);
6235 disassemble_info tm_print_insn_info;
6238 extern void _initialize_gdbarch (void);
6241 _initialize_gdbarch (void)
6243 struct cmd_list_element *c;
6245 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
6246 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
6247 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
6248 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
6249 tm_print_insn_info.print_address_func = dis_asm_print_address;
6251 add_show_from_set (add_set_cmd ("arch",
6254 (char *)&gdbarch_debug,
6255 "Set architecture debugging.\n\
6256 When non-zero, architecture debugging is enabled.", &setdebuglist),
6258 c = add_set_cmd ("archdebug",
6261 (char *)&gdbarch_debug,
6262 "Set architecture debugging.\n\
6263 When non-zero, architecture debugging is enabled.", &setlist);
6265 deprecate_cmd (c, "set debug arch");
6266 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");