1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
4 Copyright 1998-1999, 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 bourn 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 makeing 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 */
61 #include "floatformat.h"
63 /* Static function declarations */
65 static void verify_gdbarch (struct gdbarch
*gdbarch
);
66 static void init_gdbarch_data (struct gdbarch
*);
67 static void init_gdbarch_swap (struct gdbarch
*);
68 static void swapout_gdbarch_swap (struct gdbarch
*);
69 static void swapin_gdbarch_swap (struct gdbarch
*);
71 /* Convenience macro for allocting typesafe memory. */
74 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
78 /* Non-zero if we want to trace architecture code. */
81 #define GDBARCH_DEBUG 0
83 int gdbarch_debug
= GDBARCH_DEBUG
;
86 /* Maintain the struct gdbarch object */
90 /* basic architectural information */
91 const struct bfd_arch_info
* bfd_arch_info
;
94 /* target specific vector. */
95 struct gdbarch_tdep
*tdep
;
96 gdbarch_dump_tdep_ftype
*dump_tdep
;
98 /* per-architecture data-pointers */
102 /* per-architecture swap-regions */
103 struct gdbarch_swap
*swap
;
105 /* Multi-arch values.
107 When extending this structure you must:
111 Declare set/get functions and define the corresponding
114 gdbarch_alloc(): If zero/NULL is not a suitable default,
115 initialize the new field.
117 verify_gdbarch(): Confirm that the target updated the field
120 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
123 ``startup_gdbarch()'': Append an initial value to the static
124 variable (base values on the host's c-type system).
126 get_gdbarch(): Implement the set/get functions (probably using
127 the macro's as shortcuts).
141 gdbarch_read_pc_ftype
*read_pc
;
142 gdbarch_write_pc_ftype
*write_pc
;
143 gdbarch_read_fp_ftype
*read_fp
;
144 gdbarch_write_fp_ftype
*write_fp
;
145 gdbarch_read_sp_ftype
*read_sp
;
146 gdbarch_write_sp_ftype
*write_sp
;
155 gdbarch_register_name_ftype
*register_name
;
158 gdbarch_register_byte_ftype
*register_byte
;
159 gdbarch_register_raw_size_ftype
*register_raw_size
;
160 int max_register_raw_size
;
161 gdbarch_register_virtual_size_ftype
*register_virtual_size
;
162 int max_register_virtual_size
;
163 gdbarch_register_virtual_type_ftype
*register_virtual_type
;
164 gdbarch_do_registers_info_ftype
*do_registers_info
;
165 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
166 int use_generic_dummy_frames
;
167 int call_dummy_location
;
168 gdbarch_call_dummy_address_ftype
*call_dummy_address
;
169 CORE_ADDR call_dummy_start_offset
;
170 CORE_ADDR call_dummy_breakpoint_offset
;
171 int call_dummy_breakpoint_offset_p
;
172 int call_dummy_length
;
173 gdbarch_pc_in_call_dummy_ftype
*pc_in_call_dummy
;
175 LONGEST
* call_dummy_words
;
176 int sizeof_call_dummy_words
;
177 int call_dummy_stack_adjust_p
;
178 int call_dummy_stack_adjust
;
179 gdbarch_fix_call_dummy_ftype
*fix_call_dummy
;
180 int believe_pcc_promotion
;
181 int believe_pcc_promotion_type
;
182 gdbarch_coerce_float_to_double_ftype
*coerce_float_to_double
;
183 gdbarch_get_saved_register_ftype
*get_saved_register
;
184 gdbarch_register_convertible_ftype
*register_convertible
;
185 gdbarch_register_convert_to_virtual_ftype
*register_convert_to_virtual
;
186 gdbarch_register_convert_to_raw_ftype
*register_convert_to_raw
;
187 gdbarch_fetch_pseudo_register_ftype
*fetch_pseudo_register
;
188 gdbarch_store_pseudo_register_ftype
*store_pseudo_register
;
189 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
190 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
191 gdbarch_return_value_on_stack_ftype
*return_value_on_stack
;
192 gdbarch_extract_return_value_ftype
*extract_return_value
;
193 gdbarch_push_arguments_ftype
*push_arguments
;
194 gdbarch_push_dummy_frame_ftype
*push_dummy_frame
;
195 gdbarch_push_return_address_ftype
*push_return_address
;
196 gdbarch_pop_frame_ftype
*pop_frame
;
197 gdbarch_d10v_make_daddr_ftype
*d10v_make_daddr
;
198 gdbarch_d10v_make_iaddr_ftype
*d10v_make_iaddr
;
199 gdbarch_d10v_daddr_p_ftype
*d10v_daddr_p
;
200 gdbarch_d10v_iaddr_p_ftype
*d10v_iaddr_p
;
201 gdbarch_d10v_convert_daddr_to_raw_ftype
*d10v_convert_daddr_to_raw
;
202 gdbarch_d10v_convert_iaddr_to_raw_ftype
*d10v_convert_iaddr_to_raw
;
203 gdbarch_store_struct_return_ftype
*store_struct_return
;
204 gdbarch_store_return_value_ftype
*store_return_value
;
205 gdbarch_extract_struct_value_address_ftype
*extract_struct_value_address
;
206 gdbarch_use_struct_convention_ftype
*use_struct_convention
;
207 gdbarch_frame_init_saved_regs_ftype
*frame_init_saved_regs
;
208 gdbarch_init_extra_frame_info_ftype
*init_extra_frame_info
;
209 gdbarch_skip_prologue_ftype
*skip_prologue
;
210 gdbarch_prologue_frameless_p_ftype
*prologue_frameless_p
;
211 gdbarch_inner_than_ftype
*inner_than
;
212 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
213 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
214 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
215 CORE_ADDR decr_pc_after_break
;
216 CORE_ADDR function_start_offset
;
217 gdbarch_remote_translate_xfer_address_ftype
*remote_translate_xfer_address
;
218 CORE_ADDR frame_args_skip
;
219 gdbarch_frameless_function_invocation_ftype
*frameless_function_invocation
;
220 gdbarch_frame_chain_ftype
*frame_chain
;
221 gdbarch_frame_chain_valid_ftype
*frame_chain_valid
;
222 gdbarch_frame_saved_pc_ftype
*frame_saved_pc
;
223 gdbarch_frame_args_address_ftype
*frame_args_address
;
224 gdbarch_frame_locals_address_ftype
*frame_locals_address
;
225 gdbarch_saved_pc_after_call_ftype
*saved_pc_after_call
;
226 gdbarch_frame_num_args_ftype
*frame_num_args
;
227 gdbarch_stack_align_ftype
*stack_align
;
228 int extra_stack_alignment_needed
;
229 gdbarch_reg_struct_has_addr_ftype
*reg_struct_has_addr
;
230 gdbarch_save_dummy_frame_tos_ftype
*save_dummy_frame_tos
;
231 const struct floatformat
* float_format
;
232 const struct floatformat
* double_format
;
233 const struct floatformat
* long_double_format
;
237 /* The default architecture uses host values (for want of a better
240 extern const struct bfd_arch_info bfd_default_arch_struct
;
242 struct gdbarch startup_gdbarch
=
244 /* basic architecture information */
245 &bfd_default_arch_struct
,
247 /* target specific vector and its dump routine */
249 /*per-architecture data-pointers and swap regions */
251 /* Multi-arch values */
257 8 * sizeof (LONGEST
),
260 8 * sizeof (long double),
304 generic_get_saved_register
,
355 /* startup_gdbarch() */
358 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
361 /* Create a new ``struct gdbarch'' based in information provided by
362 ``struct gdbarch_info''. */
365 gdbarch_alloc (const struct gdbarch_info
*info
,
366 struct gdbarch_tdep
*tdep
)
368 struct gdbarch
*gdbarch
= XMALLOC (struct gdbarch
);
369 memset (gdbarch
, 0, sizeof (*gdbarch
));
371 gdbarch
->tdep
= tdep
;
373 gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
374 gdbarch
->byte_order
= info
->byte_order
;
376 /* Force the explicit initialization of these. */
377 gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
378 gdbarch
->num_regs
= -1;
379 gdbarch
->sp_regnum
= -1;
380 gdbarch
->fp_regnum
= -1;
381 gdbarch
->pc_regnum
= -1;
382 gdbarch
->fp0_regnum
= -1;
383 gdbarch
->npc_regnum
= -1;
384 gdbarch
->nnpc_regnum
= -1;
385 gdbarch
->register_name
= legacy_register_name
;
386 gdbarch
->register_size
= -1;
387 gdbarch
->register_bytes
= -1;
388 gdbarch
->max_register_raw_size
= -1;
389 gdbarch
->max_register_virtual_size
= -1;
390 gdbarch
->do_registers_info
= do_registers_info
;
391 gdbarch
->register_sim_regno
= default_register_sim_regno
;
392 gdbarch
->use_generic_dummy_frames
= -1;
393 gdbarch
->call_dummy_start_offset
= -1;
394 gdbarch
->call_dummy_breakpoint_offset
= -1;
395 gdbarch
->call_dummy_breakpoint_offset_p
= -1;
396 gdbarch
->call_dummy_length
= -1;
397 gdbarch
->call_dummy_p
= -1;
398 gdbarch
->call_dummy_words
= legacy_call_dummy_words
;
399 gdbarch
->sizeof_call_dummy_words
= legacy_sizeof_call_dummy_words
;
400 gdbarch
->call_dummy_stack_adjust_p
= -1;
401 gdbarch
->coerce_float_to_double
= default_coerce_float_to_double
;
402 gdbarch
->register_convertible
= generic_register_convertible_not
;
403 gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
404 gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
405 gdbarch
->return_value_on_stack
= generic_return_value_on_stack_not
;
406 gdbarch
->prologue_frameless_p
= generic_prologue_frameless_p
;
407 gdbarch
->breakpoint_from_pc
= legacy_breakpoint_from_pc
;
408 gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
409 gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
410 gdbarch
->decr_pc_after_break
= -1;
411 gdbarch
->function_start_offset
= -1;
412 gdbarch
->remote_translate_xfer_address
= generic_remote_translate_xfer_address
;
413 gdbarch
->frame_args_skip
= -1;
414 gdbarch
->frameless_function_invocation
= generic_frameless_function_invocation_not
;
415 gdbarch
->extra_stack_alignment_needed
= 1;
416 /* gdbarch_alloc() */
422 /* Free a gdbarch struct. This should never happen in normal
423 operation --- once you've created a gdbarch, you keep it around.
424 However, if an architecture's init function encounters an error
425 building the structure, it may need to clean up a partially
426 constructed gdbarch. */
429 gdbarch_free (struct gdbarch
*arch
)
431 /* At the moment, this is trivial. */
436 /* Ensure that all values in a GDBARCH are reasonable. */
439 verify_gdbarch (struct gdbarch
*gdbarch
)
441 /* Only perform sanity checks on a multi-arch target. */
445 if (gdbarch
->byte_order
== 0)
446 internal_error ("verify_gdbarch: byte-order unset");
447 if (gdbarch
->bfd_arch_info
== NULL
)
448 internal_error ("verify_gdbarch: bfd_arch_info unset");
449 /* Check those that need to be defined for the given multi-arch level. */
450 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
451 if ((GDB_MULTI_ARCH
>= 1)
452 && (gdbarch
->ptr_bit
== 0))
453 internal_error ("gdbarch: verify_gdbarch: ptr_bit invalid");
454 if ((GDB_MULTI_ARCH
>= 1)
455 && (gdbarch
->short_bit
== 0))
456 internal_error ("gdbarch: verify_gdbarch: short_bit invalid");
457 if ((GDB_MULTI_ARCH
>= 1)
458 && (gdbarch
->int_bit
== 0))
459 internal_error ("gdbarch: verify_gdbarch: int_bit invalid");
460 if ((GDB_MULTI_ARCH
>= 1)
461 && (gdbarch
->long_bit
== 0))
462 internal_error ("gdbarch: verify_gdbarch: long_bit invalid");
463 if ((GDB_MULTI_ARCH
>= 1)
464 && (gdbarch
->long_long_bit
== 0))
465 internal_error ("gdbarch: verify_gdbarch: long_long_bit invalid");
466 if ((GDB_MULTI_ARCH
>= 1)
467 && (gdbarch
->float_bit
== 0))
468 internal_error ("gdbarch: verify_gdbarch: float_bit invalid");
469 if ((GDB_MULTI_ARCH
>= 1)
470 && (gdbarch
->double_bit
== 0))
471 internal_error ("gdbarch: verify_gdbarch: double_bit invalid");
472 if ((GDB_MULTI_ARCH
>= 1)
473 && (gdbarch
->long_double_bit
== 0))
474 internal_error ("gdbarch: verify_gdbarch: long_double_bit invalid");
475 /* Skip verify of ieee_float, invalid_p == 0 */
476 if ((GDB_MULTI_ARCH
>= 1)
477 && (gdbarch
->read_pc
== 0))
478 internal_error ("gdbarch: verify_gdbarch: read_pc invalid");
479 if ((GDB_MULTI_ARCH
>= 1)
480 && (gdbarch
->write_pc
== 0))
481 internal_error ("gdbarch: verify_gdbarch: write_pc invalid");
482 if ((GDB_MULTI_ARCH
>= 1)
483 && (gdbarch
->read_fp
== 0))
484 internal_error ("gdbarch: verify_gdbarch: read_fp invalid");
485 if ((GDB_MULTI_ARCH
>= 1)
486 && (gdbarch
->write_fp
== 0))
487 internal_error ("gdbarch: verify_gdbarch: write_fp invalid");
488 if ((GDB_MULTI_ARCH
>= 1)
489 && (gdbarch
->read_sp
== 0))
490 internal_error ("gdbarch: verify_gdbarch: read_sp invalid");
491 if ((GDB_MULTI_ARCH
>= 1)
492 && (gdbarch
->write_sp
== 0))
493 internal_error ("gdbarch: verify_gdbarch: write_sp invalid");
494 if ((GDB_MULTI_ARCH
>= 2)
495 && (gdbarch
->num_regs
== -1))
496 internal_error ("gdbarch: verify_gdbarch: num_regs invalid");
497 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
498 if ((GDB_MULTI_ARCH
>= 2)
499 && (gdbarch
->sp_regnum
== -1))
500 internal_error ("gdbarch: verify_gdbarch: sp_regnum invalid");
501 if ((GDB_MULTI_ARCH
>= 2)
502 && (gdbarch
->fp_regnum
== -1))
503 internal_error ("gdbarch: verify_gdbarch: fp_regnum invalid");
504 if ((GDB_MULTI_ARCH
>= 2)
505 && (gdbarch
->pc_regnum
== -1))
506 internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid");
507 /* Skip verify of fp0_regnum, invalid_p == 0 */
508 /* Skip verify of npc_regnum, invalid_p == 0 */
509 /* Skip verify of nnpc_regnum, invalid_p == 0 */
510 /* Skip verify of register_name, invalid_p == 0 */
511 if ((GDB_MULTI_ARCH
>= 2)
512 && (gdbarch
->register_size
== -1))
513 internal_error ("gdbarch: verify_gdbarch: register_size invalid");
514 if ((GDB_MULTI_ARCH
>= 2)
515 && (gdbarch
->register_bytes
== -1))
516 internal_error ("gdbarch: verify_gdbarch: register_bytes invalid");
517 if ((GDB_MULTI_ARCH
>= 2)
518 && (gdbarch
->register_byte
== 0))
519 internal_error ("gdbarch: verify_gdbarch: register_byte invalid");
520 if ((GDB_MULTI_ARCH
>= 2)
521 && (gdbarch
->register_raw_size
== 0))
522 internal_error ("gdbarch: verify_gdbarch: register_raw_size invalid");
523 if ((GDB_MULTI_ARCH
>= 2)
524 && (gdbarch
->max_register_raw_size
== -1))
525 internal_error ("gdbarch: verify_gdbarch: max_register_raw_size invalid");
526 if ((GDB_MULTI_ARCH
>= 2)
527 && (gdbarch
->register_virtual_size
== 0))
528 internal_error ("gdbarch: verify_gdbarch: register_virtual_size invalid");
529 if ((GDB_MULTI_ARCH
>= 2)
530 && (gdbarch
->max_register_virtual_size
== -1))
531 internal_error ("gdbarch: verify_gdbarch: max_register_virtual_size invalid");
532 if ((GDB_MULTI_ARCH
>= 2)
533 && (gdbarch
->register_virtual_type
== 0))
534 internal_error ("gdbarch: verify_gdbarch: register_virtual_type invalid");
535 /* Skip verify of do_registers_info, invalid_p == 0 */
536 /* Skip verify of register_sim_regno, invalid_p == 0 */
537 if ((GDB_MULTI_ARCH
>= 1)
538 && (gdbarch
->use_generic_dummy_frames
== -1))
539 internal_error ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid");
540 if ((GDB_MULTI_ARCH
>= 2)
541 && (gdbarch
->call_dummy_location
== 0))
542 internal_error ("gdbarch: verify_gdbarch: call_dummy_location invalid");
543 if ((GDB_MULTI_ARCH
>= 2)
544 && (gdbarch
->call_dummy_location
== AT_ENTRY_POINT
&& gdbarch
->call_dummy_address
== 0))
545 internal_error ("gdbarch: verify_gdbarch: call_dummy_address invalid");
546 if ((GDB_MULTI_ARCH
>= 2)
547 && (gdbarch
->call_dummy_start_offset
== -1))
548 internal_error ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid");
549 if ((GDB_MULTI_ARCH
>= 2)
550 && (gdbarch
->call_dummy_breakpoint_offset
== -1))
551 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid");
552 if ((GDB_MULTI_ARCH
>= 1)
553 && (gdbarch
->call_dummy_breakpoint_offset_p
== -1))
554 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid");
555 if ((GDB_MULTI_ARCH
>= 2)
556 && (gdbarch
->call_dummy_length
== -1))
557 internal_error ("gdbarch: verify_gdbarch: call_dummy_length invalid");
558 if ((GDB_MULTI_ARCH
>= 2)
559 && (gdbarch
->pc_in_call_dummy
== 0))
560 internal_error ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid");
561 if ((GDB_MULTI_ARCH
>= 1)
562 && (gdbarch
->call_dummy_p
== -1))
563 internal_error ("gdbarch: verify_gdbarch: call_dummy_p invalid");
564 /* Skip verify of call_dummy_words, invalid_p == 0 */
565 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
566 if ((GDB_MULTI_ARCH
>= 1)
567 && (gdbarch
->call_dummy_stack_adjust_p
== -1))
568 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid");
569 if ((GDB_MULTI_ARCH
>= 2)
570 && (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0))
571 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid");
572 if ((GDB_MULTI_ARCH
>= 2)
573 && (gdbarch
->fix_call_dummy
== 0))
574 internal_error ("gdbarch: verify_gdbarch: fix_call_dummy invalid");
575 /* Skip verify of coerce_float_to_double, invalid_p == 0 */
576 if ((GDB_MULTI_ARCH
>= 1)
577 && (gdbarch
->get_saved_register
== 0))
578 internal_error ("gdbarch: verify_gdbarch: get_saved_register invalid");
579 /* Skip verify of register_convertible, invalid_p == 0 */
580 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
581 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
582 /* Skip verify of fetch_pseudo_register, invalid_p == 0 */
583 /* Skip verify of store_pseudo_register, invalid_p == 0 */
584 /* Skip verify of pointer_to_address, invalid_p == 0 */
585 /* Skip verify of address_to_pointer, invalid_p == 0 */
586 /* Skip verify of return_value_on_stack, invalid_p == 0 */
587 if ((GDB_MULTI_ARCH
>= 2)
588 && (gdbarch
->extract_return_value
== 0))
589 internal_error ("gdbarch: verify_gdbarch: extract_return_value invalid");
590 if ((GDB_MULTI_ARCH
>= 1)
591 && (gdbarch
->push_arguments
== 0))
592 internal_error ("gdbarch: verify_gdbarch: push_arguments invalid");
593 if ((GDB_MULTI_ARCH
>= 2)
594 && (gdbarch
->push_dummy_frame
== 0))
595 internal_error ("gdbarch: verify_gdbarch: push_dummy_frame invalid");
596 if ((GDB_MULTI_ARCH
>= 1)
597 && (gdbarch
->push_return_address
== 0))
598 internal_error ("gdbarch: verify_gdbarch: push_return_address invalid");
599 if ((GDB_MULTI_ARCH
>= 2)
600 && (gdbarch
->pop_frame
== 0))
601 internal_error ("gdbarch: verify_gdbarch: pop_frame invalid");
602 /* Skip verify of d10v_make_daddr, invalid_p == 0 */
603 /* Skip verify of d10v_make_iaddr, invalid_p == 0 */
604 /* Skip verify of d10v_daddr_p, invalid_p == 0 */
605 /* Skip verify of d10v_iaddr_p, invalid_p == 0 */
606 /* Skip verify of d10v_convert_daddr_to_raw, invalid_p == 0 */
607 /* Skip verify of d10v_convert_iaddr_to_raw, invalid_p == 0 */
608 if ((GDB_MULTI_ARCH
>= 2)
609 && (gdbarch
->store_struct_return
== 0))
610 internal_error ("gdbarch: verify_gdbarch: store_struct_return invalid");
611 if ((GDB_MULTI_ARCH
>= 2)
612 && (gdbarch
->store_return_value
== 0))
613 internal_error ("gdbarch: verify_gdbarch: store_return_value invalid");
614 if ((GDB_MULTI_ARCH
>= 2)
615 && (gdbarch
->extract_struct_value_address
== 0))
616 internal_error ("gdbarch: verify_gdbarch: extract_struct_value_address invalid");
617 if ((GDB_MULTI_ARCH
>= 2)
618 && (gdbarch
->use_struct_convention
== 0))
619 internal_error ("gdbarch: verify_gdbarch: use_struct_convention invalid");
620 if ((GDB_MULTI_ARCH
>= 2)
621 && (gdbarch
->frame_init_saved_regs
== 0))
622 internal_error ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid");
623 if ((GDB_MULTI_ARCH
>= 2)
624 && (gdbarch
->init_extra_frame_info
== 0))
625 internal_error ("gdbarch: verify_gdbarch: init_extra_frame_info invalid");
626 if ((GDB_MULTI_ARCH
>= 2)
627 && (gdbarch
->skip_prologue
== 0))
628 internal_error ("gdbarch: verify_gdbarch: skip_prologue invalid");
629 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
630 if ((GDB_MULTI_ARCH
>= 2)
631 && (gdbarch
->inner_than
== 0))
632 internal_error ("gdbarch: verify_gdbarch: inner_than invalid");
633 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
634 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
635 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
636 if ((GDB_MULTI_ARCH
>= 2)
637 && (gdbarch
->decr_pc_after_break
== -1))
638 internal_error ("gdbarch: verify_gdbarch: decr_pc_after_break invalid");
639 if ((GDB_MULTI_ARCH
>= 2)
640 && (gdbarch
->function_start_offset
== -1))
641 internal_error ("gdbarch: verify_gdbarch: function_start_offset invalid");
642 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
643 if ((GDB_MULTI_ARCH
>= 2)
644 && (gdbarch
->frame_args_skip
== -1))
645 internal_error ("gdbarch: verify_gdbarch: frame_args_skip invalid");
646 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
647 if ((GDB_MULTI_ARCH
>= 2)
648 && (gdbarch
->frame_chain
== 0))
649 internal_error ("gdbarch: verify_gdbarch: frame_chain invalid");
650 if ((GDB_MULTI_ARCH
>= 1)
651 && (gdbarch
->frame_chain_valid
== 0))
652 internal_error ("gdbarch: verify_gdbarch: frame_chain_valid invalid");
653 if ((GDB_MULTI_ARCH
>= 2)
654 && (gdbarch
->frame_saved_pc
== 0))
655 internal_error ("gdbarch: verify_gdbarch: frame_saved_pc invalid");
656 if ((GDB_MULTI_ARCH
>= 2)
657 && (gdbarch
->frame_args_address
== 0))
658 internal_error ("gdbarch: verify_gdbarch: frame_args_address invalid");
659 if ((GDB_MULTI_ARCH
>= 2)
660 && (gdbarch
->frame_locals_address
== 0))
661 internal_error ("gdbarch: verify_gdbarch: frame_locals_address invalid");
662 if ((GDB_MULTI_ARCH
>= 2)
663 && (gdbarch
->saved_pc_after_call
== 0))
664 internal_error ("gdbarch: verify_gdbarch: saved_pc_after_call invalid");
665 if ((GDB_MULTI_ARCH
>= 2)
666 && (gdbarch
->frame_num_args
== 0))
667 internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid");
668 /* Skip verify of stack_align, has predicate */
669 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
670 /* Skip verify of reg_struct_has_addr, has predicate */
671 /* Skip verify of save_dummy_frame_tos, has predicate */
672 if (gdbarch
->float_format
== 0)
673 gdbarch
->float_format
= default_float_format (gdbarch
);
674 if (gdbarch
->double_format
== 0)
675 gdbarch
->double_format
= default_double_format (gdbarch
);
676 if (gdbarch
->long_double_format
== 0)
677 gdbarch
->long_double_format
= &floatformat_unknown
;
681 /* Print out the details of the current architecture. */
683 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
684 just happens to match the global variable ``current_gdbarch''. That
685 way macros refering to that variable get the local and not the global
686 version - ulgh. Once everything is parameterised with gdbarch, this
690 gdbarch_dump (struct gdbarch
*gdbarch
, struct ui_file
*file
)
692 fprintf_unfiltered (file
,
693 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
695 #ifdef TARGET_ARCHITECTURE
696 fprintf_unfiltered (file
,
697 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
698 XSTRING (TARGET_ARCHITECTURE
));
700 #ifdef TARGET_BYTE_ORDER
701 fprintf_unfiltered (file
,
702 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
703 XSTRING (TARGET_BYTE_ORDER
));
705 #ifdef TARGET_BFD_VMA_BIT
706 fprintf_unfiltered (file
,
707 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
708 XSTRING (TARGET_BFD_VMA_BIT
));
710 #ifdef TARGET_PTR_BIT
711 fprintf_unfiltered (file
,
712 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
713 XSTRING (TARGET_PTR_BIT
));
715 #ifdef TARGET_SHORT_BIT
716 fprintf_unfiltered (file
,
717 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
718 XSTRING (TARGET_SHORT_BIT
));
720 #ifdef TARGET_INT_BIT
721 fprintf_unfiltered (file
,
722 "gdbarch_dump: TARGET_INT_BIT # %s\n",
723 XSTRING (TARGET_INT_BIT
));
725 #ifdef TARGET_LONG_BIT
726 fprintf_unfiltered (file
,
727 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
728 XSTRING (TARGET_LONG_BIT
));
730 #ifdef TARGET_LONG_LONG_BIT
731 fprintf_unfiltered (file
,
732 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
733 XSTRING (TARGET_LONG_LONG_BIT
));
735 #ifdef TARGET_FLOAT_BIT
736 fprintf_unfiltered (file
,
737 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
738 XSTRING (TARGET_FLOAT_BIT
));
740 #ifdef TARGET_DOUBLE_BIT
741 fprintf_unfiltered (file
,
742 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
743 XSTRING (TARGET_DOUBLE_BIT
));
745 #ifdef TARGET_LONG_DOUBLE_BIT
746 fprintf_unfiltered (file
,
747 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
748 XSTRING (TARGET_LONG_DOUBLE_BIT
));
751 fprintf_unfiltered (file
,
752 "gdbarch_dump: IEEE_FLOAT # %s\n",
753 XSTRING (IEEE_FLOAT
));
755 #ifdef TARGET_READ_PC
756 fprintf_unfiltered (file
,
757 "gdbarch_dump: %s # %s\n",
758 "TARGET_READ_PC(pid)",
759 XSTRING (TARGET_READ_PC (pid
)));
761 #if defined (TARGET_WRITE_PC) && GDB_MULTI_ARCH
762 /* Macro might contain `[{}]' when not multi-arch */
763 fprintf_unfiltered (file
,
764 "gdbarch_dump: %s # %s\n",
765 "TARGET_WRITE_PC(val, pid)",
766 XSTRING (TARGET_WRITE_PC (val
, pid
)));
768 #ifdef TARGET_READ_FP
769 fprintf_unfiltered (file
,
770 "gdbarch_dump: %s # %s\n",
772 XSTRING (TARGET_READ_FP ()));
774 #if defined (TARGET_WRITE_FP) && GDB_MULTI_ARCH
775 /* Macro might contain `[{}]' when not multi-arch */
776 fprintf_unfiltered (file
,
777 "gdbarch_dump: %s # %s\n",
778 "TARGET_WRITE_FP(val)",
779 XSTRING (TARGET_WRITE_FP (val
)));
781 #ifdef TARGET_READ_SP
782 fprintf_unfiltered (file
,
783 "gdbarch_dump: %s # %s\n",
785 XSTRING (TARGET_READ_SP ()));
787 #if defined (TARGET_WRITE_SP) && GDB_MULTI_ARCH
788 /* Macro might contain `[{}]' when not multi-arch */
789 fprintf_unfiltered (file
,
790 "gdbarch_dump: %s # %s\n",
791 "TARGET_WRITE_SP(val)",
792 XSTRING (TARGET_WRITE_SP (val
)));
795 fprintf_unfiltered (file
,
796 "gdbarch_dump: NUM_REGS # %s\n",
799 #ifdef NUM_PSEUDO_REGS
800 fprintf_unfiltered (file
,
801 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
802 XSTRING (NUM_PSEUDO_REGS
));
805 fprintf_unfiltered (file
,
806 "gdbarch_dump: SP_REGNUM # %s\n",
807 XSTRING (SP_REGNUM
));
810 fprintf_unfiltered (file
,
811 "gdbarch_dump: FP_REGNUM # %s\n",
812 XSTRING (FP_REGNUM
));
815 fprintf_unfiltered (file
,
816 "gdbarch_dump: PC_REGNUM # %s\n",
817 XSTRING (PC_REGNUM
));
820 fprintf_unfiltered (file
,
821 "gdbarch_dump: FP0_REGNUM # %s\n",
822 XSTRING (FP0_REGNUM
));
825 fprintf_unfiltered (file
,
826 "gdbarch_dump: NPC_REGNUM # %s\n",
827 XSTRING (NPC_REGNUM
));
830 fprintf_unfiltered (file
,
831 "gdbarch_dump: NNPC_REGNUM # %s\n",
832 XSTRING (NNPC_REGNUM
));
835 fprintf_unfiltered (file
,
836 "gdbarch_dump: %s # %s\n",
837 "REGISTER_NAME(regnr)",
838 XSTRING (REGISTER_NAME (regnr
)));
841 fprintf_unfiltered (file
,
842 "gdbarch_dump: REGISTER_SIZE # %s\n",
843 XSTRING (REGISTER_SIZE
));
845 #ifdef REGISTER_BYTES
846 fprintf_unfiltered (file
,
847 "gdbarch_dump: REGISTER_BYTES # %s\n",
848 XSTRING (REGISTER_BYTES
));
851 fprintf_unfiltered (file
,
852 "gdbarch_dump: %s # %s\n",
853 "REGISTER_BYTE(reg_nr)",
854 XSTRING (REGISTER_BYTE (reg_nr
)));
856 #ifdef REGISTER_RAW_SIZE
857 fprintf_unfiltered (file
,
858 "gdbarch_dump: %s # %s\n",
859 "REGISTER_RAW_SIZE(reg_nr)",
860 XSTRING (REGISTER_RAW_SIZE (reg_nr
)));
862 #ifdef MAX_REGISTER_RAW_SIZE
863 fprintf_unfiltered (file
,
864 "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
865 XSTRING (MAX_REGISTER_RAW_SIZE
));
867 #ifdef REGISTER_VIRTUAL_SIZE
868 fprintf_unfiltered (file
,
869 "gdbarch_dump: %s # %s\n",
870 "REGISTER_VIRTUAL_SIZE(reg_nr)",
871 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr
)));
873 #ifdef MAX_REGISTER_VIRTUAL_SIZE
874 fprintf_unfiltered (file
,
875 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
876 XSTRING (MAX_REGISTER_VIRTUAL_SIZE
));
878 #ifdef REGISTER_VIRTUAL_TYPE
879 fprintf_unfiltered (file
,
880 "gdbarch_dump: %s # %s\n",
881 "REGISTER_VIRTUAL_TYPE(reg_nr)",
882 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr
)));
884 #if defined (DO_REGISTERS_INFO) && GDB_MULTI_ARCH
885 /* Macro might contain `[{}]' when not multi-arch */
886 fprintf_unfiltered (file
,
887 "gdbarch_dump: %s # %s\n",
888 "DO_REGISTERS_INFO(reg_nr, fpregs)",
889 XSTRING (DO_REGISTERS_INFO (reg_nr
, fpregs
)));
891 #ifdef REGISTER_SIM_REGNO
892 fprintf_unfiltered (file
,
893 "gdbarch_dump: %s # %s\n",
894 "REGISTER_SIM_REGNO(reg_nr)",
895 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
897 #ifdef USE_GENERIC_DUMMY_FRAMES
898 fprintf_unfiltered (file
,
899 "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n",
900 XSTRING (USE_GENERIC_DUMMY_FRAMES
));
902 #ifdef CALL_DUMMY_LOCATION
903 fprintf_unfiltered (file
,
904 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
905 XSTRING (CALL_DUMMY_LOCATION
));
907 #ifdef CALL_DUMMY_ADDRESS
908 fprintf_unfiltered (file
,
909 "gdbarch_dump: %s # %s\n",
910 "CALL_DUMMY_ADDRESS()",
911 XSTRING (CALL_DUMMY_ADDRESS ()));
913 #ifdef CALL_DUMMY_START_OFFSET
914 fprintf_unfiltered (file
,
915 "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
916 XSTRING (CALL_DUMMY_START_OFFSET
));
918 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
919 fprintf_unfiltered (file
,
920 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
921 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET
));
923 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
924 fprintf_unfiltered (file
,
925 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
926 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P
));
928 #ifdef CALL_DUMMY_LENGTH
929 fprintf_unfiltered (file
,
930 "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
931 XSTRING (CALL_DUMMY_LENGTH
));
933 #ifdef PC_IN_CALL_DUMMY
934 fprintf_unfiltered (file
,
935 "gdbarch_dump: %s # %s\n",
936 "PC_IN_CALL_DUMMY(pc, sp, frame_address)",
937 XSTRING (PC_IN_CALL_DUMMY (pc
, sp
, frame_address
)));
940 fprintf_unfiltered (file
,
941 "gdbarch_dump: CALL_DUMMY_P # %s\n",
942 XSTRING (CALL_DUMMY_P
));
944 #ifdef CALL_DUMMY_WORDS
945 fprintf_unfiltered (file
,
946 "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
947 XSTRING (CALL_DUMMY_WORDS
));
949 #ifdef SIZEOF_CALL_DUMMY_WORDS
950 fprintf_unfiltered (file
,
951 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
952 XSTRING (SIZEOF_CALL_DUMMY_WORDS
));
954 #ifdef CALL_DUMMY_STACK_ADJUST_P
955 fprintf_unfiltered (file
,
956 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
957 XSTRING (CALL_DUMMY_STACK_ADJUST_P
));
959 #ifdef CALL_DUMMY_STACK_ADJUST
960 fprintf_unfiltered (file
,
961 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
962 XSTRING (CALL_DUMMY_STACK_ADJUST
));
964 #if defined (FIX_CALL_DUMMY) && GDB_MULTI_ARCH
965 /* Macro might contain `[{}]' when not multi-arch */
966 fprintf_unfiltered (file
,
967 "gdbarch_dump: %s # %s\n",
968 "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
969 XSTRING (FIX_CALL_DUMMY (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)));
971 #ifdef BELIEVE_PCC_PROMOTION
972 fprintf_unfiltered (file
,
973 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
974 XSTRING (BELIEVE_PCC_PROMOTION
));
976 #ifdef BELIEVE_PCC_PROMOTION_TYPE
977 fprintf_unfiltered (file
,
978 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
979 XSTRING (BELIEVE_PCC_PROMOTION_TYPE
));
981 #ifdef COERCE_FLOAT_TO_DOUBLE
982 fprintf_unfiltered (file
,
983 "gdbarch_dump: %s # %s\n",
984 "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
985 XSTRING (COERCE_FLOAT_TO_DOUBLE (formal
, actual
)));
987 #if defined (GET_SAVED_REGISTER) && GDB_MULTI_ARCH
988 /* Macro might contain `[{}]' when not multi-arch */
989 fprintf_unfiltered (file
,
990 "gdbarch_dump: %s # %s\n",
991 "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
992 XSTRING (GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)));
994 #ifdef REGISTER_CONVERTIBLE
995 fprintf_unfiltered (file
,
996 "gdbarch_dump: %s # %s\n",
997 "REGISTER_CONVERTIBLE(nr)",
998 XSTRING (REGISTER_CONVERTIBLE (nr
)));
1000 #if defined (REGISTER_CONVERT_TO_VIRTUAL) && GDB_MULTI_ARCH
1001 /* Macro might contain `[{}]' when not multi-arch */
1002 fprintf_unfiltered (file
,
1003 "gdbarch_dump: %s # %s\n",
1004 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1005 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
)));
1007 #if defined (REGISTER_CONVERT_TO_RAW) && GDB_MULTI_ARCH
1008 /* Macro might contain `[{}]' when not multi-arch */
1009 fprintf_unfiltered (file
,
1010 "gdbarch_dump: %s # %s\n",
1011 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1012 XSTRING (REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
)));
1014 #if defined (FETCH_PSEUDO_REGISTER) && GDB_MULTI_ARCH
1015 /* Macro might contain `[{}]' when not multi-arch */
1016 fprintf_unfiltered (file
,
1017 "gdbarch_dump: %s # %s\n",
1018 "FETCH_PSEUDO_REGISTER(regnum)",
1019 XSTRING (FETCH_PSEUDO_REGISTER (regnum
)));
1021 #if defined (STORE_PSEUDO_REGISTER) && GDB_MULTI_ARCH
1022 /* Macro might contain `[{}]' when not multi-arch */
1023 fprintf_unfiltered (file
,
1024 "gdbarch_dump: %s # %s\n",
1025 "STORE_PSEUDO_REGISTER(regnum)",
1026 XSTRING (STORE_PSEUDO_REGISTER (regnum
)));
1028 #ifdef POINTER_TO_ADDRESS
1029 fprintf_unfiltered (file
,
1030 "gdbarch_dump: %s # %s\n",
1031 "POINTER_TO_ADDRESS(type, buf)",
1032 XSTRING (POINTER_TO_ADDRESS (type
, buf
)));
1034 #if defined (ADDRESS_TO_POINTER) && GDB_MULTI_ARCH
1035 /* Macro might contain `[{}]' when not multi-arch */
1036 fprintf_unfiltered (file
,
1037 "gdbarch_dump: %s # %s\n",
1038 "ADDRESS_TO_POINTER(type, buf, addr)",
1039 XSTRING (ADDRESS_TO_POINTER (type
, buf
, addr
)));
1041 #ifdef RETURN_VALUE_ON_STACK
1042 fprintf_unfiltered (file
,
1043 "gdbarch_dump: %s # %s\n",
1044 "RETURN_VALUE_ON_STACK(type)",
1045 XSTRING (RETURN_VALUE_ON_STACK (type
)));
1047 #if defined (EXTRACT_RETURN_VALUE) && GDB_MULTI_ARCH
1048 /* Macro might contain `[{}]' when not multi-arch */
1049 fprintf_unfiltered (file
,
1050 "gdbarch_dump: %s # %s\n",
1051 "EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1052 XSTRING (EXTRACT_RETURN_VALUE (type
, regbuf
, valbuf
)));
1054 #ifdef PUSH_ARGUMENTS
1055 fprintf_unfiltered (file
,
1056 "gdbarch_dump: %s # %s\n",
1057 "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1058 XSTRING (PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
)));
1060 #if defined (PUSH_DUMMY_FRAME) && GDB_MULTI_ARCH
1061 /* Macro might contain `[{}]' when not multi-arch */
1062 fprintf_unfiltered (file
,
1063 "gdbarch_dump: %s # %s\n",
1064 "PUSH_DUMMY_FRAME(-)",
1065 XSTRING (PUSH_DUMMY_FRAME (-)));
1067 #ifdef PUSH_RETURN_ADDRESS
1068 fprintf_unfiltered (file
,
1069 "gdbarch_dump: %s # %s\n",
1070 "PUSH_RETURN_ADDRESS(pc, sp)",
1071 XSTRING (PUSH_RETURN_ADDRESS (pc
, sp
)));
1073 #if defined (POP_FRAME) && GDB_MULTI_ARCH
1074 /* Macro might contain `[{}]' when not multi-arch */
1075 fprintf_unfiltered (file
,
1076 "gdbarch_dump: %s # %s\n",
1078 XSTRING (POP_FRAME (-)));
1080 #ifdef D10V_MAKE_DADDR
1081 fprintf_unfiltered (file
,
1082 "gdbarch_dump: %s # %s\n",
1083 "D10V_MAKE_DADDR(x)",
1084 XSTRING (D10V_MAKE_DADDR (x
)));
1086 #ifdef D10V_MAKE_IADDR
1087 fprintf_unfiltered (file
,
1088 "gdbarch_dump: %s # %s\n",
1089 "D10V_MAKE_IADDR(x)",
1090 XSTRING (D10V_MAKE_IADDR (x
)));
1093 fprintf_unfiltered (file
,
1094 "gdbarch_dump: %s # %s\n",
1096 XSTRING (D10V_DADDR_P (x
)));
1099 fprintf_unfiltered (file
,
1100 "gdbarch_dump: %s # %s\n",
1102 XSTRING (D10V_IADDR_P (x
)));
1104 #ifdef D10V_CONVERT_DADDR_TO_RAW
1105 fprintf_unfiltered (file
,
1106 "gdbarch_dump: %s # %s\n",
1107 "D10V_CONVERT_DADDR_TO_RAW(x)",
1108 XSTRING (D10V_CONVERT_DADDR_TO_RAW (x
)));
1110 #ifdef D10V_CONVERT_IADDR_TO_RAW
1111 fprintf_unfiltered (file
,
1112 "gdbarch_dump: %s # %s\n",
1113 "D10V_CONVERT_IADDR_TO_RAW(x)",
1114 XSTRING (D10V_CONVERT_IADDR_TO_RAW (x
)));
1116 #if defined (STORE_STRUCT_RETURN) && GDB_MULTI_ARCH
1117 /* Macro might contain `[{}]' when not multi-arch */
1118 fprintf_unfiltered (file
,
1119 "gdbarch_dump: %s # %s\n",
1120 "STORE_STRUCT_RETURN(addr, sp)",
1121 XSTRING (STORE_STRUCT_RETURN (addr
, sp
)));
1123 #if defined (STORE_RETURN_VALUE) && GDB_MULTI_ARCH
1124 /* Macro might contain `[{}]' when not multi-arch */
1125 fprintf_unfiltered (file
,
1126 "gdbarch_dump: %s # %s\n",
1127 "STORE_RETURN_VALUE(type, valbuf)",
1128 XSTRING (STORE_RETURN_VALUE (type
, valbuf
)));
1130 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1131 fprintf_unfiltered (file
,
1132 "gdbarch_dump: %s # %s\n",
1133 "EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1134 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regbuf
)));
1136 #ifdef USE_STRUCT_CONVENTION
1137 fprintf_unfiltered (file
,
1138 "gdbarch_dump: %s # %s\n",
1139 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
1140 XSTRING (USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
1142 #if defined (FRAME_INIT_SAVED_REGS) && GDB_MULTI_ARCH
1143 /* Macro might contain `[{}]' when not multi-arch */
1144 fprintf_unfiltered (file
,
1145 "gdbarch_dump: %s # %s\n",
1146 "FRAME_INIT_SAVED_REGS(frame)",
1147 XSTRING (FRAME_INIT_SAVED_REGS (frame
)));
1149 #if defined (INIT_EXTRA_FRAME_INFO) && GDB_MULTI_ARCH
1150 /* Macro might contain `[{}]' when not multi-arch */
1151 fprintf_unfiltered (file
,
1152 "gdbarch_dump: %s # %s\n",
1153 "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1154 XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf
, frame
)));
1156 #ifdef SKIP_PROLOGUE
1157 fprintf_unfiltered (file
,
1158 "gdbarch_dump: %s # %s\n",
1159 "SKIP_PROLOGUE(ip)",
1160 XSTRING (SKIP_PROLOGUE (ip
)));
1162 #ifdef PROLOGUE_FRAMELESS_P
1163 fprintf_unfiltered (file
,
1164 "gdbarch_dump: %s # %s\n",
1165 "PROLOGUE_FRAMELESS_P(ip)",
1166 XSTRING (PROLOGUE_FRAMELESS_P (ip
)));
1169 fprintf_unfiltered (file
,
1170 "gdbarch_dump: %s # %s\n",
1171 "INNER_THAN(lhs, rhs)",
1172 XSTRING (INNER_THAN (lhs
, rhs
)));
1174 #ifdef BREAKPOINT_FROM_PC
1175 fprintf_unfiltered (file
,
1176 "gdbarch_dump: %s # %s\n",
1177 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
1178 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
1180 #ifdef MEMORY_INSERT_BREAKPOINT
1181 fprintf_unfiltered (file
,
1182 "gdbarch_dump: %s # %s\n",
1183 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1184 XSTRING (MEMORY_INSERT_BREAKPOINT (addr
, contents_cache
)));
1186 #ifdef MEMORY_REMOVE_BREAKPOINT
1187 fprintf_unfiltered (file
,
1188 "gdbarch_dump: %s # %s\n",
1189 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1190 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr
, contents_cache
)));
1192 #ifdef DECR_PC_AFTER_BREAK
1193 fprintf_unfiltered (file
,
1194 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1195 XSTRING (DECR_PC_AFTER_BREAK
));
1197 #ifdef FUNCTION_START_OFFSET
1198 fprintf_unfiltered (file
,
1199 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1200 XSTRING (FUNCTION_START_OFFSET
));
1202 #if defined (REMOTE_TRANSLATE_XFER_ADDRESS) && GDB_MULTI_ARCH
1203 /* Macro might contain `[{}]' when not multi-arch */
1204 fprintf_unfiltered (file
,
1205 "gdbarch_dump: %s # %s\n",
1206 "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
1207 XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr
, gdb_len
, rem_addr
, rem_len
)));
1209 #ifdef FRAME_ARGS_SKIP
1210 fprintf_unfiltered (file
,
1211 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1212 XSTRING (FRAME_ARGS_SKIP
));
1214 #ifdef FRAMELESS_FUNCTION_INVOCATION
1215 fprintf_unfiltered (file
,
1216 "gdbarch_dump: %s # %s\n",
1217 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1218 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi
)));
1221 fprintf_unfiltered (file
,
1222 "gdbarch_dump: %s # %s\n",
1223 "FRAME_CHAIN(frame)",
1224 XSTRING (FRAME_CHAIN (frame
)));
1226 #ifdef FRAME_CHAIN_VALID
1227 fprintf_unfiltered (file
,
1228 "gdbarch_dump: %s # %s\n",
1229 "FRAME_CHAIN_VALID(chain, thisframe)",
1230 XSTRING (FRAME_CHAIN_VALID (chain
, thisframe
)));
1232 #ifdef FRAME_SAVED_PC
1233 fprintf_unfiltered (file
,
1234 "gdbarch_dump: %s # %s\n",
1235 "FRAME_SAVED_PC(fi)",
1236 XSTRING (FRAME_SAVED_PC (fi
)));
1238 #ifdef FRAME_ARGS_ADDRESS
1239 fprintf_unfiltered (file
,
1240 "gdbarch_dump: %s # %s\n",
1241 "FRAME_ARGS_ADDRESS(fi)",
1242 XSTRING (FRAME_ARGS_ADDRESS (fi
)));
1244 #ifdef FRAME_LOCALS_ADDRESS
1245 fprintf_unfiltered (file
,
1246 "gdbarch_dump: %s # %s\n",
1247 "FRAME_LOCALS_ADDRESS(fi)",
1248 XSTRING (FRAME_LOCALS_ADDRESS (fi
)));
1250 #ifdef SAVED_PC_AFTER_CALL
1251 fprintf_unfiltered (file
,
1252 "gdbarch_dump: %s # %s\n",
1253 "SAVED_PC_AFTER_CALL(frame)",
1254 XSTRING (SAVED_PC_AFTER_CALL (frame
)));
1256 #ifdef FRAME_NUM_ARGS
1257 fprintf_unfiltered (file
,
1258 "gdbarch_dump: %s # %s\n",
1259 "FRAME_NUM_ARGS(frame)",
1260 XSTRING (FRAME_NUM_ARGS (frame
)));
1263 fprintf_unfiltered (file
,
1264 "gdbarch_dump: %s # %s\n",
1266 XSTRING (STACK_ALIGN (sp
)));
1268 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1269 fprintf_unfiltered (file
,
1270 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1271 XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED
));
1273 #ifdef REG_STRUCT_HAS_ADDR
1274 fprintf_unfiltered (file
,
1275 "gdbarch_dump: %s # %s\n",
1276 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
1277 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
1279 #if defined (SAVE_DUMMY_FRAME_TOS) && GDB_MULTI_ARCH
1280 /* Macro might contain `[{}]' when not multi-arch */
1281 fprintf_unfiltered (file
,
1282 "gdbarch_dump: %s # %s\n",
1283 "SAVE_DUMMY_FRAME_TOS(sp)",
1284 XSTRING (SAVE_DUMMY_FRAME_TOS (sp
)));
1286 #ifdef TARGET_FLOAT_FORMAT
1287 fprintf_unfiltered (file
,
1288 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
1289 XSTRING (TARGET_FLOAT_FORMAT
));
1291 #ifdef TARGET_DOUBLE_FORMAT
1292 fprintf_unfiltered (file
,
1293 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
1294 XSTRING (TARGET_DOUBLE_FORMAT
));
1296 #ifdef TARGET_LONG_DOUBLE_FORMAT
1297 fprintf_unfiltered (file
,
1298 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1299 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
1301 #ifdef TARGET_ARCHITECTURE
1302 if (TARGET_ARCHITECTURE
!= NULL
)
1303 fprintf_unfiltered (file
,
1304 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
1305 TARGET_ARCHITECTURE
->printable_name
);
1307 #ifdef TARGET_BYTE_ORDER
1308 fprintf_unfiltered (file
,
1309 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
1310 (long) TARGET_BYTE_ORDER
);
1312 #ifdef TARGET_BFD_VMA_BIT
1313 fprintf_unfiltered (file
,
1314 "gdbarch_dump: TARGET_BFD_VMA_BIT = %ld\n",
1315 (long) TARGET_BFD_VMA_BIT
);
1317 #ifdef TARGET_PTR_BIT
1318 fprintf_unfiltered (file
,
1319 "gdbarch_dump: TARGET_PTR_BIT = %ld\n",
1320 (long) TARGET_PTR_BIT
);
1322 #ifdef TARGET_SHORT_BIT
1323 fprintf_unfiltered (file
,
1324 "gdbarch_dump: TARGET_SHORT_BIT = %ld\n",
1325 (long) TARGET_SHORT_BIT
);
1327 #ifdef TARGET_INT_BIT
1328 fprintf_unfiltered (file
,
1329 "gdbarch_dump: TARGET_INT_BIT = %ld\n",
1330 (long) TARGET_INT_BIT
);
1332 #ifdef TARGET_LONG_BIT
1333 fprintf_unfiltered (file
,
1334 "gdbarch_dump: TARGET_LONG_BIT = %ld\n",
1335 (long) TARGET_LONG_BIT
);
1337 #ifdef TARGET_LONG_LONG_BIT
1338 fprintf_unfiltered (file
,
1339 "gdbarch_dump: TARGET_LONG_LONG_BIT = %ld\n",
1340 (long) TARGET_LONG_LONG_BIT
);
1342 #ifdef TARGET_FLOAT_BIT
1343 fprintf_unfiltered (file
,
1344 "gdbarch_dump: TARGET_FLOAT_BIT = %ld\n",
1345 (long) TARGET_FLOAT_BIT
);
1347 #ifdef TARGET_DOUBLE_BIT
1348 fprintf_unfiltered (file
,
1349 "gdbarch_dump: TARGET_DOUBLE_BIT = %ld\n",
1350 (long) TARGET_DOUBLE_BIT
);
1352 #ifdef TARGET_LONG_DOUBLE_BIT
1353 fprintf_unfiltered (file
,
1354 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %ld\n",
1355 (long) TARGET_LONG_DOUBLE_BIT
);
1358 fprintf_unfiltered (file
,
1359 "gdbarch_dump: IEEE_FLOAT = %ld\n",
1362 #ifdef TARGET_READ_PC
1364 fprintf_unfiltered (file
,
1365 "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
1366 (long) current_gdbarch
->read_pc
1367 /*TARGET_READ_PC ()*/);
1369 #ifdef TARGET_WRITE_PC
1371 fprintf_unfiltered (file
,
1372 "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
1373 (long) current_gdbarch
->write_pc
1374 /*TARGET_WRITE_PC ()*/);
1376 #ifdef TARGET_READ_FP
1378 fprintf_unfiltered (file
,
1379 "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n",
1380 (long) current_gdbarch
->read_fp
1381 /*TARGET_READ_FP ()*/);
1383 #ifdef TARGET_WRITE_FP
1385 fprintf_unfiltered (file
,
1386 "gdbarch_dump: TARGET_WRITE_FP = 0x%08lx\n",
1387 (long) current_gdbarch
->write_fp
1388 /*TARGET_WRITE_FP ()*/);
1390 #ifdef TARGET_READ_SP
1392 fprintf_unfiltered (file
,
1393 "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
1394 (long) current_gdbarch
->read_sp
1395 /*TARGET_READ_SP ()*/);
1397 #ifdef TARGET_WRITE_SP
1399 fprintf_unfiltered (file
,
1400 "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
1401 (long) current_gdbarch
->write_sp
1402 /*TARGET_WRITE_SP ()*/);
1405 fprintf_unfiltered (file
,
1406 "gdbarch_dump: NUM_REGS = %ld\n",
1409 #ifdef NUM_PSEUDO_REGS
1410 fprintf_unfiltered (file
,
1411 "gdbarch_dump: NUM_PSEUDO_REGS = %ld\n",
1412 (long) NUM_PSEUDO_REGS
);
1415 fprintf_unfiltered (file
,
1416 "gdbarch_dump: SP_REGNUM = %ld\n",
1420 fprintf_unfiltered (file
,
1421 "gdbarch_dump: FP_REGNUM = %ld\n",
1425 fprintf_unfiltered (file
,
1426 "gdbarch_dump: PC_REGNUM = %ld\n",
1430 fprintf_unfiltered (file
,
1431 "gdbarch_dump: FP0_REGNUM = %ld\n",
1435 fprintf_unfiltered (file
,
1436 "gdbarch_dump: NPC_REGNUM = %ld\n",
1440 fprintf_unfiltered (file
,
1441 "gdbarch_dump: NNPC_REGNUM = %ld\n",
1442 (long) NNPC_REGNUM
);
1444 #ifdef REGISTER_NAME
1446 fprintf_unfiltered (file
,
1447 "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
1448 (long) current_gdbarch
->register_name
1449 /*REGISTER_NAME ()*/);
1451 #ifdef REGISTER_SIZE
1452 fprintf_unfiltered (file
,
1453 "gdbarch_dump: REGISTER_SIZE = %ld\n",
1454 (long) REGISTER_SIZE
);
1456 #ifdef REGISTER_BYTES
1457 fprintf_unfiltered (file
,
1458 "gdbarch_dump: REGISTER_BYTES = %ld\n",
1459 (long) REGISTER_BYTES
);
1461 #ifdef REGISTER_BYTE
1463 fprintf_unfiltered (file
,
1464 "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
1465 (long) current_gdbarch
->register_byte
1466 /*REGISTER_BYTE ()*/);
1468 #ifdef REGISTER_RAW_SIZE
1470 fprintf_unfiltered (file
,
1471 "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
1472 (long) current_gdbarch
->register_raw_size
1473 /*REGISTER_RAW_SIZE ()*/);
1475 #ifdef MAX_REGISTER_RAW_SIZE
1476 fprintf_unfiltered (file
,
1477 "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %ld\n",
1478 (long) MAX_REGISTER_RAW_SIZE
);
1480 #ifdef REGISTER_VIRTUAL_SIZE
1482 fprintf_unfiltered (file
,
1483 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
1484 (long) current_gdbarch
->register_virtual_size
1485 /*REGISTER_VIRTUAL_SIZE ()*/);
1487 #ifdef MAX_REGISTER_VIRTUAL_SIZE
1488 fprintf_unfiltered (file
,
1489 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
1490 (long) MAX_REGISTER_VIRTUAL_SIZE
);
1492 #ifdef REGISTER_VIRTUAL_TYPE
1494 fprintf_unfiltered (file
,
1495 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
1496 (long) current_gdbarch
->register_virtual_type
1497 /*REGISTER_VIRTUAL_TYPE ()*/);
1499 #ifdef DO_REGISTERS_INFO
1501 fprintf_unfiltered (file
,
1502 "gdbarch_dump: DO_REGISTERS_INFO = 0x%08lx\n",
1503 (long) current_gdbarch
->do_registers_info
1504 /*DO_REGISTERS_INFO ()*/);
1506 #ifdef REGISTER_SIM_REGNO
1508 fprintf_unfiltered (file
,
1509 "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n",
1510 (long) current_gdbarch
->register_sim_regno
1511 /*REGISTER_SIM_REGNO ()*/);
1513 #ifdef USE_GENERIC_DUMMY_FRAMES
1514 fprintf_unfiltered (file
,
1515 "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %ld\n",
1516 (long) USE_GENERIC_DUMMY_FRAMES
);
1518 #ifdef CALL_DUMMY_LOCATION
1519 fprintf_unfiltered (file
,
1520 "gdbarch_dump: CALL_DUMMY_LOCATION = %ld\n",
1521 (long) CALL_DUMMY_LOCATION
);
1523 #ifdef CALL_DUMMY_ADDRESS
1525 fprintf_unfiltered (file
,
1526 "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
1527 (long) current_gdbarch
->call_dummy_address
1528 /*CALL_DUMMY_ADDRESS ()*/);
1530 #ifdef CALL_DUMMY_START_OFFSET
1531 fprintf_unfiltered (file
,
1532 "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
1533 (long) CALL_DUMMY_START_OFFSET
);
1535 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
1536 if (CALL_DUMMY_BREAKPOINT_OFFSET_P
)
1537 fprintf_unfiltered (file
,
1538 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
1539 (long) CALL_DUMMY_BREAKPOINT_OFFSET
);
1541 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
1542 fprintf_unfiltered (file
,
1543 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
1544 (long) CALL_DUMMY_BREAKPOINT_OFFSET_P
);
1546 #ifdef CALL_DUMMY_LENGTH
1547 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
|| CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
1548 fprintf_unfiltered (file
,
1549 "gdbarch_dump: CALL_DUMMY_LENGTH = %ld\n",
1550 (long) CALL_DUMMY_LENGTH
);
1552 #ifdef PC_IN_CALL_DUMMY
1554 fprintf_unfiltered (file
,
1555 "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n",
1556 (long) current_gdbarch
->pc_in_call_dummy
1557 /*PC_IN_CALL_DUMMY ()*/);
1560 fprintf_unfiltered (file
,
1561 "gdbarch_dump: CALL_DUMMY_P = %ld\n",
1562 (long) CALL_DUMMY_P
);
1564 #ifdef CALL_DUMMY_WORDS
1565 fprintf_unfiltered (file
,
1566 "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
1567 (long) CALL_DUMMY_WORDS
);
1569 #ifdef SIZEOF_CALL_DUMMY_WORDS
1570 fprintf_unfiltered (file
,
1571 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
1572 (long) SIZEOF_CALL_DUMMY_WORDS
);
1574 #ifdef CALL_DUMMY_STACK_ADJUST_P
1575 fprintf_unfiltered (file
,
1576 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
1577 (long) CALL_DUMMY_STACK_ADJUST_P
);
1579 #ifdef CALL_DUMMY_STACK_ADJUST
1580 if (CALL_DUMMY_STACK_ADJUST_P
)
1581 fprintf_unfiltered (file
,
1582 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
1583 (long) CALL_DUMMY_STACK_ADJUST
);
1585 #ifdef FIX_CALL_DUMMY
1587 fprintf_unfiltered (file
,
1588 "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
1589 (long) current_gdbarch
->fix_call_dummy
1590 /*FIX_CALL_DUMMY ()*/);
1592 #ifdef BELIEVE_PCC_PROMOTION
1593 fprintf_unfiltered (file
,
1594 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %ld\n",
1595 (long) BELIEVE_PCC_PROMOTION
);
1597 #ifdef BELIEVE_PCC_PROMOTION_TYPE
1598 fprintf_unfiltered (file
,
1599 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
1600 (long) BELIEVE_PCC_PROMOTION_TYPE
);
1602 #ifdef COERCE_FLOAT_TO_DOUBLE
1604 fprintf_unfiltered (file
,
1605 "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
1606 (long) current_gdbarch
->coerce_float_to_double
1607 /*COERCE_FLOAT_TO_DOUBLE ()*/);
1609 #ifdef GET_SAVED_REGISTER
1611 fprintf_unfiltered (file
,
1612 "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n",
1613 (long) current_gdbarch
->get_saved_register
1614 /*GET_SAVED_REGISTER ()*/);
1616 #ifdef REGISTER_CONVERTIBLE
1618 fprintf_unfiltered (file
,
1619 "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
1620 (long) current_gdbarch
->register_convertible
1621 /*REGISTER_CONVERTIBLE ()*/);
1623 #ifdef REGISTER_CONVERT_TO_VIRTUAL
1625 fprintf_unfiltered (file
,
1626 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
1627 (long) current_gdbarch
->register_convert_to_virtual
1628 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
1630 #ifdef REGISTER_CONVERT_TO_RAW
1632 fprintf_unfiltered (file
,
1633 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
1634 (long) current_gdbarch
->register_convert_to_raw
1635 /*REGISTER_CONVERT_TO_RAW ()*/);
1637 #ifdef FETCH_PSEUDO_REGISTER
1639 fprintf_unfiltered (file
,
1640 "gdbarch_dump: FETCH_PSEUDO_REGISTER = 0x%08lx\n",
1641 (long) current_gdbarch
->fetch_pseudo_register
1642 /*FETCH_PSEUDO_REGISTER ()*/);
1644 #ifdef STORE_PSEUDO_REGISTER
1646 fprintf_unfiltered (file
,
1647 "gdbarch_dump: STORE_PSEUDO_REGISTER = 0x%08lx\n",
1648 (long) current_gdbarch
->store_pseudo_register
1649 /*STORE_PSEUDO_REGISTER ()*/);
1651 #ifdef POINTER_TO_ADDRESS
1653 fprintf_unfiltered (file
,
1654 "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
1655 (long) current_gdbarch
->pointer_to_address
1656 /*POINTER_TO_ADDRESS ()*/);
1658 #ifdef ADDRESS_TO_POINTER
1660 fprintf_unfiltered (file
,
1661 "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
1662 (long) current_gdbarch
->address_to_pointer
1663 /*ADDRESS_TO_POINTER ()*/);
1665 #ifdef RETURN_VALUE_ON_STACK
1667 fprintf_unfiltered (file
,
1668 "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
1669 (long) current_gdbarch
->return_value_on_stack
1670 /*RETURN_VALUE_ON_STACK ()*/);
1672 #ifdef EXTRACT_RETURN_VALUE
1674 fprintf_unfiltered (file
,
1675 "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
1676 (long) current_gdbarch
->extract_return_value
1677 /*EXTRACT_RETURN_VALUE ()*/);
1679 #ifdef PUSH_ARGUMENTS
1681 fprintf_unfiltered (file
,
1682 "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
1683 (long) current_gdbarch
->push_arguments
1684 /*PUSH_ARGUMENTS ()*/);
1686 #ifdef PUSH_DUMMY_FRAME
1688 fprintf_unfiltered (file
,
1689 "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
1690 (long) current_gdbarch
->push_dummy_frame
1691 /*PUSH_DUMMY_FRAME ()*/);
1693 #ifdef PUSH_RETURN_ADDRESS
1695 fprintf_unfiltered (file
,
1696 "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
1697 (long) current_gdbarch
->push_return_address
1698 /*PUSH_RETURN_ADDRESS ()*/);
1702 fprintf_unfiltered (file
,
1703 "gdbarch_dump: POP_FRAME = 0x%08lx\n",
1704 (long) current_gdbarch
->pop_frame
1707 #ifdef D10V_MAKE_DADDR
1709 fprintf_unfiltered (file
,
1710 "gdbarch_dump: D10V_MAKE_DADDR = 0x%08lx\n",
1711 (long) current_gdbarch
->d10v_make_daddr
1712 /*D10V_MAKE_DADDR ()*/);
1714 #ifdef D10V_MAKE_IADDR
1716 fprintf_unfiltered (file
,
1717 "gdbarch_dump: D10V_MAKE_IADDR = 0x%08lx\n",
1718 (long) current_gdbarch
->d10v_make_iaddr
1719 /*D10V_MAKE_IADDR ()*/);
1723 fprintf_unfiltered (file
,
1724 "gdbarch_dump: D10V_DADDR_P = 0x%08lx\n",
1725 (long) current_gdbarch
->d10v_daddr_p
1726 /*D10V_DADDR_P ()*/);
1730 fprintf_unfiltered (file
,
1731 "gdbarch_dump: D10V_IADDR_P = 0x%08lx\n",
1732 (long) current_gdbarch
->d10v_iaddr_p
1733 /*D10V_IADDR_P ()*/);
1735 #ifdef D10V_CONVERT_DADDR_TO_RAW
1737 fprintf_unfiltered (file
,
1738 "gdbarch_dump: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
1739 (long) current_gdbarch
->d10v_convert_daddr_to_raw
1740 /*D10V_CONVERT_DADDR_TO_RAW ()*/);
1742 #ifdef D10V_CONVERT_IADDR_TO_RAW
1744 fprintf_unfiltered (file
,
1745 "gdbarch_dump: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
1746 (long) current_gdbarch
->d10v_convert_iaddr_to_raw
1747 /*D10V_CONVERT_IADDR_TO_RAW ()*/);
1749 #ifdef STORE_STRUCT_RETURN
1751 fprintf_unfiltered (file
,
1752 "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
1753 (long) current_gdbarch
->store_struct_return
1754 /*STORE_STRUCT_RETURN ()*/);
1756 #ifdef STORE_RETURN_VALUE
1758 fprintf_unfiltered (file
,
1759 "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
1760 (long) current_gdbarch
->store_return_value
1761 /*STORE_RETURN_VALUE ()*/);
1763 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1765 fprintf_unfiltered (file
,
1766 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
1767 (long) current_gdbarch
->extract_struct_value_address
1768 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1770 #ifdef USE_STRUCT_CONVENTION
1772 fprintf_unfiltered (file
,
1773 "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
1774 (long) current_gdbarch
->use_struct_convention
1775 /*USE_STRUCT_CONVENTION ()*/);
1777 #ifdef FRAME_INIT_SAVED_REGS
1779 fprintf_unfiltered (file
,
1780 "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
1781 (long) current_gdbarch
->frame_init_saved_regs
1782 /*FRAME_INIT_SAVED_REGS ()*/);
1784 #ifdef INIT_EXTRA_FRAME_INFO
1786 fprintf_unfiltered (file
,
1787 "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
1788 (long) current_gdbarch
->init_extra_frame_info
1789 /*INIT_EXTRA_FRAME_INFO ()*/);
1791 #ifdef SKIP_PROLOGUE
1793 fprintf_unfiltered (file
,
1794 "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
1795 (long) current_gdbarch
->skip_prologue
1796 /*SKIP_PROLOGUE ()*/);
1798 #ifdef PROLOGUE_FRAMELESS_P
1800 fprintf_unfiltered (file
,
1801 "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
1802 (long) current_gdbarch
->prologue_frameless_p
1803 /*PROLOGUE_FRAMELESS_P ()*/);
1807 fprintf_unfiltered (file
,
1808 "gdbarch_dump: INNER_THAN = 0x%08lx\n",
1809 (long) current_gdbarch
->inner_than
1812 #ifdef BREAKPOINT_FROM_PC
1814 fprintf_unfiltered (file
,
1815 "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
1816 (long) current_gdbarch
->breakpoint_from_pc
1817 /*BREAKPOINT_FROM_PC ()*/);
1819 #ifdef MEMORY_INSERT_BREAKPOINT
1821 fprintf_unfiltered (file
,
1822 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
1823 (long) current_gdbarch
->memory_insert_breakpoint
1824 /*MEMORY_INSERT_BREAKPOINT ()*/);
1826 #ifdef MEMORY_REMOVE_BREAKPOINT
1828 fprintf_unfiltered (file
,
1829 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
1830 (long) current_gdbarch
->memory_remove_breakpoint
1831 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1833 #ifdef DECR_PC_AFTER_BREAK
1834 fprintf_unfiltered (file
,
1835 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1836 (long) DECR_PC_AFTER_BREAK
);
1838 #ifdef FUNCTION_START_OFFSET
1839 fprintf_unfiltered (file
,
1840 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1841 (long) FUNCTION_START_OFFSET
);
1843 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
1845 fprintf_unfiltered (file
,
1846 "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
1847 (long) current_gdbarch
->remote_translate_xfer_address
1848 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
1850 #ifdef FRAME_ARGS_SKIP
1851 fprintf_unfiltered (file
,
1852 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1853 (long) FRAME_ARGS_SKIP
);
1855 #ifdef FRAMELESS_FUNCTION_INVOCATION
1857 fprintf_unfiltered (file
,
1858 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
1859 (long) current_gdbarch
->frameless_function_invocation
1860 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1864 fprintf_unfiltered (file
,
1865 "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n",
1866 (long) current_gdbarch
->frame_chain
1867 /*FRAME_CHAIN ()*/);
1869 #ifdef FRAME_CHAIN_VALID
1871 fprintf_unfiltered (file
,
1872 "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n",
1873 (long) current_gdbarch
->frame_chain_valid
1874 /*FRAME_CHAIN_VALID ()*/);
1876 #ifdef FRAME_SAVED_PC
1878 fprintf_unfiltered (file
,
1879 "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n",
1880 (long) current_gdbarch
->frame_saved_pc
1881 /*FRAME_SAVED_PC ()*/);
1883 #ifdef FRAME_ARGS_ADDRESS
1885 fprintf_unfiltered (file
,
1886 "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
1887 (long) current_gdbarch
->frame_args_address
1888 /*FRAME_ARGS_ADDRESS ()*/);
1890 #ifdef FRAME_LOCALS_ADDRESS
1892 fprintf_unfiltered (file
,
1893 "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
1894 (long) current_gdbarch
->frame_locals_address
1895 /*FRAME_LOCALS_ADDRESS ()*/);
1897 #ifdef SAVED_PC_AFTER_CALL
1899 fprintf_unfiltered (file
,
1900 "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
1901 (long) current_gdbarch
->saved_pc_after_call
1902 /*SAVED_PC_AFTER_CALL ()*/);
1904 #ifdef FRAME_NUM_ARGS
1906 fprintf_unfiltered (file
,
1907 "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
1908 (long) current_gdbarch
->frame_num_args
1909 /*FRAME_NUM_ARGS ()*/);
1913 fprintf_unfiltered (file
,
1914 "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
1915 (long) current_gdbarch
->stack_align
1916 /*STACK_ALIGN ()*/);
1918 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1919 fprintf_unfiltered (file
,
1920 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %ld\n",
1921 (long) EXTRA_STACK_ALIGNMENT_NEEDED
);
1923 #ifdef REG_STRUCT_HAS_ADDR
1925 fprintf_unfiltered (file
,
1926 "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
1927 (long) current_gdbarch
->reg_struct_has_addr
1928 /*REG_STRUCT_HAS_ADDR ()*/);
1930 #ifdef SAVE_DUMMY_FRAME_TOS
1932 fprintf_unfiltered (file
,
1933 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
1934 (long) current_gdbarch
->save_dummy_frame_tos
1935 /*SAVE_DUMMY_FRAME_TOS ()*/);
1937 #ifdef TARGET_FLOAT_FORMAT
1938 fprintf_unfiltered (file
,
1939 "gdbarch_dump: TARGET_FLOAT_FORMAT = %ld\n",
1940 (long) TARGET_FLOAT_FORMAT
);
1942 #ifdef TARGET_DOUBLE_FORMAT
1943 fprintf_unfiltered (file
,
1944 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %ld\n",
1945 (long) TARGET_DOUBLE_FORMAT
);
1947 #ifdef TARGET_LONG_DOUBLE_FORMAT
1948 fprintf_unfiltered (file
,
1949 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
1950 (long) TARGET_LONG_DOUBLE_FORMAT
);
1952 if (current_gdbarch
->dump_tdep
!= NULL
)
1953 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1956 struct gdbarch_tdep
*
1957 gdbarch_tdep (struct gdbarch
*gdbarch
)
1959 if (gdbarch_debug
>= 2)
1960 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1961 return gdbarch
->tdep
;
1965 const struct bfd_arch_info
*
1966 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1968 if (gdbarch_debug
>= 2)
1969 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1970 return gdbarch
->bfd_arch_info
;
1974 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1976 if (gdbarch_debug
>= 2)
1977 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1978 return gdbarch
->byte_order
;
1982 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1984 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1985 if (gdbarch_debug
>= 2)
1986 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1987 return gdbarch
->bfd_vma_bit
;
1991 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1994 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1998 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
2000 if (gdbarch
->ptr_bit
== 0)
2001 internal_error ("gdbarch: gdbarch_ptr_bit invalid");
2002 if (gdbarch_debug
>= 2)
2003 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
2004 return gdbarch
->ptr_bit
;
2008 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
2011 gdbarch
->ptr_bit
= ptr_bit
;
2015 gdbarch_short_bit (struct gdbarch
*gdbarch
)
2017 if (gdbarch
->short_bit
== 0)
2018 internal_error ("gdbarch: gdbarch_short_bit invalid");
2019 if (gdbarch_debug
>= 2)
2020 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
2021 return gdbarch
->short_bit
;
2025 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
2028 gdbarch
->short_bit
= short_bit
;
2032 gdbarch_int_bit (struct gdbarch
*gdbarch
)
2034 if (gdbarch
->int_bit
== 0)
2035 internal_error ("gdbarch: gdbarch_int_bit invalid");
2036 if (gdbarch_debug
>= 2)
2037 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
2038 return gdbarch
->int_bit
;
2042 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
2045 gdbarch
->int_bit
= int_bit
;
2049 gdbarch_long_bit (struct gdbarch
*gdbarch
)
2051 if (gdbarch
->long_bit
== 0)
2052 internal_error ("gdbarch: gdbarch_long_bit invalid");
2053 if (gdbarch_debug
>= 2)
2054 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
2055 return gdbarch
->long_bit
;
2059 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
2062 gdbarch
->long_bit
= long_bit
;
2066 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
2068 if (gdbarch
->long_long_bit
== 0)
2069 internal_error ("gdbarch: gdbarch_long_long_bit invalid");
2070 if (gdbarch_debug
>= 2)
2071 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
2072 return gdbarch
->long_long_bit
;
2076 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
2079 gdbarch
->long_long_bit
= long_long_bit
;
2083 gdbarch_float_bit (struct gdbarch
*gdbarch
)
2085 if (gdbarch
->float_bit
== 0)
2086 internal_error ("gdbarch: gdbarch_float_bit invalid");
2087 if (gdbarch_debug
>= 2)
2088 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
2089 return gdbarch
->float_bit
;
2093 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
2096 gdbarch
->float_bit
= float_bit
;
2100 gdbarch_double_bit (struct gdbarch
*gdbarch
)
2102 if (gdbarch
->double_bit
== 0)
2103 internal_error ("gdbarch: gdbarch_double_bit invalid");
2104 if (gdbarch_debug
>= 2)
2105 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
2106 return gdbarch
->double_bit
;
2110 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
2113 gdbarch
->double_bit
= double_bit
;
2117 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
2119 if (gdbarch
->long_double_bit
== 0)
2120 internal_error ("gdbarch: gdbarch_long_double_bit invalid");
2121 if (gdbarch_debug
>= 2)
2122 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
2123 return gdbarch
->long_double_bit
;
2127 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
2128 int long_double_bit
)
2130 gdbarch
->long_double_bit
= long_double_bit
;
2134 gdbarch_ieee_float (struct gdbarch
*gdbarch
)
2136 /* Skip verify of ieee_float, invalid_p == 0 */
2137 if (gdbarch_debug
>= 2)
2138 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ieee_float called\n");
2139 return gdbarch
->ieee_float
;
2143 set_gdbarch_ieee_float (struct gdbarch
*gdbarch
,
2146 gdbarch
->ieee_float
= ieee_float
;
2150 gdbarch_read_pc (struct gdbarch
*gdbarch
, int pid
)
2152 if (gdbarch
->read_pc
== 0)
2153 internal_error ("gdbarch: gdbarch_read_pc invalid");
2154 if (gdbarch_debug
>= 2)
2155 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
2156 return gdbarch
->read_pc (pid
);
2160 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
2161 gdbarch_read_pc_ftype read_pc
)
2163 gdbarch
->read_pc
= read_pc
;
2167 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, int pid
)
2169 if (gdbarch
->write_pc
== 0)
2170 internal_error ("gdbarch: gdbarch_write_pc invalid");
2171 if (gdbarch_debug
>= 2)
2172 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
2173 gdbarch
->write_pc (val
, pid
);
2177 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
2178 gdbarch_write_pc_ftype write_pc
)
2180 gdbarch
->write_pc
= write_pc
;
2184 gdbarch_read_fp (struct gdbarch
*gdbarch
)
2186 if (gdbarch
->read_fp
== 0)
2187 internal_error ("gdbarch: gdbarch_read_fp invalid");
2188 if (gdbarch_debug
>= 2)
2189 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_fp called\n");
2190 return gdbarch
->read_fp ();
2194 set_gdbarch_read_fp (struct gdbarch
*gdbarch
,
2195 gdbarch_read_fp_ftype read_fp
)
2197 gdbarch
->read_fp
= read_fp
;
2201 gdbarch_write_fp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2203 if (gdbarch
->write_fp
== 0)
2204 internal_error ("gdbarch: gdbarch_write_fp invalid");
2205 if (gdbarch_debug
>= 2)
2206 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_fp called\n");
2207 gdbarch
->write_fp (val
);
2211 set_gdbarch_write_fp (struct gdbarch
*gdbarch
,
2212 gdbarch_write_fp_ftype write_fp
)
2214 gdbarch
->write_fp
= write_fp
;
2218 gdbarch_read_sp (struct gdbarch
*gdbarch
)
2220 if (gdbarch
->read_sp
== 0)
2221 internal_error ("gdbarch: gdbarch_read_sp invalid");
2222 if (gdbarch_debug
>= 2)
2223 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_sp called\n");
2224 return gdbarch
->read_sp ();
2228 set_gdbarch_read_sp (struct gdbarch
*gdbarch
,
2229 gdbarch_read_sp_ftype read_sp
)
2231 gdbarch
->read_sp
= read_sp
;
2235 gdbarch_write_sp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2237 if (gdbarch
->write_sp
== 0)
2238 internal_error ("gdbarch: gdbarch_write_sp invalid");
2239 if (gdbarch_debug
>= 2)
2240 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_sp called\n");
2241 gdbarch
->write_sp (val
);
2245 set_gdbarch_write_sp (struct gdbarch
*gdbarch
,
2246 gdbarch_write_sp_ftype write_sp
)
2248 gdbarch
->write_sp
= write_sp
;
2252 gdbarch_num_regs (struct gdbarch
*gdbarch
)
2254 if (gdbarch
->num_regs
== -1)
2255 internal_error ("gdbarch: gdbarch_num_regs invalid");
2256 if (gdbarch_debug
>= 2)
2257 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
2258 return gdbarch
->num_regs
;
2262 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
2265 gdbarch
->num_regs
= num_regs
;
2269 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
2271 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2272 if (gdbarch_debug
>= 2)
2273 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
2274 return gdbarch
->num_pseudo_regs
;
2278 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
2279 int num_pseudo_regs
)
2281 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
2285 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
2287 if (gdbarch
->sp_regnum
== -1)
2288 internal_error ("gdbarch: gdbarch_sp_regnum invalid");
2289 if (gdbarch_debug
>= 2)
2290 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
2291 return gdbarch
->sp_regnum
;
2295 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
2298 gdbarch
->sp_regnum
= sp_regnum
;
2302 gdbarch_fp_regnum (struct gdbarch
*gdbarch
)
2304 if (gdbarch
->fp_regnum
== -1)
2305 internal_error ("gdbarch: gdbarch_fp_regnum invalid");
2306 if (gdbarch_debug
>= 2)
2307 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp_regnum called\n");
2308 return gdbarch
->fp_regnum
;
2312 set_gdbarch_fp_regnum (struct gdbarch
*gdbarch
,
2315 gdbarch
->fp_regnum
= fp_regnum
;
2319 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
2321 if (gdbarch
->pc_regnum
== -1)
2322 internal_error ("gdbarch: gdbarch_pc_regnum invalid");
2323 if (gdbarch_debug
>= 2)
2324 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
2325 return gdbarch
->pc_regnum
;
2329 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
2332 gdbarch
->pc_regnum
= pc_regnum
;
2336 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
2338 /* Skip verify of fp0_regnum, invalid_p == 0 */
2339 if (gdbarch_debug
>= 2)
2340 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
2341 return gdbarch
->fp0_regnum
;
2345 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
2348 gdbarch
->fp0_regnum
= fp0_regnum
;
2352 gdbarch_npc_regnum (struct gdbarch
*gdbarch
)
2354 /* Skip verify of npc_regnum, invalid_p == 0 */
2355 if (gdbarch_debug
>= 2)
2356 fprintf_unfiltered (gdb_stdlog
, "gdbarch_npc_regnum called\n");
2357 return gdbarch
->npc_regnum
;
2361 set_gdbarch_npc_regnum (struct gdbarch
*gdbarch
,
2364 gdbarch
->npc_regnum
= npc_regnum
;
2368 gdbarch_nnpc_regnum (struct gdbarch
*gdbarch
)
2370 /* Skip verify of nnpc_regnum, invalid_p == 0 */
2371 if (gdbarch_debug
>= 2)
2372 fprintf_unfiltered (gdb_stdlog
, "gdbarch_nnpc_regnum called\n");
2373 return gdbarch
->nnpc_regnum
;
2377 set_gdbarch_nnpc_regnum (struct gdbarch
*gdbarch
,
2380 gdbarch
->nnpc_regnum
= nnpc_regnum
;
2384 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
2386 if (gdbarch
->register_name
== 0)
2387 internal_error ("gdbarch: gdbarch_register_name invalid");
2388 if (gdbarch_debug
>= 2)
2389 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
2390 return gdbarch
->register_name (regnr
);
2394 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2395 gdbarch_register_name_ftype register_name
)
2397 gdbarch
->register_name
= register_name
;
2401 gdbarch_register_size (struct gdbarch
*gdbarch
)
2403 if (gdbarch
->register_size
== -1)
2404 internal_error ("gdbarch: gdbarch_register_size invalid");
2405 if (gdbarch_debug
>= 2)
2406 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_size called\n");
2407 return gdbarch
->register_size
;
2411 set_gdbarch_register_size (struct gdbarch
*gdbarch
,
2414 gdbarch
->register_size
= register_size
;
2418 gdbarch_register_bytes (struct gdbarch
*gdbarch
)
2420 if (gdbarch
->register_bytes
== -1)
2421 internal_error ("gdbarch: gdbarch_register_bytes invalid");
2422 if (gdbarch_debug
>= 2)
2423 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes called\n");
2424 return gdbarch
->register_bytes
;
2428 set_gdbarch_register_bytes (struct gdbarch
*gdbarch
,
2431 gdbarch
->register_bytes
= register_bytes
;
2435 gdbarch_register_byte (struct gdbarch
*gdbarch
, int reg_nr
)
2437 if (gdbarch
->register_byte
== 0)
2438 internal_error ("gdbarch: gdbarch_register_byte invalid");
2439 if (gdbarch_debug
>= 2)
2440 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_byte called\n");
2441 return gdbarch
->register_byte (reg_nr
);
2445 set_gdbarch_register_byte (struct gdbarch
*gdbarch
,
2446 gdbarch_register_byte_ftype register_byte
)
2448 gdbarch
->register_byte
= register_byte
;
2452 gdbarch_register_raw_size (struct gdbarch
*gdbarch
, int reg_nr
)
2454 if (gdbarch
->register_raw_size
== 0)
2455 internal_error ("gdbarch: gdbarch_register_raw_size invalid");
2456 if (gdbarch_debug
>= 2)
2457 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_raw_size called\n");
2458 return gdbarch
->register_raw_size (reg_nr
);
2462 set_gdbarch_register_raw_size (struct gdbarch
*gdbarch
,
2463 gdbarch_register_raw_size_ftype register_raw_size
)
2465 gdbarch
->register_raw_size
= register_raw_size
;
2469 gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
)
2471 if (gdbarch
->max_register_raw_size
== -1)
2472 internal_error ("gdbarch: gdbarch_max_register_raw_size invalid");
2473 if (gdbarch_debug
>= 2)
2474 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_raw_size called\n");
2475 return gdbarch
->max_register_raw_size
;
2479 set_gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
,
2480 int max_register_raw_size
)
2482 gdbarch
->max_register_raw_size
= max_register_raw_size
;
2486 gdbarch_register_virtual_size (struct gdbarch
*gdbarch
, int reg_nr
)
2488 if (gdbarch
->register_virtual_size
== 0)
2489 internal_error ("gdbarch: gdbarch_register_virtual_size invalid");
2490 if (gdbarch_debug
>= 2)
2491 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_size called\n");
2492 return gdbarch
->register_virtual_size (reg_nr
);
2496 set_gdbarch_register_virtual_size (struct gdbarch
*gdbarch
,
2497 gdbarch_register_virtual_size_ftype register_virtual_size
)
2499 gdbarch
->register_virtual_size
= register_virtual_size
;
2503 gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
)
2505 if (gdbarch
->max_register_virtual_size
== -1)
2506 internal_error ("gdbarch: gdbarch_max_register_virtual_size invalid");
2507 if (gdbarch_debug
>= 2)
2508 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_virtual_size called\n");
2509 return gdbarch
->max_register_virtual_size
;
2513 set_gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
,
2514 int max_register_virtual_size
)
2516 gdbarch
->max_register_virtual_size
= max_register_virtual_size
;
2520 gdbarch_register_virtual_type (struct gdbarch
*gdbarch
, int reg_nr
)
2522 if (gdbarch
->register_virtual_type
== 0)
2523 internal_error ("gdbarch: gdbarch_register_virtual_type invalid");
2524 if (gdbarch_debug
>= 2)
2525 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_type called\n");
2526 return gdbarch
->register_virtual_type (reg_nr
);
2530 set_gdbarch_register_virtual_type (struct gdbarch
*gdbarch
,
2531 gdbarch_register_virtual_type_ftype register_virtual_type
)
2533 gdbarch
->register_virtual_type
= register_virtual_type
;
2537 gdbarch_do_registers_info (struct gdbarch
*gdbarch
, int reg_nr
, int fpregs
)
2539 if (gdbarch
->do_registers_info
== 0)
2540 internal_error ("gdbarch: gdbarch_do_registers_info invalid");
2541 if (gdbarch_debug
>= 2)
2542 fprintf_unfiltered (gdb_stdlog
, "gdbarch_do_registers_info called\n");
2543 gdbarch
->do_registers_info (reg_nr
, fpregs
);
2547 set_gdbarch_do_registers_info (struct gdbarch
*gdbarch
,
2548 gdbarch_do_registers_info_ftype do_registers_info
)
2550 gdbarch
->do_registers_info
= do_registers_info
;
2554 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
2556 if (gdbarch
->register_sim_regno
== 0)
2557 internal_error ("gdbarch: gdbarch_register_sim_regno invalid");
2558 if (gdbarch_debug
>= 2)
2559 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
2560 return gdbarch
->register_sim_regno (reg_nr
);
2564 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
2565 gdbarch_register_sim_regno_ftype register_sim_regno
)
2567 gdbarch
->register_sim_regno
= register_sim_regno
;
2571 gdbarch_use_generic_dummy_frames (struct gdbarch
*gdbarch
)
2573 if (gdbarch
->use_generic_dummy_frames
== -1)
2574 internal_error ("gdbarch: gdbarch_use_generic_dummy_frames invalid");
2575 if (gdbarch_debug
>= 2)
2576 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_generic_dummy_frames called\n");
2577 return gdbarch
->use_generic_dummy_frames
;
2581 set_gdbarch_use_generic_dummy_frames (struct gdbarch
*gdbarch
,
2582 int use_generic_dummy_frames
)
2584 gdbarch
->use_generic_dummy_frames
= use_generic_dummy_frames
;
2588 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
2590 if (gdbarch
->call_dummy_location
== 0)
2591 internal_error ("gdbarch: gdbarch_call_dummy_location invalid");
2592 if (gdbarch_debug
>= 2)
2593 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
2594 return gdbarch
->call_dummy_location
;
2598 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
2599 int call_dummy_location
)
2601 gdbarch
->call_dummy_location
= call_dummy_location
;
2605 gdbarch_call_dummy_address (struct gdbarch
*gdbarch
)
2607 if (gdbarch
->call_dummy_address
== 0)
2608 internal_error ("gdbarch: gdbarch_call_dummy_address invalid");
2609 if (gdbarch_debug
>= 2)
2610 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_address called\n");
2611 return gdbarch
->call_dummy_address ();
2615 set_gdbarch_call_dummy_address (struct gdbarch
*gdbarch
,
2616 gdbarch_call_dummy_address_ftype call_dummy_address
)
2618 gdbarch
->call_dummy_address
= call_dummy_address
;
2622 gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
)
2624 if (gdbarch
->call_dummy_start_offset
== -1)
2625 internal_error ("gdbarch: gdbarch_call_dummy_start_offset invalid");
2626 if (gdbarch_debug
>= 2)
2627 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_start_offset called\n");
2628 return gdbarch
->call_dummy_start_offset
;
2632 set_gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
,
2633 CORE_ADDR call_dummy_start_offset
)
2635 gdbarch
->call_dummy_start_offset
= call_dummy_start_offset
;
2639 gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
)
2641 if (gdbarch
->call_dummy_breakpoint_offset
== -1)
2642 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
2643 if (gdbarch_debug
>= 2)
2644 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset called\n");
2645 return gdbarch
->call_dummy_breakpoint_offset
;
2649 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
,
2650 CORE_ADDR call_dummy_breakpoint_offset
)
2652 gdbarch
->call_dummy_breakpoint_offset
= call_dummy_breakpoint_offset
;
2656 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
)
2658 if (gdbarch
->call_dummy_breakpoint_offset_p
== -1)
2659 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
2660 if (gdbarch_debug
>= 2)
2661 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset_p called\n");
2662 return gdbarch
->call_dummy_breakpoint_offset_p
;
2666 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
,
2667 int call_dummy_breakpoint_offset_p
)
2669 gdbarch
->call_dummy_breakpoint_offset_p
= call_dummy_breakpoint_offset_p
;
2673 gdbarch_call_dummy_length (struct gdbarch
*gdbarch
)
2675 if (gdbarch
->call_dummy_length
== -1)
2676 internal_error ("gdbarch: gdbarch_call_dummy_length invalid");
2677 if (gdbarch_debug
>= 2)
2678 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_length called\n");
2679 return gdbarch
->call_dummy_length
;
2683 set_gdbarch_call_dummy_length (struct gdbarch
*gdbarch
,
2684 int call_dummy_length
)
2686 gdbarch
->call_dummy_length
= call_dummy_length
;
2690 gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
2692 if (gdbarch
->pc_in_call_dummy
== 0)
2693 internal_error ("gdbarch: gdbarch_pc_in_call_dummy invalid");
2694 if (gdbarch_debug
>= 2)
2695 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_call_dummy called\n");
2696 return gdbarch
->pc_in_call_dummy (pc
, sp
, frame_address
);
2700 set_gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
,
2701 gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy
)
2703 gdbarch
->pc_in_call_dummy
= pc_in_call_dummy
;
2707 gdbarch_call_dummy_p (struct gdbarch
*gdbarch
)
2709 if (gdbarch
->call_dummy_p
== -1)
2710 internal_error ("gdbarch: gdbarch_call_dummy_p invalid");
2711 if (gdbarch_debug
>= 2)
2712 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_p called\n");
2713 return gdbarch
->call_dummy_p
;
2717 set_gdbarch_call_dummy_p (struct gdbarch
*gdbarch
,
2720 gdbarch
->call_dummy_p
= call_dummy_p
;
2724 gdbarch_call_dummy_words (struct gdbarch
*gdbarch
)
2726 /* Skip verify of call_dummy_words, invalid_p == 0 */
2727 if (gdbarch_debug
>= 2)
2728 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_words called\n");
2729 return gdbarch
->call_dummy_words
;
2733 set_gdbarch_call_dummy_words (struct gdbarch
*gdbarch
,
2734 LONGEST
* call_dummy_words
)
2736 gdbarch
->call_dummy_words
= call_dummy_words
;
2740 gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
)
2742 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
2743 if (gdbarch_debug
>= 2)
2744 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sizeof_call_dummy_words called\n");
2745 return gdbarch
->sizeof_call_dummy_words
;
2749 set_gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
,
2750 int sizeof_call_dummy_words
)
2752 gdbarch
->sizeof_call_dummy_words
= sizeof_call_dummy_words
;
2756 gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
)
2758 if (gdbarch
->call_dummy_stack_adjust_p
== -1)
2759 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
2760 if (gdbarch_debug
>= 2)
2761 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust_p called\n");
2762 return gdbarch
->call_dummy_stack_adjust_p
;
2766 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
,
2767 int call_dummy_stack_adjust_p
)
2769 gdbarch
->call_dummy_stack_adjust_p
= call_dummy_stack_adjust_p
;
2773 gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
)
2775 if (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0)
2776 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust invalid");
2777 if (gdbarch_debug
>= 2)
2778 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust called\n");
2779 return gdbarch
->call_dummy_stack_adjust
;
2783 set_gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
,
2784 int call_dummy_stack_adjust
)
2786 gdbarch
->call_dummy_stack_adjust
= call_dummy_stack_adjust
;
2790 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
)
2792 if (gdbarch
->fix_call_dummy
== 0)
2793 internal_error ("gdbarch: gdbarch_fix_call_dummy invalid");
2794 if (gdbarch_debug
>= 2)
2795 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fix_call_dummy called\n");
2796 gdbarch
->fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
);
2800 set_gdbarch_fix_call_dummy (struct gdbarch
*gdbarch
,
2801 gdbarch_fix_call_dummy_ftype fix_call_dummy
)
2803 gdbarch
->fix_call_dummy
= fix_call_dummy
;
2807 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2809 if (gdbarch_debug
>= 2)
2810 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2811 return gdbarch
->believe_pcc_promotion
;
2815 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2816 int believe_pcc_promotion
)
2818 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2822 gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
)
2824 if (gdbarch_debug
>= 2)
2825 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion_type called\n");
2826 return gdbarch
->believe_pcc_promotion_type
;
2830 set_gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
,
2831 int believe_pcc_promotion_type
)
2833 gdbarch
->believe_pcc_promotion_type
= believe_pcc_promotion_type
;
2837 gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
, struct type
*formal
, struct type
*actual
)
2839 if (gdbarch
->coerce_float_to_double
== 0)
2840 internal_error ("gdbarch: gdbarch_coerce_float_to_double invalid");
2841 if (gdbarch_debug
>= 2)
2842 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coerce_float_to_double called\n");
2843 return gdbarch
->coerce_float_to_double (formal
, actual
);
2847 set_gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
,
2848 gdbarch_coerce_float_to_double_ftype coerce_float_to_double
)
2850 gdbarch
->coerce_float_to_double
= coerce_float_to_double
;
2854 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
)
2856 if (gdbarch
->get_saved_register
== 0)
2857 internal_error ("gdbarch: gdbarch_get_saved_register invalid");
2858 if (gdbarch_debug
>= 2)
2859 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_saved_register called\n");
2860 gdbarch
->get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
2864 set_gdbarch_get_saved_register (struct gdbarch
*gdbarch
,
2865 gdbarch_get_saved_register_ftype get_saved_register
)
2867 gdbarch
->get_saved_register
= get_saved_register
;
2871 gdbarch_register_convertible (struct gdbarch
*gdbarch
, int nr
)
2873 if (gdbarch
->register_convertible
== 0)
2874 internal_error ("gdbarch: gdbarch_register_convertible invalid");
2875 if (gdbarch_debug
>= 2)
2876 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convertible called\n");
2877 return gdbarch
->register_convertible (nr
);
2881 set_gdbarch_register_convertible (struct gdbarch
*gdbarch
,
2882 gdbarch_register_convertible_ftype register_convertible
)
2884 gdbarch
->register_convertible
= register_convertible
;
2888 gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
2890 if (gdbarch
->register_convert_to_virtual
== 0)
2891 internal_error ("gdbarch: gdbarch_register_convert_to_virtual invalid");
2892 if (gdbarch_debug
>= 2)
2893 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_virtual called\n");
2894 gdbarch
->register_convert_to_virtual (regnum
, type
, from
, to
);
2898 set_gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
,
2899 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual
)
2901 gdbarch
->register_convert_to_virtual
= register_convert_to_virtual
;
2905 gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
2907 if (gdbarch
->register_convert_to_raw
== 0)
2908 internal_error ("gdbarch: gdbarch_register_convert_to_raw invalid");
2909 if (gdbarch_debug
>= 2)
2910 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_raw called\n");
2911 gdbarch
->register_convert_to_raw (type
, regnum
, from
, to
);
2915 set_gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
,
2916 gdbarch_register_convert_to_raw_ftype register_convert_to_raw
)
2918 gdbarch
->register_convert_to_raw
= register_convert_to_raw
;
2922 gdbarch_fetch_pseudo_register (struct gdbarch
*gdbarch
, int regnum
)
2924 if (gdbarch
->fetch_pseudo_register
== 0)
2925 internal_error ("gdbarch: gdbarch_fetch_pseudo_register invalid");
2926 if (gdbarch_debug
>= 2)
2927 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pseudo_register called\n");
2928 gdbarch
->fetch_pseudo_register (regnum
);
2932 set_gdbarch_fetch_pseudo_register (struct gdbarch
*gdbarch
,
2933 gdbarch_fetch_pseudo_register_ftype fetch_pseudo_register
)
2935 gdbarch
->fetch_pseudo_register
= fetch_pseudo_register
;
2939 gdbarch_store_pseudo_register (struct gdbarch
*gdbarch
, int regnum
)
2941 if (gdbarch
->store_pseudo_register
== 0)
2942 internal_error ("gdbarch: gdbarch_store_pseudo_register invalid");
2943 if (gdbarch_debug
>= 2)
2944 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_pseudo_register called\n");
2945 gdbarch
->store_pseudo_register (regnum
);
2949 set_gdbarch_store_pseudo_register (struct gdbarch
*gdbarch
,
2950 gdbarch_store_pseudo_register_ftype store_pseudo_register
)
2952 gdbarch
->store_pseudo_register
= store_pseudo_register
;
2956 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
2958 if (gdbarch
->pointer_to_address
== 0)
2959 internal_error ("gdbarch: gdbarch_pointer_to_address invalid");
2960 if (gdbarch_debug
>= 2)
2961 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2962 return gdbarch
->pointer_to_address (type
, buf
);
2966 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2967 gdbarch_pointer_to_address_ftype pointer_to_address
)
2969 gdbarch
->pointer_to_address
= pointer_to_address
;
2973 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
, CORE_ADDR addr
)
2975 if (gdbarch
->address_to_pointer
== 0)
2976 internal_error ("gdbarch: gdbarch_address_to_pointer invalid");
2977 if (gdbarch_debug
>= 2)
2978 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
2979 gdbarch
->address_to_pointer (type
, buf
, addr
);
2983 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
2984 gdbarch_address_to_pointer_ftype address_to_pointer
)
2986 gdbarch
->address_to_pointer
= address_to_pointer
;
2990 gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
, struct type
*type
)
2992 if (gdbarch
->return_value_on_stack
== 0)
2993 internal_error ("gdbarch: gdbarch_return_value_on_stack invalid");
2994 if (gdbarch_debug
>= 2)
2995 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value_on_stack called\n");
2996 return gdbarch
->return_value_on_stack (type
);
3000 set_gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
,
3001 gdbarch_return_value_on_stack_ftype return_value_on_stack
)
3003 gdbarch
->return_value_on_stack
= return_value_on_stack
;
3007 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *regbuf
, char *valbuf
)
3009 if (gdbarch
->extract_return_value
== 0)
3010 internal_error ("gdbarch: gdbarch_extract_return_value invalid");
3011 if (gdbarch_debug
>= 2)
3012 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
3013 gdbarch
->extract_return_value (type
, regbuf
, valbuf
);
3017 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
3018 gdbarch_extract_return_value_ftype extract_return_value
)
3020 gdbarch
->extract_return_value
= extract_return_value
;
3024 gdbarch_push_arguments (struct gdbarch
*gdbarch
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
3026 if (gdbarch
->push_arguments
== 0)
3027 internal_error ("gdbarch: gdbarch_push_arguments invalid");
3028 if (gdbarch_debug
>= 2)
3029 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_arguments called\n");
3030 return gdbarch
->push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
3034 set_gdbarch_push_arguments (struct gdbarch
*gdbarch
,
3035 gdbarch_push_arguments_ftype push_arguments
)
3037 gdbarch
->push_arguments
= push_arguments
;
3041 gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
)
3043 if (gdbarch
->push_dummy_frame
== 0)
3044 internal_error ("gdbarch: gdbarch_push_dummy_frame invalid");
3045 if (gdbarch_debug
>= 2)
3046 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_frame called\n");
3047 gdbarch
->push_dummy_frame ();
3051 set_gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
,
3052 gdbarch_push_dummy_frame_ftype push_dummy_frame
)
3054 gdbarch
->push_dummy_frame
= push_dummy_frame
;
3058 gdbarch_push_return_address (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
)
3060 if (gdbarch
->push_return_address
== 0)
3061 internal_error ("gdbarch: gdbarch_push_return_address invalid");
3062 if (gdbarch_debug
>= 2)
3063 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_return_address called\n");
3064 return gdbarch
->push_return_address (pc
, sp
);
3068 set_gdbarch_push_return_address (struct gdbarch
*gdbarch
,
3069 gdbarch_push_return_address_ftype push_return_address
)
3071 gdbarch
->push_return_address
= push_return_address
;
3075 gdbarch_pop_frame (struct gdbarch
*gdbarch
)
3077 if (gdbarch
->pop_frame
== 0)
3078 internal_error ("gdbarch: gdbarch_pop_frame invalid");
3079 if (gdbarch_debug
>= 2)
3080 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pop_frame called\n");
3081 gdbarch
->pop_frame ();
3085 set_gdbarch_pop_frame (struct gdbarch
*gdbarch
,
3086 gdbarch_pop_frame_ftype pop_frame
)
3088 gdbarch
->pop_frame
= pop_frame
;
3092 gdbarch_d10v_make_daddr (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3094 if (gdbarch
->d10v_make_daddr
== 0)
3095 internal_error ("gdbarch: gdbarch_d10v_make_daddr invalid");
3096 if (gdbarch_debug
>= 2)
3097 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_make_daddr called\n");
3098 return gdbarch
->d10v_make_daddr (x
);
3102 set_gdbarch_d10v_make_daddr (struct gdbarch
*gdbarch
,
3103 gdbarch_d10v_make_daddr_ftype d10v_make_daddr
)
3105 gdbarch
->d10v_make_daddr
= d10v_make_daddr
;
3109 gdbarch_d10v_make_iaddr (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3111 if (gdbarch
->d10v_make_iaddr
== 0)
3112 internal_error ("gdbarch: gdbarch_d10v_make_iaddr invalid");
3113 if (gdbarch_debug
>= 2)
3114 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_make_iaddr called\n");
3115 return gdbarch
->d10v_make_iaddr (x
);
3119 set_gdbarch_d10v_make_iaddr (struct gdbarch
*gdbarch
,
3120 gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr
)
3122 gdbarch
->d10v_make_iaddr
= d10v_make_iaddr
;
3126 gdbarch_d10v_daddr_p (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3128 if (gdbarch
->d10v_daddr_p
== 0)
3129 internal_error ("gdbarch: gdbarch_d10v_daddr_p invalid");
3130 if (gdbarch_debug
>= 2)
3131 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_daddr_p called\n");
3132 return gdbarch
->d10v_daddr_p (x
);
3136 set_gdbarch_d10v_daddr_p (struct gdbarch
*gdbarch
,
3137 gdbarch_d10v_daddr_p_ftype d10v_daddr_p
)
3139 gdbarch
->d10v_daddr_p
= d10v_daddr_p
;
3143 gdbarch_d10v_iaddr_p (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3145 if (gdbarch
->d10v_iaddr_p
== 0)
3146 internal_error ("gdbarch: gdbarch_d10v_iaddr_p invalid");
3147 if (gdbarch_debug
>= 2)
3148 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_iaddr_p called\n");
3149 return gdbarch
->d10v_iaddr_p (x
);
3153 set_gdbarch_d10v_iaddr_p (struct gdbarch
*gdbarch
,
3154 gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p
)
3156 gdbarch
->d10v_iaddr_p
= d10v_iaddr_p
;
3160 gdbarch_d10v_convert_daddr_to_raw (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3162 if (gdbarch
->d10v_convert_daddr_to_raw
== 0)
3163 internal_error ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid");
3164 if (gdbarch_debug
>= 2)
3165 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_convert_daddr_to_raw called\n");
3166 return gdbarch
->d10v_convert_daddr_to_raw (x
);
3170 set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch
*gdbarch
,
3171 gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw
)
3173 gdbarch
->d10v_convert_daddr_to_raw
= d10v_convert_daddr_to_raw
;
3177 gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3179 if (gdbarch
->d10v_convert_iaddr_to_raw
== 0)
3180 internal_error ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid");
3181 if (gdbarch_debug
>= 2)
3182 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_convert_iaddr_to_raw called\n");
3183 return gdbarch
->d10v_convert_iaddr_to_raw (x
);
3187 set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch
*gdbarch
,
3188 gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw
)
3190 gdbarch
->d10v_convert_iaddr_to_raw
= d10v_convert_iaddr_to_raw
;
3194 gdbarch_store_struct_return (struct gdbarch
*gdbarch
, CORE_ADDR addr
, CORE_ADDR sp
)
3196 if (gdbarch
->store_struct_return
== 0)
3197 internal_error ("gdbarch: gdbarch_store_struct_return invalid");
3198 if (gdbarch_debug
>= 2)
3199 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_struct_return called\n");
3200 gdbarch
->store_struct_return (addr
, sp
);
3204 set_gdbarch_store_struct_return (struct gdbarch
*gdbarch
,
3205 gdbarch_store_struct_return_ftype store_struct_return
)
3207 gdbarch
->store_struct_return
= store_struct_return
;
3211 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *valbuf
)
3213 if (gdbarch
->store_return_value
== 0)
3214 internal_error ("gdbarch: gdbarch_store_return_value invalid");
3215 if (gdbarch_debug
>= 2)
3216 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
3217 gdbarch
->store_return_value (type
, valbuf
);
3221 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
3222 gdbarch_store_return_value_ftype store_return_value
)
3224 gdbarch
->store_return_value
= store_return_value
;
3228 gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
, char *regbuf
)
3230 if (gdbarch
->extract_struct_value_address
== 0)
3231 internal_error ("gdbarch: gdbarch_extract_struct_value_address invalid");
3232 if (gdbarch_debug
>= 2)
3233 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_struct_value_address called\n");
3234 return gdbarch
->extract_struct_value_address (regbuf
);
3238 set_gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
,
3239 gdbarch_extract_struct_value_address_ftype extract_struct_value_address
)
3241 gdbarch
->extract_struct_value_address
= extract_struct_value_address
;
3245 gdbarch_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
3247 if (gdbarch
->use_struct_convention
== 0)
3248 internal_error ("gdbarch: gdbarch_use_struct_convention invalid");
3249 if (gdbarch_debug
>= 2)
3250 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_struct_convention called\n");
3251 return gdbarch
->use_struct_convention (gcc_p
, value_type
);
3255 set_gdbarch_use_struct_convention (struct gdbarch
*gdbarch
,
3256 gdbarch_use_struct_convention_ftype use_struct_convention
)
3258 gdbarch
->use_struct_convention
= use_struct_convention
;
3262 gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3264 if (gdbarch
->frame_init_saved_regs
== 0)
3265 internal_error ("gdbarch: gdbarch_frame_init_saved_regs invalid");
3266 if (gdbarch_debug
>= 2)
3267 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_init_saved_regs called\n");
3268 gdbarch
->frame_init_saved_regs (frame
);
3272 set_gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
,
3273 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs
)
3275 gdbarch
->frame_init_saved_regs
= frame_init_saved_regs
;
3279 gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*frame
)
3281 if (gdbarch
->init_extra_frame_info
== 0)
3282 internal_error ("gdbarch: gdbarch_init_extra_frame_info invalid");
3283 if (gdbarch_debug
>= 2)
3284 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_extra_frame_info called\n");
3285 gdbarch
->init_extra_frame_info (fromleaf
, frame
);
3289 set_gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
,
3290 gdbarch_init_extra_frame_info_ftype init_extra_frame_info
)
3292 gdbarch
->init_extra_frame_info
= init_extra_frame_info
;
3296 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
3298 if (gdbarch
->skip_prologue
== 0)
3299 internal_error ("gdbarch: gdbarch_skip_prologue invalid");
3300 if (gdbarch_debug
>= 2)
3301 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
3302 return gdbarch
->skip_prologue (ip
);
3306 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
3307 gdbarch_skip_prologue_ftype skip_prologue
)
3309 gdbarch
->skip_prologue
= skip_prologue
;
3313 gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
3315 if (gdbarch
->prologue_frameless_p
== 0)
3316 internal_error ("gdbarch: gdbarch_prologue_frameless_p invalid");
3317 if (gdbarch_debug
>= 2)
3318 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prologue_frameless_p called\n");
3319 return gdbarch
->prologue_frameless_p (ip
);
3323 set_gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
,
3324 gdbarch_prologue_frameless_p_ftype prologue_frameless_p
)
3326 gdbarch
->prologue_frameless_p
= prologue_frameless_p
;
3330 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
3332 if (gdbarch
->inner_than
== 0)
3333 internal_error ("gdbarch: gdbarch_inner_than invalid");
3334 if (gdbarch_debug
>= 2)
3335 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
3336 return gdbarch
->inner_than (lhs
, rhs
);
3340 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
3341 gdbarch_inner_than_ftype inner_than
)
3343 gdbarch
->inner_than
= inner_than
;
3347 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
3349 if (gdbarch
->breakpoint_from_pc
== 0)
3350 internal_error ("gdbarch: gdbarch_breakpoint_from_pc invalid");
3351 if (gdbarch_debug
>= 2)
3352 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
3353 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
3357 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
3358 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
3360 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
3364 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
3366 if (gdbarch
->memory_insert_breakpoint
== 0)
3367 internal_error ("gdbarch: gdbarch_memory_insert_breakpoint invalid");
3368 if (gdbarch_debug
>= 2)
3369 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
3370 return gdbarch
->memory_insert_breakpoint (addr
, contents_cache
);
3374 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
3375 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
3377 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
3381 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
3383 if (gdbarch
->memory_remove_breakpoint
== 0)
3384 internal_error ("gdbarch: gdbarch_memory_remove_breakpoint invalid");
3385 if (gdbarch_debug
>= 2)
3386 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
3387 return gdbarch
->memory_remove_breakpoint (addr
, contents_cache
);
3391 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
3392 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
3394 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
3398 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
3400 if (gdbarch
->decr_pc_after_break
== -1)
3401 internal_error ("gdbarch: gdbarch_decr_pc_after_break invalid");
3402 if (gdbarch_debug
>= 2)
3403 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
3404 return gdbarch
->decr_pc_after_break
;
3408 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
3409 CORE_ADDR decr_pc_after_break
)
3411 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
3415 gdbarch_function_start_offset (struct gdbarch
*gdbarch
)
3417 if (gdbarch
->function_start_offset
== -1)
3418 internal_error ("gdbarch: gdbarch_function_start_offset invalid");
3419 if (gdbarch_debug
>= 2)
3420 fprintf_unfiltered (gdb_stdlog
, "gdbarch_function_start_offset called\n");
3421 return gdbarch
->function_start_offset
;
3425 set_gdbarch_function_start_offset (struct gdbarch
*gdbarch
,
3426 CORE_ADDR function_start_offset
)
3428 gdbarch
->function_start_offset
= function_start_offset
;
3432 gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
, CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
)
3434 if (gdbarch
->remote_translate_xfer_address
== 0)
3435 internal_error ("gdbarch: gdbarch_remote_translate_xfer_address invalid");
3436 if (gdbarch_debug
>= 2)
3437 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_translate_xfer_address called\n");
3438 gdbarch
->remote_translate_xfer_address (gdb_addr
, gdb_len
, rem_addr
, rem_len
);
3442 set_gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
3443 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address
)
3445 gdbarch
->remote_translate_xfer_address
= remote_translate_xfer_address
;
3449 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
3451 if (gdbarch
->frame_args_skip
== -1)
3452 internal_error ("gdbarch: gdbarch_frame_args_skip invalid");
3453 if (gdbarch_debug
>= 2)
3454 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
3455 return gdbarch
->frame_args_skip
;
3459 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
3460 CORE_ADDR frame_args_skip
)
3462 gdbarch
->frame_args_skip
= frame_args_skip
;
3466 gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3468 if (gdbarch
->frameless_function_invocation
== 0)
3469 internal_error ("gdbarch: gdbarch_frameless_function_invocation invalid");
3470 if (gdbarch_debug
>= 2)
3471 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frameless_function_invocation called\n");
3472 return gdbarch
->frameless_function_invocation (fi
);
3476 set_gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
,
3477 gdbarch_frameless_function_invocation_ftype frameless_function_invocation
)
3479 gdbarch
->frameless_function_invocation
= frameless_function_invocation
;
3483 gdbarch_frame_chain (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3485 if (gdbarch
->frame_chain
== 0)
3486 internal_error ("gdbarch: gdbarch_frame_chain invalid");
3487 if (gdbarch_debug
>= 2)
3488 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain called\n");
3489 return gdbarch
->frame_chain (frame
);
3493 set_gdbarch_frame_chain (struct gdbarch
*gdbarch
,
3494 gdbarch_frame_chain_ftype frame_chain
)
3496 gdbarch
->frame_chain
= frame_chain
;
3500 gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
, CORE_ADDR chain
, struct frame_info
*thisframe
)
3502 if (gdbarch
->frame_chain_valid
== 0)
3503 internal_error ("gdbarch: gdbarch_frame_chain_valid invalid");
3504 if (gdbarch_debug
>= 2)
3505 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain_valid called\n");
3506 return gdbarch
->frame_chain_valid (chain
, thisframe
);
3510 set_gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
,
3511 gdbarch_frame_chain_valid_ftype frame_chain_valid
)
3513 gdbarch
->frame_chain_valid
= frame_chain_valid
;
3517 gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3519 if (gdbarch
->frame_saved_pc
== 0)
3520 internal_error ("gdbarch: gdbarch_frame_saved_pc invalid");
3521 if (gdbarch_debug
>= 2)
3522 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_saved_pc called\n");
3523 return gdbarch
->frame_saved_pc (fi
);
3527 set_gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
,
3528 gdbarch_frame_saved_pc_ftype frame_saved_pc
)
3530 gdbarch
->frame_saved_pc
= frame_saved_pc
;
3534 gdbarch_frame_args_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3536 if (gdbarch
->frame_args_address
== 0)
3537 internal_error ("gdbarch: gdbarch_frame_args_address invalid");
3538 if (gdbarch_debug
>= 2)
3539 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_address called\n");
3540 return gdbarch
->frame_args_address (fi
);
3544 set_gdbarch_frame_args_address (struct gdbarch
*gdbarch
,
3545 gdbarch_frame_args_address_ftype frame_args_address
)
3547 gdbarch
->frame_args_address
= frame_args_address
;
3551 gdbarch_frame_locals_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3553 if (gdbarch
->frame_locals_address
== 0)
3554 internal_error ("gdbarch: gdbarch_frame_locals_address invalid");
3555 if (gdbarch_debug
>= 2)
3556 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_locals_address called\n");
3557 return gdbarch
->frame_locals_address (fi
);
3561 set_gdbarch_frame_locals_address (struct gdbarch
*gdbarch
,
3562 gdbarch_frame_locals_address_ftype frame_locals_address
)
3564 gdbarch
->frame_locals_address
= frame_locals_address
;
3568 gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3570 if (gdbarch
->saved_pc_after_call
== 0)
3571 internal_error ("gdbarch: gdbarch_saved_pc_after_call invalid");
3572 if (gdbarch_debug
>= 2)
3573 fprintf_unfiltered (gdb_stdlog
, "gdbarch_saved_pc_after_call called\n");
3574 return gdbarch
->saved_pc_after_call (frame
);
3578 set_gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
,
3579 gdbarch_saved_pc_after_call_ftype saved_pc_after_call
)
3581 gdbarch
->saved_pc_after_call
= saved_pc_after_call
;
3585 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3587 if (gdbarch
->frame_num_args
== 0)
3588 internal_error ("gdbarch: gdbarch_frame_num_args invalid");
3589 if (gdbarch_debug
>= 2)
3590 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
3591 return gdbarch
->frame_num_args (frame
);
3595 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
3596 gdbarch_frame_num_args_ftype frame_num_args
)
3598 gdbarch
->frame_num_args
= frame_num_args
;
3602 gdbarch_stack_align_p (struct gdbarch
*gdbarch
)
3604 return gdbarch
->stack_align
!= 0;
3608 gdbarch_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
3610 if (gdbarch
->stack_align
== 0)
3611 internal_error ("gdbarch: gdbarch_stack_align invalid");
3612 if (gdbarch_debug
>= 2)
3613 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stack_align called\n");
3614 return gdbarch
->stack_align (sp
);
3618 set_gdbarch_stack_align (struct gdbarch
*gdbarch
,
3619 gdbarch_stack_align_ftype stack_align
)
3621 gdbarch
->stack_align
= stack_align
;
3625 gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
)
3627 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
3628 if (gdbarch_debug
>= 2)
3629 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extra_stack_alignment_needed called\n");
3630 return gdbarch
->extra_stack_alignment_needed
;
3634 set_gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
,
3635 int extra_stack_alignment_needed
)
3637 gdbarch
->extra_stack_alignment_needed
= extra_stack_alignment_needed
;
3641 gdbarch_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
3643 return gdbarch
->reg_struct_has_addr
!= 0;
3647 gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
3649 if (gdbarch
->reg_struct_has_addr
== 0)
3650 internal_error ("gdbarch: gdbarch_reg_struct_has_addr invalid");
3651 if (gdbarch_debug
>= 2)
3652 fprintf_unfiltered (gdb_stdlog
, "gdbarch_reg_struct_has_addr called\n");
3653 return gdbarch
->reg_struct_has_addr (gcc_p
, type
);
3657 set_gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
,
3658 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr
)
3660 gdbarch
->reg_struct_has_addr
= reg_struct_has_addr
;
3664 gdbarch_save_dummy_frame_tos_p (struct gdbarch
*gdbarch
)
3666 return gdbarch
->save_dummy_frame_tos
!= 0;
3670 gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
3672 if (gdbarch
->save_dummy_frame_tos
== 0)
3673 internal_error ("gdbarch: gdbarch_save_dummy_frame_tos invalid");
3674 if (gdbarch_debug
>= 2)
3675 fprintf_unfiltered (gdb_stdlog
, "gdbarch_save_dummy_frame_tos called\n");
3676 gdbarch
->save_dummy_frame_tos (sp
);
3680 set_gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
,
3681 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos
)
3683 gdbarch
->save_dummy_frame_tos
= save_dummy_frame_tos
;
3686 const struct floatformat
*
3687 gdbarch_float_format (struct gdbarch
*gdbarch
)
3689 if (gdbarch_debug
>= 2)
3690 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
3691 return gdbarch
->float_format
;
3695 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
3696 const struct floatformat
* float_format
)
3698 gdbarch
->float_format
= float_format
;
3701 const struct floatformat
*
3702 gdbarch_double_format (struct gdbarch
*gdbarch
)
3704 if (gdbarch_debug
>= 2)
3705 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
3706 return gdbarch
->double_format
;
3710 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
3711 const struct floatformat
* double_format
)
3713 gdbarch
->double_format
= double_format
;
3716 const struct floatformat
*
3717 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
3719 if (gdbarch_debug
>= 2)
3720 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
3721 return gdbarch
->long_double_format
;
3725 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
3726 const struct floatformat
* long_double_format
)
3728 gdbarch
->long_double_format
= long_double_format
;
3732 /* Keep a registrary of per-architecture data-pointers required by GDB
3740 struct gdbarch_data_registration
3742 gdbarch_data_ftype
*init
;
3743 struct gdbarch_data
*data
;
3744 struct gdbarch_data_registration
*next
;
3747 struct gdbarch_data_registrary
3750 struct gdbarch_data_registration
*registrations
;
3753 struct gdbarch_data_registrary gdbarch_data_registrary
=
3758 struct gdbarch_data
*
3759 register_gdbarch_data (gdbarch_data_ftype
*init
)
3761 struct gdbarch_data_registration
**curr
;
3762 for (curr
= &gdbarch_data_registrary
.registrations
;
3764 curr
= &(*curr
)->next
);
3765 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3766 (*curr
)->next
= NULL
;
3767 (*curr
)->init
= init
;
3768 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3769 (*curr
)->data
->index
= gdbarch_data_registrary
.nr
++;
3770 return (*curr
)->data
;
3774 /* Walk through all the registered users initializing each in turn. */
3777 init_gdbarch_data (struct gdbarch
*gdbarch
)
3779 struct gdbarch_data_registration
*rego
;
3780 gdbarch
->nr_data
= gdbarch_data_registrary
.nr
+ 1;
3781 gdbarch
->data
= xmalloc (sizeof (void*) * gdbarch
->nr_data
);
3782 for (rego
= gdbarch_data_registrary
.registrations
;
3786 if (rego
->data
->index
< gdbarch
->nr_data
)
3787 gdbarch
->data
[rego
->data
->index
] = rego
->init ();
3792 /* Return the current value of the specified per-architecture
3796 gdbarch_data (struct gdbarch_data
*data
)
3798 if (data
->index
>= current_gdbarch
->nr_data
)
3799 internal_error ("gdbarch_data: request for non-existant data.");
3800 return current_gdbarch
->data
[data
->index
];
3805 /* Keep a registrary of swaped data required by GDB modules. */
3810 struct gdbarch_swap_registration
*source
;
3811 struct gdbarch_swap
*next
;
3814 struct gdbarch_swap_registration
3817 unsigned long sizeof_data
;
3818 gdbarch_swap_ftype
*init
;
3819 struct gdbarch_swap_registration
*next
;
3822 struct gdbarch_swap_registrary
3825 struct gdbarch_swap_registration
*registrations
;
3828 struct gdbarch_swap_registrary gdbarch_swap_registrary
=
3834 register_gdbarch_swap (void *data
,
3835 unsigned long sizeof_data
,
3836 gdbarch_swap_ftype
*init
)
3838 struct gdbarch_swap_registration
**rego
;
3839 for (rego
= &gdbarch_swap_registrary
.registrations
;
3841 rego
= &(*rego
)->next
);
3842 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3843 (*rego
)->next
= NULL
;
3844 (*rego
)->init
= init
;
3845 (*rego
)->data
= data
;
3846 (*rego
)->sizeof_data
= sizeof_data
;
3851 init_gdbarch_swap (struct gdbarch
*gdbarch
)
3853 struct gdbarch_swap_registration
*rego
;
3854 struct gdbarch_swap
**curr
= &gdbarch
->swap
;
3855 for (rego
= gdbarch_swap_registrary
.registrations
;
3859 if (rego
->data
!= NULL
)
3861 (*curr
) = XMALLOC (struct gdbarch_swap
);
3862 (*curr
)->source
= rego
;
3863 (*curr
)->swap
= xmalloc (rego
->sizeof_data
);
3864 (*curr
)->next
= NULL
;
3865 memset (rego
->data
, 0, rego
->sizeof_data
);
3866 curr
= &(*curr
)->next
;
3868 if (rego
->init
!= NULL
)
3874 swapout_gdbarch_swap (struct gdbarch
*gdbarch
)
3876 struct gdbarch_swap
*curr
;
3877 for (curr
= gdbarch
->swap
;
3880 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3884 swapin_gdbarch_swap (struct gdbarch
*gdbarch
)
3886 struct gdbarch_swap
*curr
;
3887 for (curr
= gdbarch
->swap
;
3890 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3894 /* Keep a registrary of the architectures known by GDB. */
3896 struct gdbarch_registration
3898 enum bfd_architecture bfd_architecture
;
3899 gdbarch_init_ftype
*init
;
3900 gdbarch_dump_tdep_ftype
*dump_tdep
;
3901 struct gdbarch_list
*arches
;
3902 struct gdbarch_registration
*next
;
3905 static struct gdbarch_registration
*gdbarch_registrary
= NULL
;
3908 append_name (const char ***buf
, int *nr
, const char *name
)
3910 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3916 gdbarch_printable_names (void)
3920 /* Accumulate a list of names based on the registed list of
3922 enum bfd_architecture a
;
3924 const char **arches
= NULL
;
3925 struct gdbarch_registration
*rego
;
3926 for (rego
= gdbarch_registrary
;
3930 const struct bfd_arch_info
*ap
;
3931 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3933 internal_error ("gdbarch_architecture_names: multi-arch unknown");
3936 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3941 append_name (&arches
, &nr_arches
, NULL
);
3945 /* Just return all the architectures that BFD knows. Assume that
3946 the legacy architecture framework supports them. */
3947 return bfd_arch_list ();
3952 gdbarch_register (enum bfd_architecture bfd_architecture
,
3953 gdbarch_init_ftype
*init
,
3954 gdbarch_dump_tdep_ftype
*dump_tdep
)
3956 struct gdbarch_registration
**curr
;
3957 const struct bfd_arch_info
*bfd_arch_info
;
3958 /* Check that BFD reconizes this architecture */
3959 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
3960 if (bfd_arch_info
== NULL
)
3962 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture
);
3964 /* Check that we haven't seen this architecture before */
3965 for (curr
= &gdbarch_registrary
;
3967 curr
= &(*curr
)->next
)
3969 if (bfd_architecture
== (*curr
)->bfd_architecture
)
3970 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
3971 bfd_arch_info
->printable_name
);
3975 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
3976 bfd_arch_info
->printable_name
,
3979 (*curr
) = XMALLOC (struct gdbarch_registration
);
3980 (*curr
)->bfd_architecture
= bfd_architecture
;
3981 (*curr
)->init
= init
;
3982 (*curr
)->dump_tdep
= dump_tdep
;
3983 (*curr
)->arches
= NULL
;
3984 (*curr
)->next
= NULL
;
3985 /* When non- multi-arch, install what ever target dump routine we've
3986 been provided - hopefully that routine has been writen correct
3987 and works regardless of multi-arch. */
3988 if (!GDB_MULTI_ARCH
&& dump_tdep
!= NULL
3989 && startup_gdbarch
.dump_tdep
== NULL
)
3990 startup_gdbarch
.dump_tdep
= dump_tdep
;
3994 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
3995 gdbarch_init_ftype
*init
)
3997 gdbarch_register (bfd_architecture
, init
, NULL
);
4001 /* Look for an architecture using gdbarch_info. Base search on only
4002 BFD_ARCH_INFO and BYTE_ORDER. */
4004 struct gdbarch_list
*
4005 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
4006 const struct gdbarch_info
*info
)
4008 for (; arches
!= NULL
; arches
= arches
->next
)
4010 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
4012 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
4020 /* Update the current architecture. Return ZERO if the update request
4024 gdbarch_update (struct gdbarch_info info
)
4026 struct gdbarch
*new_gdbarch
;
4027 struct gdbarch_list
**list
;
4028 struct gdbarch_registration
*rego
;
4030 /* Fill in any missing bits. Most important is the bfd_architecture
4031 which is used to select the target architecture. */
4032 if (info
.bfd_architecture
== bfd_arch_unknown
)
4034 if (info
.bfd_arch_info
!= NULL
)
4035 info
.bfd_architecture
= info
.bfd_arch_info
->arch
;
4036 else if (info
.abfd
!= NULL
)
4037 info
.bfd_architecture
= bfd_get_arch (info
.abfd
);
4038 /* FIXME - should query BFD for its default architecture. */
4040 info
.bfd_architecture
= current_gdbarch
->bfd_arch_info
->arch
;
4042 if (info
.bfd_arch_info
== NULL
)
4044 if (target_architecture_auto
&& info
.abfd
!= NULL
)
4045 info
.bfd_arch_info
= bfd_get_arch_info (info
.abfd
);
4047 info
.bfd_arch_info
= current_gdbarch
->bfd_arch_info
;
4049 if (info
.byte_order
== 0)
4051 if (target_byte_order_auto
&& info
.abfd
!= NULL
)
4052 info
.byte_order
= (bfd_big_endian (info
.abfd
) ? BIG_ENDIAN
4053 : bfd_little_endian (info
.abfd
) ? LITTLE_ENDIAN
4056 info
.byte_order
= current_gdbarch
->byte_order
;
4057 /* FIXME - should query BFD for its default byte-order. */
4059 /* A default for abfd? */
4061 /* Find the target that knows about this architecture. */
4062 for (rego
= gdbarch_registrary
;
4065 if (rego
->bfd_architecture
== info
.bfd_architecture
)
4070 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: No matching architecture\n");
4076 fprintf_unfiltered (gdb_stdlog
,
4077 "gdbarch_update: info.bfd_architecture %d (%s)\n",
4078 info
.bfd_architecture
,
4079 bfd_lookup_arch (info
.bfd_architecture
, 0)->printable_name
);
4080 fprintf_unfiltered (gdb_stdlog
,
4081 "gdbarch_update: info.bfd_arch_info %s\n",
4082 (info
.bfd_arch_info
!= NULL
4083 ? info
.bfd_arch_info
->printable_name
4085 fprintf_unfiltered (gdb_stdlog
,
4086 "gdbarch_update: info.byte_order %d (%s)\n",
4088 (info
.byte_order
== BIG_ENDIAN
? "big"
4089 : info
.byte_order
== LITTLE_ENDIAN
? "little"
4091 fprintf_unfiltered (gdb_stdlog
,
4092 "gdbarch_update: info.abfd 0x%lx\n",
4094 fprintf_unfiltered (gdb_stdlog
,
4095 "gdbarch_update: info.tdep_info 0x%lx\n",
4096 (long) info
.tdep_info
);
4099 /* Ask the target for a replacement architecture. */
4100 new_gdbarch
= rego
->init (info
, rego
->arches
);
4102 /* Did the target like it? No. Reject the change. */
4103 if (new_gdbarch
== NULL
)
4106 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Target rejected architecture\n");
4110 /* Did the architecture change? No. Do nothing. */
4111 if (current_gdbarch
== new_gdbarch
)
4114 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
4116 new_gdbarch
->bfd_arch_info
->printable_name
);
4120 /* Swap all data belonging to the old target out */
4121 swapout_gdbarch_swap (current_gdbarch
);
4123 /* Is this a pre-existing architecture? Yes. Swap it in. */
4124 for (list
= ®o
->arches
;
4126 list
= &(*list
)->next
)
4128 if ((*list
)->gdbarch
== new_gdbarch
)
4131 fprintf_unfiltered (gdb_stdlog
,
4132 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
4134 new_gdbarch
->bfd_arch_info
->printable_name
);
4135 current_gdbarch
= new_gdbarch
;
4136 swapin_gdbarch_swap (new_gdbarch
);
4141 /* Append this new architecture to this targets list. */
4142 (*list
) = XMALLOC (struct gdbarch_list
);
4143 (*list
)->next
= NULL
;
4144 (*list
)->gdbarch
= new_gdbarch
;
4146 /* Switch to this new architecture. Dump it out. */
4147 current_gdbarch
= new_gdbarch
;
4150 fprintf_unfiltered (gdb_stdlog
,
4151 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
4153 new_gdbarch
->bfd_arch_info
->printable_name
);
4156 /* Check that the newly installed architecture is valid. Plug in
4157 any post init values. */
4158 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
4159 verify_gdbarch (new_gdbarch
);
4161 /* Initialize the per-architecture memory (swap) areas.
4162 CURRENT_GDBARCH must be update before these modules are
4164 init_gdbarch_swap (new_gdbarch
);
4166 /* Initialize the per-architecture data-pointer of all parties that
4167 registered an interest in this architecture. CURRENT_GDBARCH
4168 must be updated before these modules are called. */
4169 init_gdbarch_data (new_gdbarch
);
4172 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
4180 /* Pointer to the target-dependent disassembly function. */
4181 int (*tm_print_insn
) (bfd_vma
, disassemble_info
*);
4182 disassemble_info tm_print_insn_info
;
4185 extern void _initialize_gdbarch (void);
4188 _initialize_gdbarch (void)
4190 struct cmd_list_element
*c
;
4192 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
4193 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
4194 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
4195 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
4196 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;
4198 add_show_from_set (add_set_cmd ("arch",
4201 (char *)&gdbarch_debug
,
4202 "Set architecture debugging.\n\
4203 When non-zero, architecture debugging is enabled.", &setdebuglist
),
4205 c
= add_set_cmd ("archdebug",
4208 (char *)&gdbarch_debug
,
4209 "Set architecture debugging.\n\
4210 When non-zero, architecture debugging is enabled.", &setlist
);
4212 deprecate_cmd (c
, "set debug arch");
4213 deprecate_cmd (add_show_from_set (c
, &showlist
), "show debug arch");