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 Bourne shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when making sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
37 #include "arch-utils.h"
41 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
43 /* Just include everything in sight so that the every old definition
44 of macro is visible. */
45 #include "gdb_string.h"
50 #include "breakpoint.h"
55 #include "gdbthread.h"
57 #include "symfile.h" /* for overlay functions */
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 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).
142 gdbarch_read_pc_ftype
*read_pc
;
143 gdbarch_write_pc_ftype
*write_pc
;
144 gdbarch_read_fp_ftype
*read_fp
;
145 gdbarch_write_fp_ftype
*write_fp
;
146 gdbarch_read_sp_ftype
*read_sp
;
147 gdbarch_write_sp_ftype
*write_sp
;
156 gdbarch_register_name_ftype
*register_name
;
159 gdbarch_register_byte_ftype
*register_byte
;
160 gdbarch_register_raw_size_ftype
*register_raw_size
;
161 int max_register_raw_size
;
162 gdbarch_register_virtual_size_ftype
*register_virtual_size
;
163 int max_register_virtual_size
;
164 gdbarch_register_virtual_type_ftype
*register_virtual_type
;
165 gdbarch_do_registers_info_ftype
*do_registers_info
;
166 gdbarch_register_sim_regno_ftype
*register_sim_regno
;
167 int use_generic_dummy_frames
;
168 int call_dummy_location
;
169 gdbarch_call_dummy_address_ftype
*call_dummy_address
;
170 CORE_ADDR call_dummy_start_offset
;
171 CORE_ADDR call_dummy_breakpoint_offset
;
172 int call_dummy_breakpoint_offset_p
;
173 int call_dummy_length
;
174 gdbarch_pc_in_call_dummy_ftype
*pc_in_call_dummy
;
176 LONGEST
* call_dummy_words
;
177 int sizeof_call_dummy_words
;
178 int call_dummy_stack_adjust_p
;
179 int call_dummy_stack_adjust
;
180 gdbarch_fix_call_dummy_ftype
*fix_call_dummy
;
181 int believe_pcc_promotion
;
182 int believe_pcc_promotion_type
;
183 gdbarch_coerce_float_to_double_ftype
*coerce_float_to_double
;
184 gdbarch_get_saved_register_ftype
*get_saved_register
;
185 gdbarch_register_convertible_ftype
*register_convertible
;
186 gdbarch_register_convert_to_virtual_ftype
*register_convert_to_virtual
;
187 gdbarch_register_convert_to_raw_ftype
*register_convert_to_raw
;
188 gdbarch_fetch_pseudo_register_ftype
*fetch_pseudo_register
;
189 gdbarch_store_pseudo_register_ftype
*store_pseudo_register
;
190 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
191 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
192 gdbarch_return_value_on_stack_ftype
*return_value_on_stack
;
193 gdbarch_extract_return_value_ftype
*extract_return_value
;
194 gdbarch_push_arguments_ftype
*push_arguments
;
195 gdbarch_push_dummy_frame_ftype
*push_dummy_frame
;
196 gdbarch_push_return_address_ftype
*push_return_address
;
197 gdbarch_pop_frame_ftype
*pop_frame
;
198 gdbarch_d10v_make_daddr_ftype
*d10v_make_daddr
;
199 gdbarch_d10v_make_iaddr_ftype
*d10v_make_iaddr
;
200 gdbarch_d10v_daddr_p_ftype
*d10v_daddr_p
;
201 gdbarch_d10v_iaddr_p_ftype
*d10v_iaddr_p
;
202 gdbarch_d10v_convert_daddr_to_raw_ftype
*d10v_convert_daddr_to_raw
;
203 gdbarch_d10v_convert_iaddr_to_raw_ftype
*d10v_convert_iaddr_to_raw
;
204 gdbarch_store_struct_return_ftype
*store_struct_return
;
205 gdbarch_store_return_value_ftype
*store_return_value
;
206 gdbarch_extract_struct_value_address_ftype
*extract_struct_value_address
;
207 gdbarch_use_struct_convention_ftype
*use_struct_convention
;
208 gdbarch_frame_init_saved_regs_ftype
*frame_init_saved_regs
;
209 gdbarch_init_extra_frame_info_ftype
*init_extra_frame_info
;
210 gdbarch_skip_prologue_ftype
*skip_prologue
;
211 gdbarch_prologue_frameless_p_ftype
*prologue_frameless_p
;
212 gdbarch_inner_than_ftype
*inner_than
;
213 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
214 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
215 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
216 CORE_ADDR decr_pc_after_break
;
217 CORE_ADDR function_start_offset
;
218 gdbarch_remote_translate_xfer_address_ftype
*remote_translate_xfer_address
;
219 CORE_ADDR frame_args_skip
;
220 gdbarch_frameless_function_invocation_ftype
*frameless_function_invocation
;
221 gdbarch_frame_chain_ftype
*frame_chain
;
222 gdbarch_frame_chain_valid_ftype
*frame_chain_valid
;
223 gdbarch_frame_saved_pc_ftype
*frame_saved_pc
;
224 gdbarch_frame_args_address_ftype
*frame_args_address
;
225 gdbarch_frame_locals_address_ftype
*frame_locals_address
;
226 gdbarch_saved_pc_after_call_ftype
*saved_pc_after_call
;
227 gdbarch_frame_num_args_ftype
*frame_num_args
;
228 gdbarch_stack_align_ftype
*stack_align
;
229 int extra_stack_alignment_needed
;
230 gdbarch_reg_struct_has_addr_ftype
*reg_struct_has_addr
;
231 gdbarch_save_dummy_frame_tos_ftype
*save_dummy_frame_tos
;
232 const struct floatformat
* float_format
;
233 const struct floatformat
* double_format
;
234 const struct floatformat
* long_double_format
;
235 gdbarch_convert_from_func_ptr_addr_ftype
*convert_from_func_ptr_addr
;
239 /* The default architecture uses host values (for want of a better
242 extern const struct bfd_arch_info bfd_default_arch_struct
;
244 struct gdbarch startup_gdbarch
=
246 /* basic architecture information */
247 &bfd_default_arch_struct
,
249 /* target specific vector and its dump routine */
251 /*per-architecture data-pointers and swap regions */
253 /* Multi-arch values */
257 8 * sizeof (LONGEST
),
260 8 * sizeof (long double),
307 generic_get_saved_register
,
359 /* startup_gdbarch() */
362 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
365 /* Create a new ``struct gdbarch'' based on information provided by
366 ``struct gdbarch_info''. */
369 gdbarch_alloc (const struct gdbarch_info
*info
,
370 struct gdbarch_tdep
*tdep
)
372 struct gdbarch
*gdbarch
= XMALLOC (struct gdbarch
);
373 memset (gdbarch
, 0, sizeof (*gdbarch
));
375 gdbarch
->tdep
= tdep
;
377 gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
378 gdbarch
->byte_order
= info
->byte_order
;
380 /* Force the explicit initialization of these. */
381 gdbarch
->short_bit
= 2*TARGET_CHAR_BIT
;
382 gdbarch
->int_bit
= 4*TARGET_CHAR_BIT
;
383 gdbarch
->long_bit
= 4*TARGET_CHAR_BIT
;
384 gdbarch
->long_long_bit
= 2*TARGET_LONG_BIT
;
385 gdbarch
->float_bit
= 4*TARGET_CHAR_BIT
;
386 gdbarch
->double_bit
= 8*TARGET_CHAR_BIT
;
387 gdbarch
->long_double_bit
= 2*TARGET_DOUBLE_BIT
;
388 gdbarch
->ptr_bit
= TARGET_INT_BIT
;
389 gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
390 gdbarch
->read_pc
= generic_target_read_pc
;
391 gdbarch
->write_pc
= generic_target_write_pc
;
392 gdbarch
->read_fp
= generic_target_read_fp
;
393 gdbarch
->write_fp
= generic_target_write_fp
;
394 gdbarch
->read_sp
= generic_target_read_sp
;
395 gdbarch
->write_sp
= generic_target_write_sp
;
396 gdbarch
->num_regs
= -1;
397 gdbarch
->sp_regnum
= -1;
398 gdbarch
->fp_regnum
= -1;
399 gdbarch
->pc_regnum
= -1;
400 gdbarch
->fp0_regnum
= -1;
401 gdbarch
->npc_regnum
= -1;
402 gdbarch
->nnpc_regnum
= -1;
403 gdbarch
->register_name
= legacy_register_name
;
404 gdbarch
->register_size
= -1;
405 gdbarch
->register_bytes
= -1;
406 gdbarch
->max_register_raw_size
= -1;
407 gdbarch
->max_register_virtual_size
= -1;
408 gdbarch
->do_registers_info
= do_registers_info
;
409 gdbarch
->register_sim_regno
= default_register_sim_regno
;
410 gdbarch
->use_generic_dummy_frames
= -1;
411 gdbarch
->call_dummy_start_offset
= -1;
412 gdbarch
->call_dummy_breakpoint_offset
= -1;
413 gdbarch
->call_dummy_breakpoint_offset_p
= -1;
414 gdbarch
->call_dummy_length
= -1;
415 gdbarch
->call_dummy_p
= -1;
416 gdbarch
->call_dummy_words
= legacy_call_dummy_words
;
417 gdbarch
->sizeof_call_dummy_words
= legacy_sizeof_call_dummy_words
;
418 gdbarch
->call_dummy_stack_adjust_p
= -1;
419 gdbarch
->coerce_float_to_double
= default_coerce_float_to_double
;
420 gdbarch
->register_convertible
= generic_register_convertible_not
;
421 gdbarch
->pointer_to_address
= unsigned_pointer_to_address
;
422 gdbarch
->address_to_pointer
= unsigned_address_to_pointer
;
423 gdbarch
->return_value_on_stack
= generic_return_value_on_stack_not
;
424 gdbarch
->prologue_frameless_p
= generic_prologue_frameless_p
;
425 gdbarch
->breakpoint_from_pc
= legacy_breakpoint_from_pc
;
426 gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
427 gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
428 gdbarch
->decr_pc_after_break
= -1;
429 gdbarch
->function_start_offset
= -1;
430 gdbarch
->remote_translate_xfer_address
= generic_remote_translate_xfer_address
;
431 gdbarch
->frame_args_skip
= -1;
432 gdbarch
->frameless_function_invocation
= generic_frameless_function_invocation_not
;
433 gdbarch
->extra_stack_alignment_needed
= 1;
434 gdbarch
->convert_from_func_ptr_addr
= default_convert_from_func_ptr_addr
;
435 /* gdbarch_alloc() */
441 /* Free a gdbarch struct. This should never happen in normal
442 operation --- once you've created a gdbarch, you keep it around.
443 However, if an architecture's init function encounters an error
444 building the structure, it may need to clean up a partially
445 constructed gdbarch. */
448 gdbarch_free (struct gdbarch
*arch
)
450 /* At the moment, this is trivial. */
455 /* Ensure that all values in a GDBARCH are reasonable. */
458 verify_gdbarch (struct gdbarch
*gdbarch
)
460 /* Only perform sanity checks on a multi-arch target. */
464 if (gdbarch
->byte_order
== 0)
465 internal_error ("verify_gdbarch: byte-order unset");
466 if (gdbarch
->bfd_arch_info
== NULL
)
467 internal_error ("verify_gdbarch: bfd_arch_info unset");
468 /* Check those that need to be defined for the given multi-arch level. */
469 /* Skip verify of short_bit, invalid_p == 0 */
470 /* Skip verify of int_bit, invalid_p == 0 */
471 /* Skip verify of long_bit, invalid_p == 0 */
472 /* Skip verify of long_long_bit, invalid_p == 0 */
473 /* Skip verify of float_bit, invalid_p == 0 */
474 /* Skip verify of double_bit, invalid_p == 0 */
475 /* Skip verify of long_double_bit, invalid_p == 0 */
476 /* Skip verify of ptr_bit, invalid_p == 0 */
477 if (gdbarch
->addr_bit
== 0)
478 gdbarch
->addr_bit
= TARGET_PTR_BIT
;
479 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
480 /* Skip verify of ieee_float, invalid_p == 0 */
481 /* Skip verify of read_pc, invalid_p == 0 */
482 /* Skip verify of write_pc, invalid_p == 0 */
483 /* Skip verify of read_fp, invalid_p == 0 */
484 /* Skip verify of write_fp, invalid_p == 0 */
485 /* Skip verify of read_sp, invalid_p == 0 */
486 /* Skip verify of write_sp, invalid_p == 0 */
487 if ((GDB_MULTI_ARCH
>= 2)
488 && (gdbarch
->num_regs
== -1))
489 internal_error ("gdbarch: verify_gdbarch: num_regs invalid");
490 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
491 if ((GDB_MULTI_ARCH
>= 2)
492 && (gdbarch
->sp_regnum
== -1))
493 internal_error ("gdbarch: verify_gdbarch: sp_regnum invalid");
494 if ((GDB_MULTI_ARCH
>= 2)
495 && (gdbarch
->fp_regnum
== -1))
496 internal_error ("gdbarch: verify_gdbarch: fp_regnum invalid");
497 if ((GDB_MULTI_ARCH
>= 2)
498 && (gdbarch
->pc_regnum
== -1))
499 internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid");
500 /* Skip verify of fp0_regnum, invalid_p == 0 */
501 /* Skip verify of npc_regnum, invalid_p == 0 */
502 /* Skip verify of nnpc_regnum, invalid_p == 0 */
503 /* Skip verify of register_name, invalid_p == 0 */
504 if ((GDB_MULTI_ARCH
>= 2)
505 && (gdbarch
->register_size
== -1))
506 internal_error ("gdbarch: verify_gdbarch: register_size invalid");
507 if ((GDB_MULTI_ARCH
>= 2)
508 && (gdbarch
->register_bytes
== -1))
509 internal_error ("gdbarch: verify_gdbarch: register_bytes invalid");
510 if ((GDB_MULTI_ARCH
>= 2)
511 && (gdbarch
->register_byte
== 0))
512 internal_error ("gdbarch: verify_gdbarch: register_byte invalid");
513 if ((GDB_MULTI_ARCH
>= 2)
514 && (gdbarch
->register_raw_size
== 0))
515 internal_error ("gdbarch: verify_gdbarch: register_raw_size invalid");
516 if ((GDB_MULTI_ARCH
>= 2)
517 && (gdbarch
->max_register_raw_size
== -1))
518 internal_error ("gdbarch: verify_gdbarch: max_register_raw_size invalid");
519 if ((GDB_MULTI_ARCH
>= 2)
520 && (gdbarch
->register_virtual_size
== 0))
521 internal_error ("gdbarch: verify_gdbarch: register_virtual_size invalid");
522 if ((GDB_MULTI_ARCH
>= 2)
523 && (gdbarch
->max_register_virtual_size
== -1))
524 internal_error ("gdbarch: verify_gdbarch: max_register_virtual_size invalid");
525 if ((GDB_MULTI_ARCH
>= 2)
526 && (gdbarch
->register_virtual_type
== 0))
527 internal_error ("gdbarch: verify_gdbarch: register_virtual_type invalid");
528 /* Skip verify of do_registers_info, invalid_p == 0 */
529 /* Skip verify of register_sim_regno, invalid_p == 0 */
530 if ((GDB_MULTI_ARCH
>= 1)
531 && (gdbarch
->use_generic_dummy_frames
== -1))
532 internal_error ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid");
533 if ((GDB_MULTI_ARCH
>= 2)
534 && (gdbarch
->call_dummy_location
== 0))
535 internal_error ("gdbarch: verify_gdbarch: call_dummy_location invalid");
536 if ((GDB_MULTI_ARCH
>= 2)
537 && (gdbarch
->call_dummy_location
== AT_ENTRY_POINT
&& gdbarch
->call_dummy_address
== 0))
538 internal_error ("gdbarch: verify_gdbarch: call_dummy_address invalid");
539 if ((GDB_MULTI_ARCH
>= 2)
540 && (gdbarch
->call_dummy_start_offset
== -1))
541 internal_error ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid");
542 if ((GDB_MULTI_ARCH
>= 2)
543 && (gdbarch
->call_dummy_breakpoint_offset
== -1))
544 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid");
545 if ((GDB_MULTI_ARCH
>= 1)
546 && (gdbarch
->call_dummy_breakpoint_offset_p
== -1))
547 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid");
548 if ((GDB_MULTI_ARCH
>= 2)
549 && (gdbarch
->call_dummy_length
== -1))
550 internal_error ("gdbarch: verify_gdbarch: call_dummy_length invalid");
551 if ((GDB_MULTI_ARCH
>= 2)
552 && (gdbarch
->pc_in_call_dummy
== 0))
553 internal_error ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid");
554 if ((GDB_MULTI_ARCH
>= 1)
555 && (gdbarch
->call_dummy_p
== -1))
556 internal_error ("gdbarch: verify_gdbarch: call_dummy_p invalid");
557 /* Skip verify of call_dummy_words, invalid_p == 0 */
558 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
559 if ((GDB_MULTI_ARCH
>= 1)
560 && (gdbarch
->call_dummy_stack_adjust_p
== -1))
561 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid");
562 if ((GDB_MULTI_ARCH
>= 2)
563 && (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0))
564 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid");
565 if ((GDB_MULTI_ARCH
>= 2)
566 && (gdbarch
->fix_call_dummy
== 0))
567 internal_error ("gdbarch: verify_gdbarch: fix_call_dummy invalid");
568 /* Skip verify of coerce_float_to_double, invalid_p == 0 */
569 if ((GDB_MULTI_ARCH
>= 1)
570 && (gdbarch
->get_saved_register
== 0))
571 internal_error ("gdbarch: verify_gdbarch: get_saved_register invalid");
572 /* Skip verify of register_convertible, invalid_p == 0 */
573 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
574 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
575 /* Skip verify of fetch_pseudo_register, invalid_p == 0 */
576 /* Skip verify of store_pseudo_register, invalid_p == 0 */
577 /* Skip verify of pointer_to_address, invalid_p == 0 */
578 /* Skip verify of address_to_pointer, invalid_p == 0 */
579 /* Skip verify of return_value_on_stack, invalid_p == 0 */
580 if ((GDB_MULTI_ARCH
>= 2)
581 && (gdbarch
->extract_return_value
== 0))
582 internal_error ("gdbarch: verify_gdbarch: extract_return_value invalid");
583 if ((GDB_MULTI_ARCH
>= 1)
584 && (gdbarch
->push_arguments
== 0))
585 internal_error ("gdbarch: verify_gdbarch: push_arguments invalid");
586 if ((GDB_MULTI_ARCH
>= 2)
587 && (gdbarch
->push_dummy_frame
== 0))
588 internal_error ("gdbarch: verify_gdbarch: push_dummy_frame invalid");
589 if ((GDB_MULTI_ARCH
>= 1)
590 && (gdbarch
->push_return_address
== 0))
591 internal_error ("gdbarch: verify_gdbarch: push_return_address invalid");
592 if ((GDB_MULTI_ARCH
>= 2)
593 && (gdbarch
->pop_frame
== 0))
594 internal_error ("gdbarch: verify_gdbarch: pop_frame invalid");
595 /* Skip verify of d10v_make_daddr, invalid_p == 0 */
596 /* Skip verify of d10v_make_iaddr, invalid_p == 0 */
597 /* Skip verify of d10v_daddr_p, invalid_p == 0 */
598 /* Skip verify of d10v_iaddr_p, invalid_p == 0 */
599 /* Skip verify of d10v_convert_daddr_to_raw, invalid_p == 0 */
600 /* Skip verify of d10v_convert_iaddr_to_raw, invalid_p == 0 */
601 if ((GDB_MULTI_ARCH
>= 2)
602 && (gdbarch
->store_struct_return
== 0))
603 internal_error ("gdbarch: verify_gdbarch: store_struct_return invalid");
604 if ((GDB_MULTI_ARCH
>= 2)
605 && (gdbarch
->store_return_value
== 0))
606 internal_error ("gdbarch: verify_gdbarch: store_return_value invalid");
607 if ((GDB_MULTI_ARCH
>= 2)
608 && (gdbarch
->extract_struct_value_address
== 0))
609 internal_error ("gdbarch: verify_gdbarch: extract_struct_value_address invalid");
610 if ((GDB_MULTI_ARCH
>= 2)
611 && (gdbarch
->use_struct_convention
== 0))
612 internal_error ("gdbarch: verify_gdbarch: use_struct_convention invalid");
613 if ((GDB_MULTI_ARCH
>= 2)
614 && (gdbarch
->frame_init_saved_regs
== 0))
615 internal_error ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid");
616 if ((GDB_MULTI_ARCH
>= 2)
617 && (gdbarch
->init_extra_frame_info
== 0))
618 internal_error ("gdbarch: verify_gdbarch: init_extra_frame_info invalid");
619 if ((GDB_MULTI_ARCH
>= 2)
620 && (gdbarch
->skip_prologue
== 0))
621 internal_error ("gdbarch: verify_gdbarch: skip_prologue invalid");
622 /* Skip verify of prologue_frameless_p, invalid_p == 0 */
623 if ((GDB_MULTI_ARCH
>= 2)
624 && (gdbarch
->inner_than
== 0))
625 internal_error ("gdbarch: verify_gdbarch: inner_than invalid");
626 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
627 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
628 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
629 if ((GDB_MULTI_ARCH
>= 2)
630 && (gdbarch
->decr_pc_after_break
== -1))
631 internal_error ("gdbarch: verify_gdbarch: decr_pc_after_break invalid");
632 if ((GDB_MULTI_ARCH
>= 2)
633 && (gdbarch
->function_start_offset
== -1))
634 internal_error ("gdbarch: verify_gdbarch: function_start_offset invalid");
635 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
636 if ((GDB_MULTI_ARCH
>= 2)
637 && (gdbarch
->frame_args_skip
== -1))
638 internal_error ("gdbarch: verify_gdbarch: frame_args_skip invalid");
639 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
640 if ((GDB_MULTI_ARCH
>= 2)
641 && (gdbarch
->frame_chain
== 0))
642 internal_error ("gdbarch: verify_gdbarch: frame_chain invalid");
643 if ((GDB_MULTI_ARCH
>= 1)
644 && (gdbarch
->frame_chain_valid
== 0))
645 internal_error ("gdbarch: verify_gdbarch: frame_chain_valid invalid");
646 if ((GDB_MULTI_ARCH
>= 2)
647 && (gdbarch
->frame_saved_pc
== 0))
648 internal_error ("gdbarch: verify_gdbarch: frame_saved_pc invalid");
649 if ((GDB_MULTI_ARCH
>= 2)
650 && (gdbarch
->frame_args_address
== 0))
651 internal_error ("gdbarch: verify_gdbarch: frame_args_address invalid");
652 if ((GDB_MULTI_ARCH
>= 2)
653 && (gdbarch
->frame_locals_address
== 0))
654 internal_error ("gdbarch: verify_gdbarch: frame_locals_address invalid");
655 if ((GDB_MULTI_ARCH
>= 2)
656 && (gdbarch
->saved_pc_after_call
== 0))
657 internal_error ("gdbarch: verify_gdbarch: saved_pc_after_call invalid");
658 if ((GDB_MULTI_ARCH
>= 2)
659 && (gdbarch
->frame_num_args
== 0))
660 internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid");
661 /* Skip verify of stack_align, has predicate */
662 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
663 /* Skip verify of reg_struct_has_addr, has predicate */
664 /* Skip verify of save_dummy_frame_tos, has predicate */
665 if (gdbarch
->float_format
== 0)
666 gdbarch
->float_format
= default_float_format (gdbarch
);
667 if (gdbarch
->double_format
== 0)
668 gdbarch
->double_format
= default_double_format (gdbarch
);
669 if (gdbarch
->long_double_format
== 0)
670 gdbarch
->long_double_format
= &floatformat_unknown
;
671 /* Skip verify of convert_from_func_ptr_addr, invalid_p == 0 */
675 /* Print out the details of the current architecture. */
677 /* NOTE/WARNING: The parameter is called ``current_gdbarch'' so that it
678 just happens to match the global variable ``current_gdbarch''. That
679 way macros refering to that variable get the local and not the global
680 version - ulgh. Once everything is parameterised with gdbarch, this
684 gdbarch_dump (struct gdbarch
*gdbarch
, struct ui_file
*file
)
686 fprintf_unfiltered (file
,
687 "gdbarch_dump: GDB_MULTI_ARCH = %d\n",
689 #ifdef TARGET_ARCHITECTURE
690 fprintf_unfiltered (file
,
691 "gdbarch_dump: TARGET_ARCHITECTURE # %s\n",
692 XSTRING (TARGET_ARCHITECTURE
));
694 #ifdef TARGET_BYTE_ORDER
695 fprintf_unfiltered (file
,
696 "gdbarch_dump: TARGET_BYTE_ORDER # %s\n",
697 XSTRING (TARGET_BYTE_ORDER
));
699 #ifdef TARGET_SHORT_BIT
700 fprintf_unfiltered (file
,
701 "gdbarch_dump: TARGET_SHORT_BIT # %s\n",
702 XSTRING (TARGET_SHORT_BIT
));
704 #ifdef TARGET_INT_BIT
705 fprintf_unfiltered (file
,
706 "gdbarch_dump: TARGET_INT_BIT # %s\n",
707 XSTRING (TARGET_INT_BIT
));
709 #ifdef TARGET_LONG_BIT
710 fprintf_unfiltered (file
,
711 "gdbarch_dump: TARGET_LONG_BIT # %s\n",
712 XSTRING (TARGET_LONG_BIT
));
714 #ifdef TARGET_LONG_LONG_BIT
715 fprintf_unfiltered (file
,
716 "gdbarch_dump: TARGET_LONG_LONG_BIT # %s\n",
717 XSTRING (TARGET_LONG_LONG_BIT
));
719 #ifdef TARGET_FLOAT_BIT
720 fprintf_unfiltered (file
,
721 "gdbarch_dump: TARGET_FLOAT_BIT # %s\n",
722 XSTRING (TARGET_FLOAT_BIT
));
724 #ifdef TARGET_DOUBLE_BIT
725 fprintf_unfiltered (file
,
726 "gdbarch_dump: TARGET_DOUBLE_BIT # %s\n",
727 XSTRING (TARGET_DOUBLE_BIT
));
729 #ifdef TARGET_LONG_DOUBLE_BIT
730 fprintf_unfiltered (file
,
731 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT # %s\n",
732 XSTRING (TARGET_LONG_DOUBLE_BIT
));
734 #ifdef TARGET_PTR_BIT
735 fprintf_unfiltered (file
,
736 "gdbarch_dump: TARGET_PTR_BIT # %s\n",
737 XSTRING (TARGET_PTR_BIT
));
739 #ifdef TARGET_ADDR_BIT
740 fprintf_unfiltered (file
,
741 "gdbarch_dump: TARGET_ADDR_BIT # %s\n",
742 XSTRING (TARGET_ADDR_BIT
));
744 #ifdef TARGET_BFD_VMA_BIT
745 fprintf_unfiltered (file
,
746 "gdbarch_dump: TARGET_BFD_VMA_BIT # %s\n",
747 XSTRING (TARGET_BFD_VMA_BIT
));
750 fprintf_unfiltered (file
,
751 "gdbarch_dump: IEEE_FLOAT # %s\n",
752 XSTRING (IEEE_FLOAT
));
754 #ifdef TARGET_READ_PC
755 fprintf_unfiltered (file
,
756 "gdbarch_dump: %s # %s\n",
757 "TARGET_READ_PC(pid)",
758 XSTRING (TARGET_READ_PC (pid
)));
760 #if defined (TARGET_WRITE_PC) && GDB_MULTI_ARCH
761 /* Macro might contain `[{}]' when not multi-arch */
762 fprintf_unfiltered (file
,
763 "gdbarch_dump: %s # %s\n",
764 "TARGET_WRITE_PC(val, pid)",
765 XSTRING (TARGET_WRITE_PC (val
, pid
)));
767 #ifdef TARGET_READ_FP
768 fprintf_unfiltered (file
,
769 "gdbarch_dump: %s # %s\n",
771 XSTRING (TARGET_READ_FP ()));
773 #if defined (TARGET_WRITE_FP) && GDB_MULTI_ARCH
774 /* Macro might contain `[{}]' when not multi-arch */
775 fprintf_unfiltered (file
,
776 "gdbarch_dump: %s # %s\n",
777 "TARGET_WRITE_FP(val)",
778 XSTRING (TARGET_WRITE_FP (val
)));
780 #ifdef TARGET_READ_SP
781 fprintf_unfiltered (file
,
782 "gdbarch_dump: %s # %s\n",
784 XSTRING (TARGET_READ_SP ()));
786 #if defined (TARGET_WRITE_SP) && GDB_MULTI_ARCH
787 /* Macro might contain `[{}]' when not multi-arch */
788 fprintf_unfiltered (file
,
789 "gdbarch_dump: %s # %s\n",
790 "TARGET_WRITE_SP(val)",
791 XSTRING (TARGET_WRITE_SP (val
)));
794 fprintf_unfiltered (file
,
795 "gdbarch_dump: NUM_REGS # %s\n",
798 #ifdef NUM_PSEUDO_REGS
799 fprintf_unfiltered (file
,
800 "gdbarch_dump: NUM_PSEUDO_REGS # %s\n",
801 XSTRING (NUM_PSEUDO_REGS
));
804 fprintf_unfiltered (file
,
805 "gdbarch_dump: SP_REGNUM # %s\n",
806 XSTRING (SP_REGNUM
));
809 fprintf_unfiltered (file
,
810 "gdbarch_dump: FP_REGNUM # %s\n",
811 XSTRING (FP_REGNUM
));
814 fprintf_unfiltered (file
,
815 "gdbarch_dump: PC_REGNUM # %s\n",
816 XSTRING (PC_REGNUM
));
819 fprintf_unfiltered (file
,
820 "gdbarch_dump: FP0_REGNUM # %s\n",
821 XSTRING (FP0_REGNUM
));
824 fprintf_unfiltered (file
,
825 "gdbarch_dump: NPC_REGNUM # %s\n",
826 XSTRING (NPC_REGNUM
));
829 fprintf_unfiltered (file
,
830 "gdbarch_dump: NNPC_REGNUM # %s\n",
831 XSTRING (NNPC_REGNUM
));
834 fprintf_unfiltered (file
,
835 "gdbarch_dump: %s # %s\n",
836 "REGISTER_NAME(regnr)",
837 XSTRING (REGISTER_NAME (regnr
)));
840 fprintf_unfiltered (file
,
841 "gdbarch_dump: REGISTER_SIZE # %s\n",
842 XSTRING (REGISTER_SIZE
));
844 #ifdef REGISTER_BYTES
845 fprintf_unfiltered (file
,
846 "gdbarch_dump: REGISTER_BYTES # %s\n",
847 XSTRING (REGISTER_BYTES
));
850 fprintf_unfiltered (file
,
851 "gdbarch_dump: %s # %s\n",
852 "REGISTER_BYTE(reg_nr)",
853 XSTRING (REGISTER_BYTE (reg_nr
)));
855 #ifdef REGISTER_RAW_SIZE
856 fprintf_unfiltered (file
,
857 "gdbarch_dump: %s # %s\n",
858 "REGISTER_RAW_SIZE(reg_nr)",
859 XSTRING (REGISTER_RAW_SIZE (reg_nr
)));
861 #ifdef MAX_REGISTER_RAW_SIZE
862 fprintf_unfiltered (file
,
863 "gdbarch_dump: MAX_REGISTER_RAW_SIZE # %s\n",
864 XSTRING (MAX_REGISTER_RAW_SIZE
));
866 #ifdef REGISTER_VIRTUAL_SIZE
867 fprintf_unfiltered (file
,
868 "gdbarch_dump: %s # %s\n",
869 "REGISTER_VIRTUAL_SIZE(reg_nr)",
870 XSTRING (REGISTER_VIRTUAL_SIZE (reg_nr
)));
872 #ifdef MAX_REGISTER_VIRTUAL_SIZE
873 fprintf_unfiltered (file
,
874 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE # %s\n",
875 XSTRING (MAX_REGISTER_VIRTUAL_SIZE
));
877 #ifdef REGISTER_VIRTUAL_TYPE
878 fprintf_unfiltered (file
,
879 "gdbarch_dump: %s # %s\n",
880 "REGISTER_VIRTUAL_TYPE(reg_nr)",
881 XSTRING (REGISTER_VIRTUAL_TYPE (reg_nr
)));
883 #if defined (DO_REGISTERS_INFO) && GDB_MULTI_ARCH
884 /* Macro might contain `[{}]' when not multi-arch */
885 fprintf_unfiltered (file
,
886 "gdbarch_dump: %s # %s\n",
887 "DO_REGISTERS_INFO(reg_nr, fpregs)",
888 XSTRING (DO_REGISTERS_INFO (reg_nr
, fpregs
)));
890 #ifdef REGISTER_SIM_REGNO
891 fprintf_unfiltered (file
,
892 "gdbarch_dump: %s # %s\n",
893 "REGISTER_SIM_REGNO(reg_nr)",
894 XSTRING (REGISTER_SIM_REGNO (reg_nr
)));
896 #ifdef USE_GENERIC_DUMMY_FRAMES
897 fprintf_unfiltered (file
,
898 "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n",
899 XSTRING (USE_GENERIC_DUMMY_FRAMES
));
901 #ifdef CALL_DUMMY_LOCATION
902 fprintf_unfiltered (file
,
903 "gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
904 XSTRING (CALL_DUMMY_LOCATION
));
906 #ifdef CALL_DUMMY_ADDRESS
907 fprintf_unfiltered (file
,
908 "gdbarch_dump: %s # %s\n",
909 "CALL_DUMMY_ADDRESS()",
910 XSTRING (CALL_DUMMY_ADDRESS ()));
912 #ifdef CALL_DUMMY_START_OFFSET
913 fprintf_unfiltered (file
,
914 "gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
915 XSTRING (CALL_DUMMY_START_OFFSET
));
917 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
918 fprintf_unfiltered (file
,
919 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
920 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET
));
922 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
923 fprintf_unfiltered (file
,
924 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P # %s\n",
925 XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET_P
));
927 #ifdef CALL_DUMMY_LENGTH
928 fprintf_unfiltered (file
,
929 "gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
930 XSTRING (CALL_DUMMY_LENGTH
));
932 #ifdef PC_IN_CALL_DUMMY
933 fprintf_unfiltered (file
,
934 "gdbarch_dump: %s # %s\n",
935 "PC_IN_CALL_DUMMY(pc, sp, frame_address)",
936 XSTRING (PC_IN_CALL_DUMMY (pc
, sp
, frame_address
)));
939 fprintf_unfiltered (file
,
940 "gdbarch_dump: CALL_DUMMY_P # %s\n",
941 XSTRING (CALL_DUMMY_P
));
943 #ifdef CALL_DUMMY_WORDS
944 fprintf_unfiltered (file
,
945 "gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
946 XSTRING (CALL_DUMMY_WORDS
));
948 #ifdef SIZEOF_CALL_DUMMY_WORDS
949 fprintf_unfiltered (file
,
950 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
951 XSTRING (SIZEOF_CALL_DUMMY_WORDS
));
953 #ifdef CALL_DUMMY_STACK_ADJUST_P
954 fprintf_unfiltered (file
,
955 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P # %s\n",
956 XSTRING (CALL_DUMMY_STACK_ADJUST_P
));
958 #ifdef CALL_DUMMY_STACK_ADJUST
959 fprintf_unfiltered (file
,
960 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST # %s\n",
961 XSTRING (CALL_DUMMY_STACK_ADJUST
));
963 #if defined (FIX_CALL_DUMMY) && GDB_MULTI_ARCH
964 /* Macro might contain `[{}]' when not multi-arch */
965 fprintf_unfiltered (file
,
966 "gdbarch_dump: %s # %s\n",
967 "FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
968 XSTRING (FIX_CALL_DUMMY (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)));
970 #ifdef BELIEVE_PCC_PROMOTION
971 fprintf_unfiltered (file
,
972 "gdbarch_dump: BELIEVE_PCC_PROMOTION # %s\n",
973 XSTRING (BELIEVE_PCC_PROMOTION
));
975 #ifdef BELIEVE_PCC_PROMOTION_TYPE
976 fprintf_unfiltered (file
,
977 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE # %s\n",
978 XSTRING (BELIEVE_PCC_PROMOTION_TYPE
));
980 #ifdef COERCE_FLOAT_TO_DOUBLE
981 fprintf_unfiltered (file
,
982 "gdbarch_dump: %s # %s\n",
983 "COERCE_FLOAT_TO_DOUBLE(formal, actual)",
984 XSTRING (COERCE_FLOAT_TO_DOUBLE (formal
, actual
)));
986 #if defined (GET_SAVED_REGISTER) && GDB_MULTI_ARCH
987 /* Macro might contain `[{}]' when not multi-arch */
988 fprintf_unfiltered (file
,
989 "gdbarch_dump: %s # %s\n",
990 "GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval)",
991 XSTRING (GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)));
993 #ifdef REGISTER_CONVERTIBLE
994 fprintf_unfiltered (file
,
995 "gdbarch_dump: %s # %s\n",
996 "REGISTER_CONVERTIBLE(nr)",
997 XSTRING (REGISTER_CONVERTIBLE (nr
)));
999 #if defined (REGISTER_CONVERT_TO_VIRTUAL) && GDB_MULTI_ARCH
1000 /* Macro might contain `[{}]' when not multi-arch */
1001 fprintf_unfiltered (file
,
1002 "gdbarch_dump: %s # %s\n",
1003 "REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to)",
1004 XSTRING (REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
)));
1006 #if defined (REGISTER_CONVERT_TO_RAW) && GDB_MULTI_ARCH
1007 /* Macro might contain `[{}]' when not multi-arch */
1008 fprintf_unfiltered (file
,
1009 "gdbarch_dump: %s # %s\n",
1010 "REGISTER_CONVERT_TO_RAW(type, regnum, from, to)",
1011 XSTRING (REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
)));
1013 #if defined (FETCH_PSEUDO_REGISTER) && GDB_MULTI_ARCH
1014 /* Macro might contain `[{}]' when not multi-arch */
1015 fprintf_unfiltered (file
,
1016 "gdbarch_dump: %s # %s\n",
1017 "FETCH_PSEUDO_REGISTER(regnum)",
1018 XSTRING (FETCH_PSEUDO_REGISTER (regnum
)));
1020 #if defined (STORE_PSEUDO_REGISTER) && GDB_MULTI_ARCH
1021 /* Macro might contain `[{}]' when not multi-arch */
1022 fprintf_unfiltered (file
,
1023 "gdbarch_dump: %s # %s\n",
1024 "STORE_PSEUDO_REGISTER(regnum)",
1025 XSTRING (STORE_PSEUDO_REGISTER (regnum
)));
1027 #ifdef POINTER_TO_ADDRESS
1028 fprintf_unfiltered (file
,
1029 "gdbarch_dump: %s # %s\n",
1030 "POINTER_TO_ADDRESS(type, buf)",
1031 XSTRING (POINTER_TO_ADDRESS (type
, buf
)));
1033 #if defined (ADDRESS_TO_POINTER) && GDB_MULTI_ARCH
1034 /* Macro might contain `[{}]' when not multi-arch */
1035 fprintf_unfiltered (file
,
1036 "gdbarch_dump: %s # %s\n",
1037 "ADDRESS_TO_POINTER(type, buf, addr)",
1038 XSTRING (ADDRESS_TO_POINTER (type
, buf
, addr
)));
1040 #ifdef RETURN_VALUE_ON_STACK
1041 fprintf_unfiltered (file
,
1042 "gdbarch_dump: %s # %s\n",
1043 "RETURN_VALUE_ON_STACK(type)",
1044 XSTRING (RETURN_VALUE_ON_STACK (type
)));
1046 #if defined (EXTRACT_RETURN_VALUE) && GDB_MULTI_ARCH
1047 /* Macro might contain `[{}]' when not multi-arch */
1048 fprintf_unfiltered (file
,
1049 "gdbarch_dump: %s # %s\n",
1050 "EXTRACT_RETURN_VALUE(type, regbuf, valbuf)",
1051 XSTRING (EXTRACT_RETURN_VALUE (type
, regbuf
, valbuf
)));
1053 #ifdef PUSH_ARGUMENTS
1054 fprintf_unfiltered (file
,
1055 "gdbarch_dump: %s # %s\n",
1056 "PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr)",
1057 XSTRING (PUSH_ARGUMENTS (nargs
, args
, sp
, struct_return
, struct_addr
)));
1059 #if defined (PUSH_DUMMY_FRAME) && GDB_MULTI_ARCH
1060 /* Macro might contain `[{}]' when not multi-arch */
1061 fprintf_unfiltered (file
,
1062 "gdbarch_dump: %s # %s\n",
1063 "PUSH_DUMMY_FRAME(-)",
1064 XSTRING (PUSH_DUMMY_FRAME (-)));
1066 #ifdef PUSH_RETURN_ADDRESS
1067 fprintf_unfiltered (file
,
1068 "gdbarch_dump: %s # %s\n",
1069 "PUSH_RETURN_ADDRESS(pc, sp)",
1070 XSTRING (PUSH_RETURN_ADDRESS (pc
, sp
)));
1072 #if defined (POP_FRAME) && GDB_MULTI_ARCH
1073 /* Macro might contain `[{}]' when not multi-arch */
1074 fprintf_unfiltered (file
,
1075 "gdbarch_dump: %s # %s\n",
1077 XSTRING (POP_FRAME (-)));
1079 #ifdef D10V_MAKE_DADDR
1080 fprintf_unfiltered (file
,
1081 "gdbarch_dump: %s # %s\n",
1082 "D10V_MAKE_DADDR(x)",
1083 XSTRING (D10V_MAKE_DADDR (x
)));
1085 #ifdef D10V_MAKE_IADDR
1086 fprintf_unfiltered (file
,
1087 "gdbarch_dump: %s # %s\n",
1088 "D10V_MAKE_IADDR(x)",
1089 XSTRING (D10V_MAKE_IADDR (x
)));
1092 fprintf_unfiltered (file
,
1093 "gdbarch_dump: %s # %s\n",
1095 XSTRING (D10V_DADDR_P (x
)));
1098 fprintf_unfiltered (file
,
1099 "gdbarch_dump: %s # %s\n",
1101 XSTRING (D10V_IADDR_P (x
)));
1103 #ifdef D10V_CONVERT_DADDR_TO_RAW
1104 fprintf_unfiltered (file
,
1105 "gdbarch_dump: %s # %s\n",
1106 "D10V_CONVERT_DADDR_TO_RAW(x)",
1107 XSTRING (D10V_CONVERT_DADDR_TO_RAW (x
)));
1109 #ifdef D10V_CONVERT_IADDR_TO_RAW
1110 fprintf_unfiltered (file
,
1111 "gdbarch_dump: %s # %s\n",
1112 "D10V_CONVERT_IADDR_TO_RAW(x)",
1113 XSTRING (D10V_CONVERT_IADDR_TO_RAW (x
)));
1115 #if defined (STORE_STRUCT_RETURN) && GDB_MULTI_ARCH
1116 /* Macro might contain `[{}]' when not multi-arch */
1117 fprintf_unfiltered (file
,
1118 "gdbarch_dump: %s # %s\n",
1119 "STORE_STRUCT_RETURN(addr, sp)",
1120 XSTRING (STORE_STRUCT_RETURN (addr
, sp
)));
1122 #if defined (STORE_RETURN_VALUE) && GDB_MULTI_ARCH
1123 /* Macro might contain `[{}]' when not multi-arch */
1124 fprintf_unfiltered (file
,
1125 "gdbarch_dump: %s # %s\n",
1126 "STORE_RETURN_VALUE(type, valbuf)",
1127 XSTRING (STORE_RETURN_VALUE (type
, valbuf
)));
1129 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1130 fprintf_unfiltered (file
,
1131 "gdbarch_dump: %s # %s\n",
1132 "EXTRACT_STRUCT_VALUE_ADDRESS(regbuf)",
1133 XSTRING (EXTRACT_STRUCT_VALUE_ADDRESS (regbuf
)));
1135 #ifdef USE_STRUCT_CONVENTION
1136 fprintf_unfiltered (file
,
1137 "gdbarch_dump: %s # %s\n",
1138 "USE_STRUCT_CONVENTION(gcc_p, value_type)",
1139 XSTRING (USE_STRUCT_CONVENTION (gcc_p
, value_type
)));
1141 #if defined (FRAME_INIT_SAVED_REGS) && GDB_MULTI_ARCH
1142 /* Macro might contain `[{}]' when not multi-arch */
1143 fprintf_unfiltered (file
,
1144 "gdbarch_dump: %s # %s\n",
1145 "FRAME_INIT_SAVED_REGS(frame)",
1146 XSTRING (FRAME_INIT_SAVED_REGS (frame
)));
1148 #if defined (INIT_EXTRA_FRAME_INFO) && GDB_MULTI_ARCH
1149 /* Macro might contain `[{}]' when not multi-arch */
1150 fprintf_unfiltered (file
,
1151 "gdbarch_dump: %s # %s\n",
1152 "INIT_EXTRA_FRAME_INFO(fromleaf, frame)",
1153 XSTRING (INIT_EXTRA_FRAME_INFO (fromleaf
, frame
)));
1155 #ifdef SKIP_PROLOGUE
1156 fprintf_unfiltered (file
,
1157 "gdbarch_dump: %s # %s\n",
1158 "SKIP_PROLOGUE(ip)",
1159 XSTRING (SKIP_PROLOGUE (ip
)));
1161 #ifdef PROLOGUE_FRAMELESS_P
1162 fprintf_unfiltered (file
,
1163 "gdbarch_dump: %s # %s\n",
1164 "PROLOGUE_FRAMELESS_P(ip)",
1165 XSTRING (PROLOGUE_FRAMELESS_P (ip
)));
1168 fprintf_unfiltered (file
,
1169 "gdbarch_dump: %s # %s\n",
1170 "INNER_THAN(lhs, rhs)",
1171 XSTRING (INNER_THAN (lhs
, rhs
)));
1173 #ifdef BREAKPOINT_FROM_PC
1174 fprintf_unfiltered (file
,
1175 "gdbarch_dump: %s # %s\n",
1176 "BREAKPOINT_FROM_PC(pcptr, lenptr)",
1177 XSTRING (BREAKPOINT_FROM_PC (pcptr
, lenptr
)));
1179 #ifdef MEMORY_INSERT_BREAKPOINT
1180 fprintf_unfiltered (file
,
1181 "gdbarch_dump: %s # %s\n",
1182 "MEMORY_INSERT_BREAKPOINT(addr, contents_cache)",
1183 XSTRING (MEMORY_INSERT_BREAKPOINT (addr
, contents_cache
)));
1185 #ifdef MEMORY_REMOVE_BREAKPOINT
1186 fprintf_unfiltered (file
,
1187 "gdbarch_dump: %s # %s\n",
1188 "MEMORY_REMOVE_BREAKPOINT(addr, contents_cache)",
1189 XSTRING (MEMORY_REMOVE_BREAKPOINT (addr
, contents_cache
)));
1191 #ifdef DECR_PC_AFTER_BREAK
1192 fprintf_unfiltered (file
,
1193 "gdbarch_dump: DECR_PC_AFTER_BREAK # %s\n",
1194 XSTRING (DECR_PC_AFTER_BREAK
));
1196 #ifdef FUNCTION_START_OFFSET
1197 fprintf_unfiltered (file
,
1198 "gdbarch_dump: FUNCTION_START_OFFSET # %s\n",
1199 XSTRING (FUNCTION_START_OFFSET
));
1201 #if defined (REMOTE_TRANSLATE_XFER_ADDRESS) && GDB_MULTI_ARCH
1202 /* Macro might contain `[{}]' when not multi-arch */
1203 fprintf_unfiltered (file
,
1204 "gdbarch_dump: %s # %s\n",
1205 "REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len)",
1206 XSTRING (REMOTE_TRANSLATE_XFER_ADDRESS (gdb_addr
, gdb_len
, rem_addr
, rem_len
)));
1208 #ifdef FRAME_ARGS_SKIP
1209 fprintf_unfiltered (file
,
1210 "gdbarch_dump: FRAME_ARGS_SKIP # %s\n",
1211 XSTRING (FRAME_ARGS_SKIP
));
1213 #ifdef FRAMELESS_FUNCTION_INVOCATION
1214 fprintf_unfiltered (file
,
1215 "gdbarch_dump: %s # %s\n",
1216 "FRAMELESS_FUNCTION_INVOCATION(fi)",
1217 XSTRING (FRAMELESS_FUNCTION_INVOCATION (fi
)));
1220 fprintf_unfiltered (file
,
1221 "gdbarch_dump: %s # %s\n",
1222 "FRAME_CHAIN(frame)",
1223 XSTRING (FRAME_CHAIN (frame
)));
1225 #ifdef FRAME_CHAIN_VALID
1226 fprintf_unfiltered (file
,
1227 "gdbarch_dump: %s # %s\n",
1228 "FRAME_CHAIN_VALID(chain, thisframe)",
1229 XSTRING (FRAME_CHAIN_VALID (chain
, thisframe
)));
1231 #ifdef FRAME_SAVED_PC
1232 fprintf_unfiltered (file
,
1233 "gdbarch_dump: %s # %s\n",
1234 "FRAME_SAVED_PC(fi)",
1235 XSTRING (FRAME_SAVED_PC (fi
)));
1237 #ifdef FRAME_ARGS_ADDRESS
1238 fprintf_unfiltered (file
,
1239 "gdbarch_dump: %s # %s\n",
1240 "FRAME_ARGS_ADDRESS(fi)",
1241 XSTRING (FRAME_ARGS_ADDRESS (fi
)));
1243 #ifdef FRAME_LOCALS_ADDRESS
1244 fprintf_unfiltered (file
,
1245 "gdbarch_dump: %s # %s\n",
1246 "FRAME_LOCALS_ADDRESS(fi)",
1247 XSTRING (FRAME_LOCALS_ADDRESS (fi
)));
1249 #ifdef SAVED_PC_AFTER_CALL
1250 fprintf_unfiltered (file
,
1251 "gdbarch_dump: %s # %s\n",
1252 "SAVED_PC_AFTER_CALL(frame)",
1253 XSTRING (SAVED_PC_AFTER_CALL (frame
)));
1255 #ifdef FRAME_NUM_ARGS
1256 fprintf_unfiltered (file
,
1257 "gdbarch_dump: %s # %s\n",
1258 "FRAME_NUM_ARGS(frame)",
1259 XSTRING (FRAME_NUM_ARGS (frame
)));
1262 fprintf_unfiltered (file
,
1263 "gdbarch_dump: %s # %s\n",
1265 XSTRING (STACK_ALIGN (sp
)));
1267 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1268 fprintf_unfiltered (file
,
1269 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED # %s\n",
1270 XSTRING (EXTRA_STACK_ALIGNMENT_NEEDED
));
1272 #ifdef REG_STRUCT_HAS_ADDR
1273 fprintf_unfiltered (file
,
1274 "gdbarch_dump: %s # %s\n",
1275 "REG_STRUCT_HAS_ADDR(gcc_p, type)",
1276 XSTRING (REG_STRUCT_HAS_ADDR (gcc_p
, type
)));
1278 #if defined (SAVE_DUMMY_FRAME_TOS) && GDB_MULTI_ARCH
1279 /* Macro might contain `[{}]' when not multi-arch */
1280 fprintf_unfiltered (file
,
1281 "gdbarch_dump: %s # %s\n",
1282 "SAVE_DUMMY_FRAME_TOS(sp)",
1283 XSTRING (SAVE_DUMMY_FRAME_TOS (sp
)));
1285 #ifdef TARGET_FLOAT_FORMAT
1286 fprintf_unfiltered (file
,
1287 "gdbarch_dump: TARGET_FLOAT_FORMAT # %s\n",
1288 XSTRING (TARGET_FLOAT_FORMAT
));
1290 #ifdef TARGET_DOUBLE_FORMAT
1291 fprintf_unfiltered (file
,
1292 "gdbarch_dump: TARGET_DOUBLE_FORMAT # %s\n",
1293 XSTRING (TARGET_DOUBLE_FORMAT
));
1295 #ifdef TARGET_LONG_DOUBLE_FORMAT
1296 fprintf_unfiltered (file
,
1297 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT # %s\n",
1298 XSTRING (TARGET_LONG_DOUBLE_FORMAT
));
1300 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1301 fprintf_unfiltered (file
,
1302 "gdbarch_dump: %s # %s\n",
1303 "CONVERT_FROM_FUNC_PTR_ADDR(addr)",
1304 XSTRING (CONVERT_FROM_FUNC_PTR_ADDR (addr
)));
1306 #ifdef TARGET_ARCHITECTURE
1307 if (TARGET_ARCHITECTURE
!= NULL
)
1308 fprintf_unfiltered (file
,
1309 "gdbarch_dump: TARGET_ARCHITECTURE = %s\n",
1310 TARGET_ARCHITECTURE
->printable_name
);
1312 #ifdef TARGET_BYTE_ORDER
1313 fprintf_unfiltered (file
,
1314 "gdbarch_dump: TARGET_BYTE_ORDER = %ld\n",
1315 (long) TARGET_BYTE_ORDER
);
1317 #ifdef TARGET_SHORT_BIT
1318 fprintf_unfiltered (file
,
1319 "gdbarch_dump: TARGET_SHORT_BIT = %ld\n",
1320 (long) TARGET_SHORT_BIT
);
1322 #ifdef TARGET_INT_BIT
1323 fprintf_unfiltered (file
,
1324 "gdbarch_dump: TARGET_INT_BIT = %ld\n",
1325 (long) TARGET_INT_BIT
);
1327 #ifdef TARGET_LONG_BIT
1328 fprintf_unfiltered (file
,
1329 "gdbarch_dump: TARGET_LONG_BIT = %ld\n",
1330 (long) TARGET_LONG_BIT
);
1332 #ifdef TARGET_LONG_LONG_BIT
1333 fprintf_unfiltered (file
,
1334 "gdbarch_dump: TARGET_LONG_LONG_BIT = %ld\n",
1335 (long) TARGET_LONG_LONG_BIT
);
1337 #ifdef TARGET_FLOAT_BIT
1338 fprintf_unfiltered (file
,
1339 "gdbarch_dump: TARGET_FLOAT_BIT = %ld\n",
1340 (long) TARGET_FLOAT_BIT
);
1342 #ifdef TARGET_DOUBLE_BIT
1343 fprintf_unfiltered (file
,
1344 "gdbarch_dump: TARGET_DOUBLE_BIT = %ld\n",
1345 (long) TARGET_DOUBLE_BIT
);
1347 #ifdef TARGET_LONG_DOUBLE_BIT
1348 fprintf_unfiltered (file
,
1349 "gdbarch_dump: TARGET_LONG_DOUBLE_BIT = %ld\n",
1350 (long) TARGET_LONG_DOUBLE_BIT
);
1352 #ifdef TARGET_PTR_BIT
1353 fprintf_unfiltered (file
,
1354 "gdbarch_dump: TARGET_PTR_BIT = %ld\n",
1355 (long) TARGET_PTR_BIT
);
1357 #ifdef TARGET_ADDR_BIT
1358 fprintf_unfiltered (file
,
1359 "gdbarch_dump: TARGET_ADDR_BIT = %ld\n",
1360 (long) TARGET_ADDR_BIT
);
1362 #ifdef TARGET_BFD_VMA_BIT
1363 fprintf_unfiltered (file
,
1364 "gdbarch_dump: TARGET_BFD_VMA_BIT = %ld\n",
1365 (long) TARGET_BFD_VMA_BIT
);
1368 fprintf_unfiltered (file
,
1369 "gdbarch_dump: IEEE_FLOAT = %ld\n",
1372 #ifdef TARGET_READ_PC
1374 fprintf_unfiltered (file
,
1375 "gdbarch_dump: TARGET_READ_PC = 0x%08lx\n",
1376 (long) current_gdbarch
->read_pc
1377 /*TARGET_READ_PC ()*/);
1379 #ifdef TARGET_WRITE_PC
1381 fprintf_unfiltered (file
,
1382 "gdbarch_dump: TARGET_WRITE_PC = 0x%08lx\n",
1383 (long) current_gdbarch
->write_pc
1384 /*TARGET_WRITE_PC ()*/);
1386 #ifdef TARGET_READ_FP
1388 fprintf_unfiltered (file
,
1389 "gdbarch_dump: TARGET_READ_FP = 0x%08lx\n",
1390 (long) current_gdbarch
->read_fp
1391 /*TARGET_READ_FP ()*/);
1393 #ifdef TARGET_WRITE_FP
1395 fprintf_unfiltered (file
,
1396 "gdbarch_dump: TARGET_WRITE_FP = 0x%08lx\n",
1397 (long) current_gdbarch
->write_fp
1398 /*TARGET_WRITE_FP ()*/);
1400 #ifdef TARGET_READ_SP
1402 fprintf_unfiltered (file
,
1403 "gdbarch_dump: TARGET_READ_SP = 0x%08lx\n",
1404 (long) current_gdbarch
->read_sp
1405 /*TARGET_READ_SP ()*/);
1407 #ifdef TARGET_WRITE_SP
1409 fprintf_unfiltered (file
,
1410 "gdbarch_dump: TARGET_WRITE_SP = 0x%08lx\n",
1411 (long) current_gdbarch
->write_sp
1412 /*TARGET_WRITE_SP ()*/);
1415 fprintf_unfiltered (file
,
1416 "gdbarch_dump: NUM_REGS = %ld\n",
1419 #ifdef NUM_PSEUDO_REGS
1420 fprintf_unfiltered (file
,
1421 "gdbarch_dump: NUM_PSEUDO_REGS = %ld\n",
1422 (long) NUM_PSEUDO_REGS
);
1425 fprintf_unfiltered (file
,
1426 "gdbarch_dump: SP_REGNUM = %ld\n",
1430 fprintf_unfiltered (file
,
1431 "gdbarch_dump: FP_REGNUM = %ld\n",
1435 fprintf_unfiltered (file
,
1436 "gdbarch_dump: PC_REGNUM = %ld\n",
1440 fprintf_unfiltered (file
,
1441 "gdbarch_dump: FP0_REGNUM = %ld\n",
1445 fprintf_unfiltered (file
,
1446 "gdbarch_dump: NPC_REGNUM = %ld\n",
1450 fprintf_unfiltered (file
,
1451 "gdbarch_dump: NNPC_REGNUM = %ld\n",
1452 (long) NNPC_REGNUM
);
1454 #ifdef REGISTER_NAME
1456 fprintf_unfiltered (file
,
1457 "gdbarch_dump: REGISTER_NAME = 0x%08lx\n",
1458 (long) current_gdbarch
->register_name
1459 /*REGISTER_NAME ()*/);
1461 #ifdef REGISTER_SIZE
1462 fprintf_unfiltered (file
,
1463 "gdbarch_dump: REGISTER_SIZE = %ld\n",
1464 (long) REGISTER_SIZE
);
1466 #ifdef REGISTER_BYTES
1467 fprintf_unfiltered (file
,
1468 "gdbarch_dump: REGISTER_BYTES = %ld\n",
1469 (long) REGISTER_BYTES
);
1471 #ifdef REGISTER_BYTE
1473 fprintf_unfiltered (file
,
1474 "gdbarch_dump: REGISTER_BYTE = 0x%08lx\n",
1475 (long) current_gdbarch
->register_byte
1476 /*REGISTER_BYTE ()*/);
1478 #ifdef REGISTER_RAW_SIZE
1480 fprintf_unfiltered (file
,
1481 "gdbarch_dump: REGISTER_RAW_SIZE = 0x%08lx\n",
1482 (long) current_gdbarch
->register_raw_size
1483 /*REGISTER_RAW_SIZE ()*/);
1485 #ifdef MAX_REGISTER_RAW_SIZE
1486 fprintf_unfiltered (file
,
1487 "gdbarch_dump: MAX_REGISTER_RAW_SIZE = %ld\n",
1488 (long) MAX_REGISTER_RAW_SIZE
);
1490 #ifdef REGISTER_VIRTUAL_SIZE
1492 fprintf_unfiltered (file
,
1493 "gdbarch_dump: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
1494 (long) current_gdbarch
->register_virtual_size
1495 /*REGISTER_VIRTUAL_SIZE ()*/);
1497 #ifdef MAX_REGISTER_VIRTUAL_SIZE
1498 fprintf_unfiltered (file
,
1499 "gdbarch_dump: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
1500 (long) MAX_REGISTER_VIRTUAL_SIZE
);
1502 #ifdef REGISTER_VIRTUAL_TYPE
1504 fprintf_unfiltered (file
,
1505 "gdbarch_dump: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
1506 (long) current_gdbarch
->register_virtual_type
1507 /*REGISTER_VIRTUAL_TYPE ()*/);
1509 #ifdef DO_REGISTERS_INFO
1511 fprintf_unfiltered (file
,
1512 "gdbarch_dump: DO_REGISTERS_INFO = 0x%08lx\n",
1513 (long) current_gdbarch
->do_registers_info
1514 /*DO_REGISTERS_INFO ()*/);
1516 #ifdef REGISTER_SIM_REGNO
1518 fprintf_unfiltered (file
,
1519 "gdbarch_dump: REGISTER_SIM_REGNO = 0x%08lx\n",
1520 (long) current_gdbarch
->register_sim_regno
1521 /*REGISTER_SIM_REGNO ()*/);
1523 #ifdef USE_GENERIC_DUMMY_FRAMES
1524 fprintf_unfiltered (file
,
1525 "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %ld\n",
1526 (long) USE_GENERIC_DUMMY_FRAMES
);
1528 #ifdef CALL_DUMMY_LOCATION
1529 fprintf_unfiltered (file
,
1530 "gdbarch_dump: CALL_DUMMY_LOCATION = %ld\n",
1531 (long) CALL_DUMMY_LOCATION
);
1533 #ifdef CALL_DUMMY_ADDRESS
1535 fprintf_unfiltered (file
,
1536 "gdbarch_dump: CALL_DUMMY_ADDRESS = 0x%08lx\n",
1537 (long) current_gdbarch
->call_dummy_address
1538 /*CALL_DUMMY_ADDRESS ()*/);
1540 #ifdef CALL_DUMMY_START_OFFSET
1541 fprintf_unfiltered (file
,
1542 "gdbarch_dump: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
1543 (long) CALL_DUMMY_START_OFFSET
);
1545 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET
1546 if (CALL_DUMMY_BREAKPOINT_OFFSET_P
)
1547 fprintf_unfiltered (file
,
1548 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
1549 (long) CALL_DUMMY_BREAKPOINT_OFFSET
);
1551 #ifdef CALL_DUMMY_BREAKPOINT_OFFSET_P
1552 fprintf_unfiltered (file
,
1553 "gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
1554 (long) CALL_DUMMY_BREAKPOINT_OFFSET_P
);
1556 #ifdef CALL_DUMMY_LENGTH
1557 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
|| CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
1558 fprintf_unfiltered (file
,
1559 "gdbarch_dump: CALL_DUMMY_LENGTH = %ld\n",
1560 (long) CALL_DUMMY_LENGTH
);
1562 #ifdef PC_IN_CALL_DUMMY
1564 fprintf_unfiltered (file
,
1565 "gdbarch_dump: PC_IN_CALL_DUMMY = 0x%08lx\n",
1566 (long) current_gdbarch
->pc_in_call_dummy
1567 /*PC_IN_CALL_DUMMY ()*/);
1570 fprintf_unfiltered (file
,
1571 "gdbarch_dump: CALL_DUMMY_P = %ld\n",
1572 (long) CALL_DUMMY_P
);
1574 #ifdef CALL_DUMMY_WORDS
1575 fprintf_unfiltered (file
,
1576 "gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
1577 (long) CALL_DUMMY_WORDS
);
1579 #ifdef SIZEOF_CALL_DUMMY_WORDS
1580 fprintf_unfiltered (file
,
1581 "gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
1582 (long) SIZEOF_CALL_DUMMY_WORDS
);
1584 #ifdef CALL_DUMMY_STACK_ADJUST_P
1585 fprintf_unfiltered (file
,
1586 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
1587 (long) CALL_DUMMY_STACK_ADJUST_P
);
1589 #ifdef CALL_DUMMY_STACK_ADJUST
1590 if (CALL_DUMMY_STACK_ADJUST_P
)
1591 fprintf_unfiltered (file
,
1592 "gdbarch_dump: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
1593 (long) CALL_DUMMY_STACK_ADJUST
);
1595 #ifdef FIX_CALL_DUMMY
1597 fprintf_unfiltered (file
,
1598 "gdbarch_dump: FIX_CALL_DUMMY = 0x%08lx\n",
1599 (long) current_gdbarch
->fix_call_dummy
1600 /*FIX_CALL_DUMMY ()*/);
1602 #ifdef BELIEVE_PCC_PROMOTION
1603 fprintf_unfiltered (file
,
1604 "gdbarch_dump: BELIEVE_PCC_PROMOTION = %ld\n",
1605 (long) BELIEVE_PCC_PROMOTION
);
1607 #ifdef BELIEVE_PCC_PROMOTION_TYPE
1608 fprintf_unfiltered (file
,
1609 "gdbarch_dump: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
1610 (long) BELIEVE_PCC_PROMOTION_TYPE
);
1612 #ifdef COERCE_FLOAT_TO_DOUBLE
1614 fprintf_unfiltered (file
,
1615 "gdbarch_dump: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
1616 (long) current_gdbarch
->coerce_float_to_double
1617 /*COERCE_FLOAT_TO_DOUBLE ()*/);
1619 #ifdef GET_SAVED_REGISTER
1621 fprintf_unfiltered (file
,
1622 "gdbarch_dump: GET_SAVED_REGISTER = 0x%08lx\n",
1623 (long) current_gdbarch
->get_saved_register
1624 /*GET_SAVED_REGISTER ()*/);
1626 #ifdef REGISTER_CONVERTIBLE
1628 fprintf_unfiltered (file
,
1629 "gdbarch_dump: REGISTER_CONVERTIBLE = 0x%08lx\n",
1630 (long) current_gdbarch
->register_convertible
1631 /*REGISTER_CONVERTIBLE ()*/);
1633 #ifdef REGISTER_CONVERT_TO_VIRTUAL
1635 fprintf_unfiltered (file
,
1636 "gdbarch_dump: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
1637 (long) current_gdbarch
->register_convert_to_virtual
1638 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
1640 #ifdef REGISTER_CONVERT_TO_RAW
1642 fprintf_unfiltered (file
,
1643 "gdbarch_dump: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
1644 (long) current_gdbarch
->register_convert_to_raw
1645 /*REGISTER_CONVERT_TO_RAW ()*/);
1647 #ifdef FETCH_PSEUDO_REGISTER
1649 fprintf_unfiltered (file
,
1650 "gdbarch_dump: FETCH_PSEUDO_REGISTER = 0x%08lx\n",
1651 (long) current_gdbarch
->fetch_pseudo_register
1652 /*FETCH_PSEUDO_REGISTER ()*/);
1654 #ifdef STORE_PSEUDO_REGISTER
1656 fprintf_unfiltered (file
,
1657 "gdbarch_dump: STORE_PSEUDO_REGISTER = 0x%08lx\n",
1658 (long) current_gdbarch
->store_pseudo_register
1659 /*STORE_PSEUDO_REGISTER ()*/);
1661 #ifdef POINTER_TO_ADDRESS
1663 fprintf_unfiltered (file
,
1664 "gdbarch_dump: POINTER_TO_ADDRESS = 0x%08lx\n",
1665 (long) current_gdbarch
->pointer_to_address
1666 /*POINTER_TO_ADDRESS ()*/);
1668 #ifdef ADDRESS_TO_POINTER
1670 fprintf_unfiltered (file
,
1671 "gdbarch_dump: ADDRESS_TO_POINTER = 0x%08lx\n",
1672 (long) current_gdbarch
->address_to_pointer
1673 /*ADDRESS_TO_POINTER ()*/);
1675 #ifdef RETURN_VALUE_ON_STACK
1677 fprintf_unfiltered (file
,
1678 "gdbarch_dump: RETURN_VALUE_ON_STACK = 0x%08lx\n",
1679 (long) current_gdbarch
->return_value_on_stack
1680 /*RETURN_VALUE_ON_STACK ()*/);
1682 #ifdef EXTRACT_RETURN_VALUE
1684 fprintf_unfiltered (file
,
1685 "gdbarch_dump: EXTRACT_RETURN_VALUE = 0x%08lx\n",
1686 (long) current_gdbarch
->extract_return_value
1687 /*EXTRACT_RETURN_VALUE ()*/);
1689 #ifdef PUSH_ARGUMENTS
1691 fprintf_unfiltered (file
,
1692 "gdbarch_dump: PUSH_ARGUMENTS = 0x%08lx\n",
1693 (long) current_gdbarch
->push_arguments
1694 /*PUSH_ARGUMENTS ()*/);
1696 #ifdef PUSH_DUMMY_FRAME
1698 fprintf_unfiltered (file
,
1699 "gdbarch_dump: PUSH_DUMMY_FRAME = 0x%08lx\n",
1700 (long) current_gdbarch
->push_dummy_frame
1701 /*PUSH_DUMMY_FRAME ()*/);
1703 #ifdef PUSH_RETURN_ADDRESS
1705 fprintf_unfiltered (file
,
1706 "gdbarch_dump: PUSH_RETURN_ADDRESS = 0x%08lx\n",
1707 (long) current_gdbarch
->push_return_address
1708 /*PUSH_RETURN_ADDRESS ()*/);
1712 fprintf_unfiltered (file
,
1713 "gdbarch_dump: POP_FRAME = 0x%08lx\n",
1714 (long) current_gdbarch
->pop_frame
1717 #ifdef D10V_MAKE_DADDR
1719 fprintf_unfiltered (file
,
1720 "gdbarch_dump: D10V_MAKE_DADDR = 0x%08lx\n",
1721 (long) current_gdbarch
->d10v_make_daddr
1722 /*D10V_MAKE_DADDR ()*/);
1724 #ifdef D10V_MAKE_IADDR
1726 fprintf_unfiltered (file
,
1727 "gdbarch_dump: D10V_MAKE_IADDR = 0x%08lx\n",
1728 (long) current_gdbarch
->d10v_make_iaddr
1729 /*D10V_MAKE_IADDR ()*/);
1733 fprintf_unfiltered (file
,
1734 "gdbarch_dump: D10V_DADDR_P = 0x%08lx\n",
1735 (long) current_gdbarch
->d10v_daddr_p
1736 /*D10V_DADDR_P ()*/);
1740 fprintf_unfiltered (file
,
1741 "gdbarch_dump: D10V_IADDR_P = 0x%08lx\n",
1742 (long) current_gdbarch
->d10v_iaddr_p
1743 /*D10V_IADDR_P ()*/);
1745 #ifdef D10V_CONVERT_DADDR_TO_RAW
1747 fprintf_unfiltered (file
,
1748 "gdbarch_dump: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
1749 (long) current_gdbarch
->d10v_convert_daddr_to_raw
1750 /*D10V_CONVERT_DADDR_TO_RAW ()*/);
1752 #ifdef D10V_CONVERT_IADDR_TO_RAW
1754 fprintf_unfiltered (file
,
1755 "gdbarch_dump: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
1756 (long) current_gdbarch
->d10v_convert_iaddr_to_raw
1757 /*D10V_CONVERT_IADDR_TO_RAW ()*/);
1759 #ifdef STORE_STRUCT_RETURN
1761 fprintf_unfiltered (file
,
1762 "gdbarch_dump: STORE_STRUCT_RETURN = 0x%08lx\n",
1763 (long) current_gdbarch
->store_struct_return
1764 /*STORE_STRUCT_RETURN ()*/);
1766 #ifdef STORE_RETURN_VALUE
1768 fprintf_unfiltered (file
,
1769 "gdbarch_dump: STORE_RETURN_VALUE = 0x%08lx\n",
1770 (long) current_gdbarch
->store_return_value
1771 /*STORE_RETURN_VALUE ()*/);
1773 #ifdef EXTRACT_STRUCT_VALUE_ADDRESS
1775 fprintf_unfiltered (file
,
1776 "gdbarch_dump: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
1777 (long) current_gdbarch
->extract_struct_value_address
1778 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
1780 #ifdef USE_STRUCT_CONVENTION
1782 fprintf_unfiltered (file
,
1783 "gdbarch_dump: USE_STRUCT_CONVENTION = 0x%08lx\n",
1784 (long) current_gdbarch
->use_struct_convention
1785 /*USE_STRUCT_CONVENTION ()*/);
1787 #ifdef FRAME_INIT_SAVED_REGS
1789 fprintf_unfiltered (file
,
1790 "gdbarch_dump: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
1791 (long) current_gdbarch
->frame_init_saved_regs
1792 /*FRAME_INIT_SAVED_REGS ()*/);
1794 #ifdef INIT_EXTRA_FRAME_INFO
1796 fprintf_unfiltered (file
,
1797 "gdbarch_dump: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
1798 (long) current_gdbarch
->init_extra_frame_info
1799 /*INIT_EXTRA_FRAME_INFO ()*/);
1801 #ifdef SKIP_PROLOGUE
1803 fprintf_unfiltered (file
,
1804 "gdbarch_dump: SKIP_PROLOGUE = 0x%08lx\n",
1805 (long) current_gdbarch
->skip_prologue
1806 /*SKIP_PROLOGUE ()*/);
1808 #ifdef PROLOGUE_FRAMELESS_P
1810 fprintf_unfiltered (file
,
1811 "gdbarch_dump: PROLOGUE_FRAMELESS_P = 0x%08lx\n",
1812 (long) current_gdbarch
->prologue_frameless_p
1813 /*PROLOGUE_FRAMELESS_P ()*/);
1817 fprintf_unfiltered (file
,
1818 "gdbarch_dump: INNER_THAN = 0x%08lx\n",
1819 (long) current_gdbarch
->inner_than
1822 #ifdef BREAKPOINT_FROM_PC
1824 fprintf_unfiltered (file
,
1825 "gdbarch_dump: BREAKPOINT_FROM_PC = 0x%08lx\n",
1826 (long) current_gdbarch
->breakpoint_from_pc
1827 /*BREAKPOINT_FROM_PC ()*/);
1829 #ifdef MEMORY_INSERT_BREAKPOINT
1831 fprintf_unfiltered (file
,
1832 "gdbarch_dump: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
1833 (long) current_gdbarch
->memory_insert_breakpoint
1834 /*MEMORY_INSERT_BREAKPOINT ()*/);
1836 #ifdef MEMORY_REMOVE_BREAKPOINT
1838 fprintf_unfiltered (file
,
1839 "gdbarch_dump: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
1840 (long) current_gdbarch
->memory_remove_breakpoint
1841 /*MEMORY_REMOVE_BREAKPOINT ()*/);
1843 #ifdef DECR_PC_AFTER_BREAK
1844 fprintf_unfiltered (file
,
1845 "gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
1846 (long) DECR_PC_AFTER_BREAK
);
1848 #ifdef FUNCTION_START_OFFSET
1849 fprintf_unfiltered (file
,
1850 "gdbarch_dump: FUNCTION_START_OFFSET = %ld\n",
1851 (long) FUNCTION_START_OFFSET
);
1853 #ifdef REMOTE_TRANSLATE_XFER_ADDRESS
1855 fprintf_unfiltered (file
,
1856 "gdbarch_dump: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
1857 (long) current_gdbarch
->remote_translate_xfer_address
1858 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
1860 #ifdef FRAME_ARGS_SKIP
1861 fprintf_unfiltered (file
,
1862 "gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
1863 (long) FRAME_ARGS_SKIP
);
1865 #ifdef FRAMELESS_FUNCTION_INVOCATION
1867 fprintf_unfiltered (file
,
1868 "gdbarch_dump: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
1869 (long) current_gdbarch
->frameless_function_invocation
1870 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
1874 fprintf_unfiltered (file
,
1875 "gdbarch_dump: FRAME_CHAIN = 0x%08lx\n",
1876 (long) current_gdbarch
->frame_chain
1877 /*FRAME_CHAIN ()*/);
1879 #ifdef FRAME_CHAIN_VALID
1881 fprintf_unfiltered (file
,
1882 "gdbarch_dump: FRAME_CHAIN_VALID = 0x%08lx\n",
1883 (long) current_gdbarch
->frame_chain_valid
1884 /*FRAME_CHAIN_VALID ()*/);
1886 #ifdef FRAME_SAVED_PC
1888 fprintf_unfiltered (file
,
1889 "gdbarch_dump: FRAME_SAVED_PC = 0x%08lx\n",
1890 (long) current_gdbarch
->frame_saved_pc
1891 /*FRAME_SAVED_PC ()*/);
1893 #ifdef FRAME_ARGS_ADDRESS
1895 fprintf_unfiltered (file
,
1896 "gdbarch_dump: FRAME_ARGS_ADDRESS = 0x%08lx\n",
1897 (long) current_gdbarch
->frame_args_address
1898 /*FRAME_ARGS_ADDRESS ()*/);
1900 #ifdef FRAME_LOCALS_ADDRESS
1902 fprintf_unfiltered (file
,
1903 "gdbarch_dump: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
1904 (long) current_gdbarch
->frame_locals_address
1905 /*FRAME_LOCALS_ADDRESS ()*/);
1907 #ifdef SAVED_PC_AFTER_CALL
1909 fprintf_unfiltered (file
,
1910 "gdbarch_dump: SAVED_PC_AFTER_CALL = 0x%08lx\n",
1911 (long) current_gdbarch
->saved_pc_after_call
1912 /*SAVED_PC_AFTER_CALL ()*/);
1914 #ifdef FRAME_NUM_ARGS
1916 fprintf_unfiltered (file
,
1917 "gdbarch_dump: FRAME_NUM_ARGS = 0x%08lx\n",
1918 (long) current_gdbarch
->frame_num_args
1919 /*FRAME_NUM_ARGS ()*/);
1923 fprintf_unfiltered (file
,
1924 "gdbarch_dump: STACK_ALIGN = 0x%08lx\n",
1925 (long) current_gdbarch
->stack_align
1926 /*STACK_ALIGN ()*/);
1928 #ifdef EXTRA_STACK_ALIGNMENT_NEEDED
1929 fprintf_unfiltered (file
,
1930 "gdbarch_dump: EXTRA_STACK_ALIGNMENT_NEEDED = %ld\n",
1931 (long) EXTRA_STACK_ALIGNMENT_NEEDED
);
1933 #ifdef REG_STRUCT_HAS_ADDR
1935 fprintf_unfiltered (file
,
1936 "gdbarch_dump: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
1937 (long) current_gdbarch
->reg_struct_has_addr
1938 /*REG_STRUCT_HAS_ADDR ()*/);
1940 #ifdef SAVE_DUMMY_FRAME_TOS
1942 fprintf_unfiltered (file
,
1943 "gdbarch_dump: SAVE_DUMMY_FRAME_TOS = 0x%08lx\n",
1944 (long) current_gdbarch
->save_dummy_frame_tos
1945 /*SAVE_DUMMY_FRAME_TOS ()*/);
1947 #ifdef TARGET_FLOAT_FORMAT
1948 fprintf_unfiltered (file
,
1949 "gdbarch_dump: TARGET_FLOAT_FORMAT = %ld\n",
1950 (long) TARGET_FLOAT_FORMAT
);
1952 #ifdef TARGET_DOUBLE_FORMAT
1953 fprintf_unfiltered (file
,
1954 "gdbarch_dump: TARGET_DOUBLE_FORMAT = %ld\n",
1955 (long) TARGET_DOUBLE_FORMAT
);
1957 #ifdef TARGET_LONG_DOUBLE_FORMAT
1958 fprintf_unfiltered (file
,
1959 "gdbarch_dump: TARGET_LONG_DOUBLE_FORMAT = %ld\n",
1960 (long) TARGET_LONG_DOUBLE_FORMAT
);
1962 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1964 fprintf_unfiltered (file
,
1965 "gdbarch_dump: CONVERT_FROM_FUNC_PTR_ADDR = 0x%08lx\n",
1966 (long) current_gdbarch
->convert_from_func_ptr_addr
1967 /*CONVERT_FROM_FUNC_PTR_ADDR ()*/);
1969 if (current_gdbarch
->dump_tdep
!= NULL
)
1970 current_gdbarch
->dump_tdep (current_gdbarch
, file
);
1973 struct gdbarch_tdep
*
1974 gdbarch_tdep (struct gdbarch
*gdbarch
)
1976 if (gdbarch_debug
>= 2)
1977 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
1978 return gdbarch
->tdep
;
1982 const struct bfd_arch_info
*
1983 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
1985 if (gdbarch_debug
>= 2)
1986 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
1987 return gdbarch
->bfd_arch_info
;
1991 gdbarch_byte_order (struct gdbarch
*gdbarch
)
1993 if (gdbarch_debug
>= 2)
1994 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
1995 return gdbarch
->byte_order
;
1999 gdbarch_short_bit (struct gdbarch
*gdbarch
)
2001 /* Skip verify of short_bit, invalid_p == 0 */
2002 if (gdbarch_debug
>= 2)
2003 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
2004 return gdbarch
->short_bit
;
2008 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
2011 gdbarch
->short_bit
= short_bit
;
2015 gdbarch_int_bit (struct gdbarch
*gdbarch
)
2017 /* Skip verify of int_bit, invalid_p == 0 */
2018 if (gdbarch_debug
>= 2)
2019 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
2020 return gdbarch
->int_bit
;
2024 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
2027 gdbarch
->int_bit
= int_bit
;
2031 gdbarch_long_bit (struct gdbarch
*gdbarch
)
2033 /* Skip verify of long_bit, invalid_p == 0 */
2034 if (gdbarch_debug
>= 2)
2035 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
2036 return gdbarch
->long_bit
;
2040 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
2043 gdbarch
->long_bit
= long_bit
;
2047 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
2049 /* Skip verify of long_long_bit, invalid_p == 0 */
2050 if (gdbarch_debug
>= 2)
2051 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
2052 return gdbarch
->long_long_bit
;
2056 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
2059 gdbarch
->long_long_bit
= long_long_bit
;
2063 gdbarch_float_bit (struct gdbarch
*gdbarch
)
2065 /* Skip verify of float_bit, invalid_p == 0 */
2066 if (gdbarch_debug
>= 2)
2067 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
2068 return gdbarch
->float_bit
;
2072 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
2075 gdbarch
->float_bit
= float_bit
;
2079 gdbarch_double_bit (struct gdbarch
*gdbarch
)
2081 /* Skip verify of double_bit, invalid_p == 0 */
2082 if (gdbarch_debug
>= 2)
2083 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
2084 return gdbarch
->double_bit
;
2088 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
2091 gdbarch
->double_bit
= double_bit
;
2095 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
2097 /* Skip verify of long_double_bit, invalid_p == 0 */
2098 if (gdbarch_debug
>= 2)
2099 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
2100 return gdbarch
->long_double_bit
;
2104 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
2105 int long_double_bit
)
2107 gdbarch
->long_double_bit
= long_double_bit
;
2111 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
2113 /* Skip verify of ptr_bit, invalid_p == 0 */
2114 if (gdbarch_debug
>= 2)
2115 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
2116 return gdbarch
->ptr_bit
;
2120 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
2123 gdbarch
->ptr_bit
= ptr_bit
;
2127 gdbarch_addr_bit (struct gdbarch
*gdbarch
)
2129 if (gdbarch
->addr_bit
== 0)
2130 internal_error ("gdbarch: gdbarch_addr_bit invalid");
2131 if (gdbarch_debug
>= 2)
2132 fprintf_unfiltered (gdb_stdlog
, "gdbarch_addr_bit called\n");
2133 return gdbarch
->addr_bit
;
2137 set_gdbarch_addr_bit (struct gdbarch
*gdbarch
,
2140 gdbarch
->addr_bit
= addr_bit
;
2144 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
2146 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
2147 if (gdbarch_debug
>= 2)
2148 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
2149 return gdbarch
->bfd_vma_bit
;
2153 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
2156 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
2160 gdbarch_ieee_float (struct gdbarch
*gdbarch
)
2162 /* Skip verify of ieee_float, invalid_p == 0 */
2163 if (gdbarch_debug
>= 2)
2164 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ieee_float called\n");
2165 return gdbarch
->ieee_float
;
2169 set_gdbarch_ieee_float (struct gdbarch
*gdbarch
,
2172 gdbarch
->ieee_float
= ieee_float
;
2176 gdbarch_read_pc (struct gdbarch
*gdbarch
, int pid
)
2178 if (gdbarch
->read_pc
== 0)
2179 internal_error ("gdbarch: gdbarch_read_pc invalid");
2180 if (gdbarch_debug
>= 2)
2181 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
2182 return gdbarch
->read_pc (pid
);
2186 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
2187 gdbarch_read_pc_ftype read_pc
)
2189 gdbarch
->read_pc
= read_pc
;
2193 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, int pid
)
2195 if (gdbarch
->write_pc
== 0)
2196 internal_error ("gdbarch: gdbarch_write_pc invalid");
2197 if (gdbarch_debug
>= 2)
2198 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
2199 gdbarch
->write_pc (val
, pid
);
2203 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
2204 gdbarch_write_pc_ftype write_pc
)
2206 gdbarch
->write_pc
= write_pc
;
2210 gdbarch_read_fp (struct gdbarch
*gdbarch
)
2212 if (gdbarch
->read_fp
== 0)
2213 internal_error ("gdbarch: gdbarch_read_fp invalid");
2214 if (gdbarch_debug
>= 2)
2215 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_fp called\n");
2216 return gdbarch
->read_fp ();
2220 set_gdbarch_read_fp (struct gdbarch
*gdbarch
,
2221 gdbarch_read_fp_ftype read_fp
)
2223 gdbarch
->read_fp
= read_fp
;
2227 gdbarch_write_fp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2229 if (gdbarch
->write_fp
== 0)
2230 internal_error ("gdbarch: gdbarch_write_fp invalid");
2231 if (gdbarch_debug
>= 2)
2232 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_fp called\n");
2233 gdbarch
->write_fp (val
);
2237 set_gdbarch_write_fp (struct gdbarch
*gdbarch
,
2238 gdbarch_write_fp_ftype write_fp
)
2240 gdbarch
->write_fp
= write_fp
;
2244 gdbarch_read_sp (struct gdbarch
*gdbarch
)
2246 if (gdbarch
->read_sp
== 0)
2247 internal_error ("gdbarch: gdbarch_read_sp invalid");
2248 if (gdbarch_debug
>= 2)
2249 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_sp called\n");
2250 return gdbarch
->read_sp ();
2254 set_gdbarch_read_sp (struct gdbarch
*gdbarch
,
2255 gdbarch_read_sp_ftype read_sp
)
2257 gdbarch
->read_sp
= read_sp
;
2261 gdbarch_write_sp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
2263 if (gdbarch
->write_sp
== 0)
2264 internal_error ("gdbarch: gdbarch_write_sp invalid");
2265 if (gdbarch_debug
>= 2)
2266 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_sp called\n");
2267 gdbarch
->write_sp (val
);
2271 set_gdbarch_write_sp (struct gdbarch
*gdbarch
,
2272 gdbarch_write_sp_ftype write_sp
)
2274 gdbarch
->write_sp
= write_sp
;
2278 gdbarch_num_regs (struct gdbarch
*gdbarch
)
2280 if (gdbarch
->num_regs
== -1)
2281 internal_error ("gdbarch: gdbarch_num_regs invalid");
2282 if (gdbarch_debug
>= 2)
2283 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
2284 return gdbarch
->num_regs
;
2288 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
2291 gdbarch
->num_regs
= num_regs
;
2295 gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
)
2297 /* Skip verify of num_pseudo_regs, invalid_p == 0 */
2298 if (gdbarch_debug
>= 2)
2299 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_pseudo_regs called\n");
2300 return gdbarch
->num_pseudo_regs
;
2304 set_gdbarch_num_pseudo_regs (struct gdbarch
*gdbarch
,
2305 int num_pseudo_regs
)
2307 gdbarch
->num_pseudo_regs
= num_pseudo_regs
;
2311 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
2313 if (gdbarch
->sp_regnum
== -1)
2314 internal_error ("gdbarch: gdbarch_sp_regnum invalid");
2315 if (gdbarch_debug
>= 2)
2316 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
2317 return gdbarch
->sp_regnum
;
2321 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
2324 gdbarch
->sp_regnum
= sp_regnum
;
2328 gdbarch_fp_regnum (struct gdbarch
*gdbarch
)
2330 if (gdbarch
->fp_regnum
== -1)
2331 internal_error ("gdbarch: gdbarch_fp_regnum invalid");
2332 if (gdbarch_debug
>= 2)
2333 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp_regnum called\n");
2334 return gdbarch
->fp_regnum
;
2338 set_gdbarch_fp_regnum (struct gdbarch
*gdbarch
,
2341 gdbarch
->fp_regnum
= fp_regnum
;
2345 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
2347 if (gdbarch
->pc_regnum
== -1)
2348 internal_error ("gdbarch: gdbarch_pc_regnum invalid");
2349 if (gdbarch_debug
>= 2)
2350 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
2351 return gdbarch
->pc_regnum
;
2355 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
2358 gdbarch
->pc_regnum
= pc_regnum
;
2362 gdbarch_fp0_regnum (struct gdbarch
*gdbarch
)
2364 /* Skip verify of fp0_regnum, invalid_p == 0 */
2365 if (gdbarch_debug
>= 2)
2366 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp0_regnum called\n");
2367 return gdbarch
->fp0_regnum
;
2371 set_gdbarch_fp0_regnum (struct gdbarch
*gdbarch
,
2374 gdbarch
->fp0_regnum
= fp0_regnum
;
2378 gdbarch_npc_regnum (struct gdbarch
*gdbarch
)
2380 /* Skip verify of npc_regnum, invalid_p == 0 */
2381 if (gdbarch_debug
>= 2)
2382 fprintf_unfiltered (gdb_stdlog
, "gdbarch_npc_regnum called\n");
2383 return gdbarch
->npc_regnum
;
2387 set_gdbarch_npc_regnum (struct gdbarch
*gdbarch
,
2390 gdbarch
->npc_regnum
= npc_regnum
;
2394 gdbarch_nnpc_regnum (struct gdbarch
*gdbarch
)
2396 /* Skip verify of nnpc_regnum, invalid_p == 0 */
2397 if (gdbarch_debug
>= 2)
2398 fprintf_unfiltered (gdb_stdlog
, "gdbarch_nnpc_regnum called\n");
2399 return gdbarch
->nnpc_regnum
;
2403 set_gdbarch_nnpc_regnum (struct gdbarch
*gdbarch
,
2406 gdbarch
->nnpc_regnum
= nnpc_regnum
;
2410 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
2412 if (gdbarch
->register_name
== 0)
2413 internal_error ("gdbarch: gdbarch_register_name invalid");
2414 if (gdbarch_debug
>= 2)
2415 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
2416 return gdbarch
->register_name (regnr
);
2420 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
2421 gdbarch_register_name_ftype register_name
)
2423 gdbarch
->register_name
= register_name
;
2427 gdbarch_register_size (struct gdbarch
*gdbarch
)
2429 if (gdbarch
->register_size
== -1)
2430 internal_error ("gdbarch: gdbarch_register_size invalid");
2431 if (gdbarch_debug
>= 2)
2432 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_size called\n");
2433 return gdbarch
->register_size
;
2437 set_gdbarch_register_size (struct gdbarch
*gdbarch
,
2440 gdbarch
->register_size
= register_size
;
2444 gdbarch_register_bytes (struct gdbarch
*gdbarch
)
2446 if (gdbarch
->register_bytes
== -1)
2447 internal_error ("gdbarch: gdbarch_register_bytes invalid");
2448 if (gdbarch_debug
>= 2)
2449 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes called\n");
2450 return gdbarch
->register_bytes
;
2454 set_gdbarch_register_bytes (struct gdbarch
*gdbarch
,
2457 gdbarch
->register_bytes
= register_bytes
;
2461 gdbarch_register_byte (struct gdbarch
*gdbarch
, int reg_nr
)
2463 if (gdbarch
->register_byte
== 0)
2464 internal_error ("gdbarch: gdbarch_register_byte invalid");
2465 if (gdbarch_debug
>= 2)
2466 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_byte called\n");
2467 return gdbarch
->register_byte (reg_nr
);
2471 set_gdbarch_register_byte (struct gdbarch
*gdbarch
,
2472 gdbarch_register_byte_ftype register_byte
)
2474 gdbarch
->register_byte
= register_byte
;
2478 gdbarch_register_raw_size (struct gdbarch
*gdbarch
, int reg_nr
)
2480 if (gdbarch
->register_raw_size
== 0)
2481 internal_error ("gdbarch: gdbarch_register_raw_size invalid");
2482 if (gdbarch_debug
>= 2)
2483 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_raw_size called\n");
2484 return gdbarch
->register_raw_size (reg_nr
);
2488 set_gdbarch_register_raw_size (struct gdbarch
*gdbarch
,
2489 gdbarch_register_raw_size_ftype register_raw_size
)
2491 gdbarch
->register_raw_size
= register_raw_size
;
2495 gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
)
2497 if (gdbarch
->max_register_raw_size
== -1)
2498 internal_error ("gdbarch: gdbarch_max_register_raw_size invalid");
2499 if (gdbarch_debug
>= 2)
2500 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_raw_size called\n");
2501 return gdbarch
->max_register_raw_size
;
2505 set_gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
,
2506 int max_register_raw_size
)
2508 gdbarch
->max_register_raw_size
= max_register_raw_size
;
2512 gdbarch_register_virtual_size (struct gdbarch
*gdbarch
, int reg_nr
)
2514 if (gdbarch
->register_virtual_size
== 0)
2515 internal_error ("gdbarch: gdbarch_register_virtual_size invalid");
2516 if (gdbarch_debug
>= 2)
2517 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_size called\n");
2518 return gdbarch
->register_virtual_size (reg_nr
);
2522 set_gdbarch_register_virtual_size (struct gdbarch
*gdbarch
,
2523 gdbarch_register_virtual_size_ftype register_virtual_size
)
2525 gdbarch
->register_virtual_size
= register_virtual_size
;
2529 gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
)
2531 if (gdbarch
->max_register_virtual_size
== -1)
2532 internal_error ("gdbarch: gdbarch_max_register_virtual_size invalid");
2533 if (gdbarch_debug
>= 2)
2534 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_virtual_size called\n");
2535 return gdbarch
->max_register_virtual_size
;
2539 set_gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
,
2540 int max_register_virtual_size
)
2542 gdbarch
->max_register_virtual_size
= max_register_virtual_size
;
2546 gdbarch_register_virtual_type (struct gdbarch
*gdbarch
, int reg_nr
)
2548 if (gdbarch
->register_virtual_type
== 0)
2549 internal_error ("gdbarch: gdbarch_register_virtual_type invalid");
2550 if (gdbarch_debug
>= 2)
2551 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_type called\n");
2552 return gdbarch
->register_virtual_type (reg_nr
);
2556 set_gdbarch_register_virtual_type (struct gdbarch
*gdbarch
,
2557 gdbarch_register_virtual_type_ftype register_virtual_type
)
2559 gdbarch
->register_virtual_type
= register_virtual_type
;
2563 gdbarch_do_registers_info (struct gdbarch
*gdbarch
, int reg_nr
, int fpregs
)
2565 if (gdbarch
->do_registers_info
== 0)
2566 internal_error ("gdbarch: gdbarch_do_registers_info invalid");
2567 if (gdbarch_debug
>= 2)
2568 fprintf_unfiltered (gdb_stdlog
, "gdbarch_do_registers_info called\n");
2569 gdbarch
->do_registers_info (reg_nr
, fpregs
);
2573 set_gdbarch_do_registers_info (struct gdbarch
*gdbarch
,
2574 gdbarch_do_registers_info_ftype do_registers_info
)
2576 gdbarch
->do_registers_info
= do_registers_info
;
2580 gdbarch_register_sim_regno (struct gdbarch
*gdbarch
, int reg_nr
)
2582 if (gdbarch
->register_sim_regno
== 0)
2583 internal_error ("gdbarch: gdbarch_register_sim_regno invalid");
2584 if (gdbarch_debug
>= 2)
2585 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_sim_regno called\n");
2586 return gdbarch
->register_sim_regno (reg_nr
);
2590 set_gdbarch_register_sim_regno (struct gdbarch
*gdbarch
,
2591 gdbarch_register_sim_regno_ftype register_sim_regno
)
2593 gdbarch
->register_sim_regno
= register_sim_regno
;
2597 gdbarch_use_generic_dummy_frames (struct gdbarch
*gdbarch
)
2599 if (gdbarch
->use_generic_dummy_frames
== -1)
2600 internal_error ("gdbarch: gdbarch_use_generic_dummy_frames invalid");
2601 if (gdbarch_debug
>= 2)
2602 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_generic_dummy_frames called\n");
2603 return gdbarch
->use_generic_dummy_frames
;
2607 set_gdbarch_use_generic_dummy_frames (struct gdbarch
*gdbarch
,
2608 int use_generic_dummy_frames
)
2610 gdbarch
->use_generic_dummy_frames
= use_generic_dummy_frames
;
2614 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
2616 if (gdbarch
->call_dummy_location
== 0)
2617 internal_error ("gdbarch: gdbarch_call_dummy_location invalid");
2618 if (gdbarch_debug
>= 2)
2619 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
2620 return gdbarch
->call_dummy_location
;
2624 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
2625 int call_dummy_location
)
2627 gdbarch
->call_dummy_location
= call_dummy_location
;
2631 gdbarch_call_dummy_address (struct gdbarch
*gdbarch
)
2633 if (gdbarch
->call_dummy_address
== 0)
2634 internal_error ("gdbarch: gdbarch_call_dummy_address invalid");
2635 if (gdbarch_debug
>= 2)
2636 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_address called\n");
2637 return gdbarch
->call_dummy_address ();
2641 set_gdbarch_call_dummy_address (struct gdbarch
*gdbarch
,
2642 gdbarch_call_dummy_address_ftype call_dummy_address
)
2644 gdbarch
->call_dummy_address
= call_dummy_address
;
2648 gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
)
2650 if (gdbarch
->call_dummy_start_offset
== -1)
2651 internal_error ("gdbarch: gdbarch_call_dummy_start_offset invalid");
2652 if (gdbarch_debug
>= 2)
2653 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_start_offset called\n");
2654 return gdbarch
->call_dummy_start_offset
;
2658 set_gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
,
2659 CORE_ADDR call_dummy_start_offset
)
2661 gdbarch
->call_dummy_start_offset
= call_dummy_start_offset
;
2665 gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
)
2667 if (gdbarch
->call_dummy_breakpoint_offset
== -1)
2668 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
2669 if (gdbarch_debug
>= 2)
2670 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset called\n");
2671 return gdbarch
->call_dummy_breakpoint_offset
;
2675 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
,
2676 CORE_ADDR call_dummy_breakpoint_offset
)
2678 gdbarch
->call_dummy_breakpoint_offset
= call_dummy_breakpoint_offset
;
2682 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
)
2684 if (gdbarch
->call_dummy_breakpoint_offset_p
== -1)
2685 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
2686 if (gdbarch_debug
>= 2)
2687 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset_p called\n");
2688 return gdbarch
->call_dummy_breakpoint_offset_p
;
2692 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
,
2693 int call_dummy_breakpoint_offset_p
)
2695 gdbarch
->call_dummy_breakpoint_offset_p
= call_dummy_breakpoint_offset_p
;
2699 gdbarch_call_dummy_length (struct gdbarch
*gdbarch
)
2701 if (gdbarch
->call_dummy_length
== -1)
2702 internal_error ("gdbarch: gdbarch_call_dummy_length invalid");
2703 if (gdbarch_debug
>= 2)
2704 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_length called\n");
2705 return gdbarch
->call_dummy_length
;
2709 set_gdbarch_call_dummy_length (struct gdbarch
*gdbarch
,
2710 int call_dummy_length
)
2712 gdbarch
->call_dummy_length
= call_dummy_length
;
2716 gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
2718 if (gdbarch
->pc_in_call_dummy
== 0)
2719 internal_error ("gdbarch: gdbarch_pc_in_call_dummy invalid");
2720 if (gdbarch_debug
>= 2)
2721 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_call_dummy called\n");
2722 return gdbarch
->pc_in_call_dummy (pc
, sp
, frame_address
);
2726 set_gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
,
2727 gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy
)
2729 gdbarch
->pc_in_call_dummy
= pc_in_call_dummy
;
2733 gdbarch_call_dummy_p (struct gdbarch
*gdbarch
)
2735 if (gdbarch
->call_dummy_p
== -1)
2736 internal_error ("gdbarch: gdbarch_call_dummy_p invalid");
2737 if (gdbarch_debug
>= 2)
2738 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_p called\n");
2739 return gdbarch
->call_dummy_p
;
2743 set_gdbarch_call_dummy_p (struct gdbarch
*gdbarch
,
2746 gdbarch
->call_dummy_p
= call_dummy_p
;
2750 gdbarch_call_dummy_words (struct gdbarch
*gdbarch
)
2752 /* Skip verify of call_dummy_words, invalid_p == 0 */
2753 if (gdbarch_debug
>= 2)
2754 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_words called\n");
2755 return gdbarch
->call_dummy_words
;
2759 set_gdbarch_call_dummy_words (struct gdbarch
*gdbarch
,
2760 LONGEST
* call_dummy_words
)
2762 gdbarch
->call_dummy_words
= call_dummy_words
;
2766 gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
)
2768 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
2769 if (gdbarch_debug
>= 2)
2770 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sizeof_call_dummy_words called\n");
2771 return gdbarch
->sizeof_call_dummy_words
;
2775 set_gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
,
2776 int sizeof_call_dummy_words
)
2778 gdbarch
->sizeof_call_dummy_words
= sizeof_call_dummy_words
;
2782 gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
)
2784 if (gdbarch
->call_dummy_stack_adjust_p
== -1)
2785 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
2786 if (gdbarch_debug
>= 2)
2787 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust_p called\n");
2788 return gdbarch
->call_dummy_stack_adjust_p
;
2792 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
,
2793 int call_dummy_stack_adjust_p
)
2795 gdbarch
->call_dummy_stack_adjust_p
= call_dummy_stack_adjust_p
;
2799 gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
)
2801 if (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0)
2802 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust invalid");
2803 if (gdbarch_debug
>= 2)
2804 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust called\n");
2805 return gdbarch
->call_dummy_stack_adjust
;
2809 set_gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
,
2810 int call_dummy_stack_adjust
)
2812 gdbarch
->call_dummy_stack_adjust
= call_dummy_stack_adjust
;
2816 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
)
2818 if (gdbarch
->fix_call_dummy
== 0)
2819 internal_error ("gdbarch: gdbarch_fix_call_dummy invalid");
2820 if (gdbarch_debug
>= 2)
2821 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fix_call_dummy called\n");
2822 gdbarch
->fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
);
2826 set_gdbarch_fix_call_dummy (struct gdbarch
*gdbarch
,
2827 gdbarch_fix_call_dummy_ftype fix_call_dummy
)
2829 gdbarch
->fix_call_dummy
= fix_call_dummy
;
2833 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
2835 if (gdbarch_debug
>= 2)
2836 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
2837 return gdbarch
->believe_pcc_promotion
;
2841 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
2842 int believe_pcc_promotion
)
2844 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
2848 gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
)
2850 if (gdbarch_debug
>= 2)
2851 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion_type called\n");
2852 return gdbarch
->believe_pcc_promotion_type
;
2856 set_gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
,
2857 int believe_pcc_promotion_type
)
2859 gdbarch
->believe_pcc_promotion_type
= believe_pcc_promotion_type
;
2863 gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
, struct type
*formal
, struct type
*actual
)
2865 if (gdbarch
->coerce_float_to_double
== 0)
2866 internal_error ("gdbarch: gdbarch_coerce_float_to_double invalid");
2867 if (gdbarch_debug
>= 2)
2868 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coerce_float_to_double called\n");
2869 return gdbarch
->coerce_float_to_double (formal
, actual
);
2873 set_gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
,
2874 gdbarch_coerce_float_to_double_ftype coerce_float_to_double
)
2876 gdbarch
->coerce_float_to_double
= coerce_float_to_double
;
2880 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
)
2882 if (gdbarch
->get_saved_register
== 0)
2883 internal_error ("gdbarch: gdbarch_get_saved_register invalid");
2884 if (gdbarch_debug
>= 2)
2885 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_saved_register called\n");
2886 gdbarch
->get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
2890 set_gdbarch_get_saved_register (struct gdbarch
*gdbarch
,
2891 gdbarch_get_saved_register_ftype get_saved_register
)
2893 gdbarch
->get_saved_register
= get_saved_register
;
2897 gdbarch_register_convertible (struct gdbarch
*gdbarch
, int nr
)
2899 if (gdbarch
->register_convertible
== 0)
2900 internal_error ("gdbarch: gdbarch_register_convertible invalid");
2901 if (gdbarch_debug
>= 2)
2902 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convertible called\n");
2903 return gdbarch
->register_convertible (nr
);
2907 set_gdbarch_register_convertible (struct gdbarch
*gdbarch
,
2908 gdbarch_register_convertible_ftype register_convertible
)
2910 gdbarch
->register_convertible
= register_convertible
;
2914 gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
2916 if (gdbarch
->register_convert_to_virtual
== 0)
2917 internal_error ("gdbarch: gdbarch_register_convert_to_virtual invalid");
2918 if (gdbarch_debug
>= 2)
2919 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_virtual called\n");
2920 gdbarch
->register_convert_to_virtual (regnum
, type
, from
, to
);
2924 set_gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
,
2925 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual
)
2927 gdbarch
->register_convert_to_virtual
= register_convert_to_virtual
;
2931 gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
2933 if (gdbarch
->register_convert_to_raw
== 0)
2934 internal_error ("gdbarch: gdbarch_register_convert_to_raw invalid");
2935 if (gdbarch_debug
>= 2)
2936 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_raw called\n");
2937 gdbarch
->register_convert_to_raw (type
, regnum
, from
, to
);
2941 set_gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
,
2942 gdbarch_register_convert_to_raw_ftype register_convert_to_raw
)
2944 gdbarch
->register_convert_to_raw
= register_convert_to_raw
;
2948 gdbarch_fetch_pseudo_register (struct gdbarch
*gdbarch
, int regnum
)
2950 if (gdbarch
->fetch_pseudo_register
== 0)
2951 internal_error ("gdbarch: gdbarch_fetch_pseudo_register invalid");
2952 if (gdbarch_debug
>= 2)
2953 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fetch_pseudo_register called\n");
2954 gdbarch
->fetch_pseudo_register (regnum
);
2958 set_gdbarch_fetch_pseudo_register (struct gdbarch
*gdbarch
,
2959 gdbarch_fetch_pseudo_register_ftype fetch_pseudo_register
)
2961 gdbarch
->fetch_pseudo_register
= fetch_pseudo_register
;
2965 gdbarch_store_pseudo_register (struct gdbarch
*gdbarch
, int regnum
)
2967 if (gdbarch
->store_pseudo_register
== 0)
2968 internal_error ("gdbarch: gdbarch_store_pseudo_register invalid");
2969 if (gdbarch_debug
>= 2)
2970 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_pseudo_register called\n");
2971 gdbarch
->store_pseudo_register (regnum
);
2975 set_gdbarch_store_pseudo_register (struct gdbarch
*gdbarch
,
2976 gdbarch_store_pseudo_register_ftype store_pseudo_register
)
2978 gdbarch
->store_pseudo_register
= store_pseudo_register
;
2982 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
)
2984 if (gdbarch
->pointer_to_address
== 0)
2985 internal_error ("gdbarch: gdbarch_pointer_to_address invalid");
2986 if (gdbarch_debug
>= 2)
2987 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
2988 return gdbarch
->pointer_to_address (type
, buf
);
2992 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
2993 gdbarch_pointer_to_address_ftype pointer_to_address
)
2995 gdbarch
->pointer_to_address
= pointer_to_address
;
2999 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, void *buf
, CORE_ADDR addr
)
3001 if (gdbarch
->address_to_pointer
== 0)
3002 internal_error ("gdbarch: gdbarch_address_to_pointer invalid");
3003 if (gdbarch_debug
>= 2)
3004 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
3005 gdbarch
->address_to_pointer (type
, buf
, addr
);
3009 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
3010 gdbarch_address_to_pointer_ftype address_to_pointer
)
3012 gdbarch
->address_to_pointer
= address_to_pointer
;
3016 gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
, struct type
*type
)
3018 if (gdbarch
->return_value_on_stack
== 0)
3019 internal_error ("gdbarch: gdbarch_return_value_on_stack invalid");
3020 if (gdbarch_debug
>= 2)
3021 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value_on_stack called\n");
3022 return gdbarch
->return_value_on_stack (type
);
3026 set_gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
,
3027 gdbarch_return_value_on_stack_ftype return_value_on_stack
)
3029 gdbarch
->return_value_on_stack
= return_value_on_stack
;
3033 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *regbuf
, char *valbuf
)
3035 if (gdbarch
->extract_return_value
== 0)
3036 internal_error ("gdbarch: gdbarch_extract_return_value invalid");
3037 if (gdbarch_debug
>= 2)
3038 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
3039 gdbarch
->extract_return_value (type
, regbuf
, valbuf
);
3043 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
3044 gdbarch_extract_return_value_ftype extract_return_value
)
3046 gdbarch
->extract_return_value
= extract_return_value
;
3050 gdbarch_push_arguments (struct gdbarch
*gdbarch
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
3052 if (gdbarch
->push_arguments
== 0)
3053 internal_error ("gdbarch: gdbarch_push_arguments invalid");
3054 if (gdbarch_debug
>= 2)
3055 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_arguments called\n");
3056 return gdbarch
->push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
3060 set_gdbarch_push_arguments (struct gdbarch
*gdbarch
,
3061 gdbarch_push_arguments_ftype push_arguments
)
3063 gdbarch
->push_arguments
= push_arguments
;
3067 gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
)
3069 if (gdbarch
->push_dummy_frame
== 0)
3070 internal_error ("gdbarch: gdbarch_push_dummy_frame invalid");
3071 if (gdbarch_debug
>= 2)
3072 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_frame called\n");
3073 gdbarch
->push_dummy_frame ();
3077 set_gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
,
3078 gdbarch_push_dummy_frame_ftype push_dummy_frame
)
3080 gdbarch
->push_dummy_frame
= push_dummy_frame
;
3084 gdbarch_push_return_address (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
)
3086 if (gdbarch
->push_return_address
== 0)
3087 internal_error ("gdbarch: gdbarch_push_return_address invalid");
3088 if (gdbarch_debug
>= 2)
3089 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_return_address called\n");
3090 return gdbarch
->push_return_address (pc
, sp
);
3094 set_gdbarch_push_return_address (struct gdbarch
*gdbarch
,
3095 gdbarch_push_return_address_ftype push_return_address
)
3097 gdbarch
->push_return_address
= push_return_address
;
3101 gdbarch_pop_frame (struct gdbarch
*gdbarch
)
3103 if (gdbarch
->pop_frame
== 0)
3104 internal_error ("gdbarch: gdbarch_pop_frame invalid");
3105 if (gdbarch_debug
>= 2)
3106 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pop_frame called\n");
3107 gdbarch
->pop_frame ();
3111 set_gdbarch_pop_frame (struct gdbarch
*gdbarch
,
3112 gdbarch_pop_frame_ftype pop_frame
)
3114 gdbarch
->pop_frame
= pop_frame
;
3118 gdbarch_d10v_make_daddr (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3120 if (gdbarch
->d10v_make_daddr
== 0)
3121 internal_error ("gdbarch: gdbarch_d10v_make_daddr invalid");
3122 if (gdbarch_debug
>= 2)
3123 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_make_daddr called\n");
3124 return gdbarch
->d10v_make_daddr (x
);
3128 set_gdbarch_d10v_make_daddr (struct gdbarch
*gdbarch
,
3129 gdbarch_d10v_make_daddr_ftype d10v_make_daddr
)
3131 gdbarch
->d10v_make_daddr
= d10v_make_daddr
;
3135 gdbarch_d10v_make_iaddr (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3137 if (gdbarch
->d10v_make_iaddr
== 0)
3138 internal_error ("gdbarch: gdbarch_d10v_make_iaddr invalid");
3139 if (gdbarch_debug
>= 2)
3140 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_make_iaddr called\n");
3141 return gdbarch
->d10v_make_iaddr (x
);
3145 set_gdbarch_d10v_make_iaddr (struct gdbarch
*gdbarch
,
3146 gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr
)
3148 gdbarch
->d10v_make_iaddr
= d10v_make_iaddr
;
3152 gdbarch_d10v_daddr_p (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3154 if (gdbarch
->d10v_daddr_p
== 0)
3155 internal_error ("gdbarch: gdbarch_d10v_daddr_p invalid");
3156 if (gdbarch_debug
>= 2)
3157 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_daddr_p called\n");
3158 return gdbarch
->d10v_daddr_p (x
);
3162 set_gdbarch_d10v_daddr_p (struct gdbarch
*gdbarch
,
3163 gdbarch_d10v_daddr_p_ftype d10v_daddr_p
)
3165 gdbarch
->d10v_daddr_p
= d10v_daddr_p
;
3169 gdbarch_d10v_iaddr_p (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3171 if (gdbarch
->d10v_iaddr_p
== 0)
3172 internal_error ("gdbarch: gdbarch_d10v_iaddr_p invalid");
3173 if (gdbarch_debug
>= 2)
3174 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_iaddr_p called\n");
3175 return gdbarch
->d10v_iaddr_p (x
);
3179 set_gdbarch_d10v_iaddr_p (struct gdbarch
*gdbarch
,
3180 gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p
)
3182 gdbarch
->d10v_iaddr_p
= d10v_iaddr_p
;
3186 gdbarch_d10v_convert_daddr_to_raw (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3188 if (gdbarch
->d10v_convert_daddr_to_raw
== 0)
3189 internal_error ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid");
3190 if (gdbarch_debug
>= 2)
3191 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_convert_daddr_to_raw called\n");
3192 return gdbarch
->d10v_convert_daddr_to_raw (x
);
3196 set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch
*gdbarch
,
3197 gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw
)
3199 gdbarch
->d10v_convert_daddr_to_raw
= d10v_convert_daddr_to_raw
;
3203 gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch
*gdbarch
, CORE_ADDR x
)
3205 if (gdbarch
->d10v_convert_iaddr_to_raw
== 0)
3206 internal_error ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid");
3207 if (gdbarch_debug
>= 2)
3208 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_convert_iaddr_to_raw called\n");
3209 return gdbarch
->d10v_convert_iaddr_to_raw (x
);
3213 set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch
*gdbarch
,
3214 gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw
)
3216 gdbarch
->d10v_convert_iaddr_to_raw
= d10v_convert_iaddr_to_raw
;
3220 gdbarch_store_struct_return (struct gdbarch
*gdbarch
, CORE_ADDR addr
, CORE_ADDR sp
)
3222 if (gdbarch
->store_struct_return
== 0)
3223 internal_error ("gdbarch: gdbarch_store_struct_return invalid");
3224 if (gdbarch_debug
>= 2)
3225 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_struct_return called\n");
3226 gdbarch
->store_struct_return (addr
, sp
);
3230 set_gdbarch_store_struct_return (struct gdbarch
*gdbarch
,
3231 gdbarch_store_struct_return_ftype store_struct_return
)
3233 gdbarch
->store_struct_return
= store_struct_return
;
3237 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *valbuf
)
3239 if (gdbarch
->store_return_value
== 0)
3240 internal_error ("gdbarch: gdbarch_store_return_value invalid");
3241 if (gdbarch_debug
>= 2)
3242 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
3243 gdbarch
->store_return_value (type
, valbuf
);
3247 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
3248 gdbarch_store_return_value_ftype store_return_value
)
3250 gdbarch
->store_return_value
= store_return_value
;
3254 gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
, char *regbuf
)
3256 if (gdbarch
->extract_struct_value_address
== 0)
3257 internal_error ("gdbarch: gdbarch_extract_struct_value_address invalid");
3258 if (gdbarch_debug
>= 2)
3259 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_struct_value_address called\n");
3260 return gdbarch
->extract_struct_value_address (regbuf
);
3264 set_gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
,
3265 gdbarch_extract_struct_value_address_ftype extract_struct_value_address
)
3267 gdbarch
->extract_struct_value_address
= extract_struct_value_address
;
3271 gdbarch_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
3273 if (gdbarch
->use_struct_convention
== 0)
3274 internal_error ("gdbarch: gdbarch_use_struct_convention invalid");
3275 if (gdbarch_debug
>= 2)
3276 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_struct_convention called\n");
3277 return gdbarch
->use_struct_convention (gcc_p
, value_type
);
3281 set_gdbarch_use_struct_convention (struct gdbarch
*gdbarch
,
3282 gdbarch_use_struct_convention_ftype use_struct_convention
)
3284 gdbarch
->use_struct_convention
= use_struct_convention
;
3288 gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3290 if (gdbarch
->frame_init_saved_regs
== 0)
3291 internal_error ("gdbarch: gdbarch_frame_init_saved_regs invalid");
3292 if (gdbarch_debug
>= 2)
3293 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_init_saved_regs called\n");
3294 gdbarch
->frame_init_saved_regs (frame
);
3298 set_gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
,
3299 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs
)
3301 gdbarch
->frame_init_saved_regs
= frame_init_saved_regs
;
3305 gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*frame
)
3307 if (gdbarch
->init_extra_frame_info
== 0)
3308 internal_error ("gdbarch: gdbarch_init_extra_frame_info invalid");
3309 if (gdbarch_debug
>= 2)
3310 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_extra_frame_info called\n");
3311 gdbarch
->init_extra_frame_info (fromleaf
, frame
);
3315 set_gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
,
3316 gdbarch_init_extra_frame_info_ftype init_extra_frame_info
)
3318 gdbarch
->init_extra_frame_info
= init_extra_frame_info
;
3322 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
3324 if (gdbarch
->skip_prologue
== 0)
3325 internal_error ("gdbarch: gdbarch_skip_prologue invalid");
3326 if (gdbarch_debug
>= 2)
3327 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
3328 return gdbarch
->skip_prologue (ip
);
3332 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
3333 gdbarch_skip_prologue_ftype skip_prologue
)
3335 gdbarch
->skip_prologue
= skip_prologue
;
3339 gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
3341 if (gdbarch
->prologue_frameless_p
== 0)
3342 internal_error ("gdbarch: gdbarch_prologue_frameless_p invalid");
3343 if (gdbarch_debug
>= 2)
3344 fprintf_unfiltered (gdb_stdlog
, "gdbarch_prologue_frameless_p called\n");
3345 return gdbarch
->prologue_frameless_p (ip
);
3349 set_gdbarch_prologue_frameless_p (struct gdbarch
*gdbarch
,
3350 gdbarch_prologue_frameless_p_ftype prologue_frameless_p
)
3352 gdbarch
->prologue_frameless_p
= prologue_frameless_p
;
3356 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
3358 if (gdbarch
->inner_than
== 0)
3359 internal_error ("gdbarch: gdbarch_inner_than invalid");
3360 if (gdbarch_debug
>= 2)
3361 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
3362 return gdbarch
->inner_than (lhs
, rhs
);
3366 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
3367 gdbarch_inner_than_ftype inner_than
)
3369 gdbarch
->inner_than
= inner_than
;
3373 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
3375 if (gdbarch
->breakpoint_from_pc
== 0)
3376 internal_error ("gdbarch: gdbarch_breakpoint_from_pc invalid");
3377 if (gdbarch_debug
>= 2)
3378 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
3379 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
3383 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
3384 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
3386 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
3390 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
3392 if (gdbarch
->memory_insert_breakpoint
== 0)
3393 internal_error ("gdbarch: gdbarch_memory_insert_breakpoint invalid");
3394 if (gdbarch_debug
>= 2)
3395 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
3396 return gdbarch
->memory_insert_breakpoint (addr
, contents_cache
);
3400 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
3401 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
3403 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
3407 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
3409 if (gdbarch
->memory_remove_breakpoint
== 0)
3410 internal_error ("gdbarch: gdbarch_memory_remove_breakpoint invalid");
3411 if (gdbarch_debug
>= 2)
3412 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
3413 return gdbarch
->memory_remove_breakpoint (addr
, contents_cache
);
3417 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
3418 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
3420 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
3424 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
3426 if (gdbarch
->decr_pc_after_break
== -1)
3427 internal_error ("gdbarch: gdbarch_decr_pc_after_break invalid");
3428 if (gdbarch_debug
>= 2)
3429 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
3430 return gdbarch
->decr_pc_after_break
;
3434 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
3435 CORE_ADDR decr_pc_after_break
)
3437 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
3441 gdbarch_function_start_offset (struct gdbarch
*gdbarch
)
3443 if (gdbarch
->function_start_offset
== -1)
3444 internal_error ("gdbarch: gdbarch_function_start_offset invalid");
3445 if (gdbarch_debug
>= 2)
3446 fprintf_unfiltered (gdb_stdlog
, "gdbarch_function_start_offset called\n");
3447 return gdbarch
->function_start_offset
;
3451 set_gdbarch_function_start_offset (struct gdbarch
*gdbarch
,
3452 CORE_ADDR function_start_offset
)
3454 gdbarch
->function_start_offset
= function_start_offset
;
3458 gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
, CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
)
3460 if (gdbarch
->remote_translate_xfer_address
== 0)
3461 internal_error ("gdbarch: gdbarch_remote_translate_xfer_address invalid");
3462 if (gdbarch_debug
>= 2)
3463 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_translate_xfer_address called\n");
3464 gdbarch
->remote_translate_xfer_address (gdb_addr
, gdb_len
, rem_addr
, rem_len
);
3468 set_gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
3469 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address
)
3471 gdbarch
->remote_translate_xfer_address
= remote_translate_xfer_address
;
3475 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
3477 if (gdbarch
->frame_args_skip
== -1)
3478 internal_error ("gdbarch: gdbarch_frame_args_skip invalid");
3479 if (gdbarch_debug
>= 2)
3480 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
3481 return gdbarch
->frame_args_skip
;
3485 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
3486 CORE_ADDR frame_args_skip
)
3488 gdbarch
->frame_args_skip
= frame_args_skip
;
3492 gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3494 if (gdbarch
->frameless_function_invocation
== 0)
3495 internal_error ("gdbarch: gdbarch_frameless_function_invocation invalid");
3496 if (gdbarch_debug
>= 2)
3497 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frameless_function_invocation called\n");
3498 return gdbarch
->frameless_function_invocation (fi
);
3502 set_gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
,
3503 gdbarch_frameless_function_invocation_ftype frameless_function_invocation
)
3505 gdbarch
->frameless_function_invocation
= frameless_function_invocation
;
3509 gdbarch_frame_chain (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3511 if (gdbarch
->frame_chain
== 0)
3512 internal_error ("gdbarch: gdbarch_frame_chain invalid");
3513 if (gdbarch_debug
>= 2)
3514 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain called\n");
3515 return gdbarch
->frame_chain (frame
);
3519 set_gdbarch_frame_chain (struct gdbarch
*gdbarch
,
3520 gdbarch_frame_chain_ftype frame_chain
)
3522 gdbarch
->frame_chain
= frame_chain
;
3526 gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
, CORE_ADDR chain
, struct frame_info
*thisframe
)
3528 if (gdbarch
->frame_chain_valid
== 0)
3529 internal_error ("gdbarch: gdbarch_frame_chain_valid invalid");
3530 if (gdbarch_debug
>= 2)
3531 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain_valid called\n");
3532 return gdbarch
->frame_chain_valid (chain
, thisframe
);
3536 set_gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
,
3537 gdbarch_frame_chain_valid_ftype frame_chain_valid
)
3539 gdbarch
->frame_chain_valid
= frame_chain_valid
;
3543 gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3545 if (gdbarch
->frame_saved_pc
== 0)
3546 internal_error ("gdbarch: gdbarch_frame_saved_pc invalid");
3547 if (gdbarch_debug
>= 2)
3548 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_saved_pc called\n");
3549 return gdbarch
->frame_saved_pc (fi
);
3553 set_gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
,
3554 gdbarch_frame_saved_pc_ftype frame_saved_pc
)
3556 gdbarch
->frame_saved_pc
= frame_saved_pc
;
3560 gdbarch_frame_args_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3562 if (gdbarch
->frame_args_address
== 0)
3563 internal_error ("gdbarch: gdbarch_frame_args_address invalid");
3564 if (gdbarch_debug
>= 2)
3565 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_address called\n");
3566 return gdbarch
->frame_args_address (fi
);
3570 set_gdbarch_frame_args_address (struct gdbarch
*gdbarch
,
3571 gdbarch_frame_args_address_ftype frame_args_address
)
3573 gdbarch
->frame_args_address
= frame_args_address
;
3577 gdbarch_frame_locals_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
3579 if (gdbarch
->frame_locals_address
== 0)
3580 internal_error ("gdbarch: gdbarch_frame_locals_address invalid");
3581 if (gdbarch_debug
>= 2)
3582 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_locals_address called\n");
3583 return gdbarch
->frame_locals_address (fi
);
3587 set_gdbarch_frame_locals_address (struct gdbarch
*gdbarch
,
3588 gdbarch_frame_locals_address_ftype frame_locals_address
)
3590 gdbarch
->frame_locals_address
= frame_locals_address
;
3594 gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3596 if (gdbarch
->saved_pc_after_call
== 0)
3597 internal_error ("gdbarch: gdbarch_saved_pc_after_call invalid");
3598 if (gdbarch_debug
>= 2)
3599 fprintf_unfiltered (gdb_stdlog
, "gdbarch_saved_pc_after_call called\n");
3600 return gdbarch
->saved_pc_after_call (frame
);
3604 set_gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
,
3605 gdbarch_saved_pc_after_call_ftype saved_pc_after_call
)
3607 gdbarch
->saved_pc_after_call
= saved_pc_after_call
;
3611 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
3613 if (gdbarch
->frame_num_args
== 0)
3614 internal_error ("gdbarch: gdbarch_frame_num_args invalid");
3615 if (gdbarch_debug
>= 2)
3616 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
3617 return gdbarch
->frame_num_args (frame
);
3621 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
3622 gdbarch_frame_num_args_ftype frame_num_args
)
3624 gdbarch
->frame_num_args
= frame_num_args
;
3628 gdbarch_stack_align_p (struct gdbarch
*gdbarch
)
3630 return gdbarch
->stack_align
!= 0;
3634 gdbarch_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
3636 if (gdbarch
->stack_align
== 0)
3637 internal_error ("gdbarch: gdbarch_stack_align invalid");
3638 if (gdbarch_debug
>= 2)
3639 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stack_align called\n");
3640 return gdbarch
->stack_align (sp
);
3644 set_gdbarch_stack_align (struct gdbarch
*gdbarch
,
3645 gdbarch_stack_align_ftype stack_align
)
3647 gdbarch
->stack_align
= stack_align
;
3651 gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
)
3653 /* Skip verify of extra_stack_alignment_needed, invalid_p == 0 */
3654 if (gdbarch_debug
>= 2)
3655 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extra_stack_alignment_needed called\n");
3656 return gdbarch
->extra_stack_alignment_needed
;
3660 set_gdbarch_extra_stack_alignment_needed (struct gdbarch
*gdbarch
,
3661 int extra_stack_alignment_needed
)
3663 gdbarch
->extra_stack_alignment_needed
= extra_stack_alignment_needed
;
3667 gdbarch_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
3669 return gdbarch
->reg_struct_has_addr
!= 0;
3673 gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
3675 if (gdbarch
->reg_struct_has_addr
== 0)
3676 internal_error ("gdbarch: gdbarch_reg_struct_has_addr invalid");
3677 if (gdbarch_debug
>= 2)
3678 fprintf_unfiltered (gdb_stdlog
, "gdbarch_reg_struct_has_addr called\n");
3679 return gdbarch
->reg_struct_has_addr (gcc_p
, type
);
3683 set_gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
,
3684 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr
)
3686 gdbarch
->reg_struct_has_addr
= reg_struct_has_addr
;
3690 gdbarch_save_dummy_frame_tos_p (struct gdbarch
*gdbarch
)
3692 return gdbarch
->save_dummy_frame_tos
!= 0;
3696 gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
3698 if (gdbarch
->save_dummy_frame_tos
== 0)
3699 internal_error ("gdbarch: gdbarch_save_dummy_frame_tos invalid");
3700 if (gdbarch_debug
>= 2)
3701 fprintf_unfiltered (gdb_stdlog
, "gdbarch_save_dummy_frame_tos called\n");
3702 gdbarch
->save_dummy_frame_tos (sp
);
3706 set_gdbarch_save_dummy_frame_tos (struct gdbarch
*gdbarch
,
3707 gdbarch_save_dummy_frame_tos_ftype save_dummy_frame_tos
)
3709 gdbarch
->save_dummy_frame_tos
= save_dummy_frame_tos
;
3712 const struct floatformat
*
3713 gdbarch_float_format (struct gdbarch
*gdbarch
)
3715 if (gdbarch_debug
>= 2)
3716 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_format called\n");
3717 return gdbarch
->float_format
;
3721 set_gdbarch_float_format (struct gdbarch
*gdbarch
,
3722 const struct floatformat
* float_format
)
3724 gdbarch
->float_format
= float_format
;
3727 const struct floatformat
*
3728 gdbarch_double_format (struct gdbarch
*gdbarch
)
3730 if (gdbarch_debug
>= 2)
3731 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_format called\n");
3732 return gdbarch
->double_format
;
3736 set_gdbarch_double_format (struct gdbarch
*gdbarch
,
3737 const struct floatformat
* double_format
)
3739 gdbarch
->double_format
= double_format
;
3742 const struct floatformat
*
3743 gdbarch_long_double_format (struct gdbarch
*gdbarch
)
3745 if (gdbarch_debug
>= 2)
3746 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_format called\n");
3747 return gdbarch
->long_double_format
;
3751 set_gdbarch_long_double_format (struct gdbarch
*gdbarch
,
3752 const struct floatformat
* long_double_format
)
3754 gdbarch
->long_double_format
= long_double_format
;
3758 gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
3760 if (gdbarch
->convert_from_func_ptr_addr
== 0)
3761 internal_error ("gdbarch: gdbarch_convert_from_func_ptr_addr invalid");
3762 if (gdbarch_debug
>= 2)
3763 fprintf_unfiltered (gdb_stdlog
, "gdbarch_convert_from_func_ptr_addr called\n");
3764 return gdbarch
->convert_from_func_ptr_addr (addr
);
3768 set_gdbarch_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
3769 gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr
)
3771 gdbarch
->convert_from_func_ptr_addr
= convert_from_func_ptr_addr
;
3775 /* Keep a registrary of per-architecture data-pointers required by GDB
3783 struct gdbarch_data_registration
3785 gdbarch_data_ftype
*init
;
3786 struct gdbarch_data
*data
;
3787 struct gdbarch_data_registration
*next
;
3790 struct gdbarch_data_registrary
3793 struct gdbarch_data_registration
*registrations
;
3796 struct gdbarch_data_registrary gdbarch_data_registrary
=
3801 struct gdbarch_data
*
3802 register_gdbarch_data (gdbarch_data_ftype
*init
)
3804 struct gdbarch_data_registration
**curr
;
3805 for (curr
= &gdbarch_data_registrary
.registrations
;
3807 curr
= &(*curr
)->next
);
3808 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
3809 (*curr
)->next
= NULL
;
3810 (*curr
)->init
= init
;
3811 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
3812 (*curr
)->data
->index
= gdbarch_data_registrary
.nr
++;
3813 return (*curr
)->data
;
3817 /* Walk through all the registered users initializing each in turn. */
3820 init_gdbarch_data (struct gdbarch
*gdbarch
)
3822 struct gdbarch_data_registration
*rego
;
3823 gdbarch
->nr_data
= gdbarch_data_registrary
.nr
+ 1;
3824 gdbarch
->data
= xmalloc (sizeof (void*) * gdbarch
->nr_data
);
3825 for (rego
= gdbarch_data_registrary
.registrations
;
3829 if (rego
->data
->index
< gdbarch
->nr_data
)
3830 gdbarch
->data
[rego
->data
->index
] = rego
->init ();
3835 /* Return the current value of the specified per-architecture
3839 gdbarch_data (struct gdbarch_data
*data
)
3841 if (data
->index
>= current_gdbarch
->nr_data
)
3842 internal_error ("gdbarch_data: request for non-existant data.");
3843 return current_gdbarch
->data
[data
->index
];
3848 /* Keep a registrary of swapped data required by GDB modules. */
3853 struct gdbarch_swap_registration
*source
;
3854 struct gdbarch_swap
*next
;
3857 struct gdbarch_swap_registration
3860 unsigned long sizeof_data
;
3861 gdbarch_swap_ftype
*init
;
3862 struct gdbarch_swap_registration
*next
;
3865 struct gdbarch_swap_registrary
3868 struct gdbarch_swap_registration
*registrations
;
3871 struct gdbarch_swap_registrary gdbarch_swap_registrary
=
3877 register_gdbarch_swap (void *data
,
3878 unsigned long sizeof_data
,
3879 gdbarch_swap_ftype
*init
)
3881 struct gdbarch_swap_registration
**rego
;
3882 for (rego
= &gdbarch_swap_registrary
.registrations
;
3884 rego
= &(*rego
)->next
);
3885 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
3886 (*rego
)->next
= NULL
;
3887 (*rego
)->init
= init
;
3888 (*rego
)->data
= data
;
3889 (*rego
)->sizeof_data
= sizeof_data
;
3894 init_gdbarch_swap (struct gdbarch
*gdbarch
)
3896 struct gdbarch_swap_registration
*rego
;
3897 struct gdbarch_swap
**curr
= &gdbarch
->swap
;
3898 for (rego
= gdbarch_swap_registrary
.registrations
;
3902 if (rego
->data
!= NULL
)
3904 (*curr
) = XMALLOC (struct gdbarch_swap
);
3905 (*curr
)->source
= rego
;
3906 (*curr
)->swap
= xmalloc (rego
->sizeof_data
);
3907 (*curr
)->next
= NULL
;
3908 memset (rego
->data
, 0, rego
->sizeof_data
);
3909 curr
= &(*curr
)->next
;
3911 if (rego
->init
!= NULL
)
3917 swapout_gdbarch_swap (struct gdbarch
*gdbarch
)
3919 struct gdbarch_swap
*curr
;
3920 for (curr
= gdbarch
->swap
;
3923 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
3927 swapin_gdbarch_swap (struct gdbarch
*gdbarch
)
3929 struct gdbarch_swap
*curr
;
3930 for (curr
= gdbarch
->swap
;
3933 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
3937 /* Keep a registrary of the architectures known by GDB. */
3939 struct gdbarch_registration
3941 enum bfd_architecture bfd_architecture
;
3942 gdbarch_init_ftype
*init
;
3943 gdbarch_dump_tdep_ftype
*dump_tdep
;
3944 struct gdbarch_list
*arches
;
3945 struct gdbarch_registration
*next
;
3948 static struct gdbarch_registration
*gdbarch_registrary
= NULL
;
3951 append_name (const char ***buf
, int *nr
, const char *name
)
3953 *buf
= xrealloc (*buf
, sizeof (char**) * (*nr
+ 1));
3959 gdbarch_printable_names (void)
3963 /* Accumulate a list of names based on the registed list of
3965 enum bfd_architecture a
;
3967 const char **arches
= NULL
;
3968 struct gdbarch_registration
*rego
;
3969 for (rego
= gdbarch_registrary
;
3973 const struct bfd_arch_info
*ap
;
3974 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3976 internal_error ("gdbarch_architecture_names: multi-arch unknown");
3979 append_name (&arches
, &nr_arches
, ap
->printable_name
);
3984 append_name (&arches
, &nr_arches
, NULL
);
3988 /* Just return all the architectures that BFD knows. Assume that
3989 the legacy architecture framework supports them. */
3990 return bfd_arch_list ();
3995 gdbarch_register (enum bfd_architecture bfd_architecture
,
3996 gdbarch_init_ftype
*init
,
3997 gdbarch_dump_tdep_ftype
*dump_tdep
)
3999 struct gdbarch_registration
**curr
;
4000 const struct bfd_arch_info
*bfd_arch_info
;
4001 /* Check that BFD reconizes this architecture */
4002 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
4003 if (bfd_arch_info
== NULL
)
4005 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture
);
4007 /* Check that we haven't seen this architecture before */
4008 for (curr
= &gdbarch_registrary
;
4010 curr
= &(*curr
)->next
)
4012 if (bfd_architecture
== (*curr
)->bfd_architecture
)
4013 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
4014 bfd_arch_info
->printable_name
);
4018 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
4019 bfd_arch_info
->printable_name
,
4022 (*curr
) = XMALLOC (struct gdbarch_registration
);
4023 (*curr
)->bfd_architecture
= bfd_architecture
;
4024 (*curr
)->init
= init
;
4025 (*curr
)->dump_tdep
= dump_tdep
;
4026 (*curr
)->arches
= NULL
;
4027 (*curr
)->next
= NULL
;
4028 /* When non- multi-arch, install what ever target dump routine we've
4029 been provided - hopefully that routine has been writen correct
4030 and works regardless of multi-arch. */
4031 if (!GDB_MULTI_ARCH
&& dump_tdep
!= NULL
4032 && startup_gdbarch
.dump_tdep
== NULL
)
4033 startup_gdbarch
.dump_tdep
= dump_tdep
;
4037 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
4038 gdbarch_init_ftype
*init
)
4040 gdbarch_register (bfd_architecture
, init
, NULL
);
4044 /* Look for an architecture using gdbarch_info. Base search on only
4045 BFD_ARCH_INFO and BYTE_ORDER. */
4047 struct gdbarch_list
*
4048 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
4049 const struct gdbarch_info
*info
)
4051 for (; arches
!= NULL
; arches
= arches
->next
)
4053 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
4055 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
4063 /* Update the current architecture. Return ZERO if the update request
4067 gdbarch_update_p (struct gdbarch_info info
)
4069 struct gdbarch
*new_gdbarch
;
4070 struct gdbarch_list
**list
;
4071 struct gdbarch_registration
*rego
;
4073 /* Fill in any missing bits. Most important is the bfd_architecture
4074 which is used to select the target architecture. */
4075 if (info
.bfd_architecture
== bfd_arch_unknown
)
4077 if (info
.bfd_arch_info
!= NULL
)
4078 info
.bfd_architecture
= info
.bfd_arch_info
->arch
;
4079 else if (info
.abfd
!= NULL
)
4080 info
.bfd_architecture
= bfd_get_arch (info
.abfd
);
4081 /* FIXME - should query BFD for its default architecture. */
4083 info
.bfd_architecture
= current_gdbarch
->bfd_arch_info
->arch
;
4085 if (info
.bfd_arch_info
== NULL
)
4087 if (target_architecture_auto
&& info
.abfd
!= NULL
)
4088 info
.bfd_arch_info
= bfd_get_arch_info (info
.abfd
);
4090 info
.bfd_arch_info
= current_gdbarch
->bfd_arch_info
;
4092 if (info
.byte_order
== 0)
4094 if (target_byte_order_auto
&& info
.abfd
!= NULL
)
4095 info
.byte_order
= (bfd_big_endian (info
.abfd
) ? BIG_ENDIAN
4096 : bfd_little_endian (info
.abfd
) ? LITTLE_ENDIAN
4099 info
.byte_order
= current_gdbarch
->byte_order
;
4100 /* FIXME - should query BFD for its default byte-order. */
4102 /* A default for abfd? */
4104 /* Find the target that knows about this architecture. */
4105 for (rego
= gdbarch_registrary
;
4108 if (rego
->bfd_architecture
== info
.bfd_architecture
)
4113 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: No matching architecture\n");
4119 fprintf_unfiltered (gdb_stdlog
,
4120 "gdbarch_update: info.bfd_architecture %d (%s)\n",
4121 info
.bfd_architecture
,
4122 bfd_lookup_arch (info
.bfd_architecture
, 0)->printable_name
);
4123 fprintf_unfiltered (gdb_stdlog
,
4124 "gdbarch_update: info.bfd_arch_info %s\n",
4125 (info
.bfd_arch_info
!= NULL
4126 ? info
.bfd_arch_info
->printable_name
4128 fprintf_unfiltered (gdb_stdlog
,
4129 "gdbarch_update: info.byte_order %d (%s)\n",
4131 (info
.byte_order
== BIG_ENDIAN
? "big"
4132 : info
.byte_order
== LITTLE_ENDIAN
? "little"
4134 fprintf_unfiltered (gdb_stdlog
,
4135 "gdbarch_update: info.abfd 0x%lx\n",
4137 fprintf_unfiltered (gdb_stdlog
,
4138 "gdbarch_update: info.tdep_info 0x%lx\n",
4139 (long) info
.tdep_info
);
4142 /* Ask the target for a replacement architecture. */
4143 new_gdbarch
= rego
->init (info
, rego
->arches
);
4145 /* Did the target like it? No. Reject the change. */
4146 if (new_gdbarch
== NULL
)
4149 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Target rejected architecture\n");
4153 /* Did the architecture change? No. Do nothing. */
4154 if (current_gdbarch
== new_gdbarch
)
4157 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
4159 new_gdbarch
->bfd_arch_info
->printable_name
);
4163 /* Swap all data belonging to the old target out */
4164 swapout_gdbarch_swap (current_gdbarch
);
4166 /* Is this a pre-existing architecture? Yes. Swap it in. */
4167 for (list
= ®o
->arches
;
4169 list
= &(*list
)->next
)
4171 if ((*list
)->gdbarch
== new_gdbarch
)
4174 fprintf_unfiltered (gdb_stdlog
,
4175 "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
4177 new_gdbarch
->bfd_arch_info
->printable_name
);
4178 current_gdbarch
= new_gdbarch
;
4179 swapin_gdbarch_swap (new_gdbarch
);
4184 /* Append this new architecture to this targets list. */
4185 (*list
) = XMALLOC (struct gdbarch_list
);
4186 (*list
)->next
= NULL
;
4187 (*list
)->gdbarch
= new_gdbarch
;
4189 /* Switch to this new architecture. Dump it out. */
4190 current_gdbarch
= new_gdbarch
;
4193 fprintf_unfiltered (gdb_stdlog
,
4194 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
4196 new_gdbarch
->bfd_arch_info
->printable_name
);
4199 /* Check that the newly installed architecture is valid. Plug in
4200 any post init values. */
4201 new_gdbarch
->dump_tdep
= rego
->dump_tdep
;
4202 verify_gdbarch (new_gdbarch
);
4204 /* Initialize the per-architecture memory (swap) areas.
4205 CURRENT_GDBARCH must be update before these modules are
4207 init_gdbarch_swap (new_gdbarch
);
4209 /* Initialize the per-architecture data-pointer of all parties that
4210 registered an interest in this architecture. CURRENT_GDBARCH
4211 must be updated before these modules are called. */
4212 init_gdbarch_data (new_gdbarch
);
4215 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
4223 /* Pointer to the target-dependent disassembly function. */
4224 int (*tm_print_insn
) (bfd_vma
, disassemble_info
*);
4225 disassemble_info tm_print_insn_info
;
4228 extern void _initialize_gdbarch (void);
4231 _initialize_gdbarch (void)
4233 struct cmd_list_element
*c
;
4235 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
4236 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
4237 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
4238 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
4239 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;
4241 add_show_from_set (add_set_cmd ("arch",
4244 (char *)&gdbarch_debug
,
4245 "Set architecture debugging.\n\
4246 When non-zero, architecture debugging is enabled.", &setdebuglist
),
4248 c
= add_set_cmd ("archdebug",
4251 (char *)&gdbarch_debug
,
4252 "Set architecture debugging.\n\
4253 When non-zero, architecture debugging is enabled.", &setlist
);
4255 deprecate_cmd (c
, "set debug arch");
4256 deprecate_cmd (add_show_from_set (c
, &showlist
), "show debug arch");