1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
4 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This file was created with the aid of ``gdbarch.sh''.
25 The Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
37 #include "arch-utils.h"
41 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
43 /* Just include everything in sight so that the every old definition
44 of macro is visible. */
45 #include "gdb_string.h"
50 #include "breakpoint.h"
55 #include "gdbthread.h"
57 #include "symfile.h" /* for overlay functions */
58 #include "value.h" /* For old tm.h/nm.h macros. */
62 #include "floatformat.h"
64 #include "gdb_assert.h"
65 #include "gdb_string.h"
66 #include "gdb-events.h"
67 #include "reggroups.h"
69 /* Static function declarations */
71 static void verify_gdbarch (struct gdbarch
*gdbarch
);
72 static void alloc_gdbarch_data (struct gdbarch
*);
73 static void free_gdbarch_data (struct gdbarch
*);
74 static void init_gdbarch_swap (struct gdbarch
*);
75 static void clear_gdbarch_swap (struct gdbarch
*);
76 static void swapout_gdbarch_swap (struct gdbarch
*);
77 static void swapin_gdbarch_swap (struct gdbarch
*);
79 /* Non-zero if we want to trace architecture code. */
82 #define GDBARCH_DEBUG 0
84 int gdbarch_debug
= GDBARCH_DEBUG
;
87 /* Maintain the struct gdbarch object */
91 /* Has this architecture been fully initialized? */
93 /* basic architectural information */
94 const struct bfd_arch_info
* bfd_arch_info
;
97 /* target specific vector. */
98 struct gdbarch_tdep
*tdep
;
99 gdbarch_dump_tdep_ftype
*dump_tdep
;
101 /* per-architecture data-pointers */
105 /* per-architecture swap-regions */
106 struct gdbarch_swap
*swap
;
108 /* Multi-arch values.
110 When extending this structure you must:
114 Declare set/get functions and define the corresponding
117 gdbarch_alloc(): If zero/NULL is not a suitable default,
118 initialize the new field.
120 verify_gdbarch(): Confirm that the target updated the field
123 gdbarch_dump(): Add a fprintf_unfiltered call so that the new
126 ``startup_gdbarch()'': Append an initial value to the static
127 variable (base values on the host's c-type system).
129 get_gdbarch(): Implement the set/get functions (probably using
130 the macro's as shortcuts).
145 gdbarch_read_pc_ftype
*read_pc
;
146 gdbarch_write_pc_ftype
*write_pc
;
147 gdbarch_read_fp_ftype
*read_fp
;
148 gdbarch_read_sp_ftype
*read_sp
;
149 gdbarch_write_sp_ftype
*write_sp
;
150 gdbarch_virtual_frame_pointer_ftype
*virtual_frame_pointer
;
151 gdbarch_pseudo_register_read_ftype
*pseudo_register_read
;
152 gdbarch_pseudo_register_write_ftype
*pseudo_register_write
;
161 gdbarch_stab_reg_to_regnum_ftype
*stab_reg_to_regnum
;
162 gdbarch_ecoff_reg_to_regnum_ftype
*ecoff_reg_to_regnum
;
163 gdbarch_dwarf_reg_to_regnum_ftype
*dwarf_reg_to_regnum
;
164 gdbarch_sdb_reg_to_regnum_ftype
*sdb_reg_to_regnum
;
165 gdbarch_dwarf2_reg_to_regnum_ftype
*dwarf2_reg_to_regnum
;
166 gdbarch_register_name_ftype
*register_name
;
169 gdbarch_register_byte_ftype
*register_byte
;
170 gdbarch_register_raw_size_ftype
*register_raw_size
;
171 int max_register_raw_size
;
172 gdbarch_register_virtual_size_ftype
*register_virtual_size
;
173 int max_register_virtual_size
;
174 gdbarch_register_virtual_type_ftype
*register_virtual_type
;
175 gdbarch_deprecated_do_registers_info_ftype
*deprecated_do_registers_info
;
176 gdbarch_print_registers_info_ftype
*print_registers_info
;
177 gdbarch_print_float_info_ftype
*print_float_info
;
178 gdbarch_print_vector_info_ftype
*print_vector_info
;
179 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
180 gdbarch_register_bytes_ok_ftype
*register_bytes_ok
;
181 gdbarch_cannot_fetch_register_ftype
*cannot_fetch_register
;
182 gdbarch_cannot_store_register_ftype
*cannot_store_register
;
183 gdbarch_get_longjmp_target_ftype
*get_longjmp_target
;
184 int deprecated_use_generic_dummy_frames
;
185 int call_dummy_location
;
186 gdbarch_call_dummy_address_ftype
*call_dummy_address
;
187 CORE_ADDR call_dummy_start_offset
;
188 CORE_ADDR call_dummy_breakpoint_offset
;
189 int call_dummy_breakpoint_offset_p
;
190 int call_dummy_length
;
191 gdbarch_pc_in_call_dummy_ftype
*pc_in_call_dummy
;
193 LONGEST
* call_dummy_words
;
194 int sizeof_call_dummy_words
;
195 int call_dummy_stack_adjust_p
;
196 int call_dummy_stack_adjust
;
197 gdbarch_fix_call_dummy_ftype
*fix_call_dummy
;
198 gdbarch_init_frame_pc_first_ftype
*init_frame_pc_first
;
199 gdbarch_init_frame_pc_ftype
*init_frame_pc
;
200 int believe_pcc_promotion
;
201 int believe_pcc_promotion_type
;
202 gdbarch_coerce_float_to_double_ftype
*coerce_float_to_double
;
203 gdbarch_get_saved_register_ftype
*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_push_arguments_ftype
*push_arguments
;
215 gdbarch_push_dummy_frame_ftype
*push_dummy_frame
;
216 gdbarch_push_return_address_ftype
*push_return_address
;
217 gdbarch_pop_frame_ftype
*pop_frame
;
218 gdbarch_store_struct_return_ftype
*store_struct_return
;
219 gdbarch_extract_return_value_ftype
*extract_return_value
;
220 gdbarch_store_return_value_ftype
*store_return_value
;
221 gdbarch_deprecated_extract_return_value_ftype
*deprecated_extract_return_value
;
222 gdbarch_deprecated_store_return_value_ftype
*deprecated_store_return_value
;
223 gdbarch_extract_struct_value_address_ftype
*extract_struct_value_address
;
224 gdbarch_deprecated_extract_struct_value_address_ftype
*deprecated_extract_struct_value_address
;
225 gdbarch_use_struct_convention_ftype
*use_struct_convention
;
226 gdbarch_frame_init_saved_regs_ftype
*frame_init_saved_regs
;
227 gdbarch_init_extra_frame_info_ftype
*init_extra_frame_info
;
228 gdbarch_skip_prologue_ftype
*skip_prologue
;
229 gdbarch_prologue_frameless_p_ftype
*prologue_frameless_p
;
230 gdbarch_inner_than_ftype
*inner_than
;
231 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
232 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
233 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
234 CORE_ADDR decr_pc_after_break
;
235 gdbarch_prepare_to_proceed_ftype
*prepare_to_proceed
;
236 CORE_ADDR function_start_offset
;
237 gdbarch_remote_translate_xfer_address_ftype
*remote_translate_xfer_address
;
238 CORE_ADDR frame_args_skip
;
239 gdbarch_frameless_function_invocation_ftype
*frameless_function_invocation
;
240 gdbarch_frame_chain_ftype
*frame_chain
;
241 gdbarch_frame_chain_valid_ftype
*frame_chain_valid
;
242 gdbarch_frame_saved_pc_ftype
*frame_saved_pc
;
243 gdbarch_frame_args_address_ftype
*frame_args_address
;
244 gdbarch_frame_locals_address_ftype
*frame_locals_address
;
245 gdbarch_saved_pc_after_call_ftype
*saved_pc_after_call
;
246 gdbarch_frame_num_args_ftype
*frame_num_args
;
247 gdbarch_stack_align_ftype
*stack_align
;
248 gdbarch_frame_align_ftype
*frame_align
;
249 int extra_stack_alignment_needed
;
250 gdbarch_reg_struct_has_addr_ftype
*reg_struct_has_addr
;
251 gdbarch_save_dummy_frame_tos_ftype
*save_dummy_frame_tos
;
253 const struct floatformat
* float_format
;
254 const struct floatformat
* double_format
;
255 const struct floatformat
* long_double_format
;
256 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
257 gdbarch_addr_bits_remove_ftype
*addr_bits_remove
;
258 gdbarch_smash_text_address_ftype
*smash_text_address
;
259 gdbarch_software_single_step_ftype
*software_single_step
;
260 gdbarch_print_insn_ftype
*print_insn
;
261 gdbarch_skip_trampoline_code_ftype
*skip_trampoline_code
;
262 gdbarch_in_solib_call_trampoline_ftype
*in_solib_call_trampoline
;
263 gdbarch_in_solib_return_trampoline_ftype
*in_solib_return_trampoline
;
264 gdbarch_pc_in_sigtramp_ftype
*pc_in_sigtramp
;
265 gdbarch_sigtramp_start_ftype
*sigtramp_start
;
266 gdbarch_sigtramp_end_ftype
*sigtramp_end
;
267 gdbarch_in_function_epilogue_p_ftype
*in_function_epilogue_p
;
268 gdbarch_construct_inferior_arguments_ftype
*construct_inferior_arguments
;
269 gdbarch_dwarf2_build_frame_info_ftype
*dwarf2_build_frame_info
;
270 gdbarch_elf_make_msymbol_special_ftype
*elf_make_msymbol_special
;
271 gdbarch_coff_make_msymbol_special_ftype
*coff_make_msymbol_special
;
272 const char * name_of_malloc
;
273 int cannot_step_breakpoint
;
274 int have_nonsteppable_watchpoint
;
275 gdbarch_address_class_type_flags_ftype
*address_class_type_flags
;
276 gdbarch_address_class_type_flags_to_name_ftype
*address_class_type_flags_to_name
;
277 gdbarch_address_class_name_to_type_flags_ftype
*address_class_name_to_type_flags
;
278 gdbarch_register_reggroup_p_ftype
*register_reggroup_p
;
282 /* The default architecture uses host values (for want of a better
285 extern const struct bfd_arch_info bfd_default_arch_struct
;
287 struct gdbarch startup_gdbarch
=
289 1, /* Always initialized. */
290 /* basic architecture information */
291 &bfd_default_arch_struct
,
293 /* target specific vector and its dump routine */
295 /*per-architecture data-pointers and swap regions */
297 /* Multi-arch values */
301 8 * sizeof (LONGEST
),
304 8 * sizeof (long double),
333 generic_register_byte
,
334 generic_register_size
,
336 generic_register_size
,
340 default_print_registers_info
,
431 generic_in_function_epilogue_p
,
432 construct_inferior_arguments
,
442 default_register_reggroup_p
,
443 /* startup_gdbarch() */
446 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
448 /* Do any initialization needed for a non-multiarch configuration
449 after the _initialize_MODULE functions have been run. */
451 initialize_non_multiarch (void)
453 alloc_gdbarch_data (&startup_gdbarch
);
454 /* Ensure that all swap areas are zeroed so that they again think
455 they are starting from scratch. */
456 clear_gdbarch_swap (&startup_gdbarch
);
457 init_gdbarch_swap (&startup_gdbarch
);
461 /* Create a new ``struct gdbarch'' based on information provided by
462 ``struct gdbarch_info''. */
465 gdbarch_alloc (const struct gdbarch_info
*info
,
466 struct gdbarch_tdep
*tdep
)
468 /* NOTE: The new architecture variable is named ``current_gdbarch''
469 so that macros such as TARGET_DOUBLE_BIT, when expanded, refer to
470 the current local architecture and not the previous global
471 architecture. This ensures that the new architectures initial
472 values are not influenced by the previous architecture. Once
473 everything is parameterised with gdbarch, this will go away. */
474 struct gdbarch
*current_gdbarch
= XMALLOC (struct gdbarch
);
475 memset (current_gdbarch
, 0, sizeof (*current_gdbarch
));
477 alloc_gdbarch_data (current_gdbarch
);
479 current_gdbarch
->tdep
= tdep
;
481 current_gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
482 current_gdbarch
->byte_order
= info
->byte_order
;
484 /* Force the explicit initialization of these. */
485 current_gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
486 current_gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
487 current_gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
488 current_gdbarch
->long_long_bit
= 2*TARGET_LONG_BIT
;
489 current_gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
490 current_gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
491 current_gdbarch
->long_double_bit
= 8*TARGET_CHAR_BIT
;
492 current_gdbarch
->ptr_bit
= TARGET_INT_BIT
;
493 current_gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
494 current_gdbarch
->char_signed
= -1;
495 current_gdbarch
->read_pc
= generic_target_read_pc
;
496 current_gdbarch
->write_pc
= generic_target_write_pc
;
497 current_gdbarch
->read_fp
= generic_target_read_fp
;
498 current_gdbarch
->read_sp
= generic_target_read_sp
;
499 current_gdbarch
->write_sp
= generic_target_write_sp
;
500 current_gdbarch
->virtual_frame_pointer
= legacy_virtual_frame_pointer
;
501 current_gdbarch
->num_regs
= -1;
502 current_gdbarch
->sp_regnum
= -1;
503 current_gdbarch
->fp_regnum
= -1;
504 current_gdbarch
->pc_regnum
= -1;
505 current_gdbarch
->ps_regnum
= -1;
506 current_gdbarch
->fp0_regnum
= -1;
507 current_gdbarch
->npc_regnum
= -1;
508 current_gdbarch
->stab_reg_to_regnum
= no_op_reg_to_regnum
;
509 current_gdbarch
->ecoff_reg_to_regnum
= no_op_reg_to_regnum
;
510 current_gdbarch
->dwarf_reg_to_regnum
= no_op_reg_to_regnum
;
511 current_gdbarch
->sdb_reg_to_regnum
= no_op_reg_to_regnum
;
512 current_gdbarch
->dwarf2_reg_to_regnum
= no_op_reg_to_regnum
;
513 current_gdbarch
->register_name
= legacy_register_name
;
514 current_gdbarch
->register_size
= -1;
515 current_gdbarch
->register_bytes
= -1;
516 current_gdbarch
->register_byte
= generic_register_byte
;
517 current_gdbarch
->register_raw_size
= generic_register_size
;
518 current_gdbarch
->max_register_raw_size
= -1;
519 current_gdbarch
->register_virtual_size
= generic_register_size
;
520 current_gdbarch
->max_register_virtual_size
= -1;
521 current_gdbarch
->print_registers_info
= default_print_registers_info
;
522 current_gdbarch
->register_sim_regno
= legacy_register_sim_regno
;
523 current_gdbarch
->cannot_fetch_register
= cannot_register_not
;
524 current_gdbarch
->cannot_store_register
= cannot_register_not
;
525 current_gdbarch
->deprecated_use_generic_dummy_frames
= 1;
526 current_gdbarch
->call_dummy_location
= AT_ENTRY_POINT
;
527 current_gdbarch
->call_dummy_start_offset
= -1;
528 current_gdbarch
->call_dummy_breakpoint_offset
= -1;
529 current_gdbarch
->call_dummy_breakpoint_offset_p
= -1;
530 current_gdbarch
->call_dummy_length
= -1;
531 current_gdbarch
->pc_in_call_dummy
= generic_pc_in_call_dummy
;
532 current_gdbarch
->call_dummy_p
= -1;
533 current_gdbarch
->call_dummy_words
= legacy_call_dummy_words
;
534 current_gdbarch
->sizeof_call_dummy_words
= legacy_sizeof_call_dummy_words
;
535 current_gdbarch
->call_dummy_stack_adjust_p
= -1;
536 current_gdbarch
->init_frame_pc_first
= init_frame_pc_noop
;
537 current_gdbarch
->init_frame_pc
= init_frame_pc_default
;
538 current_gdbarch
->coerce_float_to_double
= default_coerce_float_to_double
;
539 current_gdbarch
->register_convertible
= generic_register_convertible_not
;
540 current_gdbarch
->convert_register_p
= legacy_convert_register_p
;
541 current_gdbarch
->register_to_value
= legacy_register_to_value
;
542 current_gdbarch
->value_to_register
= legacy_value_to_register
;
543 current_gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
544 current_gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
545 current_gdbarch
->return_value_on_stack
= generic_return_value_on_stack_not
;
546 current_gdbarch
->push_arguments
= default_push_arguments
;
547 current_gdbarch
->extract_return_value
= legacy_extract_return_value
;
548 current_gdbarch
->store_return_value
= legacy_store_return_value
;
549 current_gdbarch
->use_struct_convention
= generic_use_struct_convention
;
550 current_gdbarch
->prologue_frameless_p
= generic_prologue_frameless_p
;
551 current_gdbarch
->breakpoint_from_pc
= legacy_breakpoint_from_pc
;
552 current_gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
553 current_gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
554 current_gdbarch
->decr_pc_after_break
= -1;
555 current_gdbarch
->prepare_to_proceed
= default_prepare_to_proceed
;
556 current_gdbarch
->function_start_offset
= -1;
557 current_gdbarch
->remote_translate_xfer_address
= generic_remote_translate_xfer_address
;
558 current_gdbarch
->frame_args_skip
= -1;
559 current_gdbarch
->frameless_function_invocation
= generic_frameless_function_invocation_not
;
560 current_gdbarch
->frame_chain_valid
= generic_func_frame_chain_valid
;
561 current_gdbarch
->frame_args_address
= get_frame_base
;
562 current_gdbarch
->frame_locals_address
= get_frame_base
;
563 current_gdbarch
->extra_stack_alignment_needed
= 1;
564 current_gdbarch
->convert_from_func_ptr_addr
= core_addr_identity
;
565 current_gdbarch
->addr_bits_remove
= core_addr_identity
;
566 current_gdbarch
->smash_text_address
= core_addr_identity
;
567 current_gdbarch
->print_insn
= legacy_print_insn
;
568 current_gdbarch
->skip_trampoline_code
= generic_skip_trampoline_code
;
569 current_gdbarch
->in_solib_call_trampoline
= generic_in_solib_call_trampoline
;
570 current_gdbarch
->in_solib_return_trampoline
= generic_in_solib_return_trampoline
;
571 current_gdbarch
->pc_in_sigtramp
= legacy_pc_in_sigtramp
;
572 current_gdbarch
->in_function_epilogue_p
= generic_in_function_epilogue_p
;
573 current_gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
574 current_gdbarch
->elf_make_msymbol_special
= default_elf_make_msymbol_special
;
575 current_gdbarch
->coff_make_msymbol_special
= default_coff_make_msymbol_special
;
576 current_gdbarch
->name_of_malloc
= "malloc";
577 current_gdbarch
->register_reggroup_p
= default_register_reggroup_p
;
578 /* gdbarch_alloc() */
580 return current_gdbarch
;
584 /* Free a gdbarch struct. This should never happen in normal
585 operation --- once you've created a gdbarch, you keep it around.
586 However, if an architecture's init function encounters an error
587 building the structure, it may need to clean up a partially
588 constructed gdbarch. */
591 gdbarch_free (struct gdbarch
*arch
)
593 gdb_assert (arch
!= NULL
);
594 free_gdbarch_data (arch
);
599 /* Ensure that all values in a GDBARCH are reasonable. */
602 verify_gdbarch (struct gdbarch
*gdbarch
)
605 struct cleanup
*cleanups
;
608 /* Only perform sanity checks on a multi-arch target. */
611 log
= mem_fileopen ();
612 cleanups
= make_cleanup_ui_file_delete (log
);
614 if (gdbarch
->byte_order
== BFD_ENDIAN_UNKNOWN
)
615 fprintf_unfiltered (log
, "\n\tbyte-order");
616 if (gdbarch
->bfd_arch_info
== NULL
)
617 fprintf_unfiltered (log
, "\n\tbfd_arch_info");
618 /* Check those that need to be defined for the given multi-arch level. */
619 /* Skip verify of short_bit, invalid_p == 0 */
620 /* Skip verify of int_bit, invalid_p == 0 */
621 /* Skip verify of long_bit, invalid_p == 0 */
622 /* Skip verify of long_long_bit, invalid_p == 0 */
623 /* Skip verify of float_bit, invalid_p == 0 */
624 /* Skip verify of double_bit, invalid_p == 0 */
625 /* Skip verify of long_double_bit, invalid_p == 0 */
626 /* Skip verify of ptr_bit, invalid_p == 0 */
627 if (gdbarch
->addr_bit
== 0)
628 gdbarch
->addr_bit
= TARGET_PTR_BIT
;
629 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
630 if (gdbarch
->char_signed
== -1)
631 gdbarch
->char_signed
= 1;
632 /* Skip verify of read_pc, invalid_p == 0 */
633 /* Skip verify of write_pc, invalid_p == 0 */
634 /* Skip verify of read_fp, invalid_p == 0 */
635 /* Skip verify of read_sp, invalid_p == 0 */
636 /* Skip verify of write_sp, invalid_p == 0 */
637 /* Skip verify of virtual_frame_pointer, invalid_p == 0 */
638 /* Skip verify of pseudo_register_read, has predicate */
639 /* Skip verify of pseudo_register_write, has predicate */
640 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
641 && (gdbarch
->num_regs
== -1))
642 fprintf_unfiltered (log
, "\n\tnum_regs");
643 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
644 /* Skip verify of sp_regnum, invalid_p == 0 */
645 /* Skip verify of fp_regnum, invalid_p == 0 */
646 /* Skip verify of pc_regnum, invalid_p == 0 */
647 /* Skip verify of ps_regnum, invalid_p == 0 */
648 /* Skip verify of fp0_regnum, invalid_p == 0 */
649 /* Skip verify of npc_regnum, invalid_p == 0 */
650 /* Skip verify of stab_reg_to_regnum, invalid_p == 0 */
651 /* Skip verify of ecoff_reg_to_regnum, invalid_p == 0 */
652 /* Skip verify of dwarf_reg_to_regnum, invalid_p == 0 */
653 /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */
654 /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */
655 /* Skip verify of register_name, invalid_p == 0 */
656 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
657 && (gdbarch
->register_size
== -1))
658 fprintf_unfiltered (log
, "\n\tregister_size");
659 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
660 && (gdbarch
->register_bytes
== -1))
661 fprintf_unfiltered (log
, "\n\tregister_bytes");
662 /* Skip verify of register_byte, invalid_p == 0 */
663 /* Skip verify of register_raw_size, invalid_p == 0 */
664 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
665 && (gdbarch
->max_register_raw_size
== -1))
666 fprintf_unfiltered (log
, "\n\tmax_register_raw_size");
667 /* Skip verify of register_virtual_size, invalid_p == 0 */
668 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
669 && (gdbarch
->max_register_virtual_size
== -1))
670 fprintf_unfiltered (log
, "\n\tmax_register_virtual_size");
671 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
672 && (gdbarch
->register_virtual_type
== 0))
673 fprintf_unfiltered (log
, "\n\tregister_virtual_type");
674 /* Skip verify of deprecated_do_registers_info, has predicate */
675 /* Skip verify of print_registers_info, invalid_p == 0 */
676 /* Skip verify of print_float_info, has predicate */
677 /* Skip verify of print_vector_info, has predicate */
678 /* Skip verify of register_sim_regno, invalid_p == 0 */
679 /* Skip verify of register_bytes_ok, has predicate */
680 /* Skip verify of cannot_fetch_register, invalid_p == 0 */
681 /* Skip verify of cannot_store_register, invalid_p == 0 */
682 /* Skip verify of get_longjmp_target, has predicate */
683 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
684 /* Skip verify of call_dummy_location, invalid_p == 0 */
685 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
686 && (gdbarch
->call_dummy_location
== AT_ENTRY_POINT
&& gdbarch
->call_dummy_address
== 0))
687 fprintf_unfiltered (log
, "\n\tcall_dummy_address");
688 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
689 && (gdbarch
->call_dummy_start_offset
== -1))
690 fprintf_unfiltered (log
, "\n\tcall_dummy_start_offset");
691 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
692 && (gdbarch
->call_dummy_breakpoint_offset_p
&& gdbarch
->call_dummy_breakpoint_offset
== -1))
693 fprintf_unfiltered (log
, "\n\tcall_dummy_breakpoint_offset");
694 if ((GDB_MULTI_ARCH
>= GDB_MULTI_ARCH_PARTIAL
)
695 && (gdbarch
->call_dummy_breakpoint_offset_p
== -1))
696 fprintf_unfiltered (log
, "\n\tcall_dummy_breakpoint_offset_p");
697 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
698 && (gdbarch
->call_dummy_length
== -1))
699 fprintf_unfiltered (log
, "\n\tcall_dummy_length");
700 /* Skip verify of pc_in_call_dummy, invalid_p == 0 */
701 if ((GDB_MULTI_ARCH
>= GDB_MULTI_ARCH_PARTIAL
)
702 && (gdbarch
->call_dummy_p
== -1))
703 fprintf_unfiltered (log
, "\n\tcall_dummy_p");
704 /* Skip verify of call_dummy_words, invalid_p == 0 */
705 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
706 if ((GDB_MULTI_ARCH
>= GDB_MULTI_ARCH_PARTIAL
)
707 && (gdbarch
->call_dummy_stack_adjust_p
== -1))
708 fprintf_unfiltered (log
, "\n\tcall_dummy_stack_adjust_p");
709 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
710 && (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0))
711 fprintf_unfiltered (log
, "\n\tcall_dummy_stack_adjust");
712 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
713 && (gdbarch
->fix_call_dummy
== 0))
714 fprintf_unfiltered (log
, "\n\tfix_call_dummy");
715 /* Skip verify of init_frame_pc_first, invalid_p == 0 */
716 /* Skip verify of init_frame_pc, invalid_p == 0 */
717 /* Skip verify of coerce_float_to_double, invalid_p == 0 */
718 /* Skip verify of get_saved_register, has predicate */
719 /* Skip verify of register_convertible, invalid_p == 0 */
720 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
721 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
722 /* Skip verify of convert_register_p, invalid_p == 0 */
723 /* Skip verify of register_to_value, invalid_p == 0 */
724 /* Skip verify of value_to_register, invalid_p == 0 */
725 /* Skip verify of pointer_to_address, invalid_p == 0 */
726 /* Skip verify of address_to_pointer, invalid_p == 0 */
727 /* Skip verify of integer_to_address, has predicate */
728 /* Skip verify of return_value_on_stack, invalid_p == 0 */
729 /* Skip verify of push_arguments, invalid_p == 0 */
730 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
731 && (gdbarch
->push_dummy_frame
== 0))
732 fprintf_unfiltered (log
, "\n\tpush_dummy_frame");
733 /* Skip verify of push_return_address, has predicate */
734 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
735 && (gdbarch
->pop_frame
== 0))
736 fprintf_unfiltered (log
, "\n\tpop_frame");
737 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
738 && (gdbarch
->store_struct_return
== 0))
739 fprintf_unfiltered (log
, "\n\tstore_struct_return");
740 /* Skip verify of extract_return_value, invalid_p == 0 */
741 /* Skip verify of store_return_value, invalid_p == 0 */
742 /* Skip verify of extract_struct_value_address, has predicate */
743 /* Skip verify of deprecated_extract_struct_value_address, has predicate */
744 /* Skip verify of use_struct_convention, invalid_p == 0 */
745 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
746 && (gdbarch
->frame_init_saved_regs
== 0))
747 fprintf_unfiltered (log
, "\n\tframe_init_saved_regs");
748 /* Skip verify of init_extra_frame_info, has predicate */
749 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
750 && (gdbarch
->skip_prologue
== 0))
751 fprintf_unfiltered (log
, "\n\tskip_prologue");
752 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
753 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
754 && (gdbarch
->inner_than
== 0))
755 fprintf_unfiltered (log
, "\n\tinner_than");
756 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
757 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
758 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
759 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
760 && (gdbarch
->decr_pc_after_break
== -1))
761 fprintf_unfiltered (log
, "\n\tdecr_pc_after_break");
762 /* Skip verify of prepare_to_proceed, invalid_p == 0 */
763 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
764 && (gdbarch
->function_start_offset
== -1))
765 fprintf_unfiltered (log
, "\n\tfunction_start_offset");
766 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
767 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
768 && (gdbarch
->frame_args_skip
== -1))
769 fprintf_unfiltered (log
, "\n\tframe_args_skip");
770 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
771 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
772 && (gdbarch
->frame_chain
== 0))
773 fprintf_unfiltered (log
, "\n\tframe_chain");
774 /* Skip verify of frame_chain_valid, invalid_p == 0 */
775 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
776 && (gdbarch
->frame_saved_pc
== 0))
777 fprintf_unfiltered (log
, "\n\tframe_saved_pc");
778 /* Skip verify of frame_args_address, invalid_p == 0 */
779 /* Skip verify of frame_locals_address, invalid_p == 0 */
780 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
781 && (gdbarch
->saved_pc_after_call
== 0))
782 fprintf_unfiltered (log
, "\n\tsaved_pc_after_call");
783 if ((GDB_MULTI_ARCH
> GDB_MULTI_ARCH_PARTIAL
)
784 && (gdbarch
->frame_num_args
== 0))
785 fprintf_unfiltered (log
, "\n\tframe_num_args");
786 /* Skip verify of stack_align, has predicate */
787 /* Skip verify of frame_align, has predicate */
788 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
789 /* Skip verify of reg_struct_has_addr, has predicate */
790 /* Skip verify of save_dummy_frame_tos, has predicate */
791 if (gdbarch
->float_format
== 0)
792 gdbarch
->float_format
= default_float_format (gdbarch
);
793 if (gdbarch
->double_format
== 0)
794 gdbarch
->double_format
= default_double_format (gdbarch
);
795 if (gdbarch
->long_double_format
== 0)
796 gdbarch
->long_double_format
= default_double_format (gdbarch
);
797 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
798 /* Skip verify of addr_bits_remove, invalid_p == 0 */
799 /* Skip verify of smash_text_address, invalid_p == 0 */
800 /* Skip verify of software_single_step, has predicate */
801 /* Skip verify of print_insn, invalid_p == 0 */
802 /* Skip verify of skip_trampoline_code, invalid_p == 0 */
803 /* Skip verify of in_solib_call_trampoline, invalid_p == 0 */
804 /* Skip verify of in_solib_return_trampoline, invalid_p == 0 */
805 /* Skip verify of pc_in_sigtramp, invalid_p == 0 */
806 /* Skip verify of sigtramp_start, has predicate */
807 /* Skip verify of sigtramp_end, has predicate */
808 /* Skip verify of in_function_epilogue_p, invalid_p == 0 */
809 /* Skip verify of construct_inferior_arguments, invalid_p == 0 */
810 /* Skip verify of dwarf2_build_frame_info, has predicate */
811 /* Skip verify of elf_make_msymbol_special, invalid_p == 0 */
812 /* Skip verify of coff_make_msymbol_special, invalid_p == 0 */
813 /* Skip verify of name_of_malloc, invalid_p == 0 */
814 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
815 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
816 /* Skip verify of address_class_type_flags, has predicate */
817 /* Skip verify of address_class_type_flags_to_name, has predicate */
818 /* Skip verify of address_class_name_to_type_flags, has predicate */
819 /* Skip verify of register_reggroup_p, invalid_p == 0 */
820 buf
= ui_file_xstrdup (log
, &dummy
);
821 make_cleanup (xfree
, buf
);
822 if (strlen (buf
) > 0)
823 internal_error (__FILE__
, __LINE__
,
824 "verify_gdbarch: the following are invalid ...%s",
826 do_cleanups (cleanups
);
830 /* Print out the details of the current architecture. */
832 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
833 just happens to match the global variable ``current_gdbarch''. That
834 way macros refering to that variable get the local and not the global
835 version - ulgh. Once everything is parameterised with gdbarch, this
839 gdbarch_dump (struct gdbarch
*gdbarch
, struct ui_file
*file
)
841 fprintf_unfiltered (file
,
842 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
845 fprintf_unfiltered (file
,
846 "gdbarch_dump: frame_align = 0x%08lx\n",
847 (long) current_gdbarch
->frame_align
);
849 fprintf_unfiltered (file
,
850 "gdbarch_dump: in_function_epilogue_p = 0x%08lx\n",
851 (long) current_gdbarch
->in_function_epilogue_p
);
853 fprintf_unfiltered (file
,
854 "gdbarch_dump: register_reggroup_p = 0x%08lx\n",
855 (long) current_gdbarch
->register_reggroup_p
);
857 fprintf_unfiltered (file
,
858 "gdbarch_dump: pseudo_register_read = 0x%08lx\n",
859 (long) current_gdbarch
->pseudo_register_read
);
861 fprintf_unfiltered (file
,
862 "gdbarch_dump: pseudo_register_write = 0x%08lx\n",
863 (long) current_gdbarch
->pseudo_register_write
);
865 fprintf_unfiltered (file
,
866 "gdbarch_dump: address_class_name_to_type_flags = 0x%08lx\n",
867 (long) current_gdbarch
->address_class_name_to_type_flags
);
868 #ifdef ADDRESS_CLASS_TYPE_FLAGS
869 fprintf_unfiltered (file
,
870 "gdbarch_dump: %s # %s\n",
871 "ADDRESS_CLASS_TYPE_FLAGS(byte_size, dwarf2_addr_class)",
872 XSTRING (ADDRESS_CLASS_TYPE_FLAGS (byte_size
, dwarf2_addr_class
)));
874 fprintf_unfiltered (file
,
875 "gdbarch_dump: ADDRESS_CLASS_TYPE_FLAGS = 0x%08lx\n",
876 (long) current_gdbarch
->address_class_type_flags
877 /*ADDRESS_CLASS_TYPE_FLAGS ()*/);
880 fprintf_unfiltered (file
,
881 "gdbarch_dump: address_class_type_flags_to_name = 0x%08lx\n",
882 (long) current_gdbarch
->address_class_type_flags_to_name
);
883 #ifdef ADDRESS_TO_POINTER
885 /* Macro might contain `[{}]' when not multi-arch */
886 fprintf_unfiltered (file
,
887 "gdbarch_dump: %s # %s\n",
888 "ADDRESS_TO_POINTER(type, buf, addr)",
889 XSTRING (ADDRESS_TO_POINTER (type
, buf
, addr
)));
892 fprintf_unfiltered (file
,
893 "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
894 (long) current_gdbarch
->address_to_pointer
895 /*ADDRESS_TO_POINTER ()*/);
897 #ifdef ADDR_BITS_REMOVE
898 fprintf_unfiltered (file
,
899 "gdbarch_dump: %s # %s\n",
900 "ADDR_BITS_REMOVE(addr)",
901 XSTRING (ADDR_BITS_REMOVE (addr
)));
903 fprintf_unfiltered (file
,
904 "gdbarch_dump: ADDR_BITS_REMOVE = 0x%08lx\n",
905 (long) current_gdbarch
->addr_bits_remove
906 /*ADDR_BITS_REMOVE ()*/);
908 #ifdef BELIEVE_PCC_PROMOTION
909 fprintf_unfiltered (file
,
910 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
911 XSTRING (BELIEVE_PCC_PROMOTION
));
912 fprintf_unfiltered (file
,
913 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %d\n",
914 BELIEVE_PCC_PROMOTION
);
916 #ifdef BELIEVE_PCC_PROMOTION_TYPE
917 fprintf_unfiltered (file
,
918 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
919 XSTRING (BELIEVE_PCC_PROMOTION_TYPE
));
920 fprintf_unfiltered (file
,
921 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %d\n",
922 BELIEVE_PCC_PROMOTION_TYPE
);
924 #ifdef BREAKPOINT_FROM_PC
925 fprintf_unfiltered (file
,
926 "gdbarch_dump: %s # %s\n",
927 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
928 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
930 fprintf_unfiltered (file
,
931 "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
932 (long) current_gdbarch
->breakpoint_from_pc
933 /*BREAKPOINT_FROM_PC ()*/);
935 #ifdef CALL_DUMMY_ADDRESS
936 fprintf_unfiltered (file
,
937 "gdbarch_dump: %s # %s\n",
938 "CALL_DUMMY_ADDRESS()",
939 XSTRING (CALL_DUMMY_ADDRESS ()));
941 fprintf_unfiltered (file
,
942 "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
943 (long) current_gdbarch
->call_dummy_address
944 /*CALL_DUMMY_ADDRESS ()*/);
946 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
947 fprintf_unfiltered (file
,
948 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
949 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET
));
950 if (CALL_DUMMY_BREAKPOINT_OFFSET_P
)
951 fprintf_unfiltered (file
,
952 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
953 (long) CALL_DUMMY_BREAKPOINT_OFFSET
);
955 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
956 fprintf_unfiltered (file
,
957 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
958 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P
));
959 fprintf_unfiltered (file
,
960 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %d\n",
961 CALL_DUMMY_BREAKPOINT_OFFSET_P
);
963 #ifdef CALL_DUMMY_LENGTH
964 fprintf_unfiltered (file
,
965 "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
966 XSTRING (CALL_DUMMY_LENGTH
));
967 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
|| CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
968 fprintf_unfiltered (file
,
969 "gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
972 #ifdef CALL_DUMMY_LOCATION
973 fprintf_unfiltered (file
,
974 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
975 XSTRING (CALL_DUMMY_LOCATION
));
976 fprintf_unfiltered (file
,
977 "gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
978 CALL_DUMMY_LOCATION
);
981 fprintf_unfiltered (file
,
982 "gdbarch_dump: CALL_DUMMY_P # %s\n",
983 XSTRING (CALL_DUMMY_P
));
984 fprintf_unfiltered (file
,
985 "gdbarch_dump: CALL_DUMMY_P = %d\n",
988 #ifdef CALL_DUMMY_STACK_ADJUST
989 fprintf_unfiltered (file
,
990 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
991 XSTRING (CALL_DUMMY_STACK_ADJUST
));
992 if (CALL_DUMMY_STACK_ADJUST_P
)
993 fprintf_unfiltered (file
,
994 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
995 (long) CALL_DUMMY_STACK_ADJUST
);
997 #ifdef CALL_DUMMY_STACK_ADJUST_P
998 fprintf_unfiltered (file
,
999 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
1000 XSTRING (CALL_DUMMY_STACK_ADJUST_P
));
1001 fprintf_unfiltered (file
,
1002 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
1003 (long) CALL_DUMMY_STACK_ADJUST_P
);
1005 #ifdef CALL_DUMMY_START_OFFSET
1006 fprintf_unfiltered (file
,
1007 "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
1008 XSTRING (CALL_DUMMY_START_OFFSET
));
1009 fprintf_unfiltered (file
,
1010 "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
1011 (long) CALL_DUMMY_START_OFFSET
);
1013 #ifdef CALL_DUMMY_WORDS
1014 fprintf_unfiltered (file
,
1015 "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
1016 XSTRING (CALL_DUMMY_WORDS
));
1017 fprintf_unfiltered (file
,
1018 "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
1019 (long) CALL_DUMMY_WORDS
);
1021 #ifdef CANNOT_FETCH_REGISTER
1022 fprintf_unfiltered (file
,
1023 "gdbarch_dump: %s # %s\n",
1024 "CANNOT_FETCH_REGISTER(regnum)",
1025 XSTRING (CANNOT_FETCH_REGISTER (regnum
)));
1027 fprintf_unfiltered (file
,
1028 "gdbarch_dump: CANNOT_FETCH_REGISTER = 0x%08lx\n",
1029 (long) current_gdbarch
->cannot_fetch_register
1030 /*CANNOT_FETCH_REGISTER ()*/);
1032 #ifdef CANNOT_STEP_BREAKPOINT
1033 fprintf_unfiltered (file
,
1034 "gdbarch_dump: CANNOT_STEP_BREAKPOINT # %s\n",
1035 XSTRING (CANNOT_STEP_BREAKPOINT
));
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: CANNOT_STEP_BREAKPOINT = %d\n",
1038 CANNOT_STEP_BREAKPOINT
);
1040 #ifdef CANNOT_STORE_REGISTER
1041 fprintf_unfiltered (file
,
1042 "gdbarch_dump: %s # %s\n",
1043 "CANNOT_STORE_REGISTER(regnum)",
1044 XSTRING (CANNOT_STORE_REGISTER (regnum
)));
1046 fprintf_unfiltered (file
,
1047 "gdbarch_dump: CANNOT_STORE_REGISTER = 0x%08lx\n",
1048 (long) current_gdbarch
->cannot_store_register
1049 /*CANNOT_STORE_REGISTER ()*/);
1051 #ifdef COERCE_FLOAT_TO_DOUBLE
1052 fprintf_unfiltered (file
,
1053 "gdbarch_dump: %s # %s\n",
1054 "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
1055 XSTRING (COERCE_FLOAT_TO_DOUBLE (formal
, actual
)));
1057 fprintf_unfiltered (file
,
1058 "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
1059 (long) current_gdbarch
->coerce_float_to_double
1060 /*COERCE_FLOAT_TO_DOUBLE ()*/);
1062 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
1064 /* Macro might contain `[{}]' when not multi-arch */
1065 fprintf_unfiltered (file
,
1066 "gdbarch_dump: %s # %s\n",
1067 "COFF_MAKE_MSYMBOL_SPECIAL(val, msym)",
1068 XSTRING (COFF_MAKE_MSYMBOL_SPECIAL (val
, msym
)));
1071 fprintf_unfiltered (file
,
1072 "gdbarch_dump: COFF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n",
1073 (long) current_gdbarch
->coff_make_msymbol_special
1074 /*COFF_MAKE_MSYMBOL_SPECIAL ()*/);
1077 fprintf_unfiltered (file
,
1078 "gdbarch_dump: construct_inferior_arguments = 0x%08lx\n",
1079 (long) current_gdbarch
->construct_inferior_arguments
);
1080 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1081 fprintf_unfiltered (file
,
1082 "gdbarch_dump: %s # %s\n",
1083 "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
1084 XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr
)));
1086 fprintf_unfiltered (file
,
1087 "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n",
1088 (long) current_gdbarch
->convert_from_func_ptr_addr
1089 /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
1091 #ifdef CONVERT_REGISTER_P
1092 fprintf_unfiltered (file
,
1093 "gdbarch_dump: %s # %s\n",
1094 "CONVERT_REGISTER_P(regnum)",
1095 XSTRING (CONVERT_REGISTER_P (regnum
)));
1097 fprintf_unfiltered (file
,
1098 "gdbarch_dump: CONVERT_REGISTER_P = 0x%08lx\n",
1099 (long) current_gdbarch
->convert_register_p
1100 /*CONVERT_REGISTER_P ()*/);
1102 #ifdef DECR_PC_AFTER_BREAK
1103 fprintf_unfiltered (file
,
1104 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1105 XSTRING (DECR_PC_AFTER_BREAK
));
1106 fprintf_unfiltered (file
,
1107 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1108 (long) DECR_PC_AFTER_BREAK
);
1110 #ifdef DEPRECATED_DO_REGISTERS_INFO
1112 /* Macro might contain `[{}]' when not multi-arch */
1113 fprintf_unfiltered (file
,
1114 "gdbarch_dump: %s # %s\n",
1115 "DEPRECATED_DO_REGISTERS_INFO(reg_nr, fpregs)",
1116 XSTRING (DEPRECATED_DO_REGISTERS_INFO (reg_nr
, fpregs
)));
1119 fprintf_unfiltered (file
,
1120 "gdbarch_dump: DEPRECATED_DO_REGISTERS_INFO = 0x%08lx\n",
1121 (long) current_gdbarch
->deprecated_do_registers_info
1122 /*DEPRECATED_DO_REGISTERS_INFO ()*/);
1124 #ifdef DEPRECATED_EXTRACT_RETURN_VALUE
1126 /* Macro might contain `[{}]' when not multi-arch */
1127 fprintf_unfiltered (file
,
1128 "gdbarch_dump: %s # %s\n",
1129 "DEPRECATED_EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1130 XSTRING (DEPRECATED_EXTRACT_RETURN_VALUE (type
, regbuf
, valbuf
)));
1133 fprintf_unfiltered (file
,
1134 "gdbarch_dump: DEPRECATED_EXTRACT_RETURN_VALUE = 0x%08lx\n",
1135 (long) current_gdbarch
->deprecated_extract_return_value
1136 /*DEPRECATED_EXTRACT_RETURN_VALUE ()*/);
1138 #ifdef DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS
1139 fprintf_unfiltered (file
,
1140 "gdbarch_dump: %s # %s\n",
1141 "DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1142 XSTRING (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (regbuf
)));
1144 fprintf_unfiltered (file
,
1145 "gdbarch_dump: DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
1146 (long) current_gdbarch
->deprecated_extract_struct_value_address
1147 /*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1149 #ifdef DEPRECATED_STORE_RETURN_VALUE
1151 /* Macro might contain `[{}]' when not multi-arch */
1152 fprintf_unfiltered (file
,
1153 "gdbarch_dump: %s # %s\n",
1154 "DEPRECATED_STORE_RETURN_VALUE(type, valbuf)",
1155 XSTRING (DEPRECATED_STORE_RETURN_VALUE (type
, valbuf
)));
1158 fprintf_unfiltered (file
,
1159 "gdbarch_dump: DEPRECATED_STORE_RETURN_VALUE = 0x%08lx\n",
1160 (long) current_gdbarch
->deprecated_store_return_value
1161 /*DEPRECATED_STORE_RETURN_VALUE ()*/);
1163 #ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1164 fprintf_unfiltered (file
,
1165 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
1166 XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
));
1167 fprintf_unfiltered (file
,
1168 "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
1169 DEPRECATED_USE_GENERIC_DUMMY_FRAMES
);
1171 #ifdef DWARF2_BUILD_FRAME_INFO
1173 /* Macro might contain `[{}]' when not multi-arch */
1174 fprintf_unfiltered (file
,
1175 "gdbarch_dump: %s # %s\n",
1176 "DWARF2_BUILD_FRAME_INFO(objfile)",
1177 XSTRING (DWARF2_BUILD_FRAME_INFO (objfile
)));
1180 fprintf_unfiltered (file
,
1181 "gdbarch_dump: DWARF2_BUILD_FRAME_INFO = 0x%08lx\n",
1182 (long) current_gdbarch
->dwarf2_build_frame_info
1183 /*DWARF2_BUILD_FRAME_INFO ()*/);
1185 #ifdef DWARF2_REG_TO_REGNUM
1186 fprintf_unfiltered (file
,
1187 "gdbarch_dump: %s # %s\n",
1188 "DWARF2_REG_TO_REGNUM(dwarf2_regnr)",
1189 XSTRING (DWARF2_REG_TO_REGNUM (dwarf2_regnr
)));
1191 fprintf_unfiltered (file
,
1192 "gdbarch_dump: DWARF2_REG_TO_REGNUM = 0x%08lx\n",
1193 (long) current_gdbarch
->dwarf2_reg_to_regnum
1194 /*DWARF2_REG_TO_REGNUM ()*/);
1196 #ifdef DWARF_REG_TO_REGNUM
1197 fprintf_unfiltered (file
,
1198 "gdbarch_dump: %s # %s\n",
1199 "DWARF_REG_TO_REGNUM(dwarf_regnr)",
1200 XSTRING (DWARF_REG_TO_REGNUM (dwarf_regnr
)));
1202 fprintf_unfiltered (file
,
1203 "gdbarch_dump: DWARF_REG_TO_REGNUM = 0x%08lx\n",
1204 (long) current_gdbarch
->dwarf_reg_to_regnum
1205 /*DWARF_REG_TO_REGNUM ()*/);
1207 #ifdef ECOFF_REG_TO_REGNUM
1208 fprintf_unfiltered (file
,
1209 "gdbarch_dump: %s # %s\n",
1210 "ECOFF_REG_TO_REGNUM(ecoff_regnr)",
1211 XSTRING (ECOFF_REG_TO_REGNUM (ecoff_regnr
)));
1213 fprintf_unfiltered (file
,
1214 "gdbarch_dump: ECOFF_REG_TO_REGNUM = 0x%08lx\n",
1215 (long) current_gdbarch
->ecoff_reg_to_regnum
1216 /*ECOFF_REG_TO_REGNUM ()*/);
1218 #ifdef ELF_MAKE_MSYMBOL_SPECIAL
1220 /* Macro might contain `[{}]' when not multi-arch */
1221 fprintf_unfiltered (file
,
1222 "gdbarch_dump: %s # %s\n",
1223 "ELF_MAKE_MSYMBOL_SPECIAL(sym, msym)",
1224 XSTRING (ELF_MAKE_MSYMBOL_SPECIAL (sym
, msym
)));
1227 fprintf_unfiltered (file
,
1228 "gdbarch_dump: ELF_MAKE_MSYMBOL_SPECIAL = 0x%08lx\n",
1229 (long) current_gdbarch
->elf_make_msymbol_special
1230 /*ELF_MAKE_MSYMBOL_SPECIAL ()*/);
1232 #ifdef EXTRACT_RETURN_VALUE
1234 /* Macro might contain `[{}]' when not multi-arch */
1235 fprintf_unfiltered (file
,
1236 "gdbarch_dump: %s # %s\n",
1237 "EXTRACT_RETURN_VALUE(type, regcache, valbuf)",
1238 XSTRING (EXTRACT_RETURN_VALUE (type
, regcache
, valbuf
)));
1241 fprintf_unfiltered (file
,
1242 "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
1243 (long) current_gdbarch
->extract_return_value
1244 /*EXTRACT_RETURN_VALUE ()*/);
1246 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1247 fprintf_unfiltered (file
,
1248 "gdbarch_dump: %s # %s\n",
1249 "EXTRACT_STRUCT_VALUE_ADDRESS(regcache)",
1250 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regcache
)));
1252 fprintf_unfiltered (file
,
1253 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
1254 (long) current_gdbarch
->extract_struct_value_address
1255 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1257 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1258 fprintf_unfiltered (file
,
1259 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1260 XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED
));
1261 fprintf_unfiltered (file
,
1262 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
1263 EXTRA_STACK_ALIGNMENT_NEEDED
);
1265 #ifdef FIX_CALL_DUMMY
1267 /* Macro might contain `[{}]' when not multi-arch */
1268 fprintf_unfiltered (file
,
1269 "gdbarch_dump: %s # %s\n",
1270 "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
1271 XSTRING (FIX_CALL_DUMMY (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)));
1274 fprintf_unfiltered (file
,
1275 "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
1276 (long) current_gdbarch
->fix_call_dummy
1277 /*FIX_CALL_DUMMY ()*/);
1280 fprintf_unfiltered (file
,
1281 "gdbarch_dump: FP0_REGNUM # %s\n",
1282 XSTRING (FP0_REGNUM
));
1283 fprintf_unfiltered (file
,
1284 "gdbarch_dump: FP0_REGNUM = %d\n",
1288 fprintf_unfiltered (file
,
1289 "gdbarch_dump: FP_REGNUM # %s\n",
1290 XSTRING (FP_REGNUM
));
1291 fprintf_unfiltered (file
,
1292 "gdbarch_dump: FP_REGNUM = %d\n",
1295 #ifdef FRAMELESS_FUNCTION_INVOCATION
1296 fprintf_unfiltered (file
,
1297 "gdbarch_dump: %s # %s\n",
1298 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1299 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi
)));
1301 fprintf_unfiltered (file
,
1302 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
1303 (long) current_gdbarch
->frameless_function_invocation
1304 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1306 #ifdef FRAME_ARGS_ADDRESS
1307 fprintf_unfiltered (file
,
1308 "gdbarch_dump: %s # %s\n",
1309 "FRAME_ARGS_ADDRESS(fi)",
1310 XSTRING (FRAME_ARGS_ADDRESS (fi
)));
1312 fprintf_unfiltered (file
,
1313 "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
1314 (long) current_gdbarch
->frame_args_address
1315 /*FRAME_ARGS_ADDRESS ()*/);
1317 #ifdef FRAME_ARGS_SKIP
1318 fprintf_unfiltered (file
,
1319 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1320 XSTRING (FRAME_ARGS_SKIP
));
1321 fprintf_unfiltered (file
,
1322 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1323 (long) FRAME_ARGS_SKIP
);
1326 fprintf_unfiltered (file
,
1327 "gdbarch_dump: %s # %s\n",
1328 "FRAME_CHAIN(frame)",
1329 XSTRING (FRAME_CHAIN (frame
)));
1331 fprintf_unfiltered (file
,
1332 "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n",
1333 (long) current_gdbarch
->frame_chain
1334 /*FRAME_CHAIN ()*/);
1336 #ifdef FRAME_CHAIN_VALID
1337 fprintf_unfiltered (file
,
1338 "gdbarch_dump: %s # %s\n",
1339 "FRAME_CHAIN_VALID(chain, thisframe)",
1340 XSTRING (FRAME_CHAIN_VALID (chain
, thisframe
)));
1342 fprintf_unfiltered (file
,
1343 "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n",
1344 (long) current_gdbarch
->frame_chain_valid
1345 /*FRAME_CHAIN_VALID ()*/);
1347 #ifdef FRAME_INIT_SAVED_REGS
1349 /* Macro might contain `[{}]' when not multi-arch */
1350 fprintf_unfiltered (file
,
1351 "gdbarch_dump: %s # %s\n",
1352 "FRAME_INIT_SAVED_REGS(frame)",
1353 XSTRING (FRAME_INIT_SAVED_REGS (frame
)));
1356 fprintf_unfiltered (file
,
1357 "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
1358 (long) current_gdbarch
->frame_init_saved_regs
1359 /*FRAME_INIT_SAVED_REGS ()*/);
1361 #ifdef FRAME_LOCALS_ADDRESS
1362 fprintf_unfiltered (file
,
1363 "gdbarch_dump: %s # %s\n",
1364 "FRAME_LOCALS_ADDRESS(fi)",
1365 XSTRING (FRAME_LOCALS_ADDRESS (fi
)));
1367 fprintf_unfiltered (file
,
1368 "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
1369 (long) current_gdbarch
->frame_locals_address
1370 /*FRAME_LOCALS_ADDRESS ()*/);
1372 #ifdef FRAME_NUM_ARGS
1373 fprintf_unfiltered (file
,
1374 "gdbarch_dump: %s # %s\n",
1375 "FRAME_NUM_ARGS(frame)",
1376 XSTRING (FRAME_NUM_ARGS (frame
)));
1378 fprintf_unfiltered (file
,
1379 "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
1380 (long) current_gdbarch
->frame_num_args
1381 /*FRAME_NUM_ARGS ()*/);
1383 #ifdef FRAME_SAVED_PC
1384 fprintf_unfiltered (file
,
1385 "gdbarch_dump: %s # %s\n",
1386 "FRAME_SAVED_PC(fi)",
1387 XSTRING (FRAME_SAVED_PC (fi
)));
1389 fprintf_unfiltered (file
,
1390 "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n",
1391 (long) current_gdbarch
->frame_saved_pc
1392 /*FRAME_SAVED_PC ()*/);
1394 #ifdef FUNCTION_START_OFFSET
1395 fprintf_unfiltered (file
,
1396 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1397 XSTRING (FUNCTION_START_OFFSET
));
1398 fprintf_unfiltered (file
,
1399 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1400 (long) FUNCTION_START_OFFSET
);
1402 #ifdef GET_LONGJMP_TARGET
1403 fprintf_unfiltered (file
,
1404 "gdbarch_dump: %s # %s\n",
1405 "GET_LONGJMP_TARGET(pc)",
1406 XSTRING (GET_LONGJMP_TARGET (pc
)));
1408 fprintf_unfiltered (file
,
1409 "gdbarch_dump: GET_LONGJMP_TARGET = 0x%08lx\n",
1410 (long) current_gdbarch
->get_longjmp_target
1411 /*GET_LONGJMP_TARGET ()*/);
1413 #ifdef GET_SAVED_REGISTER
1415 /* Macro might contain `[{}]' when not multi-arch */
1416 fprintf_unfiltered (file
,
1417 "gdbarch_dump: %s # %s\n",
1418 "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
1419 XSTRING (GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)));
1422 fprintf_unfiltered (file
,
1423 "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n",
1424 (long) current_gdbarch
->get_saved_register
1425 /*GET_SAVED_REGISTER ()*/);
1427 #ifdef HAVE_NONSTEPPABLE_WATCHPOINT
1428 fprintf_unfiltered (file
,
1429 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT # %s\n",
1430 XSTRING (HAVE_NONSTEPPABLE_WATCHPOINT
));
1431 fprintf_unfiltered (file
,
1432 "gdbarch_dump: HAVE_NONSTEPPABLE_WATCHPOINT = %d\n",
1433 HAVE_NONSTEPPABLE_WATCHPOINT
);
1435 #ifdef INIT_EXTRA_FRAME_INFO
1437 /* Macro might contain `[{}]' when not multi-arch */
1438 fprintf_unfiltered (file
,
1439 "gdbarch_dump: %s # %s\n",
1440 "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1441 XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf
, frame
)));
1444 fprintf_unfiltered (file
,
1445 "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
1446 (long) current_gdbarch
->init_extra_frame_info
1447 /*INIT_EXTRA_FRAME_INFO ()*/);
1449 #ifdef INIT_FRAME_PC
1451 /* Macro might contain `[{}]' when not multi-arch */
1452 fprintf_unfiltered (file
,
1453 "gdbarch_dump: %s # %s\n",
1454 "INIT_FRAME_PC(fromleaf, prev)",
1455 XSTRING (INIT_FRAME_PC (fromleaf
, prev
)));
1458 fprintf_unfiltered (file
,
1459 "gdbarch_dump: INIT_FRAME_PC = 0x%08lx\n",
1460 (long) current_gdbarch
->init_frame_pc
1461 /*INIT_FRAME_PC ()*/);
1463 #ifdef INIT_FRAME_PC_FIRST
1465 /* Macro might contain `[{}]' when not multi-arch */
1466 fprintf_unfiltered (file
,
1467 "gdbarch_dump: %s # %s\n",
1468 "INIT_FRAME_PC_FIRST(fromleaf, prev)",
1469 XSTRING (INIT_FRAME_PC_FIRST (fromleaf
, prev
)));
1472 fprintf_unfiltered (file
,
1473 "gdbarch_dump: INIT_FRAME_PC_FIRST = 0x%08lx\n",
1474 (long) current_gdbarch
->init_frame_pc_first
1475 /*INIT_FRAME_PC_FIRST ()*/);
1478 fprintf_unfiltered (file
,
1479 "gdbarch_dump: %s # %s\n",
1480 "INNER_THAN(lhs, rhs)",
1481 XSTRING (INNER_THAN (lhs
, rhs
)));
1483 fprintf_unfiltered (file
,
1484 "gdbarch_dump: INNER_THAN = 0x%08lx\n",
1485 (long) current_gdbarch
->inner_than
1488 #ifdef INTEGER_TO_ADDRESS
1489 fprintf_unfiltered (file
,
1490 "gdbarch_dump: %s # %s\n",
1491 "INTEGER_TO_ADDRESS(type, buf)",
1492 XSTRING (INTEGER_TO_ADDRESS (type
, buf
)));
1494 fprintf_unfiltered (file
,
1495 "gdbarch_dump: INTEGER_TO_ADDRESS = 0x%08lx\n",
1496 (long) current_gdbarch
->integer_to_address
1497 /*INTEGER_TO_ADDRESS ()*/);
1499 #ifdef IN_SOLIB_CALL_TRAMPOLINE
1500 fprintf_unfiltered (file
,
1501 "gdbarch_dump: %s # %s\n",
1502 "IN_SOLIB_CALL_TRAMPOLINE(pc, name)",
1503 XSTRING (IN_SOLIB_CALL_TRAMPOLINE (pc
, name
)));
1505 fprintf_unfiltered (file
,
1506 "gdbarch_dump: IN_SOLIB_CALL_TRAMPOLINE = 0x%08lx\n",
1507 (long) current_gdbarch
->in_solib_call_trampoline
1508 /*IN_SOLIB_CALL_TRAMPOLINE ()*/);
1510 #ifdef IN_SOLIB_RETURN_TRAMPOLINE
1511 fprintf_unfiltered (file
,
1512 "gdbarch_dump: %s # %s\n",
1513 "IN_SOLIB_RETURN_TRAMPOLINE(pc, name)",
1514 XSTRING (IN_SOLIB_RETURN_TRAMPOLINE (pc
, name
)));
1516 fprintf_unfiltered (file
,
1517 "gdbarch_dump: IN_SOLIB_RETURN_TRAMPOLINE = 0x%08lx\n",
1518 (long) current_gdbarch
->in_solib_return_trampoline
1519 /*IN_SOLIB_RETURN_TRAMPOLINE ()*/);
1521 #ifdef MAX_REGISTER_RAW_SIZE
1522 fprintf_unfiltered (file
,
1523 "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
1524 XSTRING (MAX_REGISTER_RAW_SIZE
));
1525 fprintf_unfiltered (file
,
1526 "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %d\n",
1527 MAX_REGISTER_RAW_SIZE
);
1529 #ifdef MAX_REGISTER_VIRTUAL_SIZE
1530 fprintf_unfiltered (file
,
1531 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
1532 XSTRING (MAX_REGISTER_VIRTUAL_SIZE
));
1533 fprintf_unfiltered (file
,
1534 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %d\n",
1535 MAX_REGISTER_VIRTUAL_SIZE
);
1537 #ifdef MEMORY_INSERT_BREAKPOINT
1538 fprintf_unfiltered (file
,
1539 "gdbarch_dump: %s # %s\n",
1540 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1541 XSTRING (MEMORY_INSERT_BREAKPOINT (addr
, contents_cache
)));
1543 fprintf_unfiltered (file
,
1544 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
1545 (long) current_gdbarch
->memory_insert_breakpoint
1546 /*MEMORY_INSERT_BREAKPOINT ()*/);
1548 #ifdef MEMORY_REMOVE_BREAKPOINT
1549 fprintf_unfiltered (file
,
1550 "gdbarch_dump: %s # %s\n",
1551 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1552 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr
, contents_cache
)));
1554 fprintf_unfiltered (file
,
1555 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
1556 (long) current_gdbarch
->memory_remove_breakpoint
1557 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1559 #ifdef NAME_OF_MALLOC
1560 fprintf_unfiltered (file
,
1561 "gdbarch_dump: NAME_OF_MALLOC # %s\n",
1562 XSTRING (NAME_OF_MALLOC
));
1563 fprintf_unfiltered (file
,
1564 "gdbarch_dump: NAME_OF_MALLOC = %ld\n",
1565 (long) NAME_OF_MALLOC
);
1568 fprintf_unfiltered (file
,
1569 "gdbarch_dump: NPC_REGNUM # %s\n",
1570 XSTRING (NPC_REGNUM
));
1571 fprintf_unfiltered (file
,
1572 "gdbarch_dump: NPC_REGNUM = %d\n",
1575 #ifdef NUM_PSEUDO_REGS
1576 fprintf_unfiltered (file
,
1577 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
1578 XSTRING (NUM_PSEUDO_REGS
));
1579 fprintf_unfiltered (file
,
1580 "gdbarch_dump: NUM_PSEUDO_REGS = %d\n",
1584 fprintf_unfiltered (file
,
1585 "gdbarch_dump: NUM_REGS # %s\n",
1586 XSTRING (NUM_REGS
));
1587 fprintf_unfiltered (file
,
1588 "gdbarch_dump: NUM_REGS = %d\n",
1591 #ifdef PARM_BOUNDARY
1592 fprintf_unfiltered (file
,
1593 "gdbarch_dump: PARM_BOUNDARY # %s\n",
1594 XSTRING (PARM_BOUNDARY
));
1595 fprintf_unfiltered (file
,
1596 "gdbarch_dump: PARM_BOUNDARY = %d\n",
1599 #ifdef PC_IN_CALL_DUMMY
1600 fprintf_unfiltered (file
,
1601 "gdbarch_dump: %s # %s\n",
1602 "PC_IN_CALL_DUMMY(pc, sp, frame_address)",
1603 XSTRING (PC_IN_CALL_DUMMY (pc
, sp
, frame_address
)));
1605 fprintf_unfiltered (file
,
1606 "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n",
1607 (long) current_gdbarch
->pc_in_call_dummy
1608 /*PC_IN_CALL_DUMMY ()*/);
1610 #ifdef PC_IN_SIGTRAMP
1611 fprintf_unfiltered (file
,
1612 "gdbarch_dump: %s # %s\n",
1613 "PC_IN_SIGTRAMP(pc, name)",
1614 XSTRING (PC_IN_SIGTRAMP (pc
, name
)));
1616 fprintf_unfiltered (file
,
1617 "gdbarch_dump: PC_IN_SIGTRAMP = 0x%08lx\n",
1618 (long) current_gdbarch
->pc_in_sigtramp
1619 /*PC_IN_SIGTRAMP ()*/);
1622 fprintf_unfiltered (file
,
1623 "gdbarch_dump: PC_REGNUM # %s\n",
1624 XSTRING (PC_REGNUM
));
1625 fprintf_unfiltered (file
,
1626 "gdbarch_dump: PC_REGNUM = %d\n",
1629 #ifdef POINTER_TO_ADDRESS
1630 fprintf_unfiltered (file
,
1631 "gdbarch_dump: %s # %s\n",
1632 "POINTER_TO_ADDRESS(type, buf)",
1633 XSTRING (POINTER_TO_ADDRESS (type
, buf
)));
1635 fprintf_unfiltered (file
,
1636 "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
1637 (long) current_gdbarch
->pointer_to_address
1638 /*POINTER_TO_ADDRESS ()*/);
1642 /* Macro might contain `[{}]' when not multi-arch */
1643 fprintf_unfiltered (file
,
1644 "gdbarch_dump: %s # %s\n",
1646 XSTRING (POP_FRAME (-)));
1649 fprintf_unfiltered (file
,
1650 "gdbarch_dump: POP_FRAME = 0x%08lx\n",
1651 (long) current_gdbarch
->pop_frame
1654 #ifdef PREPARE_TO_PROCEED
1655 fprintf_unfiltered (file
,
1656 "gdbarch_dump: %s # %s\n",
1657 "PREPARE_TO_PROCEED(select_it)",
1658 XSTRING (PREPARE_TO_PROCEED (select_it
)));
1660 fprintf_unfiltered (file
,
1661 "gdbarch_dump: PREPARE_TO_PROCEED = 0x%08lx\n",
1662 (long) current_gdbarch
->prepare_to_proceed
1663 /*PREPARE_TO_PROCEED ()*/);
1666 fprintf_unfiltered (file
,
1667 "gdbarch_dump: print_float_info = 0x%08lx\n",
1668 (long) current_gdbarch
->print_float_info
);
1670 fprintf_unfiltered (file
,
1671 "gdbarch_dump: print_registers_info = 0x%08lx\n",
1672 (long) current_gdbarch
->print_registers_info
);
1674 fprintf_unfiltered (file
,
1675 "gdbarch_dump: print_vector_info = 0x%08lx\n",
1676 (long) current_gdbarch
->print_vector_info
);
1677 #ifdef PROLOGUE_FRAMELESS_P
1678 fprintf_unfiltered (file
,
1679 "gdbarch_dump: %s # %s\n",
1680 "PROLOGUE_FRAMELESS_P(ip)",
1681 XSTRING (PROLOGUE_FRAMELESS_P (ip
)));
1683 fprintf_unfiltered (file
,
1684 "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
1685 (long) current_gdbarch
->prologue_frameless_p
1686 /*PROLOGUE_FRAMELESS_P ()*/);
1689 fprintf_unfiltered (file
,
1690 "gdbarch_dump: PS_REGNUM # %s\n",
1691 XSTRING (PS_REGNUM
));
1692 fprintf_unfiltered (file
,
1693 "gdbarch_dump: PS_REGNUM = %d\n",
1696 #ifdef PUSH_ARGUMENTS
1697 fprintf_unfiltered (file
,
1698 "gdbarch_dump: %s # %s\n",
1699 "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1700 XSTRING (PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
)));
1702 fprintf_unfiltered (file
,
1703 "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
1704 (long) current_gdbarch
->push_arguments
1705 /*PUSH_ARGUMENTS ()*/);
1707 #ifdef PUSH_DUMMY_FRAME
1709 /* Macro might contain `[{}]' when not multi-arch */
1710 fprintf_unfiltered (file
,
1711 "gdbarch_dump: %s # %s\n",
1712 "PUSH_DUMMY_FRAME(-)",
1713 XSTRING (PUSH_DUMMY_FRAME (-)));
1716 fprintf_unfiltered (file
,
1717 "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
1718 (long) current_gdbarch
->push_dummy_frame
1719 /*PUSH_DUMMY_FRAME ()*/);
1721 #ifdef PUSH_RETURN_ADDRESS
1722 fprintf_unfiltered (file
,
1723 "gdbarch_dump: %s # %s\n",
1724 "PUSH_RETURN_ADDRESS(pc, sp)",
1725 XSTRING (PUSH_RETURN_ADDRESS (pc
, sp
)));
1727 fprintf_unfiltered (file
,
1728 "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
1729 (long) current_gdbarch
->push_return_address
1730 /*PUSH_RETURN_ADDRESS ()*/);
1732 #ifdef REGISTER_BYTE
1733 fprintf_unfiltered (file
,
1734 "gdbarch_dump: %s # %s\n",
1735 "REGISTER_BYTE(reg_nr)",
1736 XSTRING (REGISTER_BYTE (reg_nr
)));
1738 fprintf_unfiltered (file
,
1739 "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
1740 (long) current_gdbarch
->register_byte
1741 /*REGISTER_BYTE ()*/);
1743 #ifdef REGISTER_BYTES
1744 fprintf_unfiltered (file
,
1745 "gdbarch_dump: REGISTER_BYTES # %s\n",
1746 XSTRING (REGISTER_BYTES
));
1747 fprintf_unfiltered (file
,
1748 "gdbarch_dump: REGISTER_BYTES = %d\n",
1751 #ifdef REGISTER_BYTES_OK
1752 fprintf_unfiltered (file
,
1753 "gdbarch_dump: %s # %s\n",
1754 "REGISTER_BYTES_OK(nr_bytes)",
1755 XSTRING (REGISTER_BYTES_OK (nr_bytes
)));
1757 fprintf_unfiltered (file
,
1758 "gdbarch_dump: REGISTER_BYTES_OK = 0x%08lx\n",
1759 (long) current_gdbarch
->register_bytes_ok
1760 /*REGISTER_BYTES_OK ()*/);
1762 #ifdef REGISTER_CONVERTIBLE
1763 fprintf_unfiltered (file
,
1764 "gdbarch_dump: %s # %s\n",
1765 "REGISTER_CONVERTIBLE(nr)",
1766 XSTRING (REGISTER_CONVERTIBLE (nr
)));
1768 fprintf_unfiltered (file
,
1769 "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
1770 (long) current_gdbarch
->register_convertible
1771 /*REGISTER_CONVERTIBLE ()*/);
1773 #ifdef REGISTER_CONVERT_TO_RAW
1775 /* Macro might contain `[{}]' when not multi-arch */
1776 fprintf_unfiltered (file
,
1777 "gdbarch_dump: %s # %s\n",
1778 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1779 XSTRING (REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
)));
1782 fprintf_unfiltered (file
,
1783 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
1784 (long) current_gdbarch
->register_convert_to_raw
1785 /*REGISTER_CONVERT_TO_RAW ()*/);
1787 #ifdef REGISTER_CONVERT_TO_VIRTUAL
1789 /* Macro might contain `[{}]' when not multi-arch */
1790 fprintf_unfiltered (file
,
1791 "gdbarch_dump: %s # %s\n",
1792 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1793 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
)));
1796 fprintf_unfiltered (file
,
1797 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
1798 (long) current_gdbarch
->register_convert_to_virtual
1799 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
1801 #ifdef REGISTER_NAME
1802 fprintf_unfiltered (file
,
1803 "gdbarch_dump: %s # %s\n",
1804 "REGISTER_NAME(regnr)",
1805 XSTRING (REGISTER_NAME (regnr
)));
1807 fprintf_unfiltered (file
,
1808 "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
1809 (long) current_gdbarch
->register_name
1810 /*REGISTER_NAME ()*/);
1812 #ifdef REGISTER_RAW_SIZE
1813 fprintf_unfiltered (file
,
1814 "gdbarch_dump: %s # %s\n",
1815 "REGISTER_RAW_SIZE(reg_nr)",
1816 XSTRING (REGISTER_RAW_SIZE (reg_nr
)));
1818 fprintf_unfiltered (file
,
1819 "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
1820 (long) current_gdbarch
->register_raw_size
1821 /*REGISTER_RAW_SIZE ()*/);
1823 #ifdef REGISTER_SIM_REGNO
1824 fprintf_unfiltered (file
,
1825 "gdbarch_dump: %s # %s\n",
1826 "REGISTER_SIM_REGNO(reg_nr)",
1827 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
1829 fprintf_unfiltered (file
,
1830 "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n",
1831 (long) current_gdbarch
->register_sim_regno
1832 /*REGISTER_SIM_REGNO ()*/);
1834 #ifdef REGISTER_SIZE
1835 fprintf_unfiltered (file
,
1836 "gdbarch_dump: REGISTER_SIZE # %s\n",
1837 XSTRING (REGISTER_SIZE
));
1838 fprintf_unfiltered (file
,
1839 "gdbarch_dump: REGISTER_SIZE = %d\n",
1842 #ifdef REGISTER_TO_VALUE
1844 /* Macro might contain `[{}]' when not multi-arch */
1845 fprintf_unfiltered (file
,
1846 "gdbarch_dump: %s # %s\n",
1847 "REGISTER_TO_VALUE(regnum, type, from, to)",
1848 XSTRING (REGISTER_TO_VALUE (regnum
, type
, from
, to
)));
1851 fprintf_unfiltered (file
,
1852 "gdbarch_dump: REGISTER_TO_VALUE = 0x%08lx\n",
1853 (long) current_gdbarch
->register_to_value
1854 /*REGISTER_TO_VALUE ()*/);
1856 #ifdef REGISTER_VIRTUAL_SIZE
1857 fprintf_unfiltered (file
,
1858 "gdbarch_dump: %s # %s\n",
1859 "REGISTER_VIRTUAL_SIZE(reg_nr)",
1860 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr
)));
1862 fprintf_unfiltered (file
,
1863 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
1864 (long) current_gdbarch
->register_virtual_size
1865 /*REGISTER_VIRTUAL_SIZE ()*/);
1867 #ifdef REGISTER_VIRTUAL_TYPE
1868 fprintf_unfiltered (file
,
1869 "gdbarch_dump: %s # %s\n",
1870 "REGISTER_VIRTUAL_TYPE(reg_nr)",
1871 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr
)));
1873 fprintf_unfiltered (file
,
1874 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
1875 (long) current_gdbarch
->register_virtual_type
1876 /*REGISTER_VIRTUAL_TYPE ()*/);
1878 #ifdef REG_STRUCT_HAS_ADDR
1879 fprintf_unfiltered (file
,
1880 "gdbarch_dump: %s # %s\n",
1881 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
1882 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
1884 fprintf_unfiltered (file
,
1885 "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
1886 (long) current_gdbarch
->reg_struct_has_addr
1887 /*REG_STRUCT_HAS_ADDR ()*/);
1889 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
1891 /* Macro might contain `[{}]' when not multi-arch */
1892 fprintf_unfiltered (file
,
1893 "gdbarch_dump: %s # %s\n",
1894 "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
1895 XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr
, gdb_len
, rem_addr
, rem_len
)));
1898 fprintf_unfiltered (file
,
1899 "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
1900 (long) current_gdbarch
->remote_translate_xfer_address
1901 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
1903 #ifdef RETURN_VALUE_ON_STACK
1904 fprintf_unfiltered (file
,
1905 "gdbarch_dump: %s # %s\n",
1906 "RETURN_VALUE_ON_STACK(type)",
1907 XSTRING (RETURN_VALUE_ON_STACK (type
)));
1909 fprintf_unfiltered (file
,
1910 "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
1911 (long) current_gdbarch
->return_value_on_stack
1912 /*RETURN_VALUE_ON_STACK ()*/);
1914 #ifdef SAVED_PC_AFTER_CALL
1915 fprintf_unfiltered (file
,
1916 "gdbarch_dump: %s # %s\n",
1917 "SAVED_PC_AFTER_CALL(frame)",
1918 XSTRING (SAVED_PC_AFTER_CALL (frame
)));
1920 fprintf_unfiltered (file
,
1921 "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
1922 (long) current_gdbarch
->saved_pc_after_call
1923 /*SAVED_PC_AFTER_CALL ()*/);
1925 #ifdef SAVE_DUMMY_FRAME_TOS
1927 /* Macro might contain `[{}]' when not multi-arch */
1928 fprintf_unfiltered (file
,
1929 "gdbarch_dump: %s # %s\n",
1930 "SAVE_DUMMY_FRAME_TOS(sp)",
1931 XSTRING (SAVE_DUMMY_FRAME_TOS (sp
)));
1934 fprintf_unfiltered (file
,
1935 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
1936 (long) current_gdbarch
->save_dummy_frame_tos
1937 /*SAVE_DUMMY_FRAME_TOS ()*/);
1939 #ifdef SDB_REG_TO_REGNUM
1940 fprintf_unfiltered (file
,
1941 "gdbarch_dump: %s # %s\n",
1942 "SDB_REG_TO_REGNUM(sdb_regnr)",
1943 XSTRING (SDB_REG_TO_REGNUM (sdb_regnr
)));
1945 fprintf_unfiltered (file
,
1946 "gdbarch_dump: SDB_REG_TO_REGNUM = 0x%08lx\n",
1947 (long) current_gdbarch
->sdb_reg_to_regnum
1948 /*SDB_REG_TO_REGNUM ()*/);
1951 fprintf_unfiltered (file
,
1952 "gdbarch_dump: %s # %s\n",
1954 XSTRING (SIGTRAMP_END (pc
)));
1956 fprintf_unfiltered (file
,
1957 "gdbarch_dump: SIGTRAMP_END = 0x%08lx\n",
1958 (long) current_gdbarch
->sigtramp_end
1959 /*SIGTRAMP_END ()*/);
1961 #ifdef SIGTRAMP_START
1962 fprintf_unfiltered (file
,
1963 "gdbarch_dump: %s # %s\n",
1964 "SIGTRAMP_START(pc)",
1965 XSTRING (SIGTRAMP_START (pc
)));
1967 fprintf_unfiltered (file
,
1968 "gdbarch_dump: SIGTRAMP_START = 0x%08lx\n",
1969 (long) current_gdbarch
->sigtramp_start
1970 /*SIGTRAMP_START ()*/);
1972 #ifdef SIZEOF_CALL_DUMMY_WORDS
1973 fprintf_unfiltered (file
,
1974 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
1975 XSTRING (SIZEOF_CALL_DUMMY_WORDS
));
1976 fprintf_unfiltered (file
,
1977 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
1978 (long) SIZEOF_CALL_DUMMY_WORDS
);
1980 #ifdef SKIP_PROLOGUE
1981 fprintf_unfiltered (file
,
1982 "gdbarch_dump: %s # %s\n",
1983 "SKIP_PROLOGUE(ip)",
1984 XSTRING (SKIP_PROLOGUE (ip
)));
1986 fprintf_unfiltered (file
,
1987 "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
1988 (long) current_gdbarch
->skip_prologue
1989 /*SKIP_PROLOGUE ()*/);
1991 #ifdef SKIP_TRAMPOLINE_CODE
1992 fprintf_unfiltered (file
,
1993 "gdbarch_dump: %s # %s\n",
1994 "SKIP_TRAMPOLINE_CODE(pc)",
1995 XSTRING (SKIP_TRAMPOLINE_CODE (pc
)));
1997 fprintf_unfiltered (file
,
1998 "gdbarch_dump: SKIP_TRAMPOLINE_CODE = 0x%08lx\n",
1999 (long) current_gdbarch
->skip_trampoline_code
2000 /*SKIP_TRAMPOLINE_CODE ()*/);
2002 #ifdef SMASH_TEXT_ADDRESS
2003 fprintf_unfiltered (file
,
2004 "gdbarch_dump: %s # %s\n",
2005 "SMASH_TEXT_ADDRESS(addr)",
2006 XSTRING (SMASH_TEXT_ADDRESS (addr
)));
2008 fprintf_unfiltered (file
,
2009 "gdbarch_dump: SMASH_TEXT_ADDRESS = 0x%08lx\n",
2010 (long) current_gdbarch
->smash_text_address
2011 /*SMASH_TEXT_ADDRESS ()*/);
2013 #ifdef SOFTWARE_SINGLE_STEP
2015 /* Macro might contain `[{}]' when not multi-arch */
2016 fprintf_unfiltered (file
,
2017 "gdbarch_dump: %s # %s\n",
2018 "SOFTWARE_SINGLE_STEP(sig, insert_breakpoints_p)",
2019 XSTRING (SOFTWARE_SINGLE_STEP (sig
, insert_breakpoints_p
)));
2022 fprintf_unfiltered (file
,
2023 "gdbarch_dump: SOFTWARE_SINGLE_STEP = 0x%08lx\n",
2024 (long) current_gdbarch
->software_single_step
2025 /*SOFTWARE_SINGLE_STEP ()*/);
2028 fprintf_unfiltered (file
,
2029 "gdbarch_dump: SP_REGNUM # %s\n",
2030 XSTRING (SP_REGNUM
));
2031 fprintf_unfiltered (file
,
2032 "gdbarch_dump: SP_REGNUM = %d\n",
2035 #ifdef STAB_REG_TO_REGNUM
2036 fprintf_unfiltered (file
,
2037 "gdbarch_dump: %s # %s\n",
2038 "STAB_REG_TO_REGNUM(stab_regnr)",
2039 XSTRING (STAB_REG_TO_REGNUM (stab_regnr
)));
2041 fprintf_unfiltered (file
,
2042 "gdbarch_dump: STAB_REG_TO_REGNUM = 0x%08lx\n",
2043 (long) current_gdbarch
->stab_reg_to_regnum
2044 /*STAB_REG_TO_REGNUM ()*/);
2047 fprintf_unfiltered (file
,
2048 "gdbarch_dump: %s # %s\n",
2050 XSTRING (STACK_ALIGN (sp
)));
2052 fprintf_unfiltered (file
,
2053 "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
2054 (long) current_gdbarch
->stack_align
2055 /*STACK_ALIGN ()*/);
2057 #ifdef STORE_RETURN_VALUE
2059 /* Macro might contain `[{}]' when not multi-arch */
2060 fprintf_unfiltered (file
,
2061 "gdbarch_dump: %s # %s\n",
2062 "STORE_RETURN_VALUE(type, regcache, valbuf)",
2063 XSTRING (STORE_RETURN_VALUE (type
, regcache
, valbuf
)));
2066 fprintf_unfiltered (file
,
2067 "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
2068 (long) current_gdbarch
->store_return_value
2069 /*STORE_RETURN_VALUE ()*/);
2071 #ifdef STORE_STRUCT_RETURN
2073 /* Macro might contain `[{}]' when not multi-arch */
2074 fprintf_unfiltered (file
,
2075 "gdbarch_dump: %s # %s\n",
2076 "STORE_STRUCT_RETURN(addr, sp)",
2077 XSTRING (STORE_STRUCT_RETURN (addr
, sp
)));
2080 fprintf_unfiltered (file
,
2081 "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
2082 (long) current_gdbarch
->store_struct_return
2083 /*STORE_STRUCT_RETURN ()*/);
2085 #ifdef TARGET_ADDR_BIT
2086 fprintf_unfiltered (file
,
2087 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
2088 XSTRING (TARGET_ADDR_BIT
));
2089 fprintf_unfiltered (file
,
2090 "gdbarch_dump: TARGET_ADDR_BIT = %d\n",
2093 #ifdef TARGET_ARCHITECTURE
2094 fprintf_unfiltered (file
,
2095 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
2096 XSTRING (TARGET_ARCHITECTURE
));
2097 if (TARGET_ARCHITECTURE
!= NULL
)
2098 fprintf_unfiltered (file
,
2099 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
2100 TARGET_ARCHITECTURE
->printable_name
);
2102 #ifdef TARGET_BFD_VMA_BIT
2103 fprintf_unfiltered (file
,
2104 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
2105 XSTRING (TARGET_BFD_VMA_BIT
));
2106 fprintf_unfiltered (file
,
2107 "gdbarch_dump: TARGET_BFD_VMA_BIT = %d\n",
2108 TARGET_BFD_VMA_BIT
);
2110 #ifdef TARGET_BYTE_ORDER
2111 fprintf_unfiltered (file
,
2112 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
2113 XSTRING (TARGET_BYTE_ORDER
));
2114 fprintf_unfiltered (file
,
2115 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
2116 (long) TARGET_BYTE_ORDER
);
2118 #ifdef TARGET_CHAR_SIGNED
2119 fprintf_unfiltered (file
,
2120 "gdbarch_dump: TARGET_CHAR_SIGNED # %s\n",
2121 XSTRING (TARGET_CHAR_SIGNED
));
2122 fprintf_unfiltered (file
,
2123 "gdbarch_dump: TARGET_CHAR_SIGNED = %d\n",
2124 TARGET_CHAR_SIGNED
);
2126 #ifdef TARGET_DOUBLE_BIT
2127 fprintf_unfiltered (file
,
2128 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
2129 XSTRING (TARGET_DOUBLE_BIT
));
2130 fprintf_unfiltered (file
,
2131 "gdbarch_dump: TARGET_DOUBLE_BIT = %d\n",
2134 #ifdef TARGET_DOUBLE_FORMAT
2135 fprintf_unfiltered (file
,
2136 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
2137 XSTRING (TARGET_DOUBLE_FORMAT
));
2138 fprintf_unfiltered (file
,
2139 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %s\n",
2140 gdbarch
->float_format
->name
);
2142 #ifdef TARGET_FLOAT_BIT
2143 fprintf_unfiltered (file
,
2144 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
2145 XSTRING (TARGET_FLOAT_BIT
));
2146 fprintf_unfiltered (file
,
2147 "gdbarch_dump: TARGET_FLOAT_BIT = %d\n",
2150 #ifdef TARGET_FLOAT_FORMAT
2151 fprintf_unfiltered (file
,
2152 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
2153 XSTRING (TARGET_FLOAT_FORMAT
));
2154 fprintf_unfiltered (file
,
2155 "gdbarch_dump: TARGET_FLOAT_FORMAT = %s\n",
2156 gdbarch
->float_format
->name
);
2158 #ifdef TARGET_INT_BIT
2159 fprintf_unfiltered (file
,
2160 "gdbarch_dump: TARGET_INT_BIT # %s\n",
2161 XSTRING (TARGET_INT_BIT
));
2162 fprintf_unfiltered (file
,
2163 "gdbarch_dump: TARGET_INT_BIT = %d\n",
2166 #ifdef TARGET_LONG_BIT
2167 fprintf_unfiltered (file
,
2168 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
2169 XSTRING (TARGET_LONG_BIT
));
2170 fprintf_unfiltered (file
,
2171 "gdbarch_dump: TARGET_LONG_BIT = %d\n",
2174 #ifdef TARGET_LONG_DOUBLE_BIT
2175 fprintf_unfiltered (file
,
2176 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
2177 XSTRING (TARGET_LONG_DOUBLE_BIT
));
2178 fprintf_unfiltered (file
,
2179 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %d\n",
2180 TARGET_LONG_DOUBLE_BIT
);
2182 #ifdef TARGET_LONG_DOUBLE_FORMAT
2183 fprintf_unfiltered (file
,
2184 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
2185 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
2186 fprintf_unfiltered (file
,
2187 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %s\n",
2188 gdbarch
->float_format
->name
);
2190 #ifdef TARGET_LONG_LONG_BIT
2191 fprintf_unfiltered (file
,
2192 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
2193 XSTRING (TARGET_LONG_LONG_BIT
));
2194 fprintf_unfiltered (file
,
2195 "gdbarch_dump: TARGET_LONG_LONG_BIT = %d\n",
2196 TARGET_LONG_LONG_BIT
);
2198 #ifdef TARGET_PRINT_INSN
2199 fprintf_unfiltered (file
,
2200 "gdbarch_dump: %s # %s\n",
2201 "TARGET_PRINT_INSN(vma, info)",
2202 XSTRING (TARGET_PRINT_INSN (vma
, info
)));
2204 fprintf_unfiltered (file
,
2205 "gdbarch_dump: TARGET_PRINT_INSN = 0x%08lx\n",
2206 (long) current_gdbarch
->print_insn
2207 /*TARGET_PRINT_INSN ()*/);
2209 #ifdef TARGET_PTR_BIT
2210 fprintf_unfiltered (file
,
2211 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
2212 XSTRING (TARGET_PTR_BIT
));
2213 fprintf_unfiltered (file
,
2214 "gdbarch_dump: TARGET_PTR_BIT = %d\n",
2217 #ifdef TARGET_READ_FP
2218 fprintf_unfiltered (file
,
2219 "gdbarch_dump: %s # %s\n",
2221 XSTRING (TARGET_READ_FP ()));
2223 fprintf_unfiltered (file
,
2224 "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n",
2225 (long) current_gdbarch
->read_fp
2226 /*TARGET_READ_FP ()*/);
2228 #ifdef TARGET_READ_PC
2229 fprintf_unfiltered (file
,
2230 "gdbarch_dump: %s # %s\n",
2231 "TARGET_READ_PC(ptid)",
2232 XSTRING (TARGET_READ_PC (ptid
)));
2234 fprintf_unfiltered (file
,
2235 "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
2236 (long) current_gdbarch
->read_pc
2237 /*TARGET_READ_PC ()*/);
2239 #ifdef TARGET_READ_SP
2240 fprintf_unfiltered (file
,
2241 "gdbarch_dump: %s # %s\n",
2243 XSTRING (TARGET_READ_SP ()));
2245 fprintf_unfiltered (file
,
2246 "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
2247 (long) current_gdbarch
->read_sp
2248 /*TARGET_READ_SP ()*/);
2250 #ifdef TARGET_SHORT_BIT
2251 fprintf_unfiltered (file
,
2252 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
2253 XSTRING (TARGET_SHORT_BIT
));
2254 fprintf_unfiltered (file
,
2255 "gdbarch_dump: TARGET_SHORT_BIT = %d\n",
2258 #ifdef TARGET_VIRTUAL_FRAME_POINTER
2260 /* Macro might contain `[{}]' when not multi-arch */
2261 fprintf_unfiltered (file
,
2262 "gdbarch_dump: %s # %s\n",
2263 "TARGET_VIRTUAL_FRAME_POINTER(pc, frame_regnum, frame_offset)",
2264 XSTRING (TARGET_VIRTUAL_FRAME_POINTER (pc
, frame_regnum
, frame_offset
)));
2267 fprintf_unfiltered (file
,
2268 "gdbarch_dump: TARGET_VIRTUAL_FRAME_POINTER = 0x%08lx\n",
2269 (long) current_gdbarch
->virtual_frame_pointer
2270 /*TARGET_VIRTUAL_FRAME_POINTER ()*/);
2272 #ifdef TARGET_WRITE_PC
2274 /* Macro might contain `[{}]' when not multi-arch */
2275 fprintf_unfiltered (file
,
2276 "gdbarch_dump: %s # %s\n",
2277 "TARGET_WRITE_PC(val, ptid)",
2278 XSTRING (TARGET_WRITE_PC (val
, ptid
)));
2281 fprintf_unfiltered (file
,
2282 "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
2283 (long) current_gdbarch
->write_pc
2284 /*TARGET_WRITE_PC ()*/);
2286 #ifdef TARGET_WRITE_SP
2288 /* Macro might contain `[{}]' when not multi-arch */
2289 fprintf_unfiltered (file
,
2290 "gdbarch_dump: %s # %s\n",
2291 "TARGET_WRITE_SP(val)",
2292 XSTRING (TARGET_WRITE_SP (val
)));
2295 fprintf_unfiltered (file
,
2296 "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
2297 (long) current_gdbarch
->write_sp
2298 /*TARGET_WRITE_SP ()*/);
2300 #ifdef USE_STRUCT_CONVENTION
2301 fprintf_unfiltered (file
,
2302 "gdbarch_dump: %s # %s\n",
2303 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
2304 XSTRING (USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
2306 fprintf_unfiltered (file
,
2307 "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
2308 (long) current_gdbarch
->use_struct_convention
2309 /*USE_STRUCT_CONVENTION ()*/);
2311 #ifdef VALUE_TO_REGISTER
2313 /* Macro might contain `[{}]' when not multi-arch */
2314 fprintf_unfiltered (file
,
2315 "gdbarch_dump: %s # %s\n",
2316 "VALUE_TO_REGISTER(type, regnum, from, to)",
2317 XSTRING (VALUE_TO_REGISTER (type
, regnum
, from
, to
)));
2320 fprintf_unfiltered (file
,
2321 "gdbarch_dump: VALUE_TO_REGISTER = 0x%08lx\n",
2322 (long) current_gdbarch
->value_to_register
2323 /*VALUE_TO_REGISTER ()*/);
2325 if (current_gdbarch
->dump_tdep
!= NULL
)
2326 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
2329 struct gdbarch_tdep
*
2330 gdbarch_tdep (struct gdbarch
*gdbarch
)
2332 if (gdbarch_debug
>= 2)
2333 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
2334 return gdbarch
->tdep
;
2338 const struct bfd_arch_info
*
2339 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
2341 gdb_assert (gdbarch
!= NULL
);
2342 if (gdbarch_debug
>= 2)
2343 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
2344 return gdbarch
->bfd_arch_info
;
2348 gdbarch_byte_order (struct gdbarch
*gdbarch
)
2350 gdb_assert (gdbarch
!= NULL
);
2351 if (gdbarch_debug
>= 2)
2352 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
2353 return gdbarch
->byte_order
;
2357 gdbarch_short_bit (struct gdbarch
*gdbarch
)
2359 gdb_assert (gdbarch
!= NULL
);
2360 /* Skip verify of short_bit, invalid_p == 0 */
2361 if (gdbarch_debug
>= 2)
2362 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
2363 return gdbarch
->short_bit
;
2367 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
2370 gdbarch
->short_bit
= short_bit
;
2374 gdbarch_int_bit (struct gdbarch
*gdbarch
)
2376 gdb_assert (gdbarch
!= NULL
);
2377 /* Skip verify of int_bit, invalid_p == 0 */
2378 if (gdbarch_debug
>= 2)
2379 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
2380 return gdbarch
->int_bit
;
2384 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
2387 gdbarch
->int_bit
= int_bit
;
2391 gdbarch_long_bit (struct gdbarch
*gdbarch
)
2393 gdb_assert (gdbarch
!= NULL
);
2394 /* Skip verify of long_bit, invalid_p == 0 */
2395 if (gdbarch_debug
>= 2)
2396 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
2397 return gdbarch
->long_bit
;
2401 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
2404 gdbarch
->long_bit
= long_bit
;
2408 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
2410 gdb_assert (gdbarch
!= NULL
);
2411 /* Skip verify of long_long_bit, invalid_p == 0 */
2412 if (gdbarch_debug
>= 2)
2413 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
2414 return gdbarch
->long_long_bit
;
2418 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
2421 gdbarch
->long_long_bit
= long_long_bit
;
2425 gdbarch_float_bit (struct gdbarch
*gdbarch
)
2427 gdb_assert (gdbarch
!= NULL
);
2428 /* Skip verify of float_bit, invalid_p == 0 */
2429 if (gdbarch_debug
>= 2)
2430 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
2431 return gdbarch
->float_bit
;
2435 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
2438 gdbarch
->float_bit
= float_bit
;
2442 gdbarch_double_bit (struct gdbarch
*gdbarch
)
2444 gdb_assert (gdbarch
!= NULL
);
2445 /* Skip verify of double_bit, invalid_p == 0 */
2446 if (gdbarch_debug
>= 2)
2447 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
2448 return gdbarch
->double_bit
;
2452 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
2455 gdbarch
->double_bit
= double_bit
;
2459 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
2461 gdb_assert (gdbarch
!= NULL
);
2462 /* Skip verify of long_double_bit, invalid_p == 0 */
2463 if (gdbarch_debug
>= 2)
2464 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
2465 return gdbarch
->long_double_bit
;
2469 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
2470 int long_double_bit
)
2472 gdbarch
->long_double_bit
= long_double_bit
;
2476 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
2478 gdb_assert (gdbarch
!= NULL
);
2479 /* Skip verify of ptr_bit, invalid_p == 0 */
2480 if (gdbarch_debug
>= 2)
2481 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
2482 return gdbarch
->ptr_bit
;
2486 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
2489 gdbarch
->ptr_bit
= ptr_bit
;
2493 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
2495 gdb_assert (gdbarch
!= NULL
);
2496 if (gdbarch
->addr_bit
== 0)
2497 internal_error (__FILE__
, __LINE__
,
2498 "gdbarch: gdbarch_addr_bit invalid");
2499 if (gdbarch_debug
>= 2)
2500 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
2501 return gdbarch
->addr_bit
;
2505 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
2508 gdbarch
->addr_bit
= addr_bit
;
2512 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
2514 gdb_assert (gdbarch
!= NULL
);
2515 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2516 if (gdbarch_debug
>= 2)
2517 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
2518 return gdbarch
->bfd_vma_bit
;
2522 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
2525 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
2529 gdbarch_char_signed (struct gdbarch
*gdbarch
)
2531 gdb_assert (gdbarch
!= NULL
);
2532 if (gdbarch
->char_signed
== -1)
2533 internal_error (__FILE__
, __LINE__
,
2534 "gdbarch: gdbarch_char_signed invalid");
2535 if (gdbarch_debug
>= 2)
2536 fprintf_unfiltered (gdb_stdlog
, "gdbarch_char_signed called\n");
2537 return gdbarch
->char_signed
;
2541 set_gdbarch_char_signed (struct gdbarch
*gdbarch
,
2544 gdbarch
->char_signed
= char_signed
;
2548 gdbarch_read_pc (struct gdbarch
*gdbarch
, ptid_t ptid
)
2550 gdb_assert (gdbarch
!= NULL
);
2551 if (gdbarch
->read_pc
== 0)
2552 internal_error (__FILE__
, __LINE__
,
2553 "gdbarch: gdbarch_read_pc invalid");
2554 if (gdbarch_debug
>= 2)
2555 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
2556 return gdbarch
->read_pc (ptid
);
2560 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
2561 gdbarch_read_pc_ftype read_pc
)
2563 gdbarch
->read_pc
= read_pc
;
2567 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, ptid_t ptid
)
2569 gdb_assert (gdbarch
!= NULL
);
2570 if (gdbarch
->write_pc
== 0)
2571 internal_error (__FILE__
, __LINE__
,
2572 "gdbarch: gdbarch_write_pc invalid");
2573 if (gdbarch_debug
>= 2)
2574 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
2575 gdbarch
->write_pc (val
, ptid
);
2579 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
2580 gdbarch_write_pc_ftype write_pc
)
2582 gdbarch
->write_pc
= write_pc
;
2586 gdbarch_read_fp (struct gdbarch
*gdbarch
)
2588 gdb_assert (gdbarch
!= NULL
);
2589 if (gdbarch
->read_fp
== 0)
2590 internal_error (__FILE__
, __LINE__
,
2591 "gdbarch: gdbarch_read_fp invalid");
2592 if (gdbarch_debug
>= 2)
2593 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_fp called\n");
2594 return gdbarch
->read_fp ();
2598 set_gdbarch_read_fp (struct gdbarch
*gdbarch
,
2599 gdbarch_read_fp_ftype read_fp
)
2601 gdbarch
->read_fp
= read_fp
;
2605 gdbarch_read_sp (struct gdbarch
*gdbarch
)
2607 gdb_assert (gdbarch
!= NULL
);
2608 if (gdbarch
->read_sp
== 0)
2609 internal_error (__FILE__
, __LINE__
,
2610 "gdbarch: gdbarch_read_sp invalid");
2611 if (gdbarch_debug
>= 2)
2612 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_sp called\n");
2613 return gdbarch
->read_sp ();
2617 set_gdbarch_read_sp (struct gdbarch
*gdbarch
,
2618 gdbarch_read_sp_ftype read_sp
)
2620 gdbarch
->read_sp
= read_sp
;
2624 gdbarch_write_sp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2626 gdb_assert (gdbarch
!= NULL
);
2627 if (gdbarch
->write_sp
== 0)
2628 internal_error (__FILE__
, __LINE__
,
2629 "gdbarch: gdbarch_write_sp invalid");
2630 if (gdbarch_debug
>= 2)
2631 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_sp called\n");
2632 gdbarch
->write_sp (val
);
2636 set_gdbarch_write_sp (struct gdbarch
*gdbarch
,
2637 gdbarch_write_sp_ftype write_sp
)
2639 gdbarch
->write_sp
= write_sp
;
2643 gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
, CORE_ADDR pc
, int *frame_regnum
, LONGEST
*frame_offset
)
2645 gdb_assert (gdbarch
!= NULL
);
2646 if (gdbarch
->virtual_frame_pointer
== 0)
2647 internal_error (__FILE__
, __LINE__
,
2648 "gdbarch: gdbarch_virtual_frame_pointer invalid");
2649 if (gdbarch_debug
>= 2)
2650 fprintf_unfiltered (gdb_stdlog
, "gdbarch_virtual_frame_pointer called\n");
2651 gdbarch
->virtual_frame_pointer (pc
, frame_regnum
, frame_offset
);
2655 set_gdbarch_virtual_frame_pointer (struct gdbarch
*gdbarch
,
2656 gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer
)
2658 gdbarch
->virtual_frame_pointer
= virtual_frame_pointer
;
2662 gdbarch_pseudo_register_read_p (struct gdbarch
*gdbarch
)
2664 gdb_assert (gdbarch
!= NULL
);
2665 return gdbarch
->pseudo_register_read
!= 0;
2669 gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, void *buf
)
2671 gdb_assert (gdbarch
!= NULL
);
2672 if (gdbarch
->pseudo_register_read
== 0)
2673 internal_error (__FILE__
, __LINE__
,
2674 "gdbarch: gdbarch_pseudo_register_read invalid");
2675 if (gdbarch_debug
>= 2)
2676 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_read called\n");
2677 gdbarch
->pseudo_register_read (gdbarch
, regcache
, cookednum
, buf
);
2681 set_gdbarch_pseudo_register_read (struct gdbarch
*gdbarch
,
2682 gdbarch_pseudo_register_read_ftype pseudo_register_read
)
2684 gdbarch
->pseudo_register_read
= pseudo_register_read
;
2688 gdbarch_pseudo_register_write_p (struct gdbarch
*gdbarch
)
2690 gdb_assert (gdbarch
!= NULL
);
2691 return gdbarch
->pseudo_register_write
!= 0;
2695 gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
, int cookednum
, const void *buf
)
2697 gdb_assert (gdbarch
!= NULL
);
2698 if (gdbarch
->pseudo_register_write
== 0)
2699 internal_error (__FILE__
, __LINE__
,
2700 "gdbarch: gdbarch_pseudo_register_write invalid");
2701 if (gdbarch_debug
>= 2)
2702 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pseudo_register_write called\n");
2703 gdbarch
->pseudo_register_write (gdbarch
, regcache
, cookednum
, buf
);
2707 set_gdbarch_pseudo_register_write (struct gdbarch
*gdbarch
,
2708 gdbarch_pseudo_register_write_ftype pseudo_register_write
)
2710 gdbarch
->pseudo_register_write
= pseudo_register_write
;
2714 gdbarch_num_regs (struct gdbarch
*gdbarch
)
2716 gdb_assert (gdbarch
!= NULL
);
2717 if (gdbarch
->num_regs
== -1)
2718 internal_error (__FILE__
, __LINE__
,
2719 "gdbarch: gdbarch_num_regs invalid");
2720 if (gdbarch_debug
>= 2)
2721 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
2722 return gdbarch
->num_regs
;
2726 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
2729 gdbarch
->num_regs
= num_regs
;
2733 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
2735 gdb_assert (gdbarch
!= NULL
);
2736 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2737 if (gdbarch_debug
>= 2)
2738 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
2739 return gdbarch
->num_pseudo_regs
;
2743 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
2744 int num_pseudo_regs
)
2746 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
2750 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
2752 gdb_assert (gdbarch
!= NULL
);
2753 /* Skip verify of sp_regnum, invalid_p == 0 */
2754 if (gdbarch_debug
>= 2)
2755 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
2756 return gdbarch
->sp_regnum
;
2760 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
2763 gdbarch
->sp_regnum
= sp_regnum
;
2767 gdbarch_fp_regnum (struct gdbarch
*gdbarch
)
2769 gdb_assert (gdbarch
!= NULL
);
2770 /* Skip verify of fp_regnum, invalid_p == 0 */
2771 if (gdbarch_debug
>= 2)
2772 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp_regnum called\n");
2773 return gdbarch
->fp_regnum
;
2777 set_gdbarch_fp_regnum (struct gdbarch
*gdbarch
,
2780 gdbarch
->fp_regnum
= fp_regnum
;
2784 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
2786 gdb_assert (gdbarch
!= NULL
);
2787 /* Skip verify of pc_regnum, invalid_p == 0 */
2788 if (gdbarch_debug
>= 2)
2789 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
2790 return gdbarch
->pc_regnum
;
2794 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
2797 gdbarch
->pc_regnum
= pc_regnum
;
2801 gdbarch_ps_regnum (struct gdbarch
*gdbarch
)
2803 gdb_assert (gdbarch
!= NULL
);
2804 /* Skip verify of ps_regnum, invalid_p == 0 */
2805 if (gdbarch_debug
>= 2)
2806 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ps_regnum called\n");
2807 return gdbarch
->ps_regnum
;
2811 set_gdbarch_ps_regnum (struct gdbarch
*gdbarch
,
2814 gdbarch
->ps_regnum
= ps_regnum
;
2818 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
2820 gdb_assert (gdbarch
!= NULL
);
2821 /* Skip verify of fp0_regnum, invalid_p == 0 */
2822 if (gdbarch_debug
>= 2)
2823 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
2824 return gdbarch
->fp0_regnum
;
2828 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
2831 gdbarch
->fp0_regnum
= fp0_regnum
;
2835 gdbarch_npc_regnum (struct gdbarch
*gdbarch
)
2837 gdb_assert (gdbarch
!= NULL
);
2838 /* Skip verify of npc_regnum, invalid_p == 0 */
2839 if (gdbarch_debug
>= 2)
2840 fprintf_unfiltered (gdb_stdlog
, "gdbarch_npc_regnum called\n");
2841 return gdbarch
->npc_regnum
;
2845 set_gdbarch_npc_regnum (struct gdbarch
*gdbarch
,
2848 gdbarch
->npc_regnum
= npc_regnum
;
2852 gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
, int stab_regnr
)
2854 gdb_assert (gdbarch
!= NULL
);
2855 if (gdbarch
->stab_reg_to_regnum
== 0)
2856 internal_error (__FILE__
, __LINE__
,
2857 "gdbarch: gdbarch_stab_reg_to_regnum invalid");
2858 if (gdbarch_debug
>= 2)
2859 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stab_reg_to_regnum called\n");
2860 return gdbarch
->stab_reg_to_regnum (stab_regnr
);
2864 set_gdbarch_stab_reg_to_regnum (struct gdbarch
*gdbarch
,
2865 gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum
)
2867 gdbarch
->stab_reg_to_regnum
= stab_reg_to_regnum
;
2871 gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
, int ecoff_regnr
)
2873 gdb_assert (gdbarch
!= NULL
);
2874 if (gdbarch
->ecoff_reg_to_regnum
== 0)
2875 internal_error (__FILE__
, __LINE__
,
2876 "gdbarch: gdbarch_ecoff_reg_to_regnum invalid");
2877 if (gdbarch_debug
>= 2)
2878 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ecoff_reg_to_regnum called\n");
2879 return gdbarch
->ecoff_reg_to_regnum (ecoff_regnr
);
2883 set_gdbarch_ecoff_reg_to_regnum (struct gdbarch
*gdbarch
,
2884 gdbarch_ecoff_reg_to_regnum_ftype ecoff_reg_to_regnum
)
2886 gdbarch
->ecoff_reg_to_regnum
= ecoff_reg_to_regnum
;
2890 gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf_regnr
)
2892 gdb_assert (gdbarch
!= NULL
);
2893 if (gdbarch
->dwarf_reg_to_regnum
== 0)
2894 internal_error (__FILE__
, __LINE__
,
2895 "gdbarch: gdbarch_dwarf_reg_to_regnum invalid");
2896 if (gdbarch_debug
>= 2)
2897 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf_reg_to_regnum called\n");
2898 return gdbarch
->dwarf_reg_to_regnum (dwarf_regnr
);
2902 set_gdbarch_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
,
2903 gdbarch_dwarf_reg_to_regnum_ftype dwarf_reg_to_regnum
)
2905 gdbarch
->dwarf_reg_to_regnum
= dwarf_reg_to_regnum
;
2909 gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
, int sdb_regnr
)
2911 gdb_assert (gdbarch
!= NULL
);
2912 if (gdbarch
->sdb_reg_to_regnum
== 0)
2913 internal_error (__FILE__
, __LINE__
,
2914 "gdbarch: gdbarch_sdb_reg_to_regnum invalid");
2915 if (gdbarch_debug
>= 2)
2916 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sdb_reg_to_regnum called\n");
2917 return gdbarch
->sdb_reg_to_regnum (sdb_regnr
);
2921 set_gdbarch_sdb_reg_to_regnum (struct gdbarch
*gdbarch
,
2922 gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum
)
2924 gdbarch
->sdb_reg_to_regnum
= sdb_reg_to_regnum
;
2928 gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2_regnr
)
2930 gdb_assert (gdbarch
!= NULL
);
2931 if (gdbarch
->dwarf2_reg_to_regnum
== 0)
2932 internal_error (__FILE__
, __LINE__
,
2933 "gdbarch: gdbarch_dwarf2_reg_to_regnum invalid");
2934 if (gdbarch_debug
>= 2)
2935 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_reg_to_regnum called\n");
2936 return gdbarch
->dwarf2_reg_to_regnum (dwarf2_regnr
);
2940 set_gdbarch_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
,
2941 gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum
)
2943 gdbarch
->dwarf2_reg_to_regnum
= dwarf2_reg_to_regnum
;
2947 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
2949 gdb_assert (gdbarch
!= NULL
);
2950 if (gdbarch
->register_name
== 0)
2951 internal_error (__FILE__
, __LINE__
,
2952 "gdbarch: gdbarch_register_name invalid");
2953 if (gdbarch_debug
>= 2)
2954 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
2955 return gdbarch
->register_name (regnr
);
2959 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2960 gdbarch_register_name_ftype register_name
)
2962 gdbarch
->register_name
= register_name
;
2966 gdbarch_register_size (struct gdbarch
*gdbarch
)
2968 gdb_assert (gdbarch
!= NULL
);
2969 if (gdbarch
->register_size
== -1)
2970 internal_error (__FILE__
, __LINE__
,
2971 "gdbarch: gdbarch_register_size invalid");
2972 if (gdbarch_debug
>= 2)
2973 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_size called\n");
2974 return gdbarch
->register_size
;
2978 set_gdbarch_register_size (struct gdbarch
*gdbarch
,
2981 gdbarch
->register_size
= register_size
;
2985 gdbarch_register_bytes (struct gdbarch
*gdbarch
)
2987 gdb_assert (gdbarch
!= NULL
);
2988 if (gdbarch
->register_bytes
== -1)
2989 internal_error (__FILE__
, __LINE__
,
2990 "gdbarch: gdbarch_register_bytes invalid");
2991 if (gdbarch_debug
>= 2)
2992 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes called\n");
2993 return gdbarch
->register_bytes
;
2997 set_gdbarch_register_bytes (struct gdbarch
*gdbarch
,
3000 gdbarch
->register_bytes
= register_bytes
;
3004 gdbarch_register_byte (struct gdbarch
*gdbarch
, int reg_nr
)
3006 gdb_assert (gdbarch
!= NULL
);
3007 if (gdbarch
->register_byte
== 0)
3008 internal_error (__FILE__
, __LINE__
,
3009 "gdbarch: gdbarch_register_byte invalid");
3010 if (gdbarch_debug
>= 2)
3011 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_byte called\n");
3012 return gdbarch
->register_byte (reg_nr
);
3016 set_gdbarch_register_byte (struct gdbarch
*gdbarch
,
3017 gdbarch_register_byte_ftype register_byte
)
3019 gdbarch
->register_byte
= register_byte
;
3023 gdbarch_register_raw_size (struct gdbarch
*gdbarch
, int reg_nr
)
3025 gdb_assert (gdbarch
!= NULL
);
3026 if (gdbarch
->register_raw_size
== 0)
3027 internal_error (__FILE__
, __LINE__
,
3028 "gdbarch: gdbarch_register_raw_size invalid");
3029 if (gdbarch_debug
>= 2)
3030 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_raw_size called\n");
3031 return gdbarch
->register_raw_size (reg_nr
);
3035 set_gdbarch_register_raw_size (struct gdbarch
*gdbarch
,
3036 gdbarch_register_raw_size_ftype register_raw_size
)
3038 gdbarch
->register_raw_size
= register_raw_size
;
3042 gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
)
3044 gdb_assert (gdbarch
!= NULL
);
3045 if (gdbarch
->max_register_raw_size
== -1)
3046 internal_error (__FILE__
, __LINE__
,
3047 "gdbarch: gdbarch_max_register_raw_size invalid");
3048 if (gdbarch_debug
>= 2)
3049 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_raw_size called\n");
3050 return gdbarch
->max_register_raw_size
;
3054 set_gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
,
3055 int max_register_raw_size
)
3057 gdbarch
->max_register_raw_size
= max_register_raw_size
;
3061 gdbarch_register_virtual_size (struct gdbarch
*gdbarch
, int reg_nr
)
3063 gdb_assert (gdbarch
!= NULL
);
3064 if (gdbarch
->register_virtual_size
== 0)
3065 internal_error (__FILE__
, __LINE__
,
3066 "gdbarch: gdbarch_register_virtual_size invalid");
3067 if (gdbarch_debug
>= 2)
3068 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_size called\n");
3069 return gdbarch
->register_virtual_size (reg_nr
);
3073 set_gdbarch_register_virtual_size (struct gdbarch
*gdbarch
,
3074 gdbarch_register_virtual_size_ftype register_virtual_size
)
3076 gdbarch
->register_virtual_size
= register_virtual_size
;
3080 gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
)
3082 gdb_assert (gdbarch
!= NULL
);
3083 if (gdbarch
->max_register_virtual_size
== -1)
3084 internal_error (__FILE__
, __LINE__
,
3085 "gdbarch: gdbarch_max_register_virtual_size invalid");
3086 if (gdbarch_debug
>= 2)
3087 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_virtual_size called\n");
3088 return gdbarch
->max_register_virtual_size
;
3092 set_gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
,
3093 int max_register_virtual_size
)
3095 gdbarch
->max_register_virtual_size
= max_register_virtual_size
;
3099 gdbarch_register_virtual_type (struct gdbarch
*gdbarch
, int reg_nr
)
3101 gdb_assert (gdbarch
!= NULL
);
3102 if (gdbarch
->register_virtual_type
== 0)
3103 internal_error (__FILE__
, __LINE__
,
3104 "gdbarch: gdbarch_register_virtual_type invalid");
3105 if (gdbarch_debug
>= 2)
3106 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_type called\n");
3107 return gdbarch
->register_virtual_type (reg_nr
);
3111 set_gdbarch_register_virtual_type (struct gdbarch
*gdbarch
,
3112 gdbarch_register_virtual_type_ftype register_virtual_type
)
3114 gdbarch
->register_virtual_type
= register_virtual_type
;
3118 gdbarch_deprecated_do_registers_info_p (struct gdbarch
*gdbarch
)
3120 gdb_assert (gdbarch
!= NULL
);
3121 return gdbarch
->deprecated_do_registers_info
!= 0;
3125 gdbarch_deprecated_do_registers_info (struct gdbarch
*gdbarch
, int reg_nr
, int fpregs
)
3127 gdb_assert (gdbarch
!= NULL
);
3128 if (gdbarch
->deprecated_do_registers_info
== 0)
3129 internal_error (__FILE__
, __LINE__
,
3130 "gdbarch: gdbarch_deprecated_do_registers_info invalid");
3131 if (gdbarch_debug
>= 2)
3132 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_do_registers_info called\n");
3133 gdbarch
->deprecated_do_registers_info (reg_nr
, fpregs
);
3137 set_gdbarch_deprecated_do_registers_info (struct gdbarch
*gdbarch
,
3138 gdbarch_deprecated_do_registers_info_ftype deprecated_do_registers_info
)
3140 gdbarch
->deprecated_do_registers_info
= deprecated_do_registers_info
;
3144 gdbarch_print_registers_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, int regnum
, int all
)
3146 gdb_assert (gdbarch
!= NULL
);
3147 if (gdbarch
->print_registers_info
== 0)
3148 internal_error (__FILE__
, __LINE__
,
3149 "gdbarch: gdbarch_print_registers_info invalid");
3150 if (gdbarch_debug
>= 2)
3151 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_registers_info called\n");
3152 gdbarch
->print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
3156 set_gdbarch_print_registers_info (struct gdbarch
*gdbarch
,
3157 gdbarch_print_registers_info_ftype print_registers_info
)
3159 gdbarch
->print_registers_info
= print_registers_info
;
3163 gdbarch_print_float_info_p (struct gdbarch
*gdbarch
)
3165 gdb_assert (gdbarch
!= NULL
);
3166 return gdbarch
->print_float_info
!= 0;
3170 gdbarch_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
3172 gdb_assert (gdbarch
!= NULL
);
3173 if (gdbarch
->print_float_info
== 0)
3174 internal_error (__FILE__
, __LINE__
,
3175 "gdbarch: gdbarch_print_float_info invalid");
3176 if (gdbarch_debug
>= 2)
3177 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_float_info called\n");
3178 gdbarch
->print_float_info (gdbarch
, file
, frame
, args
);
3182 set_gdbarch_print_float_info (struct gdbarch
*gdbarch
,
3183 gdbarch_print_float_info_ftype print_float_info
)
3185 gdbarch
->print_float_info
= print_float_info
;
3189 gdbarch_print_vector_info_p (struct gdbarch
*gdbarch
)
3191 gdb_assert (gdbarch
!= NULL
);
3192 return gdbarch
->print_vector_info
!= 0;
3196 gdbarch_print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
, struct frame_info
*frame
, const char *args
)
3198 gdb_assert (gdbarch
!= NULL
);
3199 if (gdbarch
->print_vector_info
== 0)
3200 internal_error (__FILE__
, __LINE__
,
3201 "gdbarch: gdbarch_print_vector_info invalid");
3202 if (gdbarch_debug
>= 2)
3203 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_vector_info called\n");
3204 gdbarch
->print_vector_info (gdbarch
, file
, frame
, args
);
3208 set_gdbarch_print_vector_info (struct gdbarch
*gdbarch
,
3209 gdbarch_print_vector_info_ftype print_vector_info
)
3211 gdbarch
->print_vector_info
= print_vector_info
;
3215 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
3217 gdb_assert (gdbarch
!= NULL
);
3218 if (gdbarch
->register_sim_regno
== 0)
3219 internal_error (__FILE__
, __LINE__
,
3220 "gdbarch: gdbarch_register_sim_regno invalid");
3221 if (gdbarch_debug
>= 2)
3222 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
3223 return gdbarch
->register_sim_regno (reg_nr
);
3227 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
3228 gdbarch_register_sim_regno_ftype register_sim_regno
)
3230 gdbarch
->register_sim_regno
= register_sim_regno
;
3234 gdbarch_register_bytes_ok_p (struct gdbarch
*gdbarch
)
3236 gdb_assert (gdbarch
!= NULL
);
3237 return gdbarch
->register_bytes_ok
!= 0;
3241 gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
, long nr_bytes
)
3243 gdb_assert (gdbarch
!= NULL
);
3244 if (gdbarch
->register_bytes_ok
== 0)
3245 internal_error (__FILE__
, __LINE__
,
3246 "gdbarch: gdbarch_register_bytes_ok invalid");
3247 if (gdbarch_debug
>= 2)
3248 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes_ok called\n");
3249 return gdbarch
->register_bytes_ok (nr_bytes
);
3253 set_gdbarch_register_bytes_ok (struct gdbarch
*gdbarch
,
3254 gdbarch_register_bytes_ok_ftype register_bytes_ok
)
3256 gdbarch
->register_bytes_ok
= register_bytes_ok
;
3260 gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
, int regnum
)
3262 gdb_assert (gdbarch
!= NULL
);
3263 if (gdbarch
->cannot_fetch_register
== 0)
3264 internal_error (__FILE__
, __LINE__
,
3265 "gdbarch: gdbarch_cannot_fetch_register invalid");
3266 if (gdbarch_debug
>= 2)
3267 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_fetch_register called\n");
3268 return gdbarch
->cannot_fetch_register (regnum
);
3272 set_gdbarch_cannot_fetch_register (struct gdbarch
*gdbarch
,
3273 gdbarch_cannot_fetch_register_ftype cannot_fetch_register
)
3275 gdbarch
->cannot_fetch_register
= cannot_fetch_register
;
3279 gdbarch_cannot_store_register (struct gdbarch
*gdbarch
, int regnum
)
3281 gdb_assert (gdbarch
!= NULL
);
3282 if (gdbarch
->cannot_store_register
== 0)
3283 internal_error (__FILE__
, __LINE__
,
3284 "gdbarch: gdbarch_cannot_store_register invalid");
3285 if (gdbarch_debug
>= 2)
3286 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_store_register called\n");
3287 return gdbarch
->cannot_store_register (regnum
);
3291 set_gdbarch_cannot_store_register (struct gdbarch
*gdbarch
,
3292 gdbarch_cannot_store_register_ftype cannot_store_register
)
3294 gdbarch
->cannot_store_register
= cannot_store_register
;
3298 gdbarch_get_longjmp_target_p (struct gdbarch
*gdbarch
)
3300 gdb_assert (gdbarch
!= NULL
);
3301 return gdbarch
->get_longjmp_target
!= 0;
3305 gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
, CORE_ADDR
*pc
)
3307 gdb_assert (gdbarch
!= NULL
);
3308 if (gdbarch
->get_longjmp_target
== 0)
3309 internal_error (__FILE__
, __LINE__
,
3310 "gdbarch: gdbarch_get_longjmp_target invalid");
3311 if (gdbarch_debug
>= 2)
3312 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_longjmp_target called\n");
3313 return gdbarch
->get_longjmp_target (pc
);
3317 set_gdbarch_get_longjmp_target (struct gdbarch
*gdbarch
,
3318 gdbarch_get_longjmp_target_ftype get_longjmp_target
)
3320 gdbarch
->get_longjmp_target
= get_longjmp_target
;
3324 gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch
*gdbarch
)
3326 gdb_assert (gdbarch
!= NULL
);
3327 /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
3328 if (gdbarch_debug
>= 2)
3329 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_use_generic_dummy_frames called\n");
3330 return gdbarch
->deprecated_use_generic_dummy_frames
;
3334 set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch
*gdbarch
,
3335 int deprecated_use_generic_dummy_frames
)
3337 gdbarch
->deprecated_use_generic_dummy_frames
= deprecated_use_generic_dummy_frames
;
3341 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
3343 gdb_assert (gdbarch
!= NULL
);
3344 /* Skip verify of call_dummy_location, invalid_p == 0 */
3345 if (gdbarch_debug
>= 2)
3346 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
3347 return gdbarch
->call_dummy_location
;
3351 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
3352 int call_dummy_location
)
3354 gdbarch
->call_dummy_location
= call_dummy_location
;
3358 gdbarch_call_dummy_address (struct gdbarch
*gdbarch
)
3360 gdb_assert (gdbarch
!= NULL
);
3361 if (gdbarch
->call_dummy_address
== 0)
3362 internal_error (__FILE__
, __LINE__
,
3363 "gdbarch: gdbarch_call_dummy_address invalid");
3364 if (gdbarch_debug
>= 2)
3365 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_address called\n");
3366 return gdbarch
->call_dummy_address ();
3370 set_gdbarch_call_dummy_address (struct gdbarch
*gdbarch
,
3371 gdbarch_call_dummy_address_ftype call_dummy_address
)
3373 gdbarch
->call_dummy_address
= call_dummy_address
;
3377 gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
)
3379 gdb_assert (gdbarch
!= NULL
);
3380 if (gdbarch
->call_dummy_start_offset
== -1)
3381 internal_error (__FILE__
, __LINE__
,
3382 "gdbarch: gdbarch_call_dummy_start_offset invalid");
3383 if (gdbarch_debug
>= 2)
3384 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_start_offset called\n");
3385 return gdbarch
->call_dummy_start_offset
;
3389 set_gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
,
3390 CORE_ADDR call_dummy_start_offset
)
3392 gdbarch
->call_dummy_start_offset
= call_dummy_start_offset
;
3396 gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
)
3398 gdb_assert (gdbarch
!= NULL
);
3399 if (gdbarch
->call_dummy_breakpoint_offset_p
&& gdbarch
->call_dummy_breakpoint_offset
== -1)
3400 internal_error (__FILE__
, __LINE__
,
3401 "gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
3402 if (gdbarch_debug
>= 2)
3403 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset called\n");
3404 return gdbarch
->call_dummy_breakpoint_offset
;
3408 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
,
3409 CORE_ADDR call_dummy_breakpoint_offset
)
3411 gdbarch
->call_dummy_breakpoint_offset
= call_dummy_breakpoint_offset
;
3415 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
)
3417 gdb_assert (gdbarch
!= NULL
);
3418 if (gdbarch
->call_dummy_breakpoint_offset_p
== -1)
3419 internal_error (__FILE__
, __LINE__
,
3420 "gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
3421 if (gdbarch_debug
>= 2)
3422 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset_p called\n");
3423 return gdbarch
->call_dummy_breakpoint_offset_p
;
3427 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
,
3428 int call_dummy_breakpoint_offset_p
)
3430 gdbarch
->call_dummy_breakpoint_offset_p
= call_dummy_breakpoint_offset_p
;
3434 gdbarch_call_dummy_length (struct gdbarch
*gdbarch
)
3436 gdb_assert (gdbarch
!= NULL
);
3437 if (gdbarch
->call_dummy_length
== -1)
3438 internal_error (__FILE__
, __LINE__
,
3439 "gdbarch: gdbarch_call_dummy_length invalid");
3440 if (gdbarch_debug
>= 2)
3441 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_length called\n");
3442 return gdbarch
->call_dummy_length
;
3446 set_gdbarch_call_dummy_length (struct gdbarch
*gdbarch
,
3447 int call_dummy_length
)
3449 gdbarch
->call_dummy_length
= call_dummy_length
;
3453 gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
3455 gdb_assert (gdbarch
!= NULL
);
3456 if (gdbarch
->pc_in_call_dummy
== 0)
3457 internal_error (__FILE__
, __LINE__
,
3458 "gdbarch: gdbarch_pc_in_call_dummy invalid");
3459 if (gdbarch_debug
>= 2)
3460 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_call_dummy called\n");
3461 return gdbarch
->pc_in_call_dummy (pc
, sp
, frame_address
);
3465 set_gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
,
3466 gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy
)
3468 gdbarch
->pc_in_call_dummy
= pc_in_call_dummy
;
3472 gdbarch_call_dummy_p (struct gdbarch
*gdbarch
)
3474 gdb_assert (gdbarch
!= NULL
);
3475 if (gdbarch
->call_dummy_p
== -1)
3476 internal_error (__FILE__
, __LINE__
,
3477 "gdbarch: gdbarch_call_dummy_p invalid");
3478 if (gdbarch_debug
>= 2)
3479 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_p called\n");
3480 return gdbarch
->call_dummy_p
;
3484 set_gdbarch_call_dummy_p (struct gdbarch
*gdbarch
,
3487 gdbarch
->call_dummy_p
= call_dummy_p
;
3491 gdbarch_call_dummy_words (struct gdbarch
*gdbarch
)
3493 gdb_assert (gdbarch
!= NULL
);
3494 /* Skip verify of call_dummy_words, invalid_p == 0 */
3495 if (gdbarch_debug
>= 2)
3496 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_words called\n");
3497 return gdbarch
->call_dummy_words
;
3501 set_gdbarch_call_dummy_words (struct gdbarch
*gdbarch
,
3502 LONGEST
* call_dummy_words
)
3504 gdbarch
->call_dummy_words
= call_dummy_words
;
3508 gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
)
3510 gdb_assert (gdbarch
!= NULL
);
3511 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
3512 if (gdbarch_debug
>= 2)
3513 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sizeof_call_dummy_words called\n");
3514 return gdbarch
->sizeof_call_dummy_words
;
3518 set_gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
,
3519 int sizeof_call_dummy_words
)
3521 gdbarch
->sizeof_call_dummy_words
= sizeof_call_dummy_words
;
3525 gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
)
3527 gdb_assert (gdbarch
!= NULL
);
3528 if (gdbarch
->call_dummy_stack_adjust_p
== -1)
3529 internal_error (__FILE__
, __LINE__
,
3530 "gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
3531 if (gdbarch_debug
>= 2)
3532 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust_p called\n");
3533 return gdbarch
->call_dummy_stack_adjust_p
;
3537 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
,
3538 int call_dummy_stack_adjust_p
)
3540 gdbarch
->call_dummy_stack_adjust_p
= call_dummy_stack_adjust_p
;
3544 gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
)
3546 gdb_assert (gdbarch
!= NULL
);
3547 if (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0)
3548 internal_error (__FILE__
, __LINE__
,
3549 "gdbarch: gdbarch_call_dummy_stack_adjust invalid");
3550 if (gdbarch_debug
>= 2)
3551 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust called\n");
3552 return gdbarch
->call_dummy_stack_adjust
;
3556 set_gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
,
3557 int call_dummy_stack_adjust
)
3559 gdbarch
->call_dummy_stack_adjust
= call_dummy_stack_adjust
;
3563 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
)
3565 gdb_assert (gdbarch
!= NULL
);
3566 if (gdbarch
->fix_call_dummy
== 0)
3567 internal_error (__FILE__
, __LINE__
,
3568 "gdbarch: gdbarch_fix_call_dummy invalid");
3569 if (gdbarch_debug
>= 2)
3570 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fix_call_dummy called\n");
3571 gdbarch
->fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
);
3575 set_gdbarch_fix_call_dummy (struct gdbarch
*gdbarch
,
3576 gdbarch_fix_call_dummy_ftype fix_call_dummy
)
3578 gdbarch
->fix_call_dummy
= fix_call_dummy
;
3582 gdbarch_init_frame_pc_first (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*prev
)
3584 gdb_assert (gdbarch
!= NULL
);
3585 if (gdbarch
->init_frame_pc_first
== 0)
3586 internal_error (__FILE__
, __LINE__
,
3587 "gdbarch: gdbarch_init_frame_pc_first invalid");
3588 if (gdbarch_debug
>= 2)
3589 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_frame_pc_first called\n");
3590 gdbarch
->init_frame_pc_first (fromleaf
, prev
);
3594 set_gdbarch_init_frame_pc_first (struct gdbarch
*gdbarch
,
3595 gdbarch_init_frame_pc_first_ftype init_frame_pc_first
)
3597 gdbarch
->init_frame_pc_first
= init_frame_pc_first
;
3601 gdbarch_init_frame_pc (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*prev
)
3603 gdb_assert (gdbarch
!= NULL
);
3604 if (gdbarch
->init_frame_pc
== 0)
3605 internal_error (__FILE__
, __LINE__
,
3606 "gdbarch: gdbarch_init_frame_pc invalid");
3607 if (gdbarch_debug
>= 2)
3608 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_frame_pc called\n");
3609 gdbarch
->init_frame_pc (fromleaf
, prev
);
3613 set_gdbarch_init_frame_pc (struct gdbarch
*gdbarch
,
3614 gdbarch_init_frame_pc_ftype init_frame_pc
)
3616 gdbarch
->init_frame_pc
= init_frame_pc
;
3620 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
3622 gdb_assert (gdbarch
!= NULL
);
3623 if (gdbarch_debug
>= 2)
3624 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
3625 return gdbarch
->believe_pcc_promotion
;
3629 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
3630 int believe_pcc_promotion
)
3632 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
3636 gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
)
3638 gdb_assert (gdbarch
!= NULL
);
3639 if (gdbarch_debug
>= 2)
3640 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion_type called\n");
3641 return gdbarch
->believe_pcc_promotion_type
;
3645 set_gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
,
3646 int believe_pcc_promotion_type
)
3648 gdbarch
->believe_pcc_promotion_type
= believe_pcc_promotion_type
;
3652 gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
, struct type
*formal
, struct type
*actual
)
3654 gdb_assert (gdbarch
!= NULL
);
3655 if (gdbarch
->coerce_float_to_double
== 0)
3656 internal_error (__FILE__
, __LINE__
,
3657 "gdbarch: gdbarch_coerce_float_to_double invalid");
3658 if (gdbarch_debug
>= 2)
3659 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coerce_float_to_double called\n");
3660 return gdbarch
->coerce_float_to_double (formal
, actual
);
3664 set_gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
,
3665 gdbarch_coerce_float_to_double_ftype coerce_float_to_double
)
3667 gdbarch
->coerce_float_to_double
= coerce_float_to_double
;
3671 gdbarch_get_saved_register_p (struct gdbarch
*gdbarch
)
3673 gdb_assert (gdbarch
!= NULL
);
3674 return gdbarch
->get_saved_register
!= 0;
3678 gdbarch_get_saved_register (struct gdbarch
*gdbarch
, char *raw_buffer
, int *optimized
, CORE_ADDR
*addrp
, struct frame_info
*frame
, int regnum
, enum lval_type
*lval
)
3680 gdb_assert (gdbarch
!= NULL
);
3681 if (gdbarch
->get_saved_register
== 0)
3682 internal_error (__FILE__
, __LINE__
,
3683 "gdbarch: gdbarch_get_saved_register invalid");
3684 if (gdbarch_debug
>= 2)
3685 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_saved_register called\n");
3686 gdbarch
->get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
3690 set_gdbarch_get_saved_register (struct gdbarch
*gdbarch
,
3691 gdbarch_get_saved_register_ftype get_saved_register
)
3693 gdbarch
->get_saved_register
= get_saved_register
;
3697 gdbarch_register_convertible (struct gdbarch
*gdbarch
, int nr
)
3699 gdb_assert (gdbarch
!= NULL
);
3700 if (gdbarch
->register_convertible
== 0)
3701 internal_error (__FILE__
, __LINE__
,
3702 "gdbarch: gdbarch_register_convertible invalid");
3703 if (gdbarch_debug
>= 2)
3704 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convertible called\n");
3705 return gdbarch
->register_convertible (nr
);
3709 set_gdbarch_register_convertible (struct gdbarch
*gdbarch
,
3710 gdbarch_register_convertible_ftype register_convertible
)
3712 gdbarch
->register_convertible
= register_convertible
;
3716 gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
3718 gdb_assert (gdbarch
!= NULL
);
3719 if (gdbarch
->register_convert_to_virtual
== 0)
3720 internal_error (__FILE__
, __LINE__
,
3721 "gdbarch: gdbarch_register_convert_to_virtual invalid");
3722 if (gdbarch_debug
>= 2)
3723 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_virtual called\n");
3724 gdbarch
->register_convert_to_virtual (regnum
, type
, from
, to
);
3728 set_gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
,
3729 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual
)
3731 gdbarch
->register_convert_to_virtual
= register_convert_to_virtual
;
3735 gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
3737 gdb_assert (gdbarch
!= NULL
);
3738 if (gdbarch
->register_convert_to_raw
== 0)
3739 internal_error (__FILE__
, __LINE__
,
3740 "gdbarch: gdbarch_register_convert_to_raw invalid");
3741 if (gdbarch_debug
>= 2)
3742 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_raw called\n");
3743 gdbarch
->register_convert_to_raw (type
, regnum
, from
, to
);
3747 set_gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
,
3748 gdbarch_register_convert_to_raw_ftype register_convert_to_raw
)
3750 gdbarch
->register_convert_to_raw
= register_convert_to_raw
;
3754 gdbarch_convert_register_p (struct gdbarch
*gdbarch
, int regnum
)
3756 gdb_assert (gdbarch
!= NULL
);
3757 if (gdbarch
->convert_register_p
== 0)
3758 internal_error (__FILE__
, __LINE__
,
3759 "gdbarch: gdbarch_convert_register_p invalid");
3760 if (gdbarch_debug
>= 2)
3761 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_register_p called\n");
3762 return gdbarch
->convert_register_p (regnum
);
3766 set_gdbarch_convert_register_p (struct gdbarch
*gdbarch
,
3767 gdbarch_convert_register_p_ftype convert_register_p
)
3769 gdbarch
->convert_register_p
= convert_register_p
;
3773 gdbarch_register_to_value (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
3775 gdb_assert (gdbarch
!= NULL
);
3776 if (gdbarch
->register_to_value
== 0)
3777 internal_error (__FILE__
, __LINE__
,
3778 "gdbarch: gdbarch_register_to_value invalid");
3779 if (gdbarch_debug
>= 2)
3780 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_to_value called\n");
3781 gdbarch
->register_to_value (regnum
, type
, from
, to
);
3785 set_gdbarch_register_to_value (struct gdbarch
*gdbarch
,
3786 gdbarch_register_to_value_ftype register_to_value
)
3788 gdbarch
->register_to_value
= register_to_value
;
3792 gdbarch_value_to_register (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
3794 gdb_assert (gdbarch
!= NULL
);
3795 if (gdbarch
->value_to_register
== 0)
3796 internal_error (__FILE__
, __LINE__
,
3797 "gdbarch: gdbarch_value_to_register invalid");
3798 if (gdbarch_debug
>= 2)
3799 fprintf_unfiltered (gdb_stdlog
, "gdbarch_value_to_register called\n");
3800 gdbarch
->value_to_register (type
, regnum
, from
, to
);
3804 set_gdbarch_value_to_register (struct gdbarch
*gdbarch
,
3805 gdbarch_value_to_register_ftype value_to_register
)
3807 gdbarch
->value_to_register
= value_to_register
;
3811 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
3813 gdb_assert (gdbarch
!= NULL
);
3814 if (gdbarch
->pointer_to_address
== 0)
3815 internal_error (__FILE__
, __LINE__
,
3816 "gdbarch: gdbarch_pointer_to_address invalid");
3817 if (gdbarch_debug
>= 2)
3818 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
3819 return gdbarch
->pointer_to_address (type
, buf
);
3823 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
3824 gdbarch_pointer_to_address_ftype pointer_to_address
)
3826 gdbarch
->pointer_to_address
= pointer_to_address
;
3830 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
, CORE_ADDR addr
)
3832 gdb_assert (gdbarch
!= NULL
);
3833 if (gdbarch
->address_to_pointer
== 0)
3834 internal_error (__FILE__
, __LINE__
,
3835 "gdbarch: gdbarch_address_to_pointer invalid");
3836 if (gdbarch_debug
>= 2)
3837 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
3838 gdbarch
->address_to_pointer (type
, buf
, addr
);
3842 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
3843 gdbarch_address_to_pointer_ftype address_to_pointer
)
3845 gdbarch
->address_to_pointer
= address_to_pointer
;
3849 gdbarch_integer_to_address_p (struct gdbarch
*gdbarch
)
3851 gdb_assert (gdbarch
!= NULL
);
3852 return gdbarch
->integer_to_address
!= 0;
3856 gdbarch_integer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
3858 gdb_assert (gdbarch
!= NULL
);
3859 if (gdbarch
->integer_to_address
== 0)
3860 internal_error (__FILE__
, __LINE__
,
3861 "gdbarch: gdbarch_integer_to_address invalid");
3862 if (gdbarch_debug
>= 2)
3863 fprintf_unfiltered (gdb_stdlog
, "gdbarch_integer_to_address called\n");
3864 return gdbarch
->integer_to_address (type
, buf
);
3868 set_gdbarch_integer_to_address (struct gdbarch
*gdbarch
,
3869 gdbarch_integer_to_address_ftype integer_to_address
)
3871 gdbarch
->integer_to_address
= integer_to_address
;
3875 gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
, struct type
*type
)
3877 gdb_assert (gdbarch
!= NULL
);
3878 if (gdbarch
->return_value_on_stack
== 0)
3879 internal_error (__FILE__
, __LINE__
,
3880 "gdbarch: gdbarch_return_value_on_stack invalid");
3881 if (gdbarch_debug
>= 2)
3882 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value_on_stack called\n");
3883 return gdbarch
->return_value_on_stack (type
);
3887 set_gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
,
3888 gdbarch_return_value_on_stack_ftype return_value_on_stack
)
3890 gdbarch
->return_value_on_stack
= return_value_on_stack
;
3894 gdbarch_push_arguments (struct gdbarch
*gdbarch
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
3896 gdb_assert (gdbarch
!= NULL
);
3897 if (gdbarch
->push_arguments
== 0)
3898 internal_error (__FILE__
, __LINE__
,
3899 "gdbarch: gdbarch_push_arguments invalid");
3900 if (gdbarch_debug
>= 2)
3901 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_arguments called\n");
3902 return gdbarch
->push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
3906 set_gdbarch_push_arguments (struct gdbarch
*gdbarch
,
3907 gdbarch_push_arguments_ftype push_arguments
)
3909 gdbarch
->push_arguments
= push_arguments
;
3913 gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
)
3915 gdb_assert (gdbarch
!= NULL
);
3916 if (gdbarch
->push_dummy_frame
== 0)
3917 internal_error (__FILE__
, __LINE__
,
3918 "gdbarch: gdbarch_push_dummy_frame invalid");
3919 if (gdbarch_debug
>= 2)
3920 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_frame called\n");
3921 gdbarch
->push_dummy_frame ();
3925 set_gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
,
3926 gdbarch_push_dummy_frame_ftype push_dummy_frame
)
3928 gdbarch
->push_dummy_frame
= push_dummy_frame
;
3932 gdbarch_push_return_address_p (struct gdbarch
*gdbarch
)
3934 gdb_assert (gdbarch
!= NULL
);
3935 return gdbarch
->push_return_address
!= 0;
3939 gdbarch_push_return_address (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
)
3941 gdb_assert (gdbarch
!= NULL
);
3942 if (gdbarch
->push_return_address
== 0)
3943 internal_error (__FILE__
, __LINE__
,
3944 "gdbarch: gdbarch_push_return_address invalid");
3945 if (gdbarch_debug
>= 2)
3946 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_return_address called\n");
3947 return gdbarch
->push_return_address (pc
, sp
);
3951 set_gdbarch_push_return_address (struct gdbarch
*gdbarch
,
3952 gdbarch_push_return_address_ftype push_return_address
)
3954 gdbarch
->push_return_address
= push_return_address
;
3958 gdbarch_pop_frame (struct gdbarch
*gdbarch
)
3960 gdb_assert (gdbarch
!= NULL
);
3961 if (gdbarch
->pop_frame
== 0)
3962 internal_error (__FILE__
, __LINE__
,
3963 "gdbarch: gdbarch_pop_frame invalid");
3964 if (gdbarch_debug
>= 2)
3965 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pop_frame called\n");
3966 gdbarch
->pop_frame ();
3970 set_gdbarch_pop_frame (struct gdbarch
*gdbarch
,
3971 gdbarch_pop_frame_ftype pop_frame
)
3973 gdbarch
->pop_frame
= pop_frame
;
3977 gdbarch_store_struct_return (struct gdbarch
*gdbarch
, CORE_ADDR addr
, CORE_ADDR sp
)
3979 gdb_assert (gdbarch
!= NULL
);
3980 if (gdbarch
->store_struct_return
== 0)
3981 internal_error (__FILE__
, __LINE__
,
3982 "gdbarch: gdbarch_store_struct_return invalid");
3983 if (gdbarch_debug
>= 2)
3984 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_struct_return called\n");
3985 gdbarch
->store_struct_return (addr
, sp
);
3989 set_gdbarch_store_struct_return (struct gdbarch
*gdbarch
,
3990 gdbarch_store_struct_return_ftype store_struct_return
)
3992 gdbarch
->store_struct_return
= store_struct_return
;
3996 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, void *valbuf
)
3998 gdb_assert (gdbarch
!= NULL
);
3999 if (gdbarch
->extract_return_value
== 0)
4000 internal_error (__FILE__
, __LINE__
,
4001 "gdbarch: gdbarch_extract_return_value invalid");
4002 if (gdbarch_debug
>= 2)
4003 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
4004 gdbarch
->extract_return_value (type
, regcache
, valbuf
);
4008 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
4009 gdbarch_extract_return_value_ftype extract_return_value
)
4011 gdbarch
->extract_return_value
= extract_return_value
;
4015 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, struct regcache
*regcache
, const void *valbuf
)
4017 gdb_assert (gdbarch
!= NULL
);
4018 if (gdbarch
->store_return_value
== 0)
4019 internal_error (__FILE__
, __LINE__
,
4020 "gdbarch: gdbarch_store_return_value invalid");
4021 if (gdbarch_debug
>= 2)
4022 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
4023 gdbarch
->store_return_value (type
, regcache
, valbuf
);
4027 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
4028 gdbarch_store_return_value_ftype store_return_value
)
4030 gdbarch
->store_return_value
= store_return_value
;
4034 gdbarch_deprecated_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *regbuf
, char *valbuf
)
4036 gdb_assert (gdbarch
!= NULL
);
4037 if (gdbarch
->deprecated_extract_return_value
== 0)
4038 internal_error (__FILE__
, __LINE__
,
4039 "gdbarch: gdbarch_deprecated_extract_return_value invalid");
4040 if (gdbarch_debug
>= 2)
4041 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_return_value called\n");
4042 gdbarch
->deprecated_extract_return_value (type
, regbuf
, valbuf
);
4046 set_gdbarch_deprecated_extract_return_value (struct gdbarch
*gdbarch
,
4047 gdbarch_deprecated_extract_return_value_ftype deprecated_extract_return_value
)
4049 gdbarch
->deprecated_extract_return_value
= deprecated_extract_return_value
;
4053 gdbarch_deprecated_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *valbuf
)
4055 gdb_assert (gdbarch
!= NULL
);
4056 if (gdbarch
->deprecated_store_return_value
== 0)
4057 internal_error (__FILE__
, __LINE__
,
4058 "gdbarch: gdbarch_deprecated_store_return_value invalid");
4059 if (gdbarch_debug
>= 2)
4060 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_store_return_value called\n");
4061 gdbarch
->deprecated_store_return_value (type
, valbuf
);
4065 set_gdbarch_deprecated_store_return_value (struct gdbarch
*gdbarch
,
4066 gdbarch_deprecated_store_return_value_ftype deprecated_store_return_value
)
4068 gdbarch
->deprecated_store_return_value
= deprecated_store_return_value
;
4072 gdbarch_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
4074 gdb_assert (gdbarch
!= NULL
);
4075 return gdbarch
->extract_struct_value_address
!= 0;
4079 gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
4081 gdb_assert (gdbarch
!= NULL
);
4082 if (gdbarch
->extract_struct_value_address
== 0)
4083 internal_error (__FILE__
, __LINE__
,
4084 "gdbarch: gdbarch_extract_struct_value_address invalid");
4085 if (gdbarch_debug
>= 2)
4086 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_struct_value_address called\n");
4087 return gdbarch
->extract_struct_value_address (regcache
);
4091 set_gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
,
4092 gdbarch_extract_struct_value_address_ftype extract_struct_value_address
)
4094 gdbarch
->extract_struct_value_address
= extract_struct_value_address
;
4098 gdbarch_deprecated_extract_struct_value_address_p (struct gdbarch
*gdbarch
)
4100 gdb_assert (gdbarch
!= NULL
);
4101 return gdbarch
->deprecated_extract_struct_value_address
!= 0;
4105 gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
, char *regbuf
)
4107 gdb_assert (gdbarch
!= NULL
);
4108 if (gdbarch
->deprecated_extract_struct_value_address
== 0)
4109 internal_error (__FILE__
, __LINE__
,
4110 "gdbarch: gdbarch_deprecated_extract_struct_value_address invalid");
4111 if (gdbarch_debug
>= 2)
4112 fprintf_unfiltered (gdb_stdlog
, "gdbarch_deprecated_extract_struct_value_address called\n");
4113 return gdbarch
->deprecated_extract_struct_value_address (regbuf
);
4117 set_gdbarch_deprecated_extract_struct_value_address (struct gdbarch
*gdbarch
,
4118 gdbarch_deprecated_extract_struct_value_address_ftype deprecated_extract_struct_value_address
)
4120 gdbarch
->deprecated_extract_struct_value_address
= deprecated_extract_struct_value_address
;
4124 gdbarch_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
4126 gdb_assert (gdbarch
!= NULL
);
4127 if (gdbarch
->use_struct_convention
== 0)
4128 internal_error (__FILE__
, __LINE__
,
4129 "gdbarch: gdbarch_use_struct_convention invalid");
4130 if (gdbarch_debug
>= 2)
4131 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_struct_convention called\n");
4132 return gdbarch
->use_struct_convention (gcc_p
, value_type
);
4136 set_gdbarch_use_struct_convention (struct gdbarch
*gdbarch
,
4137 gdbarch_use_struct_convention_ftype use_struct_convention
)
4139 gdbarch
->use_struct_convention
= use_struct_convention
;
4143 gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4145 gdb_assert (gdbarch
!= NULL
);
4146 if (gdbarch
->frame_init_saved_regs
== 0)
4147 internal_error (__FILE__
, __LINE__
,
4148 "gdbarch: gdbarch_frame_init_saved_regs invalid");
4149 if (gdbarch_debug
>= 2)
4150 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_init_saved_regs called\n");
4151 gdbarch
->frame_init_saved_regs (frame
);
4155 set_gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
,
4156 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs
)
4158 gdbarch
->frame_init_saved_regs
= frame_init_saved_regs
;
4162 gdbarch_init_extra_frame_info_p (struct gdbarch
*gdbarch
)
4164 gdb_assert (gdbarch
!= NULL
);
4165 return gdbarch
->init_extra_frame_info
!= 0;
4169 gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*frame
)
4171 gdb_assert (gdbarch
!= NULL
);
4172 if (gdbarch
->init_extra_frame_info
== 0)
4173 internal_error (__FILE__
, __LINE__
,
4174 "gdbarch: gdbarch_init_extra_frame_info invalid");
4175 if (gdbarch_debug
>= 2)
4176 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_extra_frame_info called\n");
4177 gdbarch
->init_extra_frame_info (fromleaf
, frame
);
4181 set_gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
,
4182 gdbarch_init_extra_frame_info_ftype init_extra_frame_info
)
4184 gdbarch
->init_extra_frame_info
= init_extra_frame_info
;
4188 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
4190 gdb_assert (gdbarch
!= NULL
);
4191 if (gdbarch
->skip_prologue
== 0)
4192 internal_error (__FILE__
, __LINE__
,
4193 "gdbarch: gdbarch_skip_prologue invalid");
4194 if (gdbarch_debug
>= 2)
4195 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
4196 return gdbarch
->skip_prologue (ip
);
4200 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
4201 gdbarch_skip_prologue_ftype skip_prologue
)
4203 gdbarch
->skip_prologue
= skip_prologue
;
4207 gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
4209 gdb_assert (gdbarch
!= NULL
);
4210 if (gdbarch
->prologue_frameless_p
== 0)
4211 internal_error (__FILE__
, __LINE__
,
4212 "gdbarch: gdbarch_prologue_frameless_p invalid");
4213 if (gdbarch_debug
>= 2)
4214 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prologue_frameless_p called\n");
4215 return gdbarch
->prologue_frameless_p (ip
);
4219 set_gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
,
4220 gdbarch_prologue_frameless_p_ftype prologue_frameless_p
)
4222 gdbarch
->prologue_frameless_p
= prologue_frameless_p
;
4226 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
4228 gdb_assert (gdbarch
!= NULL
);
4229 if (gdbarch
->inner_than
== 0)
4230 internal_error (__FILE__
, __LINE__
,
4231 "gdbarch: gdbarch_inner_than invalid");
4232 if (gdbarch_debug
>= 2)
4233 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
4234 return gdbarch
->inner_than (lhs
, rhs
);
4238 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
4239 gdbarch_inner_than_ftype inner_than
)
4241 gdbarch
->inner_than
= inner_than
;
4244 const unsigned char *
4245 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
4247 gdb_assert (gdbarch
!= NULL
);
4248 if (gdbarch
->breakpoint_from_pc
== 0)
4249 internal_error (__FILE__
, __LINE__
,
4250 "gdbarch: gdbarch_breakpoint_from_pc invalid");
4251 if (gdbarch_debug
>= 2)
4252 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
4253 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
4257 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
4258 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
4260 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
4264 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
4266 gdb_assert (gdbarch
!= NULL
);
4267 if (gdbarch
->memory_insert_breakpoint
== 0)
4268 internal_error (__FILE__
, __LINE__
,
4269 "gdbarch: gdbarch_memory_insert_breakpoint invalid");
4270 if (gdbarch_debug
>= 2)
4271 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
4272 return gdbarch
->memory_insert_breakpoint (addr
, contents_cache
);
4276 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
4277 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
4279 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
4283 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
4285 gdb_assert (gdbarch
!= NULL
);
4286 if (gdbarch
->memory_remove_breakpoint
== 0)
4287 internal_error (__FILE__
, __LINE__
,
4288 "gdbarch: gdbarch_memory_remove_breakpoint invalid");
4289 if (gdbarch_debug
>= 2)
4290 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
4291 return gdbarch
->memory_remove_breakpoint (addr
, contents_cache
);
4295 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
4296 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
4298 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
4302 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
4304 gdb_assert (gdbarch
!= NULL
);
4305 if (gdbarch
->decr_pc_after_break
== -1)
4306 internal_error (__FILE__
, __LINE__
,
4307 "gdbarch: gdbarch_decr_pc_after_break invalid");
4308 if (gdbarch_debug
>= 2)
4309 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
4310 return gdbarch
->decr_pc_after_break
;
4314 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
4315 CORE_ADDR decr_pc_after_break
)
4317 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
4321 gdbarch_prepare_to_proceed (struct gdbarch
*gdbarch
, int select_it
)
4323 gdb_assert (gdbarch
!= NULL
);
4324 if (gdbarch
->prepare_to_proceed
== 0)
4325 internal_error (__FILE__
, __LINE__
,
4326 "gdbarch: gdbarch_prepare_to_proceed invalid");
4327 if (gdbarch_debug
>= 2)
4328 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prepare_to_proceed called\n");
4329 return gdbarch
->prepare_to_proceed (select_it
);
4333 set_gdbarch_prepare_to_proceed (struct gdbarch
*gdbarch
,
4334 gdbarch_prepare_to_proceed_ftype prepare_to_proceed
)
4336 gdbarch
->prepare_to_proceed
= prepare_to_proceed
;
4340 gdbarch_function_start_offset (struct gdbarch
*gdbarch
)
4342 gdb_assert (gdbarch
!= NULL
);
4343 if (gdbarch
->function_start_offset
== -1)
4344 internal_error (__FILE__
, __LINE__
,
4345 "gdbarch: gdbarch_function_start_offset invalid");
4346 if (gdbarch_debug
>= 2)
4347 fprintf_unfiltered (gdb_stdlog
, "gdbarch_function_start_offset called\n");
4348 return gdbarch
->function_start_offset
;
4352 set_gdbarch_function_start_offset (struct gdbarch
*gdbarch
,
4353 CORE_ADDR function_start_offset
)
4355 gdbarch
->function_start_offset
= function_start_offset
;
4359 gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
, CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
)
4361 gdb_assert (gdbarch
!= NULL
);
4362 if (gdbarch
->remote_translate_xfer_address
== 0)
4363 internal_error (__FILE__
, __LINE__
,
4364 "gdbarch: gdbarch_remote_translate_xfer_address invalid");
4365 if (gdbarch_debug
>= 2)
4366 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_translate_xfer_address called\n");
4367 gdbarch
->remote_translate_xfer_address (gdb_addr
, gdb_len
, rem_addr
, rem_len
);
4371 set_gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
4372 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address
)
4374 gdbarch
->remote_translate_xfer_address
= remote_translate_xfer_address
;
4378 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
4380 gdb_assert (gdbarch
!= NULL
);
4381 if (gdbarch
->frame_args_skip
== -1)
4382 internal_error (__FILE__
, __LINE__
,
4383 "gdbarch: gdbarch_frame_args_skip invalid");
4384 if (gdbarch_debug
>= 2)
4385 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
4386 return gdbarch
->frame_args_skip
;
4390 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
4391 CORE_ADDR frame_args_skip
)
4393 gdbarch
->frame_args_skip
= frame_args_skip
;
4397 gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4399 gdb_assert (gdbarch
!= NULL
);
4400 if (gdbarch
->frameless_function_invocation
== 0)
4401 internal_error (__FILE__
, __LINE__
,
4402 "gdbarch: gdbarch_frameless_function_invocation invalid");
4403 if (gdbarch_debug
>= 2)
4404 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frameless_function_invocation called\n");
4405 return gdbarch
->frameless_function_invocation (fi
);
4409 set_gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
,
4410 gdbarch_frameless_function_invocation_ftype frameless_function_invocation
)
4412 gdbarch
->frameless_function_invocation
= frameless_function_invocation
;
4416 gdbarch_frame_chain (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4418 gdb_assert (gdbarch
!= NULL
);
4419 if (gdbarch
->frame_chain
== 0)
4420 internal_error (__FILE__
, __LINE__
,
4421 "gdbarch: gdbarch_frame_chain invalid");
4422 if (gdbarch_debug
>= 2)
4423 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain called\n");
4424 return gdbarch
->frame_chain (frame
);
4428 set_gdbarch_frame_chain (struct gdbarch
*gdbarch
,
4429 gdbarch_frame_chain_ftype frame_chain
)
4431 gdbarch
->frame_chain
= frame_chain
;
4435 gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
, CORE_ADDR chain
, struct frame_info
*thisframe
)
4437 gdb_assert (gdbarch
!= NULL
);
4438 if (gdbarch
->frame_chain_valid
== 0)
4439 internal_error (__FILE__
, __LINE__
,
4440 "gdbarch: gdbarch_frame_chain_valid invalid");
4441 if (gdbarch_debug
>= 2)
4442 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain_valid called\n");
4443 return gdbarch
->frame_chain_valid (chain
, thisframe
);
4447 set_gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
,
4448 gdbarch_frame_chain_valid_ftype frame_chain_valid
)
4450 gdbarch
->frame_chain_valid
= frame_chain_valid
;
4454 gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4456 gdb_assert (gdbarch
!= NULL
);
4457 if (gdbarch
->frame_saved_pc
== 0)
4458 internal_error (__FILE__
, __LINE__
,
4459 "gdbarch: gdbarch_frame_saved_pc invalid");
4460 if (gdbarch_debug
>= 2)
4461 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_saved_pc called\n");
4462 return gdbarch
->frame_saved_pc (fi
);
4466 set_gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
,
4467 gdbarch_frame_saved_pc_ftype frame_saved_pc
)
4469 gdbarch
->frame_saved_pc
= frame_saved_pc
;
4473 gdbarch_frame_args_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4475 gdb_assert (gdbarch
!= NULL
);
4476 if (gdbarch
->frame_args_address
== 0)
4477 internal_error (__FILE__
, __LINE__
,
4478 "gdbarch: gdbarch_frame_args_address invalid");
4479 if (gdbarch_debug
>= 2)
4480 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_address called\n");
4481 return gdbarch
->frame_args_address (fi
);
4485 set_gdbarch_frame_args_address (struct gdbarch
*gdbarch
,
4486 gdbarch_frame_args_address_ftype frame_args_address
)
4488 gdbarch
->frame_args_address
= frame_args_address
;
4492 gdbarch_frame_locals_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
4494 gdb_assert (gdbarch
!= NULL
);
4495 if (gdbarch
->frame_locals_address
== 0)
4496 internal_error (__FILE__
, __LINE__
,
4497 "gdbarch: gdbarch_frame_locals_address invalid");
4498 if (gdbarch_debug
>= 2)
4499 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_locals_address called\n");
4500 return gdbarch
->frame_locals_address (fi
);
4504 set_gdbarch_frame_locals_address (struct gdbarch
*gdbarch
,
4505 gdbarch_frame_locals_address_ftype frame_locals_address
)
4507 gdbarch
->frame_locals_address
= frame_locals_address
;
4511 gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4513 gdb_assert (gdbarch
!= NULL
);
4514 if (gdbarch
->saved_pc_after_call
== 0)
4515 internal_error (__FILE__
, __LINE__
,
4516 "gdbarch: gdbarch_saved_pc_after_call invalid");
4517 if (gdbarch_debug
>= 2)
4518 fprintf_unfiltered (gdb_stdlog
, "gdbarch_saved_pc_after_call called\n");
4519 return gdbarch
->saved_pc_after_call (frame
);
4523 set_gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
,
4524 gdbarch_saved_pc_after_call_ftype saved_pc_after_call
)
4526 gdbarch
->saved_pc_after_call
= saved_pc_after_call
;
4530 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
4532 gdb_assert (gdbarch
!= NULL
);
4533 if (gdbarch
->frame_num_args
== 0)
4534 internal_error (__FILE__
, __LINE__
,
4535 "gdbarch: gdbarch_frame_num_args invalid");
4536 if (gdbarch_debug
>= 2)
4537 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
4538 return gdbarch
->frame_num_args (frame
);
4542 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
4543 gdbarch_frame_num_args_ftype frame_num_args
)
4545 gdbarch
->frame_num_args
= frame_num_args
;
4549 gdbarch_stack_align_p (struct gdbarch
*gdbarch
)
4551 gdb_assert (gdbarch
!= NULL
);
4552 return gdbarch
->stack_align
!= 0;
4556 gdbarch_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
4558 gdb_assert (gdbarch
!= NULL
);
4559 if (gdbarch
->stack_align
== 0)
4560 internal_error (__FILE__
, __LINE__
,
4561 "gdbarch: gdbarch_stack_align invalid");
4562 if (gdbarch_debug
>= 2)
4563 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stack_align called\n");
4564 return gdbarch
->stack_align (sp
);
4568 set_gdbarch_stack_align (struct gdbarch
*gdbarch
,
4569 gdbarch_stack_align_ftype stack_align
)
4571 gdbarch
->stack_align
= stack_align
;
4575 gdbarch_frame_align_p (struct gdbarch
*gdbarch
)
4577 gdb_assert (gdbarch
!= NULL
);
4578 return gdbarch
->frame_align
!= 0;
4582 gdbarch_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4584 gdb_assert (gdbarch
!= NULL
);
4585 if (gdbarch
->frame_align
== 0)
4586 internal_error (__FILE__
, __LINE__
,
4587 "gdbarch: gdbarch_frame_align invalid");
4588 if (gdbarch_debug
>= 2)
4589 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_align called\n");
4590 return gdbarch
->frame_align (gdbarch
, address
);
4594 set_gdbarch_frame_align (struct gdbarch
*gdbarch
,
4595 gdbarch_frame_align_ftype frame_align
)
4597 gdbarch
->frame_align
= frame_align
;
4601 gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
)
4603 gdb_assert (gdbarch
!= NULL
);
4604 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
4605 if (gdbarch_debug
>= 2)
4606 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extra_stack_alignment_needed called\n");
4607 return gdbarch
->extra_stack_alignment_needed
;
4611 set_gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
,
4612 int extra_stack_alignment_needed
)
4614 gdbarch
->extra_stack_alignment_needed
= extra_stack_alignment_needed
;
4618 gdbarch_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
4620 gdb_assert (gdbarch
!= NULL
);
4621 return gdbarch
->reg_struct_has_addr
!= 0;
4625 gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
4627 gdb_assert (gdbarch
!= NULL
);
4628 if (gdbarch
->reg_struct_has_addr
== 0)
4629 internal_error (__FILE__
, __LINE__
,
4630 "gdbarch: gdbarch_reg_struct_has_addr invalid");
4631 if (gdbarch_debug
>= 2)
4632 fprintf_unfiltered (gdb_stdlog
, "gdbarch_reg_struct_has_addr called\n");
4633 return gdbarch
->reg_struct_has_addr (gcc_p
, type
);
4637 set_gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
,
4638 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr
)
4640 gdbarch
->reg_struct_has_addr
= reg_struct_has_addr
;
4644 gdbarch_save_dummy_frame_tos_p (struct gdbarch
*gdbarch
)
4646 gdb_assert (gdbarch
!= NULL
);
4647 return gdbarch
->save_dummy_frame_tos
!= 0;
4651 gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
4653 gdb_assert (gdbarch
!= NULL
);
4654 if (gdbarch
->save_dummy_frame_tos
== 0)
4655 internal_error (__FILE__
, __LINE__
,
4656 "gdbarch: gdbarch_save_dummy_frame_tos invalid");
4657 if (gdbarch_debug
>= 2)
4658 fprintf_unfiltered (gdb_stdlog
, "gdbarch_save_dummy_frame_tos called\n");
4659 gdbarch
->save_dummy_frame_tos (sp
);
4663 set_gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
,
4664 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos
)
4666 gdbarch
->save_dummy_frame_tos
= save_dummy_frame_tos
;
4670 gdbarch_parm_boundary (struct gdbarch
*gdbarch
)
4672 gdb_assert (gdbarch
!= NULL
);
4673 if (gdbarch_debug
>= 2)
4674 fprintf_unfiltered (gdb_stdlog
, "gdbarch_parm_boundary called\n");
4675 return gdbarch
->parm_boundary
;
4679 set_gdbarch_parm_boundary (struct gdbarch
*gdbarch
,
4682 gdbarch
->parm_boundary
= parm_boundary
;
4685 const struct floatformat
*
4686 gdbarch_float_format (struct gdbarch
*gdbarch
)
4688 gdb_assert (gdbarch
!= NULL
);
4689 if (gdbarch_debug
>= 2)
4690 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
4691 return gdbarch
->float_format
;
4695 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
4696 const struct floatformat
* float_format
)
4698 gdbarch
->float_format
= float_format
;
4701 const struct floatformat
*
4702 gdbarch_double_format (struct gdbarch
*gdbarch
)
4704 gdb_assert (gdbarch
!= NULL
);
4705 if (gdbarch_debug
>= 2)
4706 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
4707 return gdbarch
->double_format
;
4711 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
4712 const struct floatformat
* double_format
)
4714 gdbarch
->double_format
= double_format
;
4717 const struct floatformat
*
4718 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
4720 gdb_assert (gdbarch
!= NULL
);
4721 if (gdbarch_debug
>= 2)
4722 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
4723 return gdbarch
->long_double_format
;
4727 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
4728 const struct floatformat
* long_double_format
)
4730 gdbarch
->long_double_format
= long_double_format
;
4734 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4736 gdb_assert (gdbarch
!= NULL
);
4737 if (gdbarch
->convert_from_func_ptr_addr
== 0)
4738 internal_error (__FILE__
, __LINE__
,
4739 "gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
4740 if (gdbarch_debug
>= 2)
4741 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
4742 return gdbarch
->convert_from_func_ptr_addr (addr
);
4746 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
4747 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
4749 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
4753 gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4755 gdb_assert (gdbarch
!= NULL
);
4756 if (gdbarch
->addr_bits_remove
== 0)
4757 internal_error (__FILE__
, __LINE__
,
4758 "gdbarch: gdbarch_addr_bits_remove invalid");
4759 if (gdbarch_debug
>= 2)
4760 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bits_remove called\n");
4761 return gdbarch
->addr_bits_remove (addr
);
4765 set_gdbarch_addr_bits_remove (struct gdbarch
*gdbarch
,
4766 gdbarch_addr_bits_remove_ftype addr_bits_remove
)
4768 gdbarch
->addr_bits_remove
= addr_bits_remove
;
4772 gdbarch_smash_text_address (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4774 gdb_assert (gdbarch
!= NULL
);
4775 if (gdbarch
->smash_text_address
== 0)
4776 internal_error (__FILE__
, __LINE__
,
4777 "gdbarch: gdbarch_smash_text_address invalid");
4778 if (gdbarch_debug
>= 2)
4779 fprintf_unfiltered (gdb_stdlog
, "gdbarch_smash_text_address called\n");
4780 return gdbarch
->smash_text_address (addr
);
4784 set_gdbarch_smash_text_address (struct gdbarch
*gdbarch
,
4785 gdbarch_smash_text_address_ftype smash_text_address
)
4787 gdbarch
->smash_text_address
= smash_text_address
;
4791 gdbarch_software_single_step_p (struct gdbarch
*gdbarch
)
4793 gdb_assert (gdbarch
!= NULL
);
4794 return gdbarch
->software_single_step
!= 0;
4798 gdbarch_software_single_step (struct gdbarch
*gdbarch
, enum target_signal sig
, int insert_breakpoints_p
)
4800 gdb_assert (gdbarch
!= NULL
);
4801 if (gdbarch
->software_single_step
== 0)
4802 internal_error (__FILE__
, __LINE__
,
4803 "gdbarch: gdbarch_software_single_step invalid");
4804 if (gdbarch_debug
>= 2)
4805 fprintf_unfiltered (gdb_stdlog
, "gdbarch_software_single_step called\n");
4806 gdbarch
->software_single_step (sig
, insert_breakpoints_p
);
4810 set_gdbarch_software_single_step (struct gdbarch
*gdbarch
,
4811 gdbarch_software_single_step_ftype software_single_step
)
4813 gdbarch
->software_single_step
= software_single_step
;
4817 gdbarch_print_insn (struct gdbarch
*gdbarch
, bfd_vma vma
, disassemble_info
*info
)
4819 gdb_assert (gdbarch
!= NULL
);
4820 if (gdbarch
->print_insn
== 0)
4821 internal_error (__FILE__
, __LINE__
,
4822 "gdbarch: gdbarch_print_insn invalid");
4823 if (gdbarch_debug
>= 2)
4824 fprintf_unfiltered (gdb_stdlog
, "gdbarch_print_insn called\n");
4825 return gdbarch
->print_insn (vma
, info
);
4829 set_gdbarch_print_insn (struct gdbarch
*gdbarch
,
4830 gdbarch_print_insn_ftype print_insn
)
4832 gdbarch
->print_insn
= print_insn
;
4836 gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
4838 gdb_assert (gdbarch
!= NULL
);
4839 if (gdbarch
->skip_trampoline_code
== 0)
4840 internal_error (__FILE__
, __LINE__
,
4841 "gdbarch: gdbarch_skip_trampoline_code invalid");
4842 if (gdbarch_debug
>= 2)
4843 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_trampoline_code called\n");
4844 return gdbarch
->skip_trampoline_code (pc
);
4848 set_gdbarch_skip_trampoline_code (struct gdbarch
*gdbarch
,
4849 gdbarch_skip_trampoline_code_ftype skip_trampoline_code
)
4851 gdbarch
->skip_trampoline_code
= skip_trampoline_code
;
4855 gdbarch_in_solib_call_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
4857 gdb_assert (gdbarch
!= NULL
);
4858 if (gdbarch
->in_solib_call_trampoline
== 0)
4859 internal_error (__FILE__
, __LINE__
,
4860 "gdbarch: gdbarch_in_solib_call_trampoline invalid");
4861 if (gdbarch_debug
>= 2)
4862 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_call_trampoline called\n");
4863 return gdbarch
->in_solib_call_trampoline (pc
, name
);
4867 set_gdbarch_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
4868 gdbarch_in_solib_call_trampoline_ftype in_solib_call_trampoline
)
4870 gdbarch
->in_solib_call_trampoline
= in_solib_call_trampoline
;
4874 gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
4876 gdb_assert (gdbarch
!= NULL
);
4877 if (gdbarch
->in_solib_return_trampoline
== 0)
4878 internal_error (__FILE__
, __LINE__
,
4879 "gdbarch: gdbarch_in_solib_return_trampoline invalid");
4880 if (gdbarch_debug
>= 2)
4881 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_solib_return_trampoline called\n");
4882 return gdbarch
->in_solib_return_trampoline (pc
, name
);
4886 set_gdbarch_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
4887 gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline
)
4889 gdbarch
->in_solib_return_trampoline
= in_solib_return_trampoline
;
4893 gdbarch_pc_in_sigtramp (struct gdbarch
*gdbarch
, CORE_ADDR pc
, char *name
)
4895 gdb_assert (gdbarch
!= NULL
);
4896 if (gdbarch
->pc_in_sigtramp
== 0)
4897 internal_error (__FILE__
, __LINE__
,
4898 "gdbarch: gdbarch_pc_in_sigtramp invalid");
4899 if (gdbarch_debug
>= 2)
4900 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_sigtramp called\n");
4901 return gdbarch
->pc_in_sigtramp (pc
, name
);
4905 set_gdbarch_pc_in_sigtramp (struct gdbarch
*gdbarch
,
4906 gdbarch_pc_in_sigtramp_ftype pc_in_sigtramp
)
4908 gdbarch
->pc_in_sigtramp
= pc_in_sigtramp
;
4912 gdbarch_sigtramp_start_p (struct gdbarch
*gdbarch
)
4914 gdb_assert (gdbarch
!= NULL
);
4915 return gdbarch
->sigtramp_start
!= 0;
4919 gdbarch_sigtramp_start (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
4921 gdb_assert (gdbarch
!= NULL
);
4922 if (gdbarch
->sigtramp_start
== 0)
4923 internal_error (__FILE__
, __LINE__
,
4924 "gdbarch: gdbarch_sigtramp_start invalid");
4925 if (gdbarch_debug
>= 2)
4926 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sigtramp_start called\n");
4927 return gdbarch
->sigtramp_start (pc
);
4931 set_gdbarch_sigtramp_start (struct gdbarch
*gdbarch
,
4932 gdbarch_sigtramp_start_ftype sigtramp_start
)
4934 gdbarch
->sigtramp_start
= sigtramp_start
;
4938 gdbarch_sigtramp_end_p (struct gdbarch
*gdbarch
)
4940 gdb_assert (gdbarch
!= NULL
);
4941 return gdbarch
->sigtramp_end
!= 0;
4945 gdbarch_sigtramp_end (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
4947 gdb_assert (gdbarch
!= NULL
);
4948 if (gdbarch
->sigtramp_end
== 0)
4949 internal_error (__FILE__
, __LINE__
,
4950 "gdbarch: gdbarch_sigtramp_end invalid");
4951 if (gdbarch_debug
>= 2)
4952 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sigtramp_end called\n");
4953 return gdbarch
->sigtramp_end (pc
);
4957 set_gdbarch_sigtramp_end (struct gdbarch
*gdbarch
,
4958 gdbarch_sigtramp_end_ftype sigtramp_end
)
4960 gdbarch
->sigtramp_end
= sigtramp_end
;
4964 gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
4966 gdb_assert (gdbarch
!= NULL
);
4967 if (gdbarch
->in_function_epilogue_p
== 0)
4968 internal_error (__FILE__
, __LINE__
,
4969 "gdbarch: gdbarch_in_function_epilogue_p invalid");
4970 if (gdbarch_debug
>= 2)
4971 fprintf_unfiltered (gdb_stdlog
, "gdbarch_in_function_epilogue_p called\n");
4972 return gdbarch
->in_function_epilogue_p (gdbarch
, addr
);
4976 set_gdbarch_in_function_epilogue_p (struct gdbarch
*gdbarch
,
4977 gdbarch_in_function_epilogue_p_ftype in_function_epilogue_p
)
4979 gdbarch
->in_function_epilogue_p
= in_function_epilogue_p
;
4983 gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
4985 gdb_assert (gdbarch
!= NULL
);
4986 if (gdbarch
->construct_inferior_arguments
== 0)
4987 internal_error (__FILE__
, __LINE__
,
4988 "gdbarch: gdbarch_construct_inferior_arguments invalid");
4989 if (gdbarch_debug
>= 2)
4990 fprintf_unfiltered (gdb_stdlog
, "gdbarch_construct_inferior_arguments called\n");
4991 return gdbarch
->construct_inferior_arguments (gdbarch
, argc
, argv
);
4995 set_gdbarch_construct_inferior_arguments (struct gdbarch
*gdbarch
,
4996 gdbarch_construct_inferior_arguments_ftype construct_inferior_arguments
)
4998 gdbarch
->construct_inferior_arguments
= construct_inferior_arguments
;
5002 gdbarch_dwarf2_build_frame_info_p (struct gdbarch
*gdbarch
)
5004 gdb_assert (gdbarch
!= NULL
);
5005 return gdbarch
->dwarf2_build_frame_info
!= 0;
5009 gdbarch_dwarf2_build_frame_info (struct gdbarch
*gdbarch
, struct objfile
*objfile
)
5011 gdb_assert (gdbarch
!= NULL
);
5012 if (gdbarch
->dwarf2_build_frame_info
== 0)
5013 internal_error (__FILE__
, __LINE__
,
5014 "gdbarch: gdbarch_dwarf2_build_frame_info invalid");
5015 if (gdbarch_debug
>= 2)
5016 fprintf_unfiltered (gdb_stdlog
, "gdbarch_dwarf2_build_frame_info called\n");
5017 gdbarch
->dwarf2_build_frame_info (objfile
);
5021 set_gdbarch_dwarf2_build_frame_info (struct gdbarch
*gdbarch
,
5022 gdbarch_dwarf2_build_frame_info_ftype dwarf2_build_frame_info
)
5024 gdbarch
->dwarf2_build_frame_info
= dwarf2_build_frame_info
;
5028 gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
, asymbol
*sym
, struct minimal_symbol
*msym
)
5030 gdb_assert (gdbarch
!= NULL
);
5031 if (gdbarch
->elf_make_msymbol_special
== 0)
5032 internal_error (__FILE__
, __LINE__
,
5033 "gdbarch: gdbarch_elf_make_msymbol_special invalid");
5034 if (gdbarch_debug
>= 2)
5035 fprintf_unfiltered (gdb_stdlog
, "gdbarch_elf_make_msymbol_special called\n");
5036 gdbarch
->elf_make_msymbol_special (sym
, msym
);
5040 set_gdbarch_elf_make_msymbol_special (struct gdbarch
*gdbarch
,
5041 gdbarch_elf_make_msymbol_special_ftype elf_make_msymbol_special
)
5043 gdbarch
->elf_make_msymbol_special
= elf_make_msymbol_special
;
5047 gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
, int val
, struct minimal_symbol
*msym
)
5049 gdb_assert (gdbarch
!= NULL
);
5050 if (gdbarch
->coff_make_msymbol_special
== 0)
5051 internal_error (__FILE__
, __LINE__
,
5052 "gdbarch: gdbarch_coff_make_msymbol_special invalid");
5053 if (gdbarch_debug
>= 2)
5054 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coff_make_msymbol_special called\n");
5055 gdbarch
->coff_make_msymbol_special (val
, msym
);
5059 set_gdbarch_coff_make_msymbol_special (struct gdbarch
*gdbarch
,
5060 gdbarch_coff_make_msymbol_special_ftype coff_make_msymbol_special
)
5062 gdbarch
->coff_make_msymbol_special
= coff_make_msymbol_special
;
5066 gdbarch_name_of_malloc (struct gdbarch
*gdbarch
)
5068 gdb_assert (gdbarch
!= NULL
);
5069 /* Skip verify of name_of_malloc, invalid_p == 0 */
5070 if (gdbarch_debug
>= 2)
5071 fprintf_unfiltered (gdb_stdlog
, "gdbarch_name_of_malloc called\n");
5072 return gdbarch
->name_of_malloc
;
5076 set_gdbarch_name_of_malloc (struct gdbarch
*gdbarch
,
5077 const char * name_of_malloc
)
5079 gdbarch
->name_of_malloc
= name_of_malloc
;
5083 gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
)
5085 gdb_assert (gdbarch
!= NULL
);
5086 /* Skip verify of cannot_step_breakpoint, invalid_p == 0 */
5087 if (gdbarch_debug
>= 2)
5088 fprintf_unfiltered (gdb_stdlog
, "gdbarch_cannot_step_breakpoint called\n");
5089 return gdbarch
->cannot_step_breakpoint
;
5093 set_gdbarch_cannot_step_breakpoint (struct gdbarch
*gdbarch
,
5094 int cannot_step_breakpoint
)
5096 gdbarch
->cannot_step_breakpoint
= cannot_step_breakpoint
;
5100 gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
)
5102 gdb_assert (gdbarch
!= NULL
);
5103 /* Skip verify of have_nonsteppable_watchpoint, invalid_p == 0 */
5104 if (gdbarch_debug
>= 2)
5105 fprintf_unfiltered (gdb_stdlog
, "gdbarch_have_nonsteppable_watchpoint called\n");
5106 return gdbarch
->have_nonsteppable_watchpoint
;
5110 set_gdbarch_have_nonsteppable_watchpoint (struct gdbarch
*gdbarch
,
5111 int have_nonsteppable_watchpoint
)
5113 gdbarch
->have_nonsteppable_watchpoint
= have_nonsteppable_watchpoint
;
5117 gdbarch_address_class_type_flags_p (struct gdbarch
*gdbarch
)
5119 gdb_assert (gdbarch
!= NULL
);
5120 return gdbarch
->address_class_type_flags
!= 0;
5124 gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
, int byte_size
, int dwarf2_addr_class
)
5126 gdb_assert (gdbarch
!= NULL
);
5127 if (gdbarch
->address_class_type_flags
== 0)
5128 internal_error (__FILE__
, __LINE__
,
5129 "gdbarch: gdbarch_address_class_type_flags invalid");
5130 if (gdbarch_debug
>= 2)
5131 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags called\n");
5132 return gdbarch
->address_class_type_flags (byte_size
, dwarf2_addr_class
);
5136 set_gdbarch_address_class_type_flags (struct gdbarch
*gdbarch
,
5137 gdbarch_address_class_type_flags_ftype address_class_type_flags
)
5139 gdbarch
->address_class_type_flags
= address_class_type_flags
;
5143 gdbarch_address_class_type_flags_to_name_p (struct gdbarch
*gdbarch
)
5145 gdb_assert (gdbarch
!= NULL
);
5146 return gdbarch
->address_class_type_flags_to_name
!= 0;
5150 gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
, int type_flags
)
5152 gdb_assert (gdbarch
!= NULL
);
5153 if (gdbarch
->address_class_type_flags_to_name
== 0)
5154 internal_error (__FILE__
, __LINE__
,
5155 "gdbarch: gdbarch_address_class_type_flags_to_name invalid");
5156 if (gdbarch_debug
>= 2)
5157 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_type_flags_to_name called\n");
5158 return gdbarch
->address_class_type_flags_to_name (gdbarch
, type_flags
);
5162 set_gdbarch_address_class_type_flags_to_name (struct gdbarch
*gdbarch
,
5163 gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name
)
5165 gdbarch
->address_class_type_flags_to_name
= address_class_type_flags_to_name
;
5169 gdbarch_address_class_name_to_type_flags_p (struct gdbarch
*gdbarch
)
5171 gdb_assert (gdbarch
!= NULL
);
5172 return gdbarch
->address_class_name_to_type_flags
!= 0;
5176 gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
, char *name
, int *type_flags_ptr
)
5178 gdb_assert (gdbarch
!= NULL
);
5179 if (gdbarch
->address_class_name_to_type_flags
== 0)
5180 internal_error (__FILE__
, __LINE__
,
5181 "gdbarch: gdbarch_address_class_name_to_type_flags invalid");
5182 if (gdbarch_debug
>= 2)
5183 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_class_name_to_type_flags called\n");
5184 return gdbarch
->address_class_name_to_type_flags (gdbarch
, name
, type_flags_ptr
);
5188 set_gdbarch_address_class_name_to_type_flags (struct gdbarch
*gdbarch
,
5189 gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags
)
5191 gdbarch
->address_class_name_to_type_flags
= address_class_name_to_type_flags
;
5195 gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
, struct reggroup
*reggroup
)
5197 gdb_assert (gdbarch
!= NULL
);
5198 if (gdbarch
->register_reggroup_p
== 0)
5199 internal_error (__FILE__
, __LINE__
,
5200 "gdbarch: gdbarch_register_reggroup_p invalid");
5201 if (gdbarch_debug
>= 2)
5202 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_reggroup_p called\n");
5203 return gdbarch
->register_reggroup_p (gdbarch
, regnum
, reggroup
);
5207 set_gdbarch_register_reggroup_p (struct gdbarch
*gdbarch
,
5208 gdbarch_register_reggroup_p_ftype register_reggroup_p
)
5210 gdbarch
->register_reggroup_p
= register_reggroup_p
;
5214 /* Keep a registry of per-architecture data-pointers required by GDB
5221 gdbarch_data_init_ftype
*init
;
5222 gdbarch_data_free_ftype
*free
;
5225 struct gdbarch_data_registration
5227 struct gdbarch_data
*data
;
5228 struct gdbarch_data_registration
*next
;
5231 struct gdbarch_data_registry
5234 struct gdbarch_data_registration
*registrations
;
5237 struct gdbarch_data_registry gdbarch_data_registry
=
5242 struct gdbarch_data
*
5243 register_gdbarch_data (gdbarch_data_init_ftype
*init
,
5244 gdbarch_data_free_ftype
*free
)
5246 struct gdbarch_data_registration
**curr
;
5247 /* Append the new registraration. */
5248 for (curr
= &gdbarch_data_registry
.registrations
;
5250 curr
= &(*curr
)->next
);
5251 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
5252 (*curr
)->next
= NULL
;
5253 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
5254 (*curr
)->data
->index
= gdbarch_data_registry
.nr
++;
5255 (*curr
)->data
->init
= init
;
5256 (*curr
)->data
->init_p
= 1;
5257 (*curr
)->data
->free
= free
;
5258 return (*curr
)->data
;
5262 /* Create/delete the gdbarch data vector. */
5265 alloc_gdbarch_data (struct gdbarch
*gdbarch
)
5267 gdb_assert (gdbarch
->data
== NULL
);
5268 gdbarch
->nr_data
= gdbarch_data_registry
.nr
;
5269 gdbarch
->data
= xcalloc (gdbarch
->nr_data
, sizeof (void*));
5273 free_gdbarch_data (struct gdbarch
*gdbarch
)
5275 struct gdbarch_data_registration
*rego
;
5276 gdb_assert (gdbarch
->data
!= NULL
);
5277 for (rego
= gdbarch_data_registry
.registrations
;
5281 struct gdbarch_data
*data
= rego
->data
;
5282 gdb_assert (data
->index
< gdbarch
->nr_data
);
5283 if (data
->free
!= NULL
&& gdbarch
->data
[data
->index
] != NULL
)
5285 data
->free (gdbarch
, gdbarch
->data
[data
->index
]);
5286 gdbarch
->data
[data
->index
] = NULL
;
5289 xfree (gdbarch
->data
);
5290 gdbarch
->data
= NULL
;
5294 /* Initialize the current value of the specified per-architecture
5298 set_gdbarch_data (struct gdbarch
*gdbarch
,
5299 struct gdbarch_data
*data
,
5302 gdb_assert (data
->index
< gdbarch
->nr_data
);
5303 if (gdbarch
->data
[data
->index
] != NULL
)
5305 gdb_assert (data
->free
!= NULL
);
5306 data
->free (gdbarch
, gdbarch
->data
[data
->index
]);
5308 gdbarch
->data
[data
->index
] = pointer
;
5311 /* Return the current value of the specified per-architecture
5315 gdbarch_data (struct gdbarch
*gdbarch
, struct gdbarch_data
*data
)
5317 gdb_assert (data
->index
< gdbarch
->nr_data
);
5318 /* The data-pointer isn't initialized, call init() to get a value but
5319 only if the architecture initializaiton has completed. Otherwise
5320 punt - hope that the caller knows what they are doing. */
5321 if (gdbarch
->data
[data
->index
] == NULL
5322 && gdbarch
->initialized_p
)
5324 /* Be careful to detect an initialization cycle. */
5325 gdb_assert (data
->init_p
);
5327 gdb_assert (data
->init
!= NULL
);
5328 gdbarch
->data
[data
->index
] = data
->init (gdbarch
);
5330 gdb_assert (gdbarch
->data
[data
->index
] != NULL
);
5332 return gdbarch
->data
[data
->index
];
5337 /* Keep a registry of swapped data required by GDB modules. */
5342 struct gdbarch_swap_registration
*source
;
5343 struct gdbarch_swap
*next
;
5346 struct gdbarch_swap_registration
5349 unsigned long sizeof_data
;
5350 gdbarch_swap_ftype
*init
;
5351 struct gdbarch_swap_registration
*next
;
5354 struct gdbarch_swap_registry
5357 struct gdbarch_swap_registration
*registrations
;
5360 struct gdbarch_swap_registry gdbarch_swap_registry
=
5366 register_gdbarch_swap (void *data
,
5367 unsigned long sizeof_data
,
5368 gdbarch_swap_ftype
*init
)
5370 struct gdbarch_swap_registration
**rego
;
5371 for (rego
= &gdbarch_swap_registry
.registrations
;
5373 rego
= &(*rego
)->next
);
5374 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
5375 (*rego
)->next
= NULL
;
5376 (*rego
)->init
= init
;
5377 (*rego
)->data
= data
;
5378 (*rego
)->sizeof_data
= sizeof_data
;
5382 clear_gdbarch_swap (struct gdbarch
*gdbarch
)
5384 struct gdbarch_swap
*curr
;
5385 for (curr
= gdbarch
->swap
;
5389 memset (curr
->source
->data
, 0, curr
->source
->sizeof_data
);
5394 init_gdbarch_swap (struct gdbarch
*gdbarch
)
5396 struct gdbarch_swap_registration
*rego
;
5397 struct gdbarch_swap
**curr
= &gdbarch
->swap
;
5398 for (rego
= gdbarch_swap_registry
.registrations
;
5402 if (rego
->data
!= NULL
)
5404 (*curr
) = XMALLOC (struct gdbarch_swap
);
5405 (*curr
)->source
= rego
;
5406 (*curr
)->swap
= xmalloc (rego
->sizeof_data
);
5407 (*curr
)->next
= NULL
;
5408 curr
= &(*curr
)->next
;
5410 if (rego
->init
!= NULL
)
5416 swapout_gdbarch_swap (struct gdbarch
*gdbarch
)
5418 struct gdbarch_swap
*curr
;
5419 for (curr
= gdbarch
->swap
;
5422 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
5426 swapin_gdbarch_swap (struct gdbarch
*gdbarch
)
5428 struct gdbarch_swap
*curr
;
5429 for (curr
= gdbarch
->swap
;
5432 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
5436 /* Keep a registry of the architectures known by GDB. */
5438 struct gdbarch_registration
5440 enum bfd_architecture bfd_architecture
;
5441 gdbarch_init_ftype
*init
;
5442 gdbarch_dump_tdep_ftype
*dump_tdep
;
5443 struct gdbarch_list
*arches
;
5444 struct gdbarch_registration
*next
;
5447 static struct gdbarch_registration
*gdbarch_registry
= NULL
;
5450 append_name (const char ***buf
, int *nr
, const char *name
)
5452 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
5458 gdbarch_printable_names (void)
5462 /* Accumulate a list of names based on the registed list of
5464 enum bfd_architecture a
;
5466 const char **arches
= NULL
;
5467 struct gdbarch_registration
*rego
;
5468 for (rego
= gdbarch_registry
;
5472 const struct bfd_arch_info
*ap
;
5473 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
5475 internal_error (__FILE__
, __LINE__
,
5476 "gdbarch_architecture_names: multi-arch unknown");
5479 append_name (&arches
, &nr_arches
, ap
->printable_name
);
5484 append_name (&arches
, &nr_arches
, NULL
);
5488 /* Just return all the architectures that BFD knows. Assume that
5489 the legacy architecture framework supports them. */
5490 return bfd_arch_list ();
5495 gdbarch_register (enum bfd_architecture bfd_architecture
,
5496 gdbarch_init_ftype
*init
,
5497 gdbarch_dump_tdep_ftype
*dump_tdep
)
5499 struct gdbarch_registration
**curr
;
5500 const struct bfd_arch_info
*bfd_arch_info
;
5501 /* Check that BFD recognizes this architecture */
5502 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
5503 if (bfd_arch_info
== NULL
)
5505 internal_error (__FILE__
, __LINE__
,
5506 "gdbarch: Attempt to register unknown architecture (%d)",
5509 /* Check that we haven't seen this architecture before */
5510 for (curr
= &gdbarch_registry
;
5512 curr
= &(*curr
)->next
)
5514 if (bfd_architecture
== (*curr
)->bfd_architecture
)
5515 internal_error (__FILE__
, __LINE__
,
5516 "gdbarch: Duplicate registraration of architecture (%s)",
5517 bfd_arch_info
->printable_name
);
5521 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
5522 bfd_arch_info
->printable_name
,
5525 (*curr
) = XMALLOC (struct gdbarch_registration
);
5526 (*curr
)->bfd_architecture
= bfd_architecture
;
5527 (*curr
)->init
= init
;
5528 (*curr
)->dump_tdep
= dump_tdep
;
5529 (*curr
)->arches
= NULL
;
5530 (*curr
)->next
= NULL
;
5531 /* When non- multi-arch, install whatever target dump routine we've
5532 been provided - hopefully that routine has been written correctly
5533 and works regardless of multi-arch. */
5534 if (!GDB_MULTI_ARCH
&& dump_tdep
!= NULL
5535 && startup_gdbarch
.dump_tdep
== NULL
)
5536 startup_gdbarch
.dump_tdep
= dump_tdep
;
5540 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
5541 gdbarch_init_ftype
*init
)
5543 gdbarch_register (bfd_architecture
, init
, NULL
);
5547 /* Look for an architecture using gdbarch_info. Base search on only
5548 BFD_ARCH_INFO and BYTE_ORDER. */
5550 struct gdbarch_list
*
5551 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
5552 const struct gdbarch_info
*info
)
5554 for (; arches
!= NULL
; arches
= arches
->next
)
5556 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
5558 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
5566 /* Update the current architecture. Return ZERO if the update request
5570 gdbarch_update_p (struct gdbarch_info info
)
5572 struct gdbarch
*new_gdbarch
;
5573 struct gdbarch
*old_gdbarch
;
5574 struct gdbarch_registration
*rego
;
5576 /* Fill in missing parts of the INFO struct using a number of
5577 sources: ``set ...''; INFOabfd supplied; existing target. */
5579 /* ``(gdb) set architecture ...'' */
5580 if (info
.bfd_arch_info
== NULL
5581 && !TARGET_ARCHITECTURE_AUTO
)
5582 info
.bfd_arch_info
= TARGET_ARCHITECTURE
;
5583 if (info
.bfd_arch_info
== NULL
5584 && info
.abfd
!= NULL
5585 && bfd_get_arch (info
.abfd
) != bfd_arch_unknown
5586 && bfd_get_arch (info
.abfd
) != bfd_arch_obscure
)
5587 info
.bfd_arch_info
= bfd_get_arch_info (info
.abfd
);
5588 if (info
.bfd_arch_info
== NULL
)
5589 info
.bfd_arch_info
= TARGET_ARCHITECTURE
;
5591 /* ``(gdb) set byte-order ...'' */
5592 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
5593 && !TARGET_BYTE_ORDER_AUTO
)
5594 info
.byte_order
= TARGET_BYTE_ORDER
;
5595 /* From the INFO struct. */
5596 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
5597 && info
.abfd
!= NULL
)
5598 info
.byte_order
= (bfd_big_endian (info
.abfd
) ? BFD_ENDIAN_BIG
5599 : bfd_little_endian (info
.abfd
) ? BFD_ENDIAN_LITTLE
5600 : BFD_ENDIAN_UNKNOWN
);
5601 /* From the current target. */
5602 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
5603 info
.byte_order
= TARGET_BYTE_ORDER
;
5605 /* Must have found some sort of architecture. */
5606 gdb_assert (info
.bfd_arch_info
!= NULL
);
5610 fprintf_unfiltered (gdb_stdlog
,
5611 "gdbarch_update: info.bfd_arch_info %s\n",
5612 (info
.bfd_arch_info
!= NULL
5613 ? info
.bfd_arch_info
->printable_name
5615 fprintf_unfiltered (gdb_stdlog
,
5616 "gdbarch_update: info.byte_order %d (%s)\n",
5618 (info
.byte_order
== BFD_ENDIAN_BIG
? "big"
5619 : info
.byte_order
== BFD_ENDIAN_LITTLE
? "little"
5621 fprintf_unfiltered (gdb_stdlog
,
5622 "gdbarch_update: info.abfd 0x%lx\n",
5624 fprintf_unfiltered (gdb_stdlog
,
5625 "gdbarch_update: info.tdep_info 0x%lx\n",
5626 (long) info
.tdep_info
);
5629 /* Find the target that knows about this architecture. */
5630 for (rego
= gdbarch_registry
;
5633 if (rego
->bfd_architecture
== info
.bfd_arch_info
->arch
)
5638 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: No matching architecture\n");
5642 /* Swap the data belonging to the old target out setting the
5643 installed data to zero. This stops the ->init() function trying
5644 to refer to the previous architecture's global data structures. */
5645 swapout_gdbarch_swap (current_gdbarch
);
5646 clear_gdbarch_swap (current_gdbarch
);
5648 /* Save the previously selected architecture, setting the global to
5649 NULL. This stops ->init() trying to use the previous
5650 architecture's configuration. The previous architecture may not
5651 even be of the same architecture family. The most recent
5652 architecture of the same family is found at the head of the
5653 rego->arches list. */
5654 old_gdbarch
= current_gdbarch
;
5655 current_gdbarch
= NULL
;
5657 /* Ask the target for a replacement architecture. */
5658 new_gdbarch
= rego
->init (info
, rego
->arches
);
5660 /* Did the target like it? No. Reject the change and revert to the
5661 old architecture. */
5662 if (new_gdbarch
== NULL
)
5665 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Target rejected architecture\n");
5666 swapin_gdbarch_swap (old_gdbarch
);
5667 current_gdbarch
= old_gdbarch
;
5671 /* Did the architecture change? No. Oops, put the old architecture
5673 if (old_gdbarch
== new_gdbarch
)
5676 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
5678 new_gdbarch
->bfd_arch_info
->printable_name
);
5679 swapin_gdbarch_swap (old_gdbarch
);
5680 current_gdbarch
= old_gdbarch
;
5684 /* Is this a pre-existing architecture? Yes. Move it to the front
5685 of the list of architectures (keeping the list sorted Most
5686 Recently Used) and then copy it in. */
5688 struct gdbarch_list
**list
;
5689 for (list
= ®o
->arches
;
5691 list
= &(*list
)->next
)
5693 if ((*list
)->gdbarch
== new_gdbarch
)
5695 struct gdbarch_list
*this;
5697 fprintf_unfiltered (gdb_stdlog
,
5698 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
5700 new_gdbarch
->bfd_arch_info
->printable_name
);
5703 (*list
) = this->next
;
5704 /* Insert in the front. */
5705 this->next
= rego
->arches
;
5706 rego
->arches
= this;
5707 /* Copy the new architecture in. */
5708 current_gdbarch
= new_gdbarch
;
5709 swapin_gdbarch_swap (new_gdbarch
);
5710 architecture_changed_event ();
5716 /* Prepend this new architecture to the architecture list (keep the
5717 list sorted Most Recently Used). */
5719 struct gdbarch_list
*this = XMALLOC (struct gdbarch_list
);
5720 this->next
= rego
->arches
;
5721 this->gdbarch
= new_gdbarch
;
5722 rego
->arches
= this;
5725 /* Switch to this new architecture marking it initialized. */
5726 current_gdbarch
= new_gdbarch
;
5727 current_gdbarch
->initialized_p
= 1;
5730 fprintf_unfiltered (gdb_stdlog
,
5731 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
5733 new_gdbarch
->bfd_arch_info
->printable_name
);
5736 /* Check that the newly installed architecture is valid. Plug in
5737 any post init values. */
5738 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
5739 verify_gdbarch (new_gdbarch
);
5741 /* Initialize the per-architecture memory (swap) areas.
5742 CURRENT_GDBARCH must be update before these modules are
5744 init_gdbarch_swap (new_gdbarch
);
5746 /* Initialize the per-architecture data. CURRENT_GDBARCH
5747 must be updated before these modules are called. */
5748 architecture_changed_event ();
5751 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
5759 /* Pointer to the target-dependent disassembly function. */
5760 int (*tm_print_insn
) (bfd_vma
, disassemble_info
*);
5761 disassemble_info tm_print_insn_info
;
5764 extern void _initialize_gdbarch (void);
5767 _initialize_gdbarch (void)
5769 struct cmd_list_element
*c
;
5771 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
5772 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
5773 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
5774 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
5775 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;
5777 add_show_from_set (add_set_cmd ("arch",
5780 (char *)&gdbarch_debug
,
5781 "Set architecture debugging.\n\
5782 When non-zero, architecture debugging is enabled.", &setdebuglist
),
5784 c
= add_set_cmd ("archdebug",
5787 (char *)&gdbarch_debug
,
5788 "Set architecture debugging.\n\
5789 When non-zero, architecture debugging is enabled.", &setlist
);
5791 deprecate_cmd (c
, "set debug arch");
5792 deprecate_cmd (add_show_from_set (c
, &showlist
), "show debug arch");