1 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
3 /* Dynamic architecture support for GDB, the GNU debugger.
4 Copyright 1998-1999, Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This file was created with the aid of ``gdbarch.sh''.
25 The bourn shell script ``gdbarch.sh'' creates the files
26 ``new-gdbarch.c'' and ``new-gdbarch.h and then compares them
27 against the existing ``gdbarch.[hc]''. Any differences found
30 If editing this file, please also run gdbarch.sh and merge any
31 changes into that script. Conversely, when makeing sweeping changes
32 to this file, modifying gdbarch.sh and using its output may prove
37 #include "arch-utils.h"
41 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
43 /* Just include everything in sight so that the every old definition
44 of macro is visible. */
45 #include "gdb_string.h"
50 #include "breakpoint.h"
55 #include "gdbthread.h"
57 #include "symfile.h" /* for overlay functions */
62 /* Static function declarations */
64 static void verify_gdbarch (struct gdbarch
*gdbarch
);
65 static void init_gdbarch_data (struct gdbarch
*);
66 static void init_gdbarch_swap (struct gdbarch
*);
67 static void swapout_gdbarch_swap (struct gdbarch
*);
68 static void swapin_gdbarch_swap (struct gdbarch
*);
70 /* Convenience macro for allocting typesafe memory. */
73 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
77 /* Non-zero if we want to trace architecture code. */
80 #define GDBARCH_DEBUG 0
82 int gdbarch_debug
= GDBARCH_DEBUG
;
85 /* Maintain the struct gdbarch object */
89 /* basic architectural information */
90 const struct bfd_arch_info
* bfd_arch_info
;
93 /* target specific vector. */
94 struct gdbarch_tdep
*tdep
;
96 /* per-architecture data-pointers */
100 /* per-architecture swap-regions */
101 struct gdbarch_swap
*swap
;
103 /* Multi-arch values.
105 When extending this structure you must:
109 Declare set/get functions and define the corresponding
112 gdbarch_alloc(): If zero/NULL is not a suitable default,
113 initialize the new field.
115 verify_gdbarch(): Confirm that the target updated the field
118 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
121 ``startup_gdbarch()'': Append an initial value to the static
122 variable (base values on the host's c-type system).
124 get_gdbarch(): Implement the set/get functions (probably using
125 the macro's as shortcuts).
139 gdbarch_read_pc_ftype
*read_pc
;
140 gdbarch_write_pc_ftype
*write_pc
;
141 gdbarch_read_fp_ftype
*read_fp
;
142 gdbarch_write_fp_ftype
*write_fp
;
143 gdbarch_read_sp_ftype
*read_sp
;
144 gdbarch_write_sp_ftype
*write_sp
;
149 gdbarch_register_name_ftype
*register_name
;
152 gdbarch_register_byte_ftype
*register_byte
;
153 gdbarch_register_raw_size_ftype
*register_raw_size
;
154 int max_register_raw_size
;
155 gdbarch_register_virtual_size_ftype
*register_virtual_size
;
156 int max_register_virtual_size
;
157 gdbarch_register_virtual_type_ftype
*register_virtual_type
;
158 int use_generic_dummy_frames
;
159 int call_dummy_location
;
160 gdbarch_call_dummy_address_ftype
*call_dummy_address
;
161 CORE_ADDR call_dummy_start_offset
;
162 CORE_ADDR call_dummy_breakpoint_offset
;
163 int call_dummy_breakpoint_offset_p
;
164 int call_dummy_length
;
165 gdbarch_pc_in_call_dummy_ftype
*pc_in_call_dummy
;
167 LONGEST
* call_dummy_words
;
168 int sizeof_call_dummy_words
;
169 int call_dummy_stack_adjust_p
;
170 int call_dummy_stack_adjust
;
171 gdbarch_fix_call_dummy_ftype
*fix_call_dummy
;
172 int believe_pcc_promotion
;
173 int believe_pcc_promotion_type
;
174 gdbarch_coerce_float_to_double_ftype
*coerce_float_to_double
;
175 gdbarch_get_saved_register_ftype
*get_saved_register
;
176 gdbarch_register_convertible_ftype
*register_convertible
;
177 gdbarch_register_convert_to_virtual_ftype
*register_convert_to_virtual
;
178 gdbarch_register_convert_to_raw_ftype
*register_convert_to_raw
;
179 gdbarch_pointer_to_address_ftype
*pointer_to_address
;
180 gdbarch_address_to_pointer_ftype
*address_to_pointer
;
181 gdbarch_return_value_on_stack_ftype
*return_value_on_stack
;
182 gdbarch_extract_return_value_ftype
*extract_return_value
;
183 gdbarch_push_arguments_ftype
*push_arguments
;
184 gdbarch_push_dummy_frame_ftype
*push_dummy_frame
;
185 gdbarch_push_return_address_ftype
*push_return_address
;
186 gdbarch_pop_frame_ftype
*pop_frame
;
187 gdbarch_d10v_make_daddr_ftype
*d10v_make_daddr
;
188 gdbarch_d10v_make_iaddr_ftype
*d10v_make_iaddr
;
189 gdbarch_d10v_daddr_p_ftype
*d10v_daddr_p
;
190 gdbarch_d10v_iaddr_p_ftype
*d10v_iaddr_p
;
191 gdbarch_d10v_convert_daddr_to_raw_ftype
*d10v_convert_daddr_to_raw
;
192 gdbarch_d10v_convert_iaddr_to_raw_ftype
*d10v_convert_iaddr_to_raw
;
193 gdbarch_store_struct_return_ftype
*store_struct_return
;
194 gdbarch_store_return_value_ftype
*store_return_value
;
195 gdbarch_extract_struct_value_address_ftype
*extract_struct_value_address
;
196 gdbarch_use_struct_convention_ftype
*use_struct_convention
;
197 gdbarch_frame_init_saved_regs_ftype
*frame_init_saved_regs
;
198 gdbarch_init_extra_frame_info_ftype
*init_extra_frame_info
;
199 gdbarch_skip_prologue_ftype
*skip_prologue
;
200 gdbarch_inner_than_ftype
*inner_than
;
201 gdbarch_breakpoint_from_pc_ftype
*breakpoint_from_pc
;
202 gdbarch_memory_insert_breakpoint_ftype
*memory_insert_breakpoint
;
203 gdbarch_memory_remove_breakpoint_ftype
*memory_remove_breakpoint
;
204 CORE_ADDR decr_pc_after_break
;
205 CORE_ADDR function_start_offset
;
206 gdbarch_remote_translate_xfer_address_ftype
*remote_translate_xfer_address
;
207 CORE_ADDR frame_args_skip
;
208 gdbarch_frameless_function_invocation_ftype
*frameless_function_invocation
;
209 gdbarch_frame_chain_ftype
*frame_chain
;
210 gdbarch_frame_chain_valid_ftype
*frame_chain_valid
;
211 gdbarch_frame_saved_pc_ftype
*frame_saved_pc
;
212 gdbarch_frame_args_address_ftype
*frame_args_address
;
213 gdbarch_frame_locals_address_ftype
*frame_locals_address
;
214 gdbarch_saved_pc_after_call_ftype
*saved_pc_after_call
;
215 gdbarch_frame_num_args_ftype
*frame_num_args
;
216 gdbarch_stack_align_ftype
*stack_align
;
217 gdbarch_reg_struct_has_addr_ftype
*reg_struct_has_addr
;
221 /* The default architecture uses host values (for want of a better
224 extern const struct bfd_arch_info bfd_default_arch_struct
;
226 struct gdbarch startup_gdbarch
= {
227 /* basic architecture information */
228 &bfd_default_arch_struct
,
230 /* target specific vector */
232 /*per-architecture data-pointers and swap regions */
234 /* Multi-arch values */
240 8 * sizeof (LONGEST
),
243 8 * sizeof (long double),
281 generic_get_saved_register
,
324 /* startup_gdbarch() */
326 struct gdbarch
*current_gdbarch
= &startup_gdbarch
;
329 /* Create a new ``struct gdbarch'' based in information provided by
330 ``struct gdbarch_info''. */
333 gdbarch_alloc (const struct gdbarch_info
*info
,
334 struct gdbarch_tdep
*tdep
)
336 struct gdbarch
*gdbarch
= XMALLOC (struct gdbarch
);
337 memset (gdbarch
, 0, sizeof (*gdbarch
));
339 gdbarch
->tdep
= tdep
;
341 gdbarch
->bfd_arch_info
= info
->bfd_arch_info
;
342 gdbarch
->byte_order
= info
->byte_order
;
344 /* Force the explicit initialization of these. */
345 gdbarch
->bfd_vma_bit
= TARGET_ARCHITECTURE
->bits_per_address
;
346 gdbarch
->num_regs
= -1;
347 gdbarch
->sp_regnum
= -1;
348 gdbarch
->fp_regnum
= -1;
349 gdbarch
->pc_regnum
= -1;
350 gdbarch
->register_name
= legacy_register_name
;
351 gdbarch
->register_size
= -1;
352 gdbarch
->register_bytes
= -1;
353 gdbarch
->max_register_raw_size
= -1;
354 gdbarch
->max_register_virtual_size
= -1;
355 gdbarch
->use_generic_dummy_frames
= -1;
356 gdbarch
->call_dummy_start_offset
= -1;
357 gdbarch
->call_dummy_breakpoint_offset
= -1;
358 gdbarch
->call_dummy_breakpoint_offset_p
= -1;
359 gdbarch
->call_dummy_length
= -1;
360 gdbarch
->call_dummy_p
= -1;
361 gdbarch
->call_dummy_words
= legacy_call_dummy_words
;
362 gdbarch
->sizeof_call_dummy_words
= legacy_sizeof_call_dummy_words
;
363 gdbarch
->call_dummy_stack_adjust_p
= -1;
364 gdbarch
->coerce_float_to_double
= default_coerce_float_to_double
;
365 gdbarch
->register_convertible
= generic_register_convertible_not
;
366 gdbarch
->pointer_to_address
= generic_pointer_to_address
;
367 gdbarch
->address_to_pointer
= generic_address_to_pointer
;
368 gdbarch
->return_value_on_stack
= generic_return_value_on_stack_not
;
369 gdbarch
->breakpoint_from_pc
= legacy_breakpoint_from_pc
;
370 gdbarch
->memory_insert_breakpoint
= default_memory_insert_breakpoint
;
371 gdbarch
->memory_remove_breakpoint
= default_memory_remove_breakpoint
;
372 gdbarch
->decr_pc_after_break
= -1;
373 gdbarch
->function_start_offset
= -1;
374 gdbarch
->remote_translate_xfer_address
= generic_remote_translate_xfer_address
;
375 gdbarch
->frame_args_skip
= -1;
376 gdbarch
->frameless_function_invocation
= generic_frameless_function_invocation_not
;
377 /* gdbarch_alloc() */
383 /* Free a gdbarch struct. This should never happen in normal
384 operation --- once you've created a gdbarch, you keep it around.
385 However, if an architecture's init function encounters an error
386 building the structure, it may need to clean up a partially
387 constructed gdbarch. */
389 gdbarch_free (struct gdbarch
*arch
)
391 /* At the moment, this is trivial. */
396 /* Ensure that all values in a GDBARCH are reasonable. */
399 verify_gdbarch (struct gdbarch
*gdbarch
)
401 /* Only perform sanity checks on a multi-arch target. */
402 if (GDB_MULTI_ARCH
<= 0)
405 if (gdbarch
->byte_order
== 0)
406 internal_error ("verify_gdbarch: byte-order unset");
407 if (gdbarch
->bfd_arch_info
== NULL
)
408 internal_error ("verify_gdbarch: bfd_arch_info unset");
409 /* Check those that need to be defined for the given multi-arch level. */
410 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
411 if ((GDB_MULTI_ARCH
>= 1)
412 && (gdbarch
->ptr_bit
== 0))
413 internal_error ("gdbarch: verify_gdbarch: ptr_bit invalid");
414 if ((GDB_MULTI_ARCH
>= 1)
415 && (gdbarch
->short_bit
== 0))
416 internal_error ("gdbarch: verify_gdbarch: short_bit invalid");
417 if ((GDB_MULTI_ARCH
>= 1)
418 && (gdbarch
->int_bit
== 0))
419 internal_error ("gdbarch: verify_gdbarch: int_bit invalid");
420 if ((GDB_MULTI_ARCH
>= 1)
421 && (gdbarch
->long_bit
== 0))
422 internal_error ("gdbarch: verify_gdbarch: long_bit invalid");
423 if ((GDB_MULTI_ARCH
>= 1)
424 && (gdbarch
->long_long_bit
== 0))
425 internal_error ("gdbarch: verify_gdbarch: long_long_bit invalid");
426 if ((GDB_MULTI_ARCH
>= 1)
427 && (gdbarch
->float_bit
== 0))
428 internal_error ("gdbarch: verify_gdbarch: float_bit invalid");
429 if ((GDB_MULTI_ARCH
>= 1)
430 && (gdbarch
->double_bit
== 0))
431 internal_error ("gdbarch: verify_gdbarch: double_bit invalid");
432 if ((GDB_MULTI_ARCH
>= 1)
433 && (gdbarch
->long_double_bit
== 0))
434 internal_error ("gdbarch: verify_gdbarch: long_double_bit invalid");
435 /* Skip verify of ieee_float, invalid_p == 0 */
436 if ((GDB_MULTI_ARCH
>= 1)
437 && (gdbarch
->read_pc
== 0))
438 internal_error ("gdbarch: verify_gdbarch: read_pc invalid");
439 if ((GDB_MULTI_ARCH
>= 1)
440 && (gdbarch
->write_pc
== 0))
441 internal_error ("gdbarch: verify_gdbarch: write_pc invalid");
442 if ((GDB_MULTI_ARCH
>= 1)
443 && (gdbarch
->read_fp
== 0))
444 internal_error ("gdbarch: verify_gdbarch: read_fp invalid");
445 if ((GDB_MULTI_ARCH
>= 1)
446 && (gdbarch
->write_fp
== 0))
447 internal_error ("gdbarch: verify_gdbarch: write_fp invalid");
448 if ((GDB_MULTI_ARCH
>= 1)
449 && (gdbarch
->read_sp
== 0))
450 internal_error ("gdbarch: verify_gdbarch: read_sp invalid");
451 if ((GDB_MULTI_ARCH
>= 1)
452 && (gdbarch
->write_sp
== 0))
453 internal_error ("gdbarch: verify_gdbarch: write_sp invalid");
454 if ((GDB_MULTI_ARCH
>= 2)
455 && (gdbarch
->num_regs
== -1))
456 internal_error ("gdbarch: verify_gdbarch: num_regs invalid");
457 if ((GDB_MULTI_ARCH
>= 2)
458 && (gdbarch
->sp_regnum
== -1))
459 internal_error ("gdbarch: verify_gdbarch: sp_regnum invalid");
460 if ((GDB_MULTI_ARCH
>= 2)
461 && (gdbarch
->fp_regnum
== -1))
462 internal_error ("gdbarch: verify_gdbarch: fp_regnum invalid");
463 if ((GDB_MULTI_ARCH
>= 2)
464 && (gdbarch
->pc_regnum
== -1))
465 internal_error ("gdbarch: verify_gdbarch: pc_regnum invalid");
466 /* Skip verify of register_name, invalid_p == 0 */
467 if ((GDB_MULTI_ARCH
>= 2)
468 && (gdbarch
->register_size
== -1))
469 internal_error ("gdbarch: verify_gdbarch: register_size invalid");
470 if ((GDB_MULTI_ARCH
>= 2)
471 && (gdbarch
->register_bytes
== -1))
472 internal_error ("gdbarch: verify_gdbarch: register_bytes invalid");
473 if ((GDB_MULTI_ARCH
>= 2)
474 && (gdbarch
->register_byte
== 0))
475 internal_error ("gdbarch: verify_gdbarch: register_byte invalid");
476 if ((GDB_MULTI_ARCH
>= 2)
477 && (gdbarch
->register_raw_size
== 0))
478 internal_error ("gdbarch: verify_gdbarch: register_raw_size invalid");
479 if ((GDB_MULTI_ARCH
>= 2)
480 && (gdbarch
->max_register_raw_size
== -1))
481 internal_error ("gdbarch: verify_gdbarch: max_register_raw_size invalid");
482 if ((GDB_MULTI_ARCH
>= 2)
483 && (gdbarch
->register_virtual_size
== 0))
484 internal_error ("gdbarch: verify_gdbarch: register_virtual_size invalid");
485 if ((GDB_MULTI_ARCH
>= 2)
486 && (gdbarch
->max_register_virtual_size
== -1))
487 internal_error ("gdbarch: verify_gdbarch: max_register_virtual_size invalid");
488 if ((GDB_MULTI_ARCH
>= 2)
489 && (gdbarch
->register_virtual_type
== 0))
490 internal_error ("gdbarch: verify_gdbarch: register_virtual_type invalid");
491 if ((GDB_MULTI_ARCH
>= 1)
492 && (gdbarch
->use_generic_dummy_frames
== -1))
493 internal_error ("gdbarch: verify_gdbarch: use_generic_dummy_frames invalid");
494 if ((GDB_MULTI_ARCH
>= 2)
495 && (gdbarch
->call_dummy_location
== 0))
496 internal_error ("gdbarch: verify_gdbarch: call_dummy_location invalid");
497 if ((GDB_MULTI_ARCH
>= 2)
498 && (gdbarch
->call_dummy_location
== AT_ENTRY_POINT
&& gdbarch
->call_dummy_address
== 0))
499 internal_error ("gdbarch: verify_gdbarch: call_dummy_address invalid");
500 if ((GDB_MULTI_ARCH
>= 2)
501 && (gdbarch
->call_dummy_start_offset
== -1))
502 internal_error ("gdbarch: verify_gdbarch: call_dummy_start_offset invalid");
503 if ((GDB_MULTI_ARCH
>= 2)
504 && (gdbarch
->call_dummy_breakpoint_offset
== -1))
505 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset invalid");
506 if ((GDB_MULTI_ARCH
>= 1)
507 && (gdbarch
->call_dummy_breakpoint_offset_p
== -1))
508 internal_error ("gdbarch: verify_gdbarch: call_dummy_breakpoint_offset_p invalid");
509 if ((GDB_MULTI_ARCH
>= 2)
510 && (gdbarch
->call_dummy_length
== -1))
511 internal_error ("gdbarch: verify_gdbarch: call_dummy_length invalid");
512 if ((GDB_MULTI_ARCH
>= 2)
513 && (gdbarch
->pc_in_call_dummy
== 0))
514 internal_error ("gdbarch: verify_gdbarch: pc_in_call_dummy invalid");
515 if ((GDB_MULTI_ARCH
>= 1)
516 && (gdbarch
->call_dummy_p
== -1))
517 internal_error ("gdbarch: verify_gdbarch: call_dummy_p invalid");
518 /* Skip verify of call_dummy_words, invalid_p == 0 */
519 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
520 if ((GDB_MULTI_ARCH
>= 1)
521 && (gdbarch
->call_dummy_stack_adjust_p
== -1))
522 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust_p invalid");
523 if ((GDB_MULTI_ARCH
>= 2)
524 && (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0))
525 internal_error ("gdbarch: verify_gdbarch: call_dummy_stack_adjust invalid");
526 if ((GDB_MULTI_ARCH
>= 2)
527 && (gdbarch
->fix_call_dummy
== 0))
528 internal_error ("gdbarch: verify_gdbarch: fix_call_dummy invalid");
529 /* Skip verify of coerce_float_to_double, invalid_p == 0 */
530 if ((GDB_MULTI_ARCH
>= 1)
531 && (gdbarch
->get_saved_register
== 0))
532 internal_error ("gdbarch: verify_gdbarch: get_saved_register invalid");
533 /* Skip verify of register_convertible, invalid_p == 0 */
534 /* Skip verify of register_convert_to_virtual, invalid_p == 0 */
535 /* Skip verify of register_convert_to_raw, invalid_p == 0 */
536 /* Skip verify of pointer_to_address, invalid_p == 0 */
537 /* Skip verify of address_to_pointer, invalid_p == 0 */
538 /* Skip verify of return_value_on_stack, invalid_p == 0 */
539 if ((GDB_MULTI_ARCH
>= 2)
540 && (gdbarch
->extract_return_value
== 0))
541 internal_error ("gdbarch: verify_gdbarch: extract_return_value invalid");
542 if ((GDB_MULTI_ARCH
>= 1)
543 && (gdbarch
->push_arguments
== 0))
544 internal_error ("gdbarch: verify_gdbarch: push_arguments invalid");
545 if ((GDB_MULTI_ARCH
>= 2)
546 && (gdbarch
->push_dummy_frame
== 0))
547 internal_error ("gdbarch: verify_gdbarch: push_dummy_frame invalid");
548 if ((GDB_MULTI_ARCH
>= 1)
549 && (gdbarch
->push_return_address
== 0))
550 internal_error ("gdbarch: verify_gdbarch: push_return_address invalid");
551 if ((GDB_MULTI_ARCH
>= 2)
552 && (gdbarch
->pop_frame
== 0))
553 internal_error ("gdbarch: verify_gdbarch: pop_frame invalid");
554 /* Skip verify of d10v_make_daddr, invalid_p == 0 */
555 /* Skip verify of d10v_make_iaddr, invalid_p == 0 */
556 if ((GDB_MULTI_ARCH
>= 2)
557 && (gdbarch
->d10v_daddr_p
== 0))
558 internal_error ("gdbarch: verify_gdbarch: d10v_daddr_p invalid");
559 if ((GDB_MULTI_ARCH
>= 2)
560 && (gdbarch
->d10v_iaddr_p
== 0))
561 internal_error ("gdbarch: verify_gdbarch: d10v_iaddr_p invalid");
562 if ((GDB_MULTI_ARCH
>= 2)
563 && (gdbarch
->d10v_convert_daddr_to_raw
== 0))
564 internal_error ("gdbarch: verify_gdbarch: d10v_convert_daddr_to_raw invalid");
565 if ((GDB_MULTI_ARCH
>= 2)
566 && (gdbarch
->d10v_convert_iaddr_to_raw
== 0))
567 internal_error ("gdbarch: verify_gdbarch: d10v_convert_iaddr_to_raw invalid");
568 if ((GDB_MULTI_ARCH
>= 2)
569 && (gdbarch
->store_struct_return
== 0))
570 internal_error ("gdbarch: verify_gdbarch: store_struct_return invalid");
571 if ((GDB_MULTI_ARCH
>= 2)
572 && (gdbarch
->store_return_value
== 0))
573 internal_error ("gdbarch: verify_gdbarch: store_return_value invalid");
574 if ((GDB_MULTI_ARCH
>= 2)
575 && (gdbarch
->extract_struct_value_address
== 0))
576 internal_error ("gdbarch: verify_gdbarch: extract_struct_value_address invalid");
577 if ((GDB_MULTI_ARCH
>= 2)
578 && (gdbarch
->use_struct_convention
== 0))
579 internal_error ("gdbarch: verify_gdbarch: use_struct_convention invalid");
580 if ((GDB_MULTI_ARCH
>= 2)
581 && (gdbarch
->frame_init_saved_regs
== 0))
582 internal_error ("gdbarch: verify_gdbarch: frame_init_saved_regs invalid");
583 if ((GDB_MULTI_ARCH
>= 2)
584 && (gdbarch
->init_extra_frame_info
== 0))
585 internal_error ("gdbarch: verify_gdbarch: init_extra_frame_info invalid");
586 if ((GDB_MULTI_ARCH
>= 2)
587 && (gdbarch
->skip_prologue
== 0))
588 internal_error ("gdbarch: verify_gdbarch: skip_prologue invalid");
589 if ((GDB_MULTI_ARCH
>= 2)
590 && (gdbarch
->inner_than
== 0))
591 internal_error ("gdbarch: verify_gdbarch: inner_than invalid");
592 /* Skip verify of breakpoint_from_pc, invalid_p == 0 */
593 /* Skip verify of memory_insert_breakpoint, invalid_p == 0 */
594 /* Skip verify of memory_remove_breakpoint, invalid_p == 0 */
595 if ((GDB_MULTI_ARCH
>= 2)
596 && (gdbarch
->decr_pc_after_break
== -1))
597 internal_error ("gdbarch: verify_gdbarch: decr_pc_after_break invalid");
598 if ((GDB_MULTI_ARCH
>= 2)
599 && (gdbarch
->function_start_offset
== -1))
600 internal_error ("gdbarch: verify_gdbarch: function_start_offset invalid");
601 /* Skip verify of remote_translate_xfer_address, invalid_p == 0 */
602 if ((GDB_MULTI_ARCH
>= 2)
603 && (gdbarch
->frame_args_skip
== -1))
604 internal_error ("gdbarch: verify_gdbarch: frame_args_skip invalid");
605 /* Skip verify of frameless_function_invocation, invalid_p == 0 */
606 if ((GDB_MULTI_ARCH
>= 2)
607 && (gdbarch
->frame_chain
== 0))
608 internal_error ("gdbarch: verify_gdbarch: frame_chain invalid");
609 if ((GDB_MULTI_ARCH
>= 1)
610 && (gdbarch
->frame_chain_valid
== 0))
611 internal_error ("gdbarch: verify_gdbarch: frame_chain_valid invalid");
612 if ((GDB_MULTI_ARCH
>= 2)
613 && (gdbarch
->frame_saved_pc
== 0))
614 internal_error ("gdbarch: verify_gdbarch: frame_saved_pc invalid");
615 if ((GDB_MULTI_ARCH
>= 2)
616 && (gdbarch
->frame_args_address
== 0))
617 internal_error ("gdbarch: verify_gdbarch: frame_args_address invalid");
618 if ((GDB_MULTI_ARCH
>= 2)
619 && (gdbarch
->frame_locals_address
== 0))
620 internal_error ("gdbarch: verify_gdbarch: frame_locals_address invalid");
621 if ((GDB_MULTI_ARCH
>= 2)
622 && (gdbarch
->saved_pc_after_call
== 0))
623 internal_error ("gdbarch: verify_gdbarch: saved_pc_after_call invalid");
624 if ((GDB_MULTI_ARCH
>= 2)
625 && (gdbarch
->frame_num_args
== 0))
626 internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid");
627 /* Skip verify of stack_align, has predicate */
628 /* Skip verify of reg_struct_has_addr, has predicate */
632 /* Print out the details of the current architecture. */
637 if (TARGET_ARCHITECTURE
!= NULL
)
638 fprintf_unfiltered (gdb_stdlog
,
639 "gdbarch_update: TARGET_ARCHITECTURE = %s\n",
640 TARGET_ARCHITECTURE
->printable_name
);
641 fprintf_unfiltered (gdb_stdlog
,
642 "gdbarch_update: TARGET_BYTE_ORDER = %ld\n",
643 (long) TARGET_BYTE_ORDER
);
644 fprintf_unfiltered (gdb_stdlog
,
645 "gdbarch_update: TARGET_BFD_VMA_BIT = %ld\n",
646 (long) TARGET_BFD_VMA_BIT
);
647 fprintf_unfiltered (gdb_stdlog
,
648 "gdbarch_update: TARGET_PTR_BIT = %ld\n",
649 (long) TARGET_PTR_BIT
);
650 fprintf_unfiltered (gdb_stdlog
,
651 "gdbarch_update: TARGET_SHORT_BIT = %ld\n",
652 (long) TARGET_SHORT_BIT
);
653 fprintf_unfiltered (gdb_stdlog
,
654 "gdbarch_update: TARGET_INT_BIT = %ld\n",
655 (long) TARGET_INT_BIT
);
656 fprintf_unfiltered (gdb_stdlog
,
657 "gdbarch_update: TARGET_LONG_BIT = %ld\n",
658 (long) TARGET_LONG_BIT
);
659 fprintf_unfiltered (gdb_stdlog
,
660 "gdbarch_update: TARGET_LONG_LONG_BIT = %ld\n",
661 (long) TARGET_LONG_LONG_BIT
);
662 fprintf_unfiltered (gdb_stdlog
,
663 "gdbarch_update: TARGET_FLOAT_BIT = %ld\n",
664 (long) TARGET_FLOAT_BIT
);
665 fprintf_unfiltered (gdb_stdlog
,
666 "gdbarch_update: TARGET_DOUBLE_BIT = %ld\n",
667 (long) TARGET_DOUBLE_BIT
);
668 fprintf_unfiltered (gdb_stdlog
,
669 "gdbarch_update: TARGET_LONG_DOUBLE_BIT = %ld\n",
670 (long) TARGET_LONG_DOUBLE_BIT
);
671 fprintf_unfiltered (gdb_stdlog
,
672 "gdbarch_update: IEEE_FLOAT = %ld\n",
674 fprintf_unfiltered (gdb_stdlog
,
675 "gdbarch_update: TARGET_READ_PC = 0x%08lx\n",
676 (long) current_gdbarch
->read_pc
677 /*TARGET_READ_PC ()*/);
678 fprintf_unfiltered (gdb_stdlog
,
679 "gdbarch_update: TARGET_WRITE_PC = 0x%08lx\n",
680 (long) current_gdbarch
->write_pc
681 /*TARGET_WRITE_PC ()*/);
682 fprintf_unfiltered (gdb_stdlog
,
683 "gdbarch_update: TARGET_READ_FP = 0x%08lx\n",
684 (long) current_gdbarch
->read_fp
685 /*TARGET_READ_FP ()*/);
686 fprintf_unfiltered (gdb_stdlog
,
687 "gdbarch_update: TARGET_WRITE_FP = 0x%08lx\n",
688 (long) current_gdbarch
->write_fp
689 /*TARGET_WRITE_FP ()*/);
690 fprintf_unfiltered (gdb_stdlog
,
691 "gdbarch_update: TARGET_READ_SP = 0x%08lx\n",
692 (long) current_gdbarch
->read_sp
693 /*TARGET_READ_SP ()*/);
694 fprintf_unfiltered (gdb_stdlog
,
695 "gdbarch_update: TARGET_WRITE_SP = 0x%08lx\n",
696 (long) current_gdbarch
->write_sp
697 /*TARGET_WRITE_SP ()*/);
698 fprintf_unfiltered (gdb_stdlog
,
699 "gdbarch_update: NUM_REGS = %ld\n",
701 fprintf_unfiltered (gdb_stdlog
,
702 "gdbarch_update: SP_REGNUM = %ld\n",
704 fprintf_unfiltered (gdb_stdlog
,
705 "gdbarch_update: FP_REGNUM = %ld\n",
707 fprintf_unfiltered (gdb_stdlog
,
708 "gdbarch_update: PC_REGNUM = %ld\n",
710 fprintf_unfiltered (gdb_stdlog
,
711 "gdbarch_update: REGISTER_NAME = 0x%08lx\n",
712 (long) current_gdbarch
->register_name
713 /*REGISTER_NAME ()*/);
714 fprintf_unfiltered (gdb_stdlog
,
715 "gdbarch_update: REGISTER_SIZE = %ld\n",
716 (long) REGISTER_SIZE
);
717 fprintf_unfiltered (gdb_stdlog
,
718 "gdbarch_update: REGISTER_BYTES = %ld\n",
719 (long) REGISTER_BYTES
);
720 fprintf_unfiltered (gdb_stdlog
,
721 "gdbarch_update: REGISTER_BYTE = 0x%08lx\n",
722 (long) current_gdbarch
->register_byte
723 /*REGISTER_BYTE ()*/);
724 fprintf_unfiltered (gdb_stdlog
,
725 "gdbarch_update: REGISTER_RAW_SIZE = 0x%08lx\n",
726 (long) current_gdbarch
->register_raw_size
727 /*REGISTER_RAW_SIZE ()*/);
728 fprintf_unfiltered (gdb_stdlog
,
729 "gdbarch_update: MAX_REGISTER_RAW_SIZE = %ld\n",
730 (long) MAX_REGISTER_RAW_SIZE
);
731 fprintf_unfiltered (gdb_stdlog
,
732 "gdbarch_update: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
733 (long) current_gdbarch
->register_virtual_size
734 /*REGISTER_VIRTUAL_SIZE ()*/);
735 fprintf_unfiltered (gdb_stdlog
,
736 "gdbarch_update: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
737 (long) MAX_REGISTER_VIRTUAL_SIZE
);
738 fprintf_unfiltered (gdb_stdlog
,
739 "gdbarch_update: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
740 (long) current_gdbarch
->register_virtual_type
741 /*REGISTER_VIRTUAL_TYPE ()*/);
742 fprintf_unfiltered (gdb_stdlog
,
743 "gdbarch_update: USE_GENERIC_DUMMY_FRAMES = %ld\n",
744 (long) USE_GENERIC_DUMMY_FRAMES
);
745 fprintf_unfiltered (gdb_stdlog
,
746 "gdbarch_update: CALL_DUMMY_LOCATION = %ld\n",
747 (long) CALL_DUMMY_LOCATION
);
748 fprintf_unfiltered (gdb_stdlog
,
749 "gdbarch_update: CALL_DUMMY_ADDRESS = 0x%08lx\n",
750 (long) current_gdbarch
->call_dummy_address
751 /*CALL_DUMMY_ADDRESS ()*/);
752 fprintf_unfiltered (gdb_stdlog
,
753 "gdbarch_update: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
754 (long) CALL_DUMMY_START_OFFSET
);
755 fprintf_unfiltered (gdb_stdlog
,
756 "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
757 (long) CALL_DUMMY_BREAKPOINT_OFFSET
);
758 fprintf_unfiltered (gdb_stdlog
,
759 "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
760 (long) CALL_DUMMY_BREAKPOINT_OFFSET_P
);
761 if (CALL_DUMMY_LOCATION
== BEFORE_TEXT_END
|| CALL_DUMMY_LOCATION
== AFTER_TEXT_END
)
762 fprintf_unfiltered (gdb_stdlog
,
763 "gdbarch_update: CALL_DUMMY_LENGTH = %ld\n",
764 (long) CALL_DUMMY_LENGTH
);
765 fprintf_unfiltered (gdb_stdlog
,
766 "gdbarch_update: PC_IN_CALL_DUMMY = 0x%08lx\n",
767 (long) current_gdbarch
->pc_in_call_dummy
768 /*PC_IN_CALL_DUMMY ()*/);
769 fprintf_unfiltered (gdb_stdlog
,
770 "gdbarch_update: CALL_DUMMY_P = %ld\n",
771 (long) CALL_DUMMY_P
);
772 fprintf_unfiltered (gdb_stdlog
,
773 "gdbarch_update: CALL_DUMMY_WORDS = 0x%08lx\n",
774 (long) CALL_DUMMY_WORDS
);
775 fprintf_unfiltered (gdb_stdlog
,
776 "gdbarch_update: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
777 (long) SIZEOF_CALL_DUMMY_WORDS
);
778 fprintf_unfiltered (gdb_stdlog
,
779 "gdbarch_update: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
780 (long) CALL_DUMMY_STACK_ADJUST_P
);
781 if (CALL_DUMMY_STACK_ADJUST_P
)
782 fprintf_unfiltered (gdb_stdlog
,
783 "gdbarch_update: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
784 (long) CALL_DUMMY_STACK_ADJUST
);
785 fprintf_unfiltered (gdb_stdlog
,
786 "gdbarch_update: FIX_CALL_DUMMY = 0x%08lx\n",
787 (long) current_gdbarch
->fix_call_dummy
788 /*FIX_CALL_DUMMY ()*/);
789 #ifdef BELIEVE_PCC_PROMOTION
790 fprintf_unfiltered (gdb_stdlog
,
791 "gdbarch_update: BELIEVE_PCC_PROMOTION = %ld\n",
792 (long) BELIEVE_PCC_PROMOTION
);
794 #ifdef BELIEVE_PCC_PROMOTION_TYPE
795 fprintf_unfiltered (gdb_stdlog
,
796 "gdbarch_update: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
797 (long) BELIEVE_PCC_PROMOTION_TYPE
);
799 fprintf_unfiltered (gdb_stdlog
,
800 "gdbarch_update: COERCE_FLOAT_TO_DOUBLE = 0x%08lx\n",
801 (long) current_gdbarch
->coerce_float_to_double
802 /*COERCE_FLOAT_TO_DOUBLE ()*/);
803 fprintf_unfiltered (gdb_stdlog
,
804 "gdbarch_update: GET_SAVED_REGISTER = 0x%08lx\n",
805 (long) current_gdbarch
->get_saved_register
806 /*GET_SAVED_REGISTER ()*/);
807 fprintf_unfiltered (gdb_stdlog
,
808 "gdbarch_update: REGISTER_CONVERTIBLE = 0x%08lx\n",
809 (long) current_gdbarch
->register_convertible
810 /*REGISTER_CONVERTIBLE ()*/);
811 fprintf_unfiltered (gdb_stdlog
,
812 "gdbarch_update: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
813 (long) current_gdbarch
->register_convert_to_virtual
814 /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
815 fprintf_unfiltered (gdb_stdlog
,
816 "gdbarch_update: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
817 (long) current_gdbarch
->register_convert_to_raw
818 /*REGISTER_CONVERT_TO_RAW ()*/);
819 fprintf_unfiltered (gdb_stdlog
,
820 "gdbarch_update: POINTER_TO_ADDRESS = 0x%08lx\n",
821 (long) current_gdbarch
->pointer_to_address
822 /*POINTER_TO_ADDRESS ()*/);
823 fprintf_unfiltered (gdb_stdlog
,
824 "gdbarch_update: ADDRESS_TO_POINTER = 0x%08lx\n",
825 (long) current_gdbarch
->address_to_pointer
826 /*ADDRESS_TO_POINTER ()*/);
827 fprintf_unfiltered (gdb_stdlog
,
828 "gdbarch_update: RETURN_VALUE_ON_STACK = 0x%08lx\n",
829 (long) current_gdbarch
->return_value_on_stack
830 /*RETURN_VALUE_ON_STACK ()*/);
831 fprintf_unfiltered (gdb_stdlog
,
832 "gdbarch_update: EXTRACT_RETURN_VALUE = 0x%08lx\n",
833 (long) current_gdbarch
->extract_return_value
834 /*EXTRACT_RETURN_VALUE ()*/);
835 fprintf_unfiltered (gdb_stdlog
,
836 "gdbarch_update: PUSH_ARGUMENTS = 0x%08lx\n",
837 (long) current_gdbarch
->push_arguments
838 /*PUSH_ARGUMENTS ()*/);
839 fprintf_unfiltered (gdb_stdlog
,
840 "gdbarch_update: PUSH_DUMMY_FRAME = 0x%08lx\n",
841 (long) current_gdbarch
->push_dummy_frame
842 /*PUSH_DUMMY_FRAME ()*/);
843 fprintf_unfiltered (gdb_stdlog
,
844 "gdbarch_update: PUSH_RETURN_ADDRESS = 0x%08lx\n",
845 (long) current_gdbarch
->push_return_address
846 /*PUSH_RETURN_ADDRESS ()*/);
847 fprintf_unfiltered (gdb_stdlog
,
848 "gdbarch_update: POP_FRAME = 0x%08lx\n",
849 (long) current_gdbarch
->pop_frame
851 fprintf_unfiltered (gdb_stdlog
,
852 "gdbarch_update: D10V_MAKE_DADDR = 0x%08lx\n",
853 (long) current_gdbarch
->d10v_make_daddr
854 /*D10V_MAKE_DADDR ()*/);
855 fprintf_unfiltered (gdb_stdlog
,
856 "gdbarch_update: D10V_MAKE_IADDR = 0x%08lx\n",
857 (long) current_gdbarch
->d10v_make_iaddr
858 /*D10V_MAKE_IADDR ()*/);
859 fprintf_unfiltered (gdb_stdlog
,
860 "gdbarch_update: D10V_DADDR_P = 0x%08lx\n",
861 (long) current_gdbarch
->d10v_daddr_p
862 /*D10V_DADDR_P ()*/);
863 fprintf_unfiltered (gdb_stdlog
,
864 "gdbarch_update: D10V_IADDR_P = 0x%08lx\n",
865 (long) current_gdbarch
->d10v_iaddr_p
866 /*D10V_IADDR_P ()*/);
867 fprintf_unfiltered (gdb_stdlog
,
868 "gdbarch_update: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
869 (long) current_gdbarch
->d10v_convert_daddr_to_raw
870 /*D10V_CONVERT_DADDR_TO_RAW ()*/);
871 fprintf_unfiltered (gdb_stdlog
,
872 "gdbarch_update: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
873 (long) current_gdbarch
->d10v_convert_iaddr_to_raw
874 /*D10V_CONVERT_IADDR_TO_RAW ()*/);
875 fprintf_unfiltered (gdb_stdlog
,
876 "gdbarch_update: STORE_STRUCT_RETURN = 0x%08lx\n",
877 (long) current_gdbarch
->store_struct_return
878 /*STORE_STRUCT_RETURN ()*/);
879 fprintf_unfiltered (gdb_stdlog
,
880 "gdbarch_update: STORE_RETURN_VALUE = 0x%08lx\n",
881 (long) current_gdbarch
->store_return_value
882 /*STORE_RETURN_VALUE ()*/);
883 fprintf_unfiltered (gdb_stdlog
,
884 "gdbarch_update: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
885 (long) current_gdbarch
->extract_struct_value_address
886 /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
887 fprintf_unfiltered (gdb_stdlog
,
888 "gdbarch_update: USE_STRUCT_CONVENTION = 0x%08lx\n",
889 (long) current_gdbarch
->use_struct_convention
890 /*USE_STRUCT_CONVENTION ()*/);
891 fprintf_unfiltered (gdb_stdlog
,
892 "gdbarch_update: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
893 (long) current_gdbarch
->frame_init_saved_regs
894 /*FRAME_INIT_SAVED_REGS ()*/);
895 fprintf_unfiltered (gdb_stdlog
,
896 "gdbarch_update: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
897 (long) current_gdbarch
->init_extra_frame_info
898 /*INIT_EXTRA_FRAME_INFO ()*/);
899 fprintf_unfiltered (gdb_stdlog
,
900 "gdbarch_update: SKIP_PROLOGUE = 0x%08lx\n",
901 (long) current_gdbarch
->skip_prologue
902 /*SKIP_PROLOGUE ()*/);
903 fprintf_unfiltered (gdb_stdlog
,
904 "gdbarch_update: INNER_THAN = 0x%08lx\n",
905 (long) current_gdbarch
->inner_than
907 fprintf_unfiltered (gdb_stdlog
,
908 "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n",
909 (long) current_gdbarch
->breakpoint_from_pc
910 /*BREAKPOINT_FROM_PC ()*/);
911 fprintf_unfiltered (gdb_stdlog
,
912 "gdbarch_update: MEMORY_INSERT_BREAKPOINT = 0x%08lx\n",
913 (long) current_gdbarch
->memory_insert_breakpoint
914 /*MEMORY_INSERT_BREAKPOINT ()*/);
915 fprintf_unfiltered (gdb_stdlog
,
916 "gdbarch_update: MEMORY_REMOVE_BREAKPOINT = 0x%08lx\n",
917 (long) current_gdbarch
->memory_remove_breakpoint
918 /*MEMORY_REMOVE_BREAKPOINT ()*/);
919 fprintf_unfiltered (gdb_stdlog
,
920 "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n",
921 (long) DECR_PC_AFTER_BREAK
);
922 fprintf_unfiltered (gdb_stdlog
,
923 "gdbarch_update: FUNCTION_START_OFFSET = %ld\n",
924 (long) FUNCTION_START_OFFSET
);
925 fprintf_unfiltered (gdb_stdlog
,
926 "gdbarch_update: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
927 (long) current_gdbarch
->remote_translate_xfer_address
928 /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
929 fprintf_unfiltered (gdb_stdlog
,
930 "gdbarch_update: FRAME_ARGS_SKIP = %ld\n",
931 (long) FRAME_ARGS_SKIP
);
932 fprintf_unfiltered (gdb_stdlog
,
933 "gdbarch_update: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
934 (long) current_gdbarch
->frameless_function_invocation
935 /*FRAMELESS_FUNCTION_INVOCATION ()*/);
936 fprintf_unfiltered (gdb_stdlog
,
937 "gdbarch_update: FRAME_CHAIN = 0x%08lx\n",
938 (long) current_gdbarch
->frame_chain
940 fprintf_unfiltered (gdb_stdlog
,
941 "gdbarch_update: FRAME_CHAIN_VALID = 0x%08lx\n",
942 (long) current_gdbarch
->frame_chain_valid
943 /*FRAME_CHAIN_VALID ()*/);
944 fprintf_unfiltered (gdb_stdlog
,
945 "gdbarch_update: FRAME_SAVED_PC = 0x%08lx\n",
946 (long) current_gdbarch
->frame_saved_pc
947 /*FRAME_SAVED_PC ()*/);
948 fprintf_unfiltered (gdb_stdlog
,
949 "gdbarch_update: FRAME_ARGS_ADDRESS = 0x%08lx\n",
950 (long) current_gdbarch
->frame_args_address
951 /*FRAME_ARGS_ADDRESS ()*/);
952 fprintf_unfiltered (gdb_stdlog
,
953 "gdbarch_update: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
954 (long) current_gdbarch
->frame_locals_address
955 /*FRAME_LOCALS_ADDRESS ()*/);
956 fprintf_unfiltered (gdb_stdlog
,
957 "gdbarch_update: SAVED_PC_AFTER_CALL = 0x%08lx\n",
958 (long) current_gdbarch
->saved_pc_after_call
959 /*SAVED_PC_AFTER_CALL ()*/);
960 fprintf_unfiltered (gdb_stdlog
,
961 "gdbarch_update: FRAME_NUM_ARGS = 0x%08lx\n",
962 (long) current_gdbarch
->frame_num_args
963 /*FRAME_NUM_ARGS ()*/);
964 fprintf_unfiltered (gdb_stdlog
,
965 "gdbarch_update: STACK_ALIGN = 0x%08lx\n",
966 (long) current_gdbarch
->stack_align
968 fprintf_unfiltered (gdb_stdlog
,
969 "gdbarch_update: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
970 (long) current_gdbarch
->reg_struct_has_addr
971 /*REG_STRUCT_HAS_ADDR ()*/);
974 struct gdbarch_tdep
*
975 gdbarch_tdep (struct gdbarch
*gdbarch
)
977 if (gdbarch_debug
>= 2)
978 fprintf_unfiltered (gdb_stdlog
, "gdbarch_tdep called\n");
979 return gdbarch
->tdep
;
983 const struct bfd_arch_info
*
984 gdbarch_bfd_arch_info (struct gdbarch
*gdbarch
)
986 if (gdbarch_debug
>= 2)
987 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_arch_info called\n");
988 return gdbarch
->bfd_arch_info
;
992 gdbarch_byte_order (struct gdbarch
*gdbarch
)
994 if (gdbarch_debug
>= 2)
995 fprintf_unfiltered (gdb_stdlog
, "gdbarch_byte_order called\n");
996 return gdbarch
->byte_order
;
1000 gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
)
1002 if (GDB_MULTI_ARCH
== 0)
1003 return TARGET_ARCHITECTURE
->bits_per_address
;
1004 /* Skip verify of bfd_vma_bit, invalid_p == 0 */
1005 if (gdbarch_debug
>= 2)
1006 fprintf_unfiltered (gdb_stdlog
, "gdbarch_bfd_vma_bit called\n");
1007 return gdbarch
->bfd_vma_bit
;
1011 set_gdbarch_bfd_vma_bit (struct gdbarch
*gdbarch
,
1014 gdbarch
->bfd_vma_bit
= bfd_vma_bit
;
1018 gdbarch_ptr_bit (struct gdbarch
*gdbarch
)
1020 if (gdbarch
->ptr_bit
== 0)
1021 internal_error ("gdbarch: gdbarch_ptr_bit invalid");
1022 if (gdbarch_debug
>= 2)
1023 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ptr_bit called\n");
1024 return gdbarch
->ptr_bit
;
1028 set_gdbarch_ptr_bit (struct gdbarch
*gdbarch
,
1031 gdbarch
->ptr_bit
= ptr_bit
;
1035 gdbarch_short_bit (struct gdbarch
*gdbarch
)
1037 if (gdbarch
->short_bit
== 0)
1038 internal_error ("gdbarch: gdbarch_short_bit invalid");
1039 if (gdbarch_debug
>= 2)
1040 fprintf_unfiltered (gdb_stdlog
, "gdbarch_short_bit called\n");
1041 return gdbarch
->short_bit
;
1045 set_gdbarch_short_bit (struct gdbarch
*gdbarch
,
1048 gdbarch
->short_bit
= short_bit
;
1052 gdbarch_int_bit (struct gdbarch
*gdbarch
)
1054 if (gdbarch
->int_bit
== 0)
1055 internal_error ("gdbarch: gdbarch_int_bit invalid");
1056 if (gdbarch_debug
>= 2)
1057 fprintf_unfiltered (gdb_stdlog
, "gdbarch_int_bit called\n");
1058 return gdbarch
->int_bit
;
1062 set_gdbarch_int_bit (struct gdbarch
*gdbarch
,
1065 gdbarch
->int_bit
= int_bit
;
1069 gdbarch_long_bit (struct gdbarch
*gdbarch
)
1071 if (gdbarch
->long_bit
== 0)
1072 internal_error ("gdbarch: gdbarch_long_bit invalid");
1073 if (gdbarch_debug
>= 2)
1074 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_bit called\n");
1075 return gdbarch
->long_bit
;
1079 set_gdbarch_long_bit (struct gdbarch
*gdbarch
,
1082 gdbarch
->long_bit
= long_bit
;
1086 gdbarch_long_long_bit (struct gdbarch
*gdbarch
)
1088 if (gdbarch
->long_long_bit
== 0)
1089 internal_error ("gdbarch: gdbarch_long_long_bit invalid");
1090 if (gdbarch_debug
>= 2)
1091 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_long_bit called\n");
1092 return gdbarch
->long_long_bit
;
1096 set_gdbarch_long_long_bit (struct gdbarch
*gdbarch
,
1099 gdbarch
->long_long_bit
= long_long_bit
;
1103 gdbarch_float_bit (struct gdbarch
*gdbarch
)
1105 if (gdbarch
->float_bit
== 0)
1106 internal_error ("gdbarch: gdbarch_float_bit invalid");
1107 if (gdbarch_debug
>= 2)
1108 fprintf_unfiltered (gdb_stdlog
, "gdbarch_float_bit called\n");
1109 return gdbarch
->float_bit
;
1113 set_gdbarch_float_bit (struct gdbarch
*gdbarch
,
1116 gdbarch
->float_bit
= float_bit
;
1120 gdbarch_double_bit (struct gdbarch
*gdbarch
)
1122 if (gdbarch
->double_bit
== 0)
1123 internal_error ("gdbarch: gdbarch_double_bit invalid");
1124 if (gdbarch_debug
>= 2)
1125 fprintf_unfiltered (gdb_stdlog
, "gdbarch_double_bit called\n");
1126 return gdbarch
->double_bit
;
1130 set_gdbarch_double_bit (struct gdbarch
*gdbarch
,
1133 gdbarch
->double_bit
= double_bit
;
1137 gdbarch_long_double_bit (struct gdbarch
*gdbarch
)
1139 if (gdbarch
->long_double_bit
== 0)
1140 internal_error ("gdbarch: gdbarch_long_double_bit invalid");
1141 if (gdbarch_debug
>= 2)
1142 fprintf_unfiltered (gdb_stdlog
, "gdbarch_long_double_bit called\n");
1143 return gdbarch
->long_double_bit
;
1147 set_gdbarch_long_double_bit (struct gdbarch
*gdbarch
,
1148 int long_double_bit
)
1150 gdbarch
->long_double_bit
= long_double_bit
;
1154 gdbarch_ieee_float (struct gdbarch
*gdbarch
)
1156 /* Skip verify of ieee_float, invalid_p == 0 */
1157 if (gdbarch_debug
>= 2)
1158 fprintf_unfiltered (gdb_stdlog
, "gdbarch_ieee_float called\n");
1159 return gdbarch
->ieee_float
;
1163 set_gdbarch_ieee_float (struct gdbarch
*gdbarch
,
1166 gdbarch
->ieee_float
= ieee_float
;
1170 gdbarch_read_pc (struct gdbarch
*gdbarch
, int pid
)
1172 if (gdbarch
->read_pc
== 0)
1173 internal_error ("gdbarch: gdbarch_read_pc invalid");
1174 if (gdbarch_debug
>= 2)
1175 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_pc called\n");
1176 return gdbarch
->read_pc (pid
);
1180 set_gdbarch_read_pc (struct gdbarch
*gdbarch
,
1181 gdbarch_read_pc_ftype read_pc
)
1183 gdbarch
->read_pc
= read_pc
;
1187 gdbarch_write_pc (struct gdbarch
*gdbarch
, CORE_ADDR val
, int pid
)
1189 if (gdbarch
->write_pc
== 0)
1190 internal_error ("gdbarch: gdbarch_write_pc invalid");
1191 if (gdbarch_debug
>= 2)
1192 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_pc called\n");
1193 gdbarch
->write_pc (val
, pid
);
1197 set_gdbarch_write_pc (struct gdbarch
*gdbarch
,
1198 gdbarch_write_pc_ftype write_pc
)
1200 gdbarch
->write_pc
= write_pc
;
1204 gdbarch_read_fp (struct gdbarch
*gdbarch
)
1206 if (gdbarch
->read_fp
== 0)
1207 internal_error ("gdbarch: gdbarch_read_fp invalid");
1208 if (gdbarch_debug
>= 2)
1209 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_fp called\n");
1210 return gdbarch
->read_fp ();
1214 set_gdbarch_read_fp (struct gdbarch
*gdbarch
,
1215 gdbarch_read_fp_ftype read_fp
)
1217 gdbarch
->read_fp
= read_fp
;
1221 gdbarch_write_fp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
1223 if (gdbarch
->write_fp
== 0)
1224 internal_error ("gdbarch: gdbarch_write_fp invalid");
1225 if (gdbarch_debug
>= 2)
1226 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_fp called\n");
1227 gdbarch
->write_fp (val
);
1231 set_gdbarch_write_fp (struct gdbarch
*gdbarch
,
1232 gdbarch_write_fp_ftype write_fp
)
1234 gdbarch
->write_fp
= write_fp
;
1238 gdbarch_read_sp (struct gdbarch
*gdbarch
)
1240 if (gdbarch
->read_sp
== 0)
1241 internal_error ("gdbarch: gdbarch_read_sp invalid");
1242 if (gdbarch_debug
>= 2)
1243 fprintf_unfiltered (gdb_stdlog
, "gdbarch_read_sp called\n");
1244 return gdbarch
->read_sp ();
1248 set_gdbarch_read_sp (struct gdbarch
*gdbarch
,
1249 gdbarch_read_sp_ftype read_sp
)
1251 gdbarch
->read_sp
= read_sp
;
1255 gdbarch_write_sp (struct gdbarch
*gdbarch
, CORE_ADDR val
)
1257 if (gdbarch
->write_sp
== 0)
1258 internal_error ("gdbarch: gdbarch_write_sp invalid");
1259 if (gdbarch_debug
>= 2)
1260 fprintf_unfiltered (gdb_stdlog
, "gdbarch_write_sp called\n");
1261 gdbarch
->write_sp (val
);
1265 set_gdbarch_write_sp (struct gdbarch
*gdbarch
,
1266 gdbarch_write_sp_ftype write_sp
)
1268 gdbarch
->write_sp
= write_sp
;
1272 gdbarch_num_regs (struct gdbarch
*gdbarch
)
1274 if (gdbarch
->num_regs
== -1)
1275 internal_error ("gdbarch: gdbarch_num_regs invalid");
1276 if (gdbarch_debug
>= 2)
1277 fprintf_unfiltered (gdb_stdlog
, "gdbarch_num_regs called\n");
1278 return gdbarch
->num_regs
;
1282 set_gdbarch_num_regs (struct gdbarch
*gdbarch
,
1285 gdbarch
->num_regs
= num_regs
;
1289 gdbarch_sp_regnum (struct gdbarch
*gdbarch
)
1291 if (gdbarch
->sp_regnum
== -1)
1292 internal_error ("gdbarch: gdbarch_sp_regnum invalid");
1293 if (gdbarch_debug
>= 2)
1294 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sp_regnum called\n");
1295 return gdbarch
->sp_regnum
;
1299 set_gdbarch_sp_regnum (struct gdbarch
*gdbarch
,
1302 gdbarch
->sp_regnum
= sp_regnum
;
1306 gdbarch_fp_regnum (struct gdbarch
*gdbarch
)
1308 if (gdbarch
->fp_regnum
== -1)
1309 internal_error ("gdbarch: gdbarch_fp_regnum invalid");
1310 if (gdbarch_debug
>= 2)
1311 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fp_regnum called\n");
1312 return gdbarch
->fp_regnum
;
1316 set_gdbarch_fp_regnum (struct gdbarch
*gdbarch
,
1319 gdbarch
->fp_regnum
= fp_regnum
;
1323 gdbarch_pc_regnum (struct gdbarch
*gdbarch
)
1325 if (gdbarch
->pc_regnum
== -1)
1326 internal_error ("gdbarch: gdbarch_pc_regnum invalid");
1327 if (gdbarch_debug
>= 2)
1328 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_regnum called\n");
1329 return gdbarch
->pc_regnum
;
1333 set_gdbarch_pc_regnum (struct gdbarch
*gdbarch
,
1336 gdbarch
->pc_regnum
= pc_regnum
;
1340 gdbarch_register_name (struct gdbarch
*gdbarch
, int regnr
)
1342 if (GDB_MULTI_ARCH
== 0)
1343 return legacy_register_name (regnr
);
1344 if (gdbarch
->register_name
== 0)
1345 internal_error ("gdbarch: gdbarch_register_name invalid");
1346 if (gdbarch_debug
>= 2)
1347 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_name called\n");
1348 return gdbarch
->register_name (regnr
);
1352 set_gdbarch_register_name (struct gdbarch
*gdbarch
,
1353 gdbarch_register_name_ftype register_name
)
1355 gdbarch
->register_name
= register_name
;
1359 gdbarch_register_size (struct gdbarch
*gdbarch
)
1361 if (gdbarch
->register_size
== -1)
1362 internal_error ("gdbarch: gdbarch_register_size invalid");
1363 if (gdbarch_debug
>= 2)
1364 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_size called\n");
1365 return gdbarch
->register_size
;
1369 set_gdbarch_register_size (struct gdbarch
*gdbarch
,
1372 gdbarch
->register_size
= register_size
;
1376 gdbarch_register_bytes (struct gdbarch
*gdbarch
)
1378 if (gdbarch
->register_bytes
== -1)
1379 internal_error ("gdbarch: gdbarch_register_bytes invalid");
1380 if (gdbarch_debug
>= 2)
1381 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_bytes called\n");
1382 return gdbarch
->register_bytes
;
1386 set_gdbarch_register_bytes (struct gdbarch
*gdbarch
,
1389 gdbarch
->register_bytes
= register_bytes
;
1393 gdbarch_register_byte (struct gdbarch
*gdbarch
, int reg_nr
)
1395 if (gdbarch
->register_byte
== 0)
1396 internal_error ("gdbarch: gdbarch_register_byte invalid");
1397 if (gdbarch_debug
>= 2)
1398 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_byte called\n");
1399 return gdbarch
->register_byte (reg_nr
);
1403 set_gdbarch_register_byte (struct gdbarch
*gdbarch
,
1404 gdbarch_register_byte_ftype register_byte
)
1406 gdbarch
->register_byte
= register_byte
;
1410 gdbarch_register_raw_size (struct gdbarch
*gdbarch
, int reg_nr
)
1412 if (gdbarch
->register_raw_size
== 0)
1413 internal_error ("gdbarch: gdbarch_register_raw_size invalid");
1414 if (gdbarch_debug
>= 2)
1415 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_raw_size called\n");
1416 return gdbarch
->register_raw_size (reg_nr
);
1420 set_gdbarch_register_raw_size (struct gdbarch
*gdbarch
,
1421 gdbarch_register_raw_size_ftype register_raw_size
)
1423 gdbarch
->register_raw_size
= register_raw_size
;
1427 gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
)
1429 if (gdbarch
->max_register_raw_size
== -1)
1430 internal_error ("gdbarch: gdbarch_max_register_raw_size invalid");
1431 if (gdbarch_debug
>= 2)
1432 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_raw_size called\n");
1433 return gdbarch
->max_register_raw_size
;
1437 set_gdbarch_max_register_raw_size (struct gdbarch
*gdbarch
,
1438 int max_register_raw_size
)
1440 gdbarch
->max_register_raw_size
= max_register_raw_size
;
1444 gdbarch_register_virtual_size (struct gdbarch
*gdbarch
, int reg_nr
)
1446 if (gdbarch
->register_virtual_size
== 0)
1447 internal_error ("gdbarch: gdbarch_register_virtual_size invalid");
1448 if (gdbarch_debug
>= 2)
1449 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_size called\n");
1450 return gdbarch
->register_virtual_size (reg_nr
);
1454 set_gdbarch_register_virtual_size (struct gdbarch
*gdbarch
,
1455 gdbarch_register_virtual_size_ftype register_virtual_size
)
1457 gdbarch
->register_virtual_size
= register_virtual_size
;
1461 gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
)
1463 if (gdbarch
->max_register_virtual_size
== -1)
1464 internal_error ("gdbarch: gdbarch_max_register_virtual_size invalid");
1465 if (gdbarch_debug
>= 2)
1466 fprintf_unfiltered (gdb_stdlog
, "gdbarch_max_register_virtual_size called\n");
1467 return gdbarch
->max_register_virtual_size
;
1471 set_gdbarch_max_register_virtual_size (struct gdbarch
*gdbarch
,
1472 int max_register_virtual_size
)
1474 gdbarch
->max_register_virtual_size
= max_register_virtual_size
;
1478 gdbarch_register_virtual_type (struct gdbarch
*gdbarch
, int reg_nr
)
1480 if (gdbarch
->register_virtual_type
== 0)
1481 internal_error ("gdbarch: gdbarch_register_virtual_type invalid");
1482 if (gdbarch_debug
>= 2)
1483 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_virtual_type called\n");
1484 return gdbarch
->register_virtual_type (reg_nr
);
1488 set_gdbarch_register_virtual_type (struct gdbarch
*gdbarch
,
1489 gdbarch_register_virtual_type_ftype register_virtual_type
)
1491 gdbarch
->register_virtual_type
= register_virtual_type
;
1495 gdbarch_use_generic_dummy_frames (struct gdbarch
*gdbarch
)
1497 if (gdbarch
->use_generic_dummy_frames
== -1)
1498 internal_error ("gdbarch: gdbarch_use_generic_dummy_frames invalid");
1499 if (gdbarch_debug
>= 2)
1500 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_generic_dummy_frames called\n");
1501 return gdbarch
->use_generic_dummy_frames
;
1505 set_gdbarch_use_generic_dummy_frames (struct gdbarch
*gdbarch
,
1506 int use_generic_dummy_frames
)
1508 gdbarch
->use_generic_dummy_frames
= use_generic_dummy_frames
;
1512 gdbarch_call_dummy_location (struct gdbarch
*gdbarch
)
1514 if (gdbarch
->call_dummy_location
== 0)
1515 internal_error ("gdbarch: gdbarch_call_dummy_location invalid");
1516 if (gdbarch_debug
>= 2)
1517 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_location called\n");
1518 return gdbarch
->call_dummy_location
;
1522 set_gdbarch_call_dummy_location (struct gdbarch
*gdbarch
,
1523 int call_dummy_location
)
1525 gdbarch
->call_dummy_location
= call_dummy_location
;
1529 gdbarch_call_dummy_address (struct gdbarch
*gdbarch
)
1531 if (gdbarch
->call_dummy_address
== 0)
1532 internal_error ("gdbarch: gdbarch_call_dummy_address invalid");
1533 if (gdbarch_debug
>= 2)
1534 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_address called\n");
1535 return gdbarch
->call_dummy_address ();
1539 set_gdbarch_call_dummy_address (struct gdbarch
*gdbarch
,
1540 gdbarch_call_dummy_address_ftype call_dummy_address
)
1542 gdbarch
->call_dummy_address
= call_dummy_address
;
1546 gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
)
1548 if (gdbarch
->call_dummy_start_offset
== -1)
1549 internal_error ("gdbarch: gdbarch_call_dummy_start_offset invalid");
1550 if (gdbarch_debug
>= 2)
1551 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_start_offset called\n");
1552 return gdbarch
->call_dummy_start_offset
;
1556 set_gdbarch_call_dummy_start_offset (struct gdbarch
*gdbarch
,
1557 CORE_ADDR call_dummy_start_offset
)
1559 gdbarch
->call_dummy_start_offset
= call_dummy_start_offset
;
1563 gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
)
1565 if (gdbarch
->call_dummy_breakpoint_offset
== -1)
1566 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
1567 if (gdbarch_debug
>= 2)
1568 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset called\n");
1569 return gdbarch
->call_dummy_breakpoint_offset
;
1573 set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch
*gdbarch
,
1574 CORE_ADDR call_dummy_breakpoint_offset
)
1576 gdbarch
->call_dummy_breakpoint_offset
= call_dummy_breakpoint_offset
;
1580 gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
)
1582 if (gdbarch
->call_dummy_breakpoint_offset_p
== -1)
1583 internal_error ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
1584 if (gdbarch_debug
>= 2)
1585 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_breakpoint_offset_p called\n");
1586 return gdbarch
->call_dummy_breakpoint_offset_p
;
1590 set_gdbarch_call_dummy_breakpoint_offset_p (struct gdbarch
*gdbarch
,
1591 int call_dummy_breakpoint_offset_p
)
1593 gdbarch
->call_dummy_breakpoint_offset_p
= call_dummy_breakpoint_offset_p
;
1597 gdbarch_call_dummy_length (struct gdbarch
*gdbarch
)
1599 if (gdbarch
->call_dummy_length
== -1)
1600 internal_error ("gdbarch: gdbarch_call_dummy_length invalid");
1601 if (gdbarch_debug
>= 2)
1602 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_length called\n");
1603 return gdbarch
->call_dummy_length
;
1607 set_gdbarch_call_dummy_length (struct gdbarch
*gdbarch
,
1608 int call_dummy_length
)
1610 gdbarch
->call_dummy_length
= call_dummy_length
;
1614 gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
, CORE_ADDR frame_address
)
1616 if (gdbarch
->pc_in_call_dummy
== 0)
1617 internal_error ("gdbarch: gdbarch_pc_in_call_dummy invalid");
1618 if (gdbarch_debug
>= 2)
1619 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pc_in_call_dummy called\n");
1620 return gdbarch
->pc_in_call_dummy (pc
, sp
, frame_address
);
1624 set_gdbarch_pc_in_call_dummy (struct gdbarch
*gdbarch
,
1625 gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy
)
1627 gdbarch
->pc_in_call_dummy
= pc_in_call_dummy
;
1631 gdbarch_call_dummy_p (struct gdbarch
*gdbarch
)
1633 if (gdbarch
->call_dummy_p
== -1)
1634 internal_error ("gdbarch: gdbarch_call_dummy_p invalid");
1635 if (gdbarch_debug
>= 2)
1636 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_p called\n");
1637 return gdbarch
->call_dummy_p
;
1641 set_gdbarch_call_dummy_p (struct gdbarch
*gdbarch
,
1644 gdbarch
->call_dummy_p
= call_dummy_p
;
1648 gdbarch_call_dummy_words (struct gdbarch
*gdbarch
)
1650 if (GDB_MULTI_ARCH
== 0)
1651 return legacy_call_dummy_words
;
1652 /* Skip verify of call_dummy_words, invalid_p == 0 */
1653 if (gdbarch_debug
>= 2)
1654 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_words called\n");
1655 return gdbarch
->call_dummy_words
;
1659 set_gdbarch_call_dummy_words (struct gdbarch
*gdbarch
,
1660 LONGEST
* call_dummy_words
)
1662 gdbarch
->call_dummy_words
= call_dummy_words
;
1666 gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
)
1668 if (GDB_MULTI_ARCH
== 0)
1669 return legacy_sizeof_call_dummy_words
;
1670 /* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
1671 if (gdbarch_debug
>= 2)
1672 fprintf_unfiltered (gdb_stdlog
, "gdbarch_sizeof_call_dummy_words called\n");
1673 return gdbarch
->sizeof_call_dummy_words
;
1677 set_gdbarch_sizeof_call_dummy_words (struct gdbarch
*gdbarch
,
1678 int sizeof_call_dummy_words
)
1680 gdbarch
->sizeof_call_dummy_words
= sizeof_call_dummy_words
;
1684 gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
)
1686 if (gdbarch
->call_dummy_stack_adjust_p
== -1)
1687 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
1688 if (gdbarch_debug
>= 2)
1689 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust_p called\n");
1690 return gdbarch
->call_dummy_stack_adjust_p
;
1694 set_gdbarch_call_dummy_stack_adjust_p (struct gdbarch
*gdbarch
,
1695 int call_dummy_stack_adjust_p
)
1697 gdbarch
->call_dummy_stack_adjust_p
= call_dummy_stack_adjust_p
;
1701 gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
)
1703 if (gdbarch
->call_dummy_stack_adjust_p
&& gdbarch
->call_dummy_stack_adjust
== 0)
1704 internal_error ("gdbarch: gdbarch_call_dummy_stack_adjust invalid");
1705 if (gdbarch_debug
>= 2)
1706 fprintf_unfiltered (gdb_stdlog
, "gdbarch_call_dummy_stack_adjust called\n");
1707 return gdbarch
->call_dummy_stack_adjust
;
1711 set_gdbarch_call_dummy_stack_adjust (struct gdbarch
*gdbarch
,
1712 int call_dummy_stack_adjust
)
1714 gdbarch
->call_dummy_stack_adjust
= call_dummy_stack_adjust
;
1718 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
)
1720 if (gdbarch
->fix_call_dummy
== 0)
1721 internal_error ("gdbarch: gdbarch_fix_call_dummy invalid");
1722 if (gdbarch_debug
>= 2)
1723 fprintf_unfiltered (gdb_stdlog
, "gdbarch_fix_call_dummy called\n");
1724 gdbarch
->fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
);
1728 set_gdbarch_fix_call_dummy (struct gdbarch
*gdbarch
,
1729 gdbarch_fix_call_dummy_ftype fix_call_dummy
)
1731 gdbarch
->fix_call_dummy
= fix_call_dummy
;
1735 gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
)
1737 if (gdbarch_debug
>= 2)
1738 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion called\n");
1739 return gdbarch
->believe_pcc_promotion
;
1743 set_gdbarch_believe_pcc_promotion (struct gdbarch
*gdbarch
,
1744 int believe_pcc_promotion
)
1746 gdbarch
->believe_pcc_promotion
= believe_pcc_promotion
;
1750 gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
)
1752 if (gdbarch_debug
>= 2)
1753 fprintf_unfiltered (gdb_stdlog
, "gdbarch_believe_pcc_promotion_type called\n");
1754 return gdbarch
->believe_pcc_promotion_type
;
1758 set_gdbarch_believe_pcc_promotion_type (struct gdbarch
*gdbarch
,
1759 int believe_pcc_promotion_type
)
1761 gdbarch
->believe_pcc_promotion_type
= believe_pcc_promotion_type
;
1765 gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
, struct type
*formal
, struct type
*actual
)
1767 if (GDB_MULTI_ARCH
== 0)
1768 return default_coerce_float_to_double (formal
, actual
);
1769 if (gdbarch
->coerce_float_to_double
== 0)
1770 internal_error ("gdbarch: gdbarch_coerce_float_to_double invalid");
1771 if (gdbarch_debug
>= 2)
1772 fprintf_unfiltered (gdb_stdlog
, "gdbarch_coerce_float_to_double called\n");
1773 return gdbarch
->coerce_float_to_double (formal
, actual
);
1777 set_gdbarch_coerce_float_to_double (struct gdbarch
*gdbarch
,
1778 gdbarch_coerce_float_to_double_ftype coerce_float_to_double
)
1780 gdbarch
->coerce_float_to_double
= coerce_float_to_double
;
1784 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
)
1786 if (gdbarch
->get_saved_register
== 0)
1787 internal_error ("gdbarch: gdbarch_get_saved_register invalid");
1788 if (gdbarch_debug
>= 2)
1789 fprintf_unfiltered (gdb_stdlog
, "gdbarch_get_saved_register called\n");
1790 gdbarch
->get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
1794 set_gdbarch_get_saved_register (struct gdbarch
*gdbarch
,
1795 gdbarch_get_saved_register_ftype get_saved_register
)
1797 gdbarch
->get_saved_register
= get_saved_register
;
1801 gdbarch_register_convertible (struct gdbarch
*gdbarch
, int nr
)
1803 if (GDB_MULTI_ARCH
== 0)
1804 return generic_register_convertible_not (nr
);
1805 if (gdbarch
->register_convertible
== 0)
1806 internal_error ("gdbarch: gdbarch_register_convertible invalid");
1807 if (gdbarch_debug
>= 2)
1808 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convertible called\n");
1809 return gdbarch
->register_convertible (nr
);
1813 set_gdbarch_register_convertible (struct gdbarch
*gdbarch
,
1814 gdbarch_register_convertible_ftype register_convertible
)
1816 gdbarch
->register_convertible
= register_convertible
;
1820 gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
, char *from
, char *to
)
1822 if (gdbarch
->register_convert_to_virtual
== 0)
1823 internal_error ("gdbarch: gdbarch_register_convert_to_virtual invalid");
1824 if (gdbarch_debug
>= 2)
1825 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_virtual called\n");
1826 gdbarch
->register_convert_to_virtual (regnum
, type
, from
, to
);
1830 set_gdbarch_register_convert_to_virtual (struct gdbarch
*gdbarch
,
1831 gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual
)
1833 gdbarch
->register_convert_to_virtual
= register_convert_to_virtual
;
1837 gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
, struct type
*type
, int regnum
, char *from
, char *to
)
1839 if (gdbarch
->register_convert_to_raw
== 0)
1840 internal_error ("gdbarch: gdbarch_register_convert_to_raw invalid");
1841 if (gdbarch_debug
>= 2)
1842 fprintf_unfiltered (gdb_stdlog
, "gdbarch_register_convert_to_raw called\n");
1843 gdbarch
->register_convert_to_raw (type
, regnum
, from
, to
);
1847 set_gdbarch_register_convert_to_raw (struct gdbarch
*gdbarch
,
1848 gdbarch_register_convert_to_raw_ftype register_convert_to_raw
)
1850 gdbarch
->register_convert_to_raw
= register_convert_to_raw
;
1854 gdbarch_pointer_to_address (struct gdbarch
*gdbarch
, struct type
*type
, char *buf
)
1856 if (GDB_MULTI_ARCH
== 0)
1857 return generic_pointer_to_address (type
, buf
);
1858 if (gdbarch
->pointer_to_address
== 0)
1859 internal_error ("gdbarch: gdbarch_pointer_to_address invalid");
1860 if (gdbarch_debug
>= 2)
1861 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pointer_to_address called\n");
1862 return gdbarch
->pointer_to_address (type
, buf
);
1866 set_gdbarch_pointer_to_address (struct gdbarch
*gdbarch
,
1867 gdbarch_pointer_to_address_ftype pointer_to_address
)
1869 gdbarch
->pointer_to_address
= pointer_to_address
;
1873 gdbarch_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
, char *buf
, CORE_ADDR addr
)
1875 if (GDB_MULTI_ARCH
== 0)
1877 generic_address_to_pointer (type
, buf
, addr
);
1880 if (gdbarch
->address_to_pointer
== 0)
1881 internal_error ("gdbarch: gdbarch_address_to_pointer invalid");
1882 if (gdbarch_debug
>= 2)
1883 fprintf_unfiltered (gdb_stdlog
, "gdbarch_address_to_pointer called\n");
1884 gdbarch
->address_to_pointer (type
, buf
, addr
);
1888 set_gdbarch_address_to_pointer (struct gdbarch
*gdbarch
,
1889 gdbarch_address_to_pointer_ftype address_to_pointer
)
1891 gdbarch
->address_to_pointer
= address_to_pointer
;
1895 gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
, struct type
*type
)
1897 if (GDB_MULTI_ARCH
== 0)
1898 return generic_return_value_on_stack_not (type
);
1899 if (gdbarch
->return_value_on_stack
== 0)
1900 internal_error ("gdbarch: gdbarch_return_value_on_stack invalid");
1901 if (gdbarch_debug
>= 2)
1902 fprintf_unfiltered (gdb_stdlog
, "gdbarch_return_value_on_stack called\n");
1903 return gdbarch
->return_value_on_stack (type
);
1907 set_gdbarch_return_value_on_stack (struct gdbarch
*gdbarch
,
1908 gdbarch_return_value_on_stack_ftype return_value_on_stack
)
1910 gdbarch
->return_value_on_stack
= return_value_on_stack
;
1914 gdbarch_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *regbuf
, char *valbuf
)
1916 if (gdbarch
->extract_return_value
== 0)
1917 internal_error ("gdbarch: gdbarch_extract_return_value invalid");
1918 if (gdbarch_debug
>= 2)
1919 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_return_value called\n");
1920 gdbarch
->extract_return_value (type
, regbuf
, valbuf
);
1924 set_gdbarch_extract_return_value (struct gdbarch
*gdbarch
,
1925 gdbarch_extract_return_value_ftype extract_return_value
)
1927 gdbarch
->extract_return_value
= extract_return_value
;
1931 gdbarch_push_arguments (struct gdbarch
*gdbarch
, int nargs
, struct value
**args
, CORE_ADDR sp
, int struct_return
, CORE_ADDR struct_addr
)
1933 if (gdbarch
->push_arguments
== 0)
1934 internal_error ("gdbarch: gdbarch_push_arguments invalid");
1935 if (gdbarch_debug
>= 2)
1936 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_arguments called\n");
1937 return gdbarch
->push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
1941 set_gdbarch_push_arguments (struct gdbarch
*gdbarch
,
1942 gdbarch_push_arguments_ftype push_arguments
)
1944 gdbarch
->push_arguments
= push_arguments
;
1948 gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
)
1950 if (gdbarch
->push_dummy_frame
== 0)
1951 internal_error ("gdbarch: gdbarch_push_dummy_frame invalid");
1952 if (gdbarch_debug
>= 2)
1953 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_dummy_frame called\n");
1954 gdbarch
->push_dummy_frame ();
1958 set_gdbarch_push_dummy_frame (struct gdbarch
*gdbarch
,
1959 gdbarch_push_dummy_frame_ftype push_dummy_frame
)
1961 gdbarch
->push_dummy_frame
= push_dummy_frame
;
1965 gdbarch_push_return_address (struct gdbarch
*gdbarch
, CORE_ADDR pc
, CORE_ADDR sp
)
1967 if (gdbarch
->push_return_address
== 0)
1968 internal_error ("gdbarch: gdbarch_push_return_address invalid");
1969 if (gdbarch_debug
>= 2)
1970 fprintf_unfiltered (gdb_stdlog
, "gdbarch_push_return_address called\n");
1971 return gdbarch
->push_return_address (pc
, sp
);
1975 set_gdbarch_push_return_address (struct gdbarch
*gdbarch
,
1976 gdbarch_push_return_address_ftype push_return_address
)
1978 gdbarch
->push_return_address
= push_return_address
;
1982 gdbarch_pop_frame (struct gdbarch
*gdbarch
)
1984 if (gdbarch
->pop_frame
== 0)
1985 internal_error ("gdbarch: gdbarch_pop_frame invalid");
1986 if (gdbarch_debug
>= 2)
1987 fprintf_unfiltered (gdb_stdlog
, "gdbarch_pop_frame called\n");
1988 gdbarch
->pop_frame ();
1992 set_gdbarch_pop_frame (struct gdbarch
*gdbarch
,
1993 gdbarch_pop_frame_ftype pop_frame
)
1995 gdbarch
->pop_frame
= pop_frame
;
1999 gdbarch_d10v_make_daddr (struct gdbarch
*gdbarch
, CORE_ADDR x
)
2001 if (gdbarch
->d10v_make_daddr
== 0)
2002 internal_error ("gdbarch: gdbarch_d10v_make_daddr invalid");
2003 if (gdbarch_debug
>= 2)
2004 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_make_daddr called\n");
2005 return gdbarch
->d10v_make_daddr (x
);
2009 set_gdbarch_d10v_make_daddr (struct gdbarch
*gdbarch
,
2010 gdbarch_d10v_make_daddr_ftype d10v_make_daddr
)
2012 gdbarch
->d10v_make_daddr
= d10v_make_daddr
;
2016 gdbarch_d10v_make_iaddr (struct gdbarch
*gdbarch
, CORE_ADDR x
)
2018 if (gdbarch
->d10v_make_iaddr
== 0)
2019 internal_error ("gdbarch: gdbarch_d10v_make_iaddr invalid");
2020 if (gdbarch_debug
>= 2)
2021 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_make_iaddr called\n");
2022 return gdbarch
->d10v_make_iaddr (x
);
2026 set_gdbarch_d10v_make_iaddr (struct gdbarch
*gdbarch
,
2027 gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr
)
2029 gdbarch
->d10v_make_iaddr
= d10v_make_iaddr
;
2033 gdbarch_d10v_daddr_p (struct gdbarch
*gdbarch
, CORE_ADDR x
)
2035 if (gdbarch
->d10v_daddr_p
== 0)
2036 internal_error ("gdbarch: gdbarch_d10v_daddr_p invalid");
2037 if (gdbarch_debug
>= 2)
2038 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_daddr_p called\n");
2039 return gdbarch
->d10v_daddr_p (x
);
2043 set_gdbarch_d10v_daddr_p (struct gdbarch
*gdbarch
,
2044 gdbarch_d10v_daddr_p_ftype d10v_daddr_p
)
2046 gdbarch
->d10v_daddr_p
= d10v_daddr_p
;
2050 gdbarch_d10v_iaddr_p (struct gdbarch
*gdbarch
, CORE_ADDR x
)
2052 if (gdbarch
->d10v_iaddr_p
== 0)
2053 internal_error ("gdbarch: gdbarch_d10v_iaddr_p invalid");
2054 if (gdbarch_debug
>= 2)
2055 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_iaddr_p called\n");
2056 return gdbarch
->d10v_iaddr_p (x
);
2060 set_gdbarch_d10v_iaddr_p (struct gdbarch
*gdbarch
,
2061 gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p
)
2063 gdbarch
->d10v_iaddr_p
= d10v_iaddr_p
;
2067 gdbarch_d10v_convert_daddr_to_raw (struct gdbarch
*gdbarch
, CORE_ADDR x
)
2069 if (gdbarch
->d10v_convert_daddr_to_raw
== 0)
2070 internal_error ("gdbarch: gdbarch_d10v_convert_daddr_to_raw invalid");
2071 if (gdbarch_debug
>= 2)
2072 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_convert_daddr_to_raw called\n");
2073 return gdbarch
->d10v_convert_daddr_to_raw (x
);
2077 set_gdbarch_d10v_convert_daddr_to_raw (struct gdbarch
*gdbarch
,
2078 gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw
)
2080 gdbarch
->d10v_convert_daddr_to_raw
= d10v_convert_daddr_to_raw
;
2084 gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch
*gdbarch
, CORE_ADDR x
)
2086 if (gdbarch
->d10v_convert_iaddr_to_raw
== 0)
2087 internal_error ("gdbarch: gdbarch_d10v_convert_iaddr_to_raw invalid");
2088 if (gdbarch_debug
>= 2)
2089 fprintf_unfiltered (gdb_stdlog
, "gdbarch_d10v_convert_iaddr_to_raw called\n");
2090 return gdbarch
->d10v_convert_iaddr_to_raw (x
);
2094 set_gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch
*gdbarch
,
2095 gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw
)
2097 gdbarch
->d10v_convert_iaddr_to_raw
= d10v_convert_iaddr_to_raw
;
2101 gdbarch_store_struct_return (struct gdbarch
*gdbarch
, CORE_ADDR addr
, CORE_ADDR sp
)
2103 if (gdbarch
->store_struct_return
== 0)
2104 internal_error ("gdbarch: gdbarch_store_struct_return invalid");
2105 if (gdbarch_debug
>= 2)
2106 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_struct_return called\n");
2107 gdbarch
->store_struct_return (addr
, sp
);
2111 set_gdbarch_store_struct_return (struct gdbarch
*gdbarch
,
2112 gdbarch_store_struct_return_ftype store_struct_return
)
2114 gdbarch
->store_struct_return
= store_struct_return
;
2118 gdbarch_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
, char *valbuf
)
2120 if (gdbarch
->store_return_value
== 0)
2121 internal_error ("gdbarch: gdbarch_store_return_value invalid");
2122 if (gdbarch_debug
>= 2)
2123 fprintf_unfiltered (gdb_stdlog
, "gdbarch_store_return_value called\n");
2124 gdbarch
->store_return_value (type
, valbuf
);
2128 set_gdbarch_store_return_value (struct gdbarch
*gdbarch
,
2129 gdbarch_store_return_value_ftype store_return_value
)
2131 gdbarch
->store_return_value
= store_return_value
;
2135 gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
, char *regbuf
)
2137 if (gdbarch
->extract_struct_value_address
== 0)
2138 internal_error ("gdbarch: gdbarch_extract_struct_value_address invalid");
2139 if (gdbarch_debug
>= 2)
2140 fprintf_unfiltered (gdb_stdlog
, "gdbarch_extract_struct_value_address called\n");
2141 return gdbarch
->extract_struct_value_address (regbuf
);
2145 set_gdbarch_extract_struct_value_address (struct gdbarch
*gdbarch
,
2146 gdbarch_extract_struct_value_address_ftype extract_struct_value_address
)
2148 gdbarch
->extract_struct_value_address
= extract_struct_value_address
;
2152 gdbarch_use_struct_convention (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*value_type
)
2154 if (gdbarch
->use_struct_convention
== 0)
2155 internal_error ("gdbarch: gdbarch_use_struct_convention invalid");
2156 if (gdbarch_debug
>= 2)
2157 fprintf_unfiltered (gdb_stdlog
, "gdbarch_use_struct_convention called\n");
2158 return gdbarch
->use_struct_convention (gcc_p
, value_type
);
2162 set_gdbarch_use_struct_convention (struct gdbarch
*gdbarch
,
2163 gdbarch_use_struct_convention_ftype use_struct_convention
)
2165 gdbarch
->use_struct_convention
= use_struct_convention
;
2169 gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2171 if (gdbarch
->frame_init_saved_regs
== 0)
2172 internal_error ("gdbarch: gdbarch_frame_init_saved_regs invalid");
2173 if (gdbarch_debug
>= 2)
2174 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_init_saved_regs called\n");
2175 gdbarch
->frame_init_saved_regs (frame
);
2179 set_gdbarch_frame_init_saved_regs (struct gdbarch
*gdbarch
,
2180 gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs
)
2182 gdbarch
->frame_init_saved_regs
= frame_init_saved_regs
;
2186 gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
, int fromleaf
, struct frame_info
*frame
)
2188 if (gdbarch
->init_extra_frame_info
== 0)
2189 internal_error ("gdbarch: gdbarch_init_extra_frame_info invalid");
2190 if (gdbarch_debug
>= 2)
2191 fprintf_unfiltered (gdb_stdlog
, "gdbarch_init_extra_frame_info called\n");
2192 gdbarch
->init_extra_frame_info (fromleaf
, frame
);
2196 set_gdbarch_init_extra_frame_info (struct gdbarch
*gdbarch
,
2197 gdbarch_init_extra_frame_info_ftype init_extra_frame_info
)
2199 gdbarch
->init_extra_frame_info
= init_extra_frame_info
;
2203 gdbarch_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR ip
)
2205 if (gdbarch
->skip_prologue
== 0)
2206 internal_error ("gdbarch: gdbarch_skip_prologue invalid");
2207 if (gdbarch_debug
>= 2)
2208 fprintf_unfiltered (gdb_stdlog
, "gdbarch_skip_prologue called\n");
2209 return gdbarch
->skip_prologue (ip
);
2213 set_gdbarch_skip_prologue (struct gdbarch
*gdbarch
,
2214 gdbarch_skip_prologue_ftype skip_prologue
)
2216 gdbarch
->skip_prologue
= skip_prologue
;
2220 gdbarch_inner_than (struct gdbarch
*gdbarch
, CORE_ADDR lhs
, CORE_ADDR rhs
)
2222 if (gdbarch
->inner_than
== 0)
2223 internal_error ("gdbarch: gdbarch_inner_than invalid");
2224 if (gdbarch_debug
>= 2)
2225 fprintf_unfiltered (gdb_stdlog
, "gdbarch_inner_than called\n");
2226 return gdbarch
->inner_than (lhs
, rhs
);
2230 set_gdbarch_inner_than (struct gdbarch
*gdbarch
,
2231 gdbarch_inner_than_ftype inner_than
)
2233 gdbarch
->inner_than
= inner_than
;
2237 gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*pcptr
, int *lenptr
)
2239 if (GDB_MULTI_ARCH
== 0)
2240 return legacy_breakpoint_from_pc (pcptr
, lenptr
);
2241 if (gdbarch
->breakpoint_from_pc
== 0)
2242 internal_error ("gdbarch: gdbarch_breakpoint_from_pc invalid");
2243 if (gdbarch_debug
>= 2)
2244 fprintf_unfiltered (gdb_stdlog
, "gdbarch_breakpoint_from_pc called\n");
2245 return gdbarch
->breakpoint_from_pc (pcptr
, lenptr
);
2249 set_gdbarch_breakpoint_from_pc (struct gdbarch
*gdbarch
,
2250 gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc
)
2252 gdbarch
->breakpoint_from_pc
= breakpoint_from_pc
;
2256 gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
2258 if (GDB_MULTI_ARCH
== 0)
2259 return default_memory_insert_breakpoint (addr
, contents_cache
);
2260 if (gdbarch
->memory_insert_breakpoint
== 0)
2261 internal_error ("gdbarch: gdbarch_memory_insert_breakpoint invalid");
2262 if (gdbarch_debug
>= 2)
2263 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_insert_breakpoint called\n");
2264 return gdbarch
->memory_insert_breakpoint (addr
, contents_cache
);
2268 set_gdbarch_memory_insert_breakpoint (struct gdbarch
*gdbarch
,
2269 gdbarch_memory_insert_breakpoint_ftype memory_insert_breakpoint
)
2271 gdbarch
->memory_insert_breakpoint
= memory_insert_breakpoint
;
2275 gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR addr
, char *contents_cache
)
2277 if (GDB_MULTI_ARCH
== 0)
2278 return default_memory_remove_breakpoint (addr
, contents_cache
);
2279 if (gdbarch
->memory_remove_breakpoint
== 0)
2280 internal_error ("gdbarch: gdbarch_memory_remove_breakpoint invalid");
2281 if (gdbarch_debug
>= 2)
2282 fprintf_unfiltered (gdb_stdlog
, "gdbarch_memory_remove_breakpoint called\n");
2283 return gdbarch
->memory_remove_breakpoint (addr
, contents_cache
);
2287 set_gdbarch_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
2288 gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint
)
2290 gdbarch
->memory_remove_breakpoint
= memory_remove_breakpoint
;
2294 gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
)
2296 if (gdbarch
->decr_pc_after_break
== -1)
2297 internal_error ("gdbarch: gdbarch_decr_pc_after_break invalid");
2298 if (gdbarch_debug
>= 2)
2299 fprintf_unfiltered (gdb_stdlog
, "gdbarch_decr_pc_after_break called\n");
2300 return gdbarch
->decr_pc_after_break
;
2304 set_gdbarch_decr_pc_after_break (struct gdbarch
*gdbarch
,
2305 CORE_ADDR decr_pc_after_break
)
2307 gdbarch
->decr_pc_after_break
= decr_pc_after_break
;
2311 gdbarch_function_start_offset (struct gdbarch
*gdbarch
)
2313 if (gdbarch
->function_start_offset
== -1)
2314 internal_error ("gdbarch: gdbarch_function_start_offset invalid");
2315 if (gdbarch_debug
>= 2)
2316 fprintf_unfiltered (gdb_stdlog
, "gdbarch_function_start_offset called\n");
2317 return gdbarch
->function_start_offset
;
2321 set_gdbarch_function_start_offset (struct gdbarch
*gdbarch
,
2322 CORE_ADDR function_start_offset
)
2324 gdbarch
->function_start_offset
= function_start_offset
;
2328 gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
, CORE_ADDR gdb_addr
, int gdb_len
, CORE_ADDR
*rem_addr
, int *rem_len
)
2330 if (GDB_MULTI_ARCH
== 0)
2332 generic_remote_translate_xfer_address (gdb_addr
, gdb_len
, rem_addr
, rem_len
);
2335 if (gdbarch
->remote_translate_xfer_address
== 0)
2336 internal_error ("gdbarch: gdbarch_remote_translate_xfer_address invalid");
2337 if (gdbarch_debug
>= 2)
2338 fprintf_unfiltered (gdb_stdlog
, "gdbarch_remote_translate_xfer_address called\n");
2339 gdbarch
->remote_translate_xfer_address (gdb_addr
, gdb_len
, rem_addr
, rem_len
);
2343 set_gdbarch_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
2344 gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address
)
2346 gdbarch
->remote_translate_xfer_address
= remote_translate_xfer_address
;
2350 gdbarch_frame_args_skip (struct gdbarch
*gdbarch
)
2352 if (gdbarch
->frame_args_skip
== -1)
2353 internal_error ("gdbarch: gdbarch_frame_args_skip invalid");
2354 if (gdbarch_debug
>= 2)
2355 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_skip called\n");
2356 return gdbarch
->frame_args_skip
;
2360 set_gdbarch_frame_args_skip (struct gdbarch
*gdbarch
,
2361 CORE_ADDR frame_args_skip
)
2363 gdbarch
->frame_args_skip
= frame_args_skip
;
2367 gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
2369 if (GDB_MULTI_ARCH
== 0)
2370 return generic_frameless_function_invocation_not (fi
);
2371 if (gdbarch
->frameless_function_invocation
== 0)
2372 internal_error ("gdbarch: gdbarch_frameless_function_invocation invalid");
2373 if (gdbarch_debug
>= 2)
2374 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frameless_function_invocation called\n");
2375 return gdbarch
->frameless_function_invocation (fi
);
2379 set_gdbarch_frameless_function_invocation (struct gdbarch
*gdbarch
,
2380 gdbarch_frameless_function_invocation_ftype frameless_function_invocation
)
2382 gdbarch
->frameless_function_invocation
= frameless_function_invocation
;
2386 gdbarch_frame_chain (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2388 if (gdbarch
->frame_chain
== 0)
2389 internal_error ("gdbarch: gdbarch_frame_chain invalid");
2390 if (gdbarch_debug
>= 2)
2391 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain called\n");
2392 return gdbarch
->frame_chain (frame
);
2396 set_gdbarch_frame_chain (struct gdbarch
*gdbarch
,
2397 gdbarch_frame_chain_ftype frame_chain
)
2399 gdbarch
->frame_chain
= frame_chain
;
2403 gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
, CORE_ADDR chain
, struct frame_info
*thisframe
)
2405 if (gdbarch
->frame_chain_valid
== 0)
2406 internal_error ("gdbarch: gdbarch_frame_chain_valid invalid");
2407 if (gdbarch_debug
>= 2)
2408 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_chain_valid called\n");
2409 return gdbarch
->frame_chain_valid (chain
, thisframe
);
2413 set_gdbarch_frame_chain_valid (struct gdbarch
*gdbarch
,
2414 gdbarch_frame_chain_valid_ftype frame_chain_valid
)
2416 gdbarch
->frame_chain_valid
= frame_chain_valid
;
2420 gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
2422 if (gdbarch
->frame_saved_pc
== 0)
2423 internal_error ("gdbarch: gdbarch_frame_saved_pc invalid");
2424 if (gdbarch_debug
>= 2)
2425 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_saved_pc called\n");
2426 return gdbarch
->frame_saved_pc (fi
);
2430 set_gdbarch_frame_saved_pc (struct gdbarch
*gdbarch
,
2431 gdbarch_frame_saved_pc_ftype frame_saved_pc
)
2433 gdbarch
->frame_saved_pc
= frame_saved_pc
;
2437 gdbarch_frame_args_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
2439 if (gdbarch
->frame_args_address
== 0)
2440 internal_error ("gdbarch: gdbarch_frame_args_address invalid");
2441 if (gdbarch_debug
>= 2)
2442 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_args_address called\n");
2443 return gdbarch
->frame_args_address (fi
);
2447 set_gdbarch_frame_args_address (struct gdbarch
*gdbarch
,
2448 gdbarch_frame_args_address_ftype frame_args_address
)
2450 gdbarch
->frame_args_address
= frame_args_address
;
2454 gdbarch_frame_locals_address (struct gdbarch
*gdbarch
, struct frame_info
*fi
)
2456 if (gdbarch
->frame_locals_address
== 0)
2457 internal_error ("gdbarch: gdbarch_frame_locals_address invalid");
2458 if (gdbarch_debug
>= 2)
2459 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_locals_address called\n");
2460 return gdbarch
->frame_locals_address (fi
);
2464 set_gdbarch_frame_locals_address (struct gdbarch
*gdbarch
,
2465 gdbarch_frame_locals_address_ftype frame_locals_address
)
2467 gdbarch
->frame_locals_address
= frame_locals_address
;
2471 gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2473 if (gdbarch
->saved_pc_after_call
== 0)
2474 internal_error ("gdbarch: gdbarch_saved_pc_after_call invalid");
2475 if (gdbarch_debug
>= 2)
2476 fprintf_unfiltered (gdb_stdlog
, "gdbarch_saved_pc_after_call called\n");
2477 return gdbarch
->saved_pc_after_call (frame
);
2481 set_gdbarch_saved_pc_after_call (struct gdbarch
*gdbarch
,
2482 gdbarch_saved_pc_after_call_ftype saved_pc_after_call
)
2484 gdbarch
->saved_pc_after_call
= saved_pc_after_call
;
2488 gdbarch_frame_num_args (struct gdbarch
*gdbarch
, struct frame_info
*frame
)
2490 if (gdbarch
->frame_num_args
== 0)
2491 internal_error ("gdbarch: gdbarch_frame_num_args invalid");
2492 if (gdbarch_debug
>= 2)
2493 fprintf_unfiltered (gdb_stdlog
, "gdbarch_frame_num_args called\n");
2494 return gdbarch
->frame_num_args (frame
);
2498 set_gdbarch_frame_num_args (struct gdbarch
*gdbarch
,
2499 gdbarch_frame_num_args_ftype frame_num_args
)
2501 gdbarch
->frame_num_args
= frame_num_args
;
2505 gdbarch_stack_align_p (struct gdbarch
*gdbarch
)
2507 return gdbarch
->stack_align
!= 0;
2511 gdbarch_stack_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
2513 if (gdbarch
->stack_align
== 0)
2514 internal_error ("gdbarch: gdbarch_stack_align invalid");
2515 if (gdbarch_debug
>= 2)
2516 fprintf_unfiltered (gdb_stdlog
, "gdbarch_stack_align called\n");
2517 return gdbarch
->stack_align (sp
);
2521 set_gdbarch_stack_align (struct gdbarch
*gdbarch
,
2522 gdbarch_stack_align_ftype stack_align
)
2524 gdbarch
->stack_align
= stack_align
;
2528 gdbarch_reg_struct_has_addr_p (struct gdbarch
*gdbarch
)
2530 return gdbarch
->reg_struct_has_addr
!= 0;
2534 gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
, int gcc_p
, struct type
*type
)
2536 if (gdbarch
->reg_struct_has_addr
== 0)
2537 internal_error ("gdbarch: gdbarch_reg_struct_has_addr invalid");
2538 if (gdbarch_debug
>= 2)
2539 fprintf_unfiltered (gdb_stdlog
, "gdbarch_reg_struct_has_addr called\n");
2540 return gdbarch
->reg_struct_has_addr (gcc_p
, type
);
2544 set_gdbarch_reg_struct_has_addr (struct gdbarch
*gdbarch
,
2545 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr
)
2547 gdbarch
->reg_struct_has_addr
= reg_struct_has_addr
;
2551 /* Keep a registrary of per-architecture data-pointers required by GDB
2559 struct gdbarch_data_registration
2561 gdbarch_data_ftype
*init
;
2562 struct gdbarch_data
*data
;
2563 struct gdbarch_data_registration
*next
;
2566 struct gdbarch_data_registrary
2569 struct gdbarch_data_registration
*registrations
;
2572 struct gdbarch_data_registrary gdbarch_data_registrary
=
2577 struct gdbarch_data
*
2578 register_gdbarch_data (gdbarch_data_ftype
*init
)
2580 struct gdbarch_data_registration
**curr
;
2581 for (curr
= &gdbarch_data_registrary
.registrations
;
2583 curr
= &(*curr
)->next
);
2584 (*curr
) = XMALLOC (struct gdbarch_data_registration
);
2585 (*curr
)->next
= NULL
;
2586 (*curr
)->init
= init
;
2587 (*curr
)->data
= XMALLOC (struct gdbarch_data
);
2588 (*curr
)->data
->index
= gdbarch_data_registrary
.nr
++;
2589 return (*curr
)->data
;
2593 /* Walk through all the registered users initializing each in turn. */
2596 init_gdbarch_data (struct gdbarch
*gdbarch
)
2598 struct gdbarch_data_registration
*rego
;
2599 gdbarch
->nr_data
= gdbarch_data_registrary
.nr
+ 1;
2600 gdbarch
->data
= xmalloc (sizeof (void*) * gdbarch
->nr_data
);
2601 for (rego
= gdbarch_data_registrary
.registrations
;
2605 if (rego
->data
->index
< gdbarch
->nr_data
)
2606 gdbarch
->data
[rego
->data
->index
] = rego
->init ();
2611 /* Return the current value of the specified per-architecture
2616 struct gdbarch_data
*data
;
2618 if (data
->index
>= current_gdbarch
->nr_data
)
2619 internal_error ("gdbarch_data: request for non-existant data.");
2620 return current_gdbarch
->data
[data
->index
];
2625 /* Keep a registrary of swaped data required by GDB modules. */
2630 struct gdbarch_swap_registration
*source
;
2631 struct gdbarch_swap
*next
;
2634 struct gdbarch_swap_registration
2637 unsigned long sizeof_data
;
2638 gdbarch_swap_ftype
*init
;
2639 struct gdbarch_swap_registration
*next
;
2642 struct gdbarch_swap_registrary
2645 struct gdbarch_swap_registration
*registrations
;
2648 struct gdbarch_swap_registrary gdbarch_swap_registrary
=
2654 register_gdbarch_swap (void *data
,
2655 unsigned long sizeof_data
,
2656 gdbarch_swap_ftype
*init
)
2658 struct gdbarch_swap_registration
**rego
;
2659 for (rego
= &gdbarch_swap_registrary
.registrations
;
2661 rego
= &(*rego
)->next
);
2662 (*rego
) = XMALLOC (struct gdbarch_swap_registration
);
2663 (*rego
)->next
= NULL
;
2664 (*rego
)->init
= init
;
2665 (*rego
)->data
= data
;
2666 (*rego
)->sizeof_data
= sizeof_data
;
2671 init_gdbarch_swap (struct gdbarch
*gdbarch
)
2673 struct gdbarch_swap_registration
*rego
;
2674 struct gdbarch_swap
**curr
= &gdbarch
->swap
;
2675 for (rego
= gdbarch_swap_registrary
.registrations
;
2679 if (rego
->data
!= NULL
)
2681 (*curr
) = XMALLOC (struct gdbarch_swap
);
2682 (*curr
)->source
= rego
;
2683 (*curr
)->swap
= xmalloc (rego
->sizeof_data
);
2684 (*curr
)->next
= NULL
;
2685 memset (rego
->data
, 0, rego
->sizeof_data
);
2686 curr
= &(*curr
)->next
;
2688 if (rego
->init
!= NULL
)
2694 swapout_gdbarch_swap (struct gdbarch
*gdbarch
)
2696 struct gdbarch_swap
*curr
;
2697 for (curr
= gdbarch
->swap
;
2700 memcpy (curr
->swap
, curr
->source
->data
, curr
->source
->sizeof_data
);
2704 swapin_gdbarch_swap (struct gdbarch
*gdbarch
)
2706 struct gdbarch_swap
*curr
;
2707 for (curr
= gdbarch
->swap
;
2710 memcpy (curr
->source
->data
, curr
->swap
, curr
->source
->sizeof_data
);
2714 /* Keep a registrary of the architectures known by GDB. */
2716 struct gdbarch_init_registration
2718 enum bfd_architecture bfd_architecture
;
2719 gdbarch_init_ftype
*init
;
2720 struct gdbarch_list
*arches
;
2721 struct gdbarch_init_registration
*next
;
2724 static struct gdbarch_init_registration
*gdbarch_init_registrary
= NULL
;
2727 register_gdbarch_init (enum bfd_architecture bfd_architecture
,
2728 gdbarch_init_ftype
*init
)
2730 struct gdbarch_init_registration
**curr
;
2731 const struct bfd_arch_info
*bfd_arch_info
;
2732 /* Check that BFD reconizes this architecture */
2733 bfd_arch_info
= bfd_lookup_arch (bfd_architecture
, 0);
2734 if (bfd_arch_info
== NULL
)
2736 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture
);
2738 /* Check that we haven't seen this architecture before */
2739 for (curr
= &gdbarch_init_registrary
;
2741 curr
= &(*curr
)->next
)
2743 if (bfd_architecture
== (*curr
)->bfd_architecture
)
2744 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
2745 bfd_arch_info
->printable_name
);
2749 fprintf_unfiltered (gdb_stdlog
, "register_gdbarch_init (%s, 0x%08lx)\n",
2750 bfd_arch_info
->printable_name
,
2753 (*curr
) = XMALLOC (struct gdbarch_init_registration
);
2754 (*curr
)->bfd_architecture
= bfd_architecture
;
2755 (*curr
)->init
= init
;
2756 (*curr
)->arches
= NULL
;
2757 (*curr
)->next
= NULL
;
2762 /* Look for an architecture using gdbarch_info. Base search on only
2763 BFD_ARCH_INFO and BYTE_ORDER. */
2765 struct gdbarch_list
*
2766 gdbarch_list_lookup_by_info (struct gdbarch_list
*arches
,
2767 const struct gdbarch_info
*info
)
2769 for (; arches
!= NULL
; arches
= arches
->next
)
2771 if (info
->bfd_arch_info
!= arches
->gdbarch
->bfd_arch_info
)
2773 if (info
->byte_order
!= arches
->gdbarch
->byte_order
)
2781 /* Update the current architecture. Return ZERO if the update request
2785 gdbarch_update (struct gdbarch_info info
)
2787 struct gdbarch
*new_gdbarch
;
2788 struct gdbarch_list
**list
;
2789 struct gdbarch_init_registration
*rego
;
2791 /* Fill in any missing bits. Most important is the bfd_architecture
2792 which is used to select the target architecture. */
2793 if (info
.bfd_architecture
== bfd_arch_unknown
)
2795 if (info
.bfd_arch_info
!= NULL
)
2796 info
.bfd_architecture
= info
.bfd_arch_info
->arch
;
2797 else if (info
.abfd
!= NULL
)
2798 info
.bfd_architecture
= bfd_get_arch (info
.abfd
);
2799 /* FIXME - should query BFD for its default architecture. */
2801 info
.bfd_architecture
= current_gdbarch
->bfd_arch_info
->arch
;
2803 if (info
.bfd_arch_info
== NULL
)
2805 if (target_architecture_auto
&& info
.abfd
!= NULL
)
2806 info
.bfd_arch_info
= bfd_get_arch_info (info
.abfd
);
2808 info
.bfd_arch_info
= current_gdbarch
->bfd_arch_info
;
2810 if (info
.byte_order
== 0)
2812 if (target_byte_order_auto
&& info
.abfd
!= NULL
)
2813 info
.byte_order
= (bfd_big_endian (info
.abfd
) ? BIG_ENDIAN
2814 : bfd_little_endian (info
.abfd
) ? LITTLE_ENDIAN
2817 info
.byte_order
= current_gdbarch
->byte_order
;
2818 /* FIXME - should query BFD for its default byte-order. */
2820 /* A default for abfd? */
2822 /* Find the target that knows about this architecture. */
2823 for (rego
= gdbarch_init_registrary
;
2824 rego
!= NULL
&& rego
->bfd_architecture
!= info
.bfd_architecture
;
2829 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: No matching architecture\n");
2835 fprintf_unfiltered (gdb_stdlog
,
2836 "gdbarch_update: info.bfd_architecture %d (%s)\n",
2837 info
.bfd_architecture
,
2838 bfd_lookup_arch (info
.bfd_architecture
, 0)->printable_name
);
2839 fprintf_unfiltered (gdb_stdlog
,
2840 "gdbarch_update: info.bfd_arch_info %s\n",
2841 (info
.bfd_arch_info
!= NULL
2842 ? info
.bfd_arch_info
->printable_name
2844 fprintf_unfiltered (gdb_stdlog
,
2845 "gdbarch_update: info.byte_order %d (%s)\n",
2847 (info
.byte_order
== BIG_ENDIAN
? "big"
2848 : info
.byte_order
== LITTLE_ENDIAN
? "little"
2850 fprintf_unfiltered (gdb_stdlog
,
2851 "gdbarch_update: info.abfd 0x%lx\n",
2853 fprintf_unfiltered (gdb_stdlog
,
2854 "gdbarch_update: info.tdep_info 0x%lx\n",
2855 (long) info
.tdep_info
);
2858 /* Ask the target for a replacement architecture. */
2859 new_gdbarch
= rego
->init (info
, rego
->arches
);
2861 /* Did the target like it? No. Reject the change. */
2862 if (new_gdbarch
== NULL
)
2865 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Target rejected architecture\n");
2869 /* Did the architecture change? No. Do nothing. */
2870 if (current_gdbarch
== new_gdbarch
)
2873 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
2875 new_gdbarch
->bfd_arch_info
->printable_name
);
2879 /* Swap all data belonging to the old target out */
2880 swapout_gdbarch_swap (current_gdbarch
);
2882 /* Is this a pre-existing architecture? Yes. Swap it in. */
2883 for (list
= ®o
->arches
;
2885 list
= &(*list
)->next
)
2887 if ((*list
)->gdbarch
== new_gdbarch
)
2890 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
2892 new_gdbarch
->bfd_arch_info
->printable_name
);
2893 current_gdbarch
= new_gdbarch
;
2894 swapin_gdbarch_swap (new_gdbarch
);
2899 /* Append this new architecture to this targets list. */
2900 (*list
) = XMALLOC (struct gdbarch_list
);
2901 (*list
)->next
= NULL
;
2902 (*list
)->gdbarch
= new_gdbarch
;
2904 /* Switch to this new architecture. Dump it out. */
2905 current_gdbarch
= new_gdbarch
;
2908 fprintf_unfiltered (gdb_stdlog
,
2909 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
2911 new_gdbarch
->bfd_arch_info
->printable_name
);
2915 /* Check that the newly installed architecture is valid. */
2916 verify_gdbarch (new_gdbarch
);
2918 /* Initialize the per-architecture memory (swap) areas.
2919 CURRENT_GDBARCH must be update before these modules are
2921 init_gdbarch_swap (new_gdbarch
);
2923 /* Initialize the per-architecture data-pointer of all parties that
2924 registered an interest in this architecture. CURRENT_GDBARCH
2925 must be updated before these modules are called. */
2926 init_gdbarch_data (new_gdbarch
);
2933 /* Functions to manipulate the endianness of the target. */
2935 #ifdef TARGET_BYTE_ORDER_SELECTABLE
2936 /* compat - Catch old targets that expect a selectable byte-order to
2937 default to BIG_ENDIAN */
2938 #ifndef TARGET_BYTE_ORDER_DEFAULT
2939 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
2942 #if !TARGET_BYTE_ORDER_SELECTABLE_P
2943 #ifndef TARGET_BYTE_ORDER_DEFAULT
2944 /* compat - Catch old non byte-order selectable targets that do not
2945 define TARGET_BYTE_ORDER_DEFAULT and instead expect
2946 TARGET_BYTE_ORDER to be used as the default. For targets that
2947 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
2948 below will get a strange compiler warning. */
2949 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
2952 #ifndef TARGET_BYTE_ORDER_DEFAULT
2953 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
2955 int target_byte_order
= TARGET_BYTE_ORDER_DEFAULT
;
2956 int target_byte_order_auto
= 1;
2958 /* Chain containing the \"set endian\" commands. */
2959 static struct cmd_list_element
*endianlist
= NULL
;
2961 /* Called by ``show endian''. */
2963 show_endian (char *args
, int from_tty
)
2966 (TARGET_BYTE_ORDER_AUTO
2967 ? "The target endianness is set automatically (currently %s endian)\n"
2968 : "The target is assumed to be %s endian\n");
2969 printf_unfiltered (msg
, (TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little"));
2972 /* Called if the user enters ``set endian'' without an argument. */
2974 set_endian (char *args
, int from_tty
)
2976 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
2977 show_endian (args
, from_tty
);
2980 /* Called by ``set endian big''. */
2982 set_endian_big (char *args
, int from_tty
)
2984 if (TARGET_BYTE_ORDER_SELECTABLE_P
)
2986 target_byte_order
= BIG_ENDIAN
;
2987 target_byte_order_auto
= 0;
2990 struct gdbarch_info info
;
2991 memset (&info
, 0, sizeof info
);
2992 info
.byte_order
= BIG_ENDIAN
;
2993 gdbarch_update (info
);
2998 printf_unfiltered ("Byte order is not selectable.");
2999 show_endian (args
, from_tty
);
3003 /* Called by ``set endian little''. */
3005 set_endian_little (char *args
, int from_tty
)
3007 if (TARGET_BYTE_ORDER_SELECTABLE_P
)
3009 target_byte_order
= LITTLE_ENDIAN
;
3010 target_byte_order_auto
= 0;
3013 struct gdbarch_info info
;
3014 memset (&info
, 0, sizeof info
);
3015 info
.byte_order
= LITTLE_ENDIAN
;
3016 gdbarch_update (info
);
3021 printf_unfiltered ("Byte order is not selectable.");
3022 show_endian (args
, from_tty
);
3026 /* Called by ``set endian auto''. */
3028 set_endian_auto (char *args
, int from_tty
)
3030 if (TARGET_BYTE_ORDER_SELECTABLE_P
)
3032 target_byte_order_auto
= 1;
3036 printf_unfiltered ("Byte order is not selectable.");
3037 show_endian (args
, from_tty
);
3041 /* Set the endianness from a BFD. */
3043 set_endian_from_file (bfd
*abfd
)
3045 if (TARGET_BYTE_ORDER_SELECTABLE_P
)
3049 if (bfd_big_endian (abfd
))
3052 want
= LITTLE_ENDIAN
;
3053 if (TARGET_BYTE_ORDER_AUTO
)
3054 target_byte_order
= want
;
3055 else if (TARGET_BYTE_ORDER
!= want
)
3056 warning ("%s endian file does not match %s endian target.",
3057 want
== BIG_ENDIAN
? "big" : "little",
3058 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
3062 if (bfd_big_endian (abfd
)
3063 ? TARGET_BYTE_ORDER
!= BIG_ENDIAN
3064 : TARGET_BYTE_ORDER
== BIG_ENDIAN
)
3065 warning ("%s endian file does not match %s endian target.",
3066 bfd_big_endian (abfd
) ? "big" : "little",
3067 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
3073 /* Functions to manipulate the architecture of the target */
3075 enum set_arch
{ set_arch_auto
, set_arch_manual
};
3077 int target_architecture_auto
= 1;
3078 extern const struct bfd_arch_info bfd_default_arch_struct
;
3079 const struct bfd_arch_info
*target_architecture
= &bfd_default_arch_struct
;
3080 int (*target_architecture_hook
) (const struct bfd_arch_info
*ap
);
3082 static void show_endian (char *, int);
3083 static void set_endian (char *, int);
3084 static void set_endian_big (char *, int);
3085 static void set_endian_little (char *, int);
3086 static void set_endian_auto (char *, int);
3087 static void set_endian_from_file (bfd
*);
3088 static int arch_ok (const struct bfd_arch_info
*arch
);
3089 static void set_arch (const struct bfd_arch_info
*arch
, enum set_arch type
);
3090 static void show_architecture (char *, int);
3091 static void set_architecture (char *, int);
3092 static void info_architecture (char *, int);
3093 static void set_architecture_from_file (bfd
*);
3095 /* Do the real work of changing the current architecture */
3098 arch_ok (const struct bfd_arch_info
*arch
)
3100 /* Should be performing the more basic check that the binary is
3101 compatible with GDB. */
3102 /* Check with the target that the architecture is valid. */
3103 return (target_architecture_hook
== NULL
3104 || target_architecture_hook (arch
));
3108 set_arch (const struct bfd_arch_info
*arch
,
3114 if (!arch_ok (arch
))
3115 warning ("Target may not support %s architecture",
3116 arch
->printable_name
);
3117 target_architecture
= arch
;
3119 case set_arch_manual
:
3120 if (!arch_ok (arch
))
3122 printf_unfiltered ("Target does not support `%s' architecture.\n",
3123 arch
->printable_name
);
3127 target_architecture_auto
= 0;
3128 target_architecture
= arch
;
3136 /* Called if the user enters ``show architecture'' without an argument. */
3138 show_architecture (char *args
, int from_tty
)
3141 arch
= TARGET_ARCHITECTURE
->printable_name
;
3142 if (target_architecture_auto
)
3143 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
3145 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
3148 /* Called if the user enters ``set architecture'' with or without an
3151 set_architecture (char *args
, int from_tty
)
3155 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
3157 else if (strcmp (args
, "auto") == 0)
3159 target_architecture_auto
= 1;
3161 else if (GDB_MULTI_ARCH
)
3163 const struct bfd_arch_info
*arch
= bfd_scan_arch (args
);
3165 printf_unfiltered ("Architecture `%s' not reconized.\n", args
);
3168 struct gdbarch_info info
;
3169 memset (&info
, 0, sizeof info
);
3170 info
.bfd_arch_info
= arch
;
3171 if (gdbarch_update (info
))
3172 target_architecture_auto
= 0;
3174 printf_unfiltered ("Architecture `%s' not reconized.\n", args
);
3179 const struct bfd_arch_info
*arch
= bfd_scan_arch (args
);
3181 set_arch (arch
, set_arch_manual
);
3183 printf_unfiltered ("Architecture `%s' not reconized.\n", args
);
3187 /* Called if the user enters ``info architecture'' without an argument. */
3189 info_architecture (char *args
, int from_tty
)
3191 enum bfd_architecture a
;
3194 if (gdbarch_init_registrary
!= NULL
)
3196 struct gdbarch_init_registration
*rego
;
3197 printf_filtered ("Available architectures are:\n");
3198 for (rego
= gdbarch_init_registrary
;
3202 const struct bfd_arch_info
*ap
;
3203 ap
= bfd_lookup_arch (rego
->bfd_architecture
, 0);
3208 printf_filtered (" %s", ap
->printable_name
);
3212 printf_filtered ("\n");
3218 printf_filtered ("There are no available architectures.\n");
3222 printf_filtered ("Available architectures are:\n");
3223 for (a
= bfd_arch_obscure
+ 1; a
< bfd_arch_last
; a
++)
3225 const struct bfd_arch_info
*ap
= bfd_lookup_arch (a
, 0);
3230 printf_filtered (" %s", ap
->printable_name
);
3234 printf_filtered ("\n");
3239 /* Set the architecture from arch/machine */
3241 set_architecture_from_arch_mach (arch
, mach
)
3242 enum bfd_architecture arch
;
3245 const struct bfd_arch_info
*wanted
= bfd_lookup_arch (arch
, mach
);
3247 set_arch (wanted
, set_arch_manual
);
3249 internal_error ("gdbarch: hardwired architecture/machine not reconized");
3252 /* Set the architecture from a BFD */
3254 set_architecture_from_file (bfd
*abfd
)
3256 const struct bfd_arch_info
*wanted
= bfd_get_arch_info (abfd
);
3257 if (target_architecture_auto
)
3259 set_arch (wanted
, set_arch_auto
);
3261 else if (wanted
!= target_architecture
)
3263 warning ("%s architecture file may be incompatible with %s target.",
3264 wanted
->printable_name
,
3265 target_architecture
->printable_name
);
3270 /* Misc helper functions for targets. */
3273 frame_num_args_unknown (fi
)
3274 struct frame_info
*fi
;
3281 generic_register_convertible_not (num
)
3290 /* Pointer to the target-dependent disassembly function. */
3291 int (*tm_print_insn
) (bfd_vma
, disassemble_info
*);
3292 disassemble_info tm_print_insn_info
;
3296 /* Set the dynamic target-system-dependant parameters (architecture,
3297 byte-order) using information found in the BFD */
3300 set_gdbarch_from_file (abfd
)
3305 struct gdbarch_info info
;
3306 memset (&info
, 0, sizeof info
);
3308 gdbarch_update (info
);
3311 set_architecture_from_file (abfd
);
3312 set_endian_from_file (abfd
);
3316 /* Initialize the current architecture. */
3318 initialize_current_architecture ()
3322 struct gdbarch_init_registration
*rego
;
3323 const struct bfd_arch_info
*chosen
= NULL
;
3324 for (rego
= gdbarch_init_registrary
; rego
!= NULL
; rego
= rego
->next
)
3326 const struct bfd_arch_info
*ap
3327 = bfd_lookup_arch (rego
->bfd_architecture
, 0);
3329 /* Choose the first architecture alphabetically. */
3331 || strcmp (ap
->printable_name
, chosen
->printable_name
) < 0)
3337 struct gdbarch_info info
;
3338 memset (&info
, 0, sizeof info
);
3339 info
.bfd_arch_info
= chosen
;
3340 gdbarch_update (info
);
3345 extern void _initialize_gdbarch (void);
3347 _initialize_gdbarch ()
3349 struct cmd_list_element
*c
;
3351 add_prefix_cmd ("endian", class_support
, set_endian
,
3352 "Set endianness of target.",
3353 &endianlist
, "set endian ", 0, &setlist
);
3354 add_cmd ("big", class_support
, set_endian_big
,
3355 "Set target as being big endian.", &endianlist
);
3356 add_cmd ("little", class_support
, set_endian_little
,
3357 "Set target as being little endian.", &endianlist
);
3358 add_cmd ("auto", class_support
, set_endian_auto
,
3359 "Select target endianness automatically.", &endianlist
);
3360 add_cmd ("endian", class_support
, show_endian
,
3361 "Show endianness of target.", &showlist
);
3363 add_cmd ("architecture", class_support
, set_architecture
,
3364 "Set architecture of target.", &setlist
);
3365 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
3366 add_cmd ("architecture", class_support
, show_architecture
,
3367 "Show architecture of target.", &showlist
);
3368 add_cmd ("architecture", class_support
, info_architecture
,
3369 "List supported target architectures", &infolist
);
3371 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info
, gdb_stdout
, (fprintf_ftype
)fprintf_filtered
);
3372 tm_print_insn_info
.flavour
= bfd_target_unknown_flavour
;
3373 tm_print_insn_info
.read_memory_func
= dis_asm_read_memory
;
3374 tm_print_insn_info
.memory_error_func
= dis_asm_memory_error
;
3375 tm_print_insn_info
.print_address_func
= dis_asm_print_address
;
3377 add_show_from_set (add_set_cmd ("arch",
3380 (char *)&gdbarch_debug
,
3381 "Set architecture debugging.\n\
3382 When non-zero, architecture debugging is enabled.", &setdebuglist
),
3384 c
= add_set_cmd ("archdebug",
3387 (char *)&gdbarch_debug
,
3388 "Set architecture debugging.\n\
3389 When non-zero, architecture debugging is enabled.", &setlist
);
3391 deprecate_cmd (c
, "set debug arch");
3392 deprecate_cmd (add_show_from_set (c
, &showlist
), "show debug arch");